Skip to content

ccoalm/ccl-skills / skills/skill-extraction-workflow

skill-extraction-workflow

Flagged

复盘 / 沉淀 / 总结经验 / 补进技能 / 技能缺陷 / 流程优化 / would other teammates hit this / will we forget next time / teamwide recurrence / extract skill / post-mortem / 深度 review·审计技能仓库 / 对标外部技能包找 gap(benchmark superpowers·gstack 等) / 核查全局安装点(~/.config/opencode 等)旧快照是否遮蔽本仓技能 / 本仓(ccl-skills 等共享技能仓)OpenCode 项目配置·命令治理 → turn reusable lessons into durable CCL skills.

FileKindSize
SKILL.mdskill md111.0 KB
agents/openai.yamlconfig257 B
references/analysis-parse-fix-test-challenge-replay.mdmarkdown1.5 KB
references/attention-budget-ratchet.mdmarkdown13.7 KB
references/attribution-verification.mdmarkdown4.4 KB
references/bootstrap-slim-c3-obligation-table.mdmarkdown8.0 KB
references/correction-routing-map.mdmarkdown3.7 KB
references/coverage-exhaustion-traps.mdmarkdown19.6 KB
references/description-authoring.mdmarkdown21.1 KB
references/dual-track-review-gate.mdmarkdown110.6 KB
references/eval-routing.mdmarkdown22.2 KB
references/evidence-card-template.mdmarkdown3.2 KB
references/example-domain-preselect.mdmarkdown4.6 KB
references/external-practice-controls.mdmarkdown45.5 KB
references/extraction-lifecycle-handoff.mdmarkdown6.9 KB
references/extraction-quickstart.mdmarkdown20.2 KB
references/firing-point-placement.mdmarkdown21.3 KB
references/harness-patterns-and-eval.mdmarkdown42.6 KB
references/incident-postmortem-extraction.mdmarkdown28.8 KB
references/l0-l1-l2-routing.mdmarkdown10.3 KB
references/online-skill-review.mdmarkdown6.7 KB
references/parallel-stack-references-pattern.mdmarkdown35.9 KB
references/r0-leakage-audit.mdmarkdown19.9 KB
references/recurring-anti-patterns-checklist.mdmarkdown34.4 KB
references/resume-paused-delivery.mdmarkdown3.0 KB
references/review-feedback-mining.mdmarkdown5.7 KB
references/review-finding-standards.mdmarkdown7.3 KB
references/review-rubric.mdmarkdown3.1 KB
references/rule-consolidation.mdmarkdown38.2 KB
references/skill-listing-budget.mdmarkdown1.7 KB
references/source-register.mdmarkdown1.0 MB
references/source-to-skill-extraction.mdmarkdown109.3 KB
references/two-source-extraction-pattern.mdmarkdown19.4 KB
references/uiux-judgment-extraction.mdmarkdown19.1 KB
references/uiux-routing-map.mdmarkdown5.8 KB
references/validation-and-landing.mdmarkdown46.9 KB
scripts/AGENTS.mdmarkdown635 B
scripts/check-ccl-skills.shexecutablescript100.7 KB
scripts/check-contract-anchors.shexecutablescript5.6 KB
scripts/check-evidence-card-leak.shexecutablescript26.1 KB
scripts/check-mr-target-freshness.shexecutablescript9.4 KB
scripts/check-size-budget.shexecutablescript36.0 KB
scripts/check-sync-pointers.shexecutablescript22.6 KB
scripts/check_review_evidence_present.pyexecutablescript4.6 KB
scripts/contract-anchors.tsvother3.8 KB
scripts/entrypoint_form_census.pyexecutablescript7.1 KB
scripts/eval-golden-trace.rbexecutablescript10.0 KB
scripts/eval-health.rbexecutablescript14.6 KB
scripts/eval-routing-bank.rbexecutablescript30.4 KB
scripts/eval-routing.rbexecutablescript9.2 KB
scripts/extraction_review_gate.shexecutablescript1.8 KB
scripts/gate_receipt.pyexecutablescript24.7 KB
scripts/generic-r0-leak-scan.shexecutablescript12.4 KB
scripts/governing-chain-diff.pyexecutablescript12.8 KB
scripts/impact-chain-gate.rbexecutablescript124.4 KB
scripts/obligation-ledger.pyscript107.0 KB
scripts/reference-access-census.shexecutablescript8.3 KB
scripts/register-firing-path-resolution.rbexecutablescript48.4 KB
scripts/shared_git_surface_gate.pyexecutablescript38.0 KB
scripts/skill-behavior-eval.pyexecutablescript39.3 KB
scripts/skill-paired-eval.pyexecutablescript76.9 KB
scripts/source-register-lifecycle.rbscript1.5 KB
scripts/source-register-pending-status.rbscript2.0 KB
scripts/test_ai_coding_implementation_gates.shexecutablescript85.2 KB
scripts/test_antipattern_grep_panel.shexecutablescript3.2 KB
scripts/test_body_compliance_grading.shexecutablescript21.0 KB
scripts/test_check_ccl_impact_chain_refscripts.shexecutablescript145.1 KB
scripts/test_check_ccl_r0_status.shexecutablescript4.2 KB
scripts/test_check_ccl_register_pending_exclusion.shexecutablescript7.4 KB
scripts/test_check_ccl_regressions.shexecutablescript14.3 KB
scripts/test_check_ccl_route_drift.shexecutablescript22.6 KB
scripts/test_check_ccl_size_budget.shexecutablescript59.5 KB
scripts/test_check_ccl_skill_catalog.shexecutablescript23.3 KB
scripts/test_check_ccl_source_register_lifecycle.shexecutablescript6.1 KB
scripts/test_check_contract_anchors.shexecutablescript7.4 KB
scripts/test_check_mr_target_freshness.shexecutablescript12.8 KB
scripts/test_check_review_evidence_present.shexecutablescript4.3 KB
scripts/test_check_sync_pointers.shexecutablescript32.5 KB
scripts/test_ci_checkout_ref_binding.shexecutablescript8.2 KB
scripts/test_controlled_escalation_pins.shexecutablescript7.7 KB
scripts/test_entrypoint_domain_scan_terms.shexecutablescript8.8 KB
scripts/test_entrypoint_form_census.shexecutablescript6.3 KB
scripts/test_eval_routing_bank_grader_diagnostics.shexecutablescript20.6 KB
scripts/test_eval_routing_bank_resolution.shexecutablescript15.3 KB
scripts/test_eval_routing_bank_surface_binding.shexecutablescript6.9 KB
scripts/test_eval_routing_prose_target.shexecutablescript3.7 KB
scripts/test_eval_runtime.pyexecutablescript43.3 KB
scripts/test_extraction_review_gate.shexecutablescript15.2 KB
scripts/test_frozen_case_sanctity.shexecutablescript6.9 KB
scripts/test_frozen_case_sanctity_selfproof.shexecutablescript4.6 KB
scripts/test_gate_receipt.shexecutablescript17.7 KB
scripts/test_generic_r0_leak_scan.shexecutablescript6.4 KB
scripts/test_git_identity_predicate_gate.shscript13.8 KB
scripts/test_governing_chain_diff.shexecutablescript15.1 KB
scripts/test_impact_chain_gate_dateless_host.shexecutablescript6.8 KB
scripts/test_impact_chain_gate_verdict_differential.shexecutablescript20.8 KB
scripts/test_impact_chain_round_attribution.shexecutablescript32.5 KB
scripts/test_impact_chain_self_adjudication.shexecutablescript31.4 KB
scripts/test_impact_chain_source_refuted.shexecutablescript14.7 KB
scripts/test_liveness_predicate_gate.shexecutablescript14.5 KB
scripts/test_locale_independent_gates.shexecutablescript13.0 KB
scripts/test_obligation_ledger.shexecutablescript94.9 KB
scripts/test_obligation_ledger_repo_audit.shexecutablescript2.7 KB
scripts/test_pinned_phrase_mutation_walk.shexecutablescript6.5 KB
scripts/test_reference_access_census.shexecutablescript17.3 KB
scripts/test_register_firing_path_resolution.shexecutablescript41.0 KB
scripts/test_register_firing_path_wiring.shexecutablescript29.9 KB
scripts/test_regression_runner_lanes.shexecutablescript4.5 KB
scripts/test_regression_runner_registration.shexecutablescript1.5 KB
scripts/test_routing_bank_integrity.shexecutablescript15.5 KB
scripts/test_routing_pointer_integrity.shexecutablescript18.9 KB
scripts/test_shared_git_surface_gate.shexecutablescript76.8 KB
scripts/test_skill_paired_eval.pyscript60.0 KB
scripts/test_teardown_guard_pins.shexecutablescript17.0 KB
scripts/test_uiux_delivery_contract.shexecutablescript118.6 KB
scripts/test_uiux_loading_budget.shexecutablescript15.4 KB
scripts/test_validate_skill_credential_cwd.shexecutablescript2.6 KB
scripts/test_validate_skill_cross_refs.shexecutablescript4.8 KB
scripts/test_validate_skill_root_depth.shexecutablescript2.5 KB
scripts/validate-skill.shexecutablescript10.5 KB

scripts/test_git_identity_predicate_gate.sh

View on GitHub
#!/usr/bin/env bash
# Behavior suite for check-ccl-skills.sh's `git_identity_predicate_scan` gate
# (recurring-anti-patterns-checklist.md, Anti-pattern 27).
#
# The gate exists because a path-shaped identity predicate fails OPEN and silently:
# nothing errors, no log line appears, and the owning suite stays green because its
# fixtures are all built in the conventional layout. So the gate's own value rests
# entirely on it being able to FAIL — a check that can only ever say "ok" is
# indistinguishable from a passing property. Every probe here therefore pins one
# direction of that: the planted-violation probes prove it fires, and the carve-out
# probes prove it does not fire on the legitimate spellings (a gate that flags the
# fix's own documentation, or a fixture's containment assertion, gets loosened by the
# next maintainer and stops catching anything).
#
#   bash skills/skill-extraction-workflow/scripts/test_git_identity_predicate_gate.sh
set -u

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
CHECKER="${CHECKER:-$SCRIPT_DIR/check-ccl-skills.sh}"
[ -f "$CHECKER" ] || { echo "FAIL: checker not found: $CHECKER" >&2; exit 1; }

pass=0; fail=0; skipped=0; skipped_labels=""
note() { fail=$((fail+1)); printf 'FAIL  %s\n' "$1" >&2; }
ok()   { pass=$((pass+1)); }
# Two probes need an unreadable path as their PRECONDITION. Some environments cannot
# produce one (root, or a filesystem/container that ignores the mode) — that is an
# environment capability, not a defect in the code under test, so failing there would
# red-line CI for the wrong reason. It must not become a silent skip either, so a skip
# is printed, counted, reported in the summary line, and allowed ONLY for these two
# named probes; any other probe reaching skip() is itself a failure.
skip() { # skip <label> <reason>
  case "$1" in
    p11|p11b) skipped=$((skipped+1)); skipped_labels="$skipped_labels $1"
              printf 'SKIP  %s: %s (uid=%s)\n' "$1" "$2" "$(id -u)" >&2 ;;
    *) note "$1: skip() is not permitted for this probe (reason was: $2)" ;;
  esac
}

TMP=$(mktemp -d "${TMPDIR:-/tmp}/git-identity-gate-test.XXXXXX") || exit 1
TMP=$(cd "$TMP" && pwd -P)
trap 'rm -rf "$TMP"' EXIT

# The gate is one section of a long checker, so run the section in isolation rather
# than standing up a whole synthetic skill tree: extract it and drive it with $root.
section=$TMP/gate-section.sh
{
  echo '#!/usr/bin/env bash'
  # MUST match the host checker's options. Running the section under laxer settings is
  # how a section that aborts the real checker (a bare `v=$(grep ...)` exiting on a
  # no-match under `set -e`) still passes every probe here.
  echo 'set -euo pipefail'
  echo 'root="$1"'
  awk '/^# Anti-pattern 27 —/{p=1} p; /^echo "git_identity_predicate_scan_ok"$/{if(p) exit}' "$CHECKER"
} > "$section"
grep -q 'git_identity_predicate_scan_ok' "$section" \
  || { echo "FAIL: could not extract the gate section from $CHECKER (anchor moved?)" >&2; exit 1; }
grep -q 'worktrees' "$section" \
  || { echo "FAIL: extracted section carries no predicate — extraction is bogus" >&2; exit 1; }

run_gate() { # run_gate <root> -> RC, OUT
  OUT=$( bash "$section" "$1" 2>&1 ); RC=$?
}

mk_root() { # mk_root <name> -> echoes a fresh root with empty hooks/ and scripts/
  local r="$TMP/$1"; mkdir -p "$r/hooks" "$r/scripts/nested"; printf '%s' "$r"
}

# --- P1: a clean tree passes ------------------------------------------------
r=$(mk_root clean)
printf '#!/usr/bin/env bash\ngd=$(git rev-parse --path-format=absolute --git-common-dir)\n' > "$r/hooks/ok.sh"
run_gate "$r"
if [ "$RC" -eq 0 ] && printf '%s' "$OUT" | grep -q 'git_identity_predicate_scan_ok'; then ok
else note "p1 clean tree must pass with the ok token (rc=$RC): $OUT"; fi

# --- P2: the violation fires (this is the gate's whole reason to exist) ------
r=$(mk_root violation)
printf '#!/usr/bin/env bash\ncase "$absgitdir" in\n  */worktrees/*) exit 0 ;;\nesac\n' > "$r/hooks/guard.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'git_identity_predicate_scan_failed'; then ok
else note "p2 planted path-name predicate must FAIL the gate (rc=$RC): $OUT"; fi

# --- P2b: the report names the offending file and line ----------------------
if printf '%s' "$OUT" | grep -q 'hooks/guard.sh:2' || printf '%s' "$OUT" | grep -q 'hooks/guard.sh:3'; then ok
else note "p2b failure output must locate the hit (file:line), got: $OUT"; fi

# --- P2c: the QUOTED spelling is the same predicate and must also fire ------
# `*"/worktrees/"*` matches identically in bash, so a gate that only knows the
# bare spelling is bypassed by ordinary quoting style — not even deliberate evasion.
r=$(mk_root quoted)
printf '#!/usr/bin/env bash\ncase "$absgitdir" in *"/worktrees/"*) exit 0 ;; esac\n' > "$r/hooks/quoted.sh"
run_gate "$r"
if [ "$RC" -ne 0 ]; then ok; else note "p2c quoted glob spelling must fire (rc=$RC): $OUT"; fi

# --- P2d: an ordinary cleanup glob over a worktrees path is NOT a predicate --
# `.work/worktrees/*` is a path, not a match pattern; flagging it would make the
# gate unusable for the very teardown scripts this repo's worktree convention needs.
r=$(mk_root cleanup)
printf '#!/usr/bin/env bash\nrm -rf "$root"/.work/worktrees/*\nls .work/worktrees/*/\n' > "$r/scripts/cleanup.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok; else note "p2d path glob over .work/worktrees/* must NOT fire (rc=$RC): $OUT"; fi

# --- P2e: DOCUMENTED SCOPE LIMIT — a backslash-continued pattern is not caught
# `*/worktrees/\<newline>*` is the same predicate to bash and does reproduce the
# defect, but matching is per physical line and joining continuations first would
# push every reported line number off the real source line. The gate declares this
# as recall limit #2 rather than pretending to cover it. This probe pins the CURRENT
# contract: if someone later adds continuation-joining, this probe must be updated
# deliberately — it must never drift silently in either direction.
r=$(mk_root continuation)
printf '#!/usr/bin/env bash\ncase "$gd" in\n  */worktrees/\\\n*) exit 0 ;;\nesac\n' > "$r/hooks/cont.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p2e continuation form is a DECLARED recall limit; the gate firing here means the declared contract is now wrong (rc=$RC): $OUT"; fi

# --- P3: the same violation under scripts/, incl. a nested dir --------------
r=$(mk_root nested)
printf '#!/usr/bin/env bash\n[[ "$gd" == */worktrees/* ]] && return 0\n' > "$r/scripts/nested/state.sh"
run_gate "$r"
if [ "$RC" -ne 0 ]; then ok; else note "p3 violation nested under scripts/ must fail (rc=$RC): $OUT"; fi

# --- P4: carve-out — a comment documenting the banned spelling is not a hit --
# The fix's own comment (and this checklist row) name the spelling; flagging them
# would make the gate unlandable and invite a maintainer to loosen the predicate.
r=$(mk_root comment)
printf '#!/usr/bin/env bash\n# never match */worktrees/* — use the common dir instead\n   # */worktrees/*\ngd=$(git rev-parse --git-common-dir)\n' > "$r/hooks/documented.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok; else note "p4 comment-only mention must NOT fire (rc=$RC): $OUT"; fi

# --- P5: carve-out — a test fixture asserting containment is not a control ---
r=$(mk_root fixture)
printf '#!/usr/bin/env bash\ncase "$(git rev-parse --absolute-git-dir)" in\n  */worktrees/*) ;;\n  *) note "fixture premise broken" ;;\nesac\n' > "$r/hooks/test_thing.sh"
cp "$r/hooks/test_thing.sh" "$r/scripts/nested/test.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok; else note "p5 test_*.sh / test.sh fixture must NOT fire (rc=$RC): $OUT"; fi

# --- P6: a violation in a NON-test file still fires when test files exist ----
# Guards against the carve-out being implemented as a whole-tree skip.
printf '#!/usr/bin/env bash\ncase "$gd" in */worktrees/*) exit 0 ;; esac\n' > "$r/hooks/real.sh"
run_gate "$r"
if [ "$RC" -ne 0 ]; then ok; else note "p6 carve-out must be per-file, not tree-wide (rc=$RC): $OUT"; fi

# --- P7: missing dirs are not an error (gate runs on partial trees) ---------
r="$TMP/empty"; mkdir -p "$r"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok; else note "p7 tree without hooks//scripts/ must pass quietly (rc=$RC): $OUT"; fi

# --- P8: the REAL repo is clean under this gate -----------------------------
# Pins the promoted class as actually eradicated, not merely described.
repo_root=$(cd "$SCRIPT_DIR/../../.." && pwd -P)
if [ -d "$repo_root/hooks" ]; then
  run_gate "$repo_root"
  if [ "$RC" -eq 0 ]; then ok; else note "p8 the repo itself must be clean under this gate (rc=$RC): $OUT"; fi
else
  note "p8 could not resolve the repo root from $SCRIPT_DIR (expected hooks/ at $repo_root)"
fi

# --- P9: a newline in a file name must not drop the file from the scan -----
# Newline-delimited traversal splits such a name into two non-existent paths and
# reports clean — a scan that never happened, wearing a pass.
r=$(mk_root newline)
nl_file=$(printf 'hooks/bad\nname.sh')
printf '#!/usr/bin/env bash\ncase "$g" in */worktrees/*) exit 0 ;; esac\n' > "$r/$nl_file" 2>/dev/null
if [ -f "$r/$nl_file" ]; then
  run_gate "$r"
  if [ "$RC" -ne 0 ]; then ok; else note "p9 file with a newline in its name must still be scanned (rc=$RC): $OUT"; fi
else
  note "p9 fixture: could not create a newline-named file (filesystem restriction)"
fi

# --- P10: a symlinked scan root must still be walked ------------------------
# `-type f` without `-L` skips symlinked dirs AND symlinked files, so an entire
# control surface can sit outside the scan while the gate reports ok.
r="$TMP/symlink"; mkdir -p "$r/real-hooks" "$r/scripts"
printf '#!/usr/bin/env bash\ncase "$g" in */worktrees/*) exit 0 ;; esac\n' > "$r/real-hooks/guard.sh"
ln -s "$r/real-hooks" "$r/hooks"
run_gate "$r"
if [ "$RC" -ne 0 ]; then ok; else note "p10 symlinked hooks/ dir must still be scanned (rc=$RC): $OUT"; fi

# --- P11: an unreadable file is UNKNOWN, never clean ------------------------
# grep exits 2; swallowing that prints the ok token for a file never inspected.
r=$(mk_root unreadable)
printf '#!/usr/bin/env bash\necho hi\n' > "$r/hooks/locked.sh"
chmod 000 "$r/hooks/locked.sh" 2>/dev/null
if [ -r "$r/hooks/locked.sh" ]; then
  skip p11 "file still readable after chmod 000; this environment cannot produce an unreadable path"
else
  run_gate "$r"
  if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'git_identity_predicate_scan_error'; then ok
  else note "p11 unreadable file must raise a scan ERROR, not an ok (rc=$RC): $OUT"; fi
  chmod 644 "$r/hooks/locked.sh" 2>/dev/null
fi

# --- P11b: a FAILED walk is an error even when only one root exists ---------
# Gating the find-status check on "both roots exist" would silently accept an
# incomplete walk in the common single-root repo — the same fail-open shape the
# gate exists to stop.
# Fixture note: an UNREADABLE subdirectory is used rather than a symlink loop.
# Loop detection is find-implementation-dependent and was measured to be
# nondeterministic here (bfs is breadth-first: the same call returned 1 standalone
# and 0 moments later), so a loop fixture would be a flaky oracle — and a probe
# that intermittently passes for the wrong reason is worse than no probe.
r="$TMP/walkfail"; mkdir -p "$r/hooks/sub"
chmod 000 "$r/hooks/sub" 2>/dev/null
if find -L "$r/hooks" -name '*.sh' -type f >/dev/null 2>&1; then
  skip p11b "unreadable subdir did not make find fail; this environment cannot produce an unwalkable dir"
else
  run_gate "$r"
  if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'git_identity_predicate_scan_error'; then ok
  else note "p11b incomplete walk (hooks/ only, unreadable subdir) must ERROR, not report clean (rc=$RC): $OUT"; fi
fi
chmod 755 "$r/hooks/sub" 2>/dev/null

# --- P12: the REAL checker entry actually reaches this gate -----------------
# Every probe above runs an extracted section. If control flow upstream in
# check-ccl-skills.sh ever returns before this gate (an early exit, a
# misplaced block), all of them stay green while the gate never runs in
# production — and the source-register row claims exactly that firing path
# (`command:...check-ccl-skills.sh`). Assert reachability through the real
# entry point. Only the token's presence is asserted, not the checker's overall
# exit code, so an unrelated gate failing elsewhere cannot make this flaky.
if [ -x "$repo_root/skills/skill-extraction-workflow/scripts/check-ccl-skills.sh" ] \
   || [ -f "$repo_root/skills/skill-extraction-workflow/scripts/check-ccl-skills.sh" ]; then
  real_out=$(cd "$repo_root" && bash skills/skill-extraction-workflow/scripts/check-ccl-skills.sh . 2>&1); real_rc=$?
  if printf '%s' "$real_out" | grep -q 'git_identity_predicate_scan_ok\|git_identity_predicate_scan_failed\|git_identity_predicate_scan_error'; then
    # A _failed/_error token that does not actually stop the checker would be a gate in
    # name only. The converse is NOT asserted: requiring rc=0 on _ok would make this probe
    # hostage to any unrelated gate elsewhere in the checker.
    if printf '%s' "$real_out" | grep -q 'git_identity_predicate_scan_failed\|git_identity_predicate_scan_error' && [ "$real_rc" -eq 0 ]; then
      note "p12 the real checker reported a gate violation but still exited 0 — the gate does not block"
    else ok; fi
  else note "p12 the real checker never reached this gate — the register's firing path is not live: $(printf '%s' "$real_out" | tail -3)"; fi
else
  note "p12 could not locate check-ccl-skills.sh at $repo_root to prove the firing path"
fi

# Self-pin: a deleted or commented-out probe must fail the suite, not shrink it.
EXPECTED_PROBES=17
actual_probes=$(grep -cE '^[[:space:]]*(ok$|ok;|if \[ "\$RC")' "$0")
echo "git_identity_predicate_gate: $pass passed, $fail failed, $skipped skipped${skipped_labels:+ ($skipped_labels )}"
[ "$((pass + fail + skipped))" -eq "$EXPECTED_PROBES" ] \
  || { echo "FAIL: suite self-pin: expected $EXPECTED_PROBES probe outcomes, accounted for $((pass + fail + skipped))" >&2; exit 1; }
[ "$fail" -eq 0 ] && echo "test_git_identity_predicate_gate_ok"
[ "$fail" -eq 0 ]
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall