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_liveness_predicate_gate.sh

View on GitHub
#!/usr/bin/env bash
# Behavior suite for check-ccl-skills.sh's `liveness_predicate_scan` gate
# (recurring-anti-patterns-checklist.md, Anti-pattern 28).
#
# The gate exists because an existence-test liveness predicate fails in the direction
# that looks like a real defect: the probe reds, names the code under test, and the code
# under test was fine. Its value therefore rests on two properties that must BOTH be
# pinned — it fires on the shape that actually shipped, and it stays silent on the
# legitimate spellings. A gate that also flagged a ppid read used to identify a parent,
# or the fix's own documentation, is one a later maintainer loosens after the first false
# positive, and a loosened gate catches nothing.
#
#   bash skills/skill-extraction-workflow/scripts/test_liveness_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
note() { fail=$((fail+1)); printf 'FAIL  %s\n' "$1" >&2; }
ok()   { pass=$((pass+1)); }

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

# Run the gate section in isolation rather than standing up a whole synthetic skill tree.
section=$TMP/gate-section.sh
{
  echo '#!/usr/bin/env bash'
  # MUST match the host checker's options, or a section that aborts the real checker
  # still passes every probe here.
  echo 'set -euo pipefail'
  echo 'root="$1"'
  awk '/^# Anti-pattern 28 —/{p=1} p; /^echo "liveness_predicate_scan_ok"$/{if(p) exit}' "$CHECKER"
} > "$section"
grep -q 'liveness_predicate_scan_ok' "$section" \
  || { echo "FAIL: could not extract the gate section from $CHECKER (anchor moved?)" >&2; exit 1; }
grep -q 'ppid=' "$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() { local r="$TMP/$1"; mkdir -p "$r/scripts"; printf '%s' "$r"; }

# The banned spelling is assembled at runtime, never written literally in this file:
# this suite is itself a `test_*.sh` inside the scanned tree, so a literal would make the
# repo's own gate flag its regression test. (The scanner-matches-itself trap.)
PPID_READ='ps -o ppid= -p "$pid"'
VIOLATION='[ "$('"$PPID_READ"' 2>/dev/null | tr -d " ")" = "1" ] && echo orphan'

# --- P1: a clean tree passes ------------------------------------------------
r=$(mk_root clean)
printf '#!/usr/bin/env bash\necho hello\n' > "$r/scripts/test_clean.sh"
run_gate "$r"
if [ "$RC" -eq 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_ok'; then ok
else note "p1 clean tree must pass with the ok token (rc=$RC): $OUT"; fi

# --- P2: the violation fires (the gate's whole reason to exist) -------------
r=$(mk_root violation)
printf '#!/usr/bin/env bash\n%s\n' "$VIOLATION" > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_failed'; then ok
else note "p2 planted orphan-oracle must FAIL the gate (rc=$RC): $OUT"; fi

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

# --- P2c: the hit and the diagnosis must not run together on one line -------
# The sorted-hit list loses its trailing newline to command substitution; without an
# explicit one the last hit and the message concatenate and neither greps cleanly.
if printf '%s' "$OUT" | grep -q '^liveness_predicate_scan_failed'; then ok
else note "p2c the diagnosis must start its own line, got: $OUT"; fi

# --- P3: consulting process state clears it (this IS the documented fix) ----
r=$(mk_root fixed)
{ printf '#!/usr/bin/env bash\n'
  printf 'st="$(ps -o stat= -p "$pid")"\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p3 a state consult within the window must clear the line (rc=$RC): $OUT"; fi

# --- P3b: a *_state helper THIS FILE DEFINES over process state clears it ---
# The real fix's shape: one helper, defined in the same file, reading `ps -o stat=`.
r=$(mk_root fixed_helper)
{ printf '#!/usr/bin/env bash\n'
  printf 'wrapper_state() {\n  ps -o stat= -p "$1"\n}\n'
  printf 'case "$(wrapper_state "$pid")" in live) : ;; esac\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p3b a file-defined state helper must clear the line (rc=$RC): $OUT"; fi

# --- P3c: an unrelated *_state call is NOT remediation ----------------------
# Found by adversarial review: accepting any `*_state` token let a bookkeeping helper
# that never reads process state clear a real hit, so the blocking gate printed ok.
r=$(mk_root fake_helper)
{ printf '#!/usr/bin/env bash\n'
  printf 'record_state "$other_pid"\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_failed'; then ok
else note "p3c an unrelated *_state call must NOT clear the violation (rc=$RC): $OUT"; fi

# --- P3d: a defined helper that does NOT read process state is not remediation
r=$(mk_root hollow_helper)
{ printf '#!/usr/bin/env bash\n'
  printf 'record_state() {\n  echo "$1" >>"$log"\n}\n'
  printf 'record_state "$other_pid"\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ]; then ok
else note "p3d a defined helper that never reads process state must not clear it (rc=$RC): $OUT"; fi

# --- P4: a whole-line comment carrying the spelling is documentation --------
# The checklist row and the gate's own comment block name the banned spelling; a gate
# that flags its own documentation gets loosened.
r=$(mk_root commented)
printf '#!/usr/bin/env bash\n# %s\n' "$VIOLATION" > "$r/scripts/test_doc.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p4 a whole-line comment must not be flagged (rc=$RC): $OUT"; fi

# --- P5: scope is test scripts — a signalling guard elsewhere is legitimate --
# Outside a test, asking whether a pid exists before signalling it is the right
# question; flagging it would trade a real false-positive cost for nothing.
r=$(mk_root nontest)
printf '#!/usr/bin/env bash\n%s\n' "$VIOLATION" > "$r/scripts/helper.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p5 non-test shell is out of scope and must not fire (rc=$RC): $OUT"; fi

# --- P6: a ppid read that IDENTIFIES a parent is not an orphan oracle -------
# The common, correct use. Flagging it is what would make precision collapse.
r=$(mk_root identify)
{ printf '#!/usr/bin/env bash\n'
  printf 'parent="$(%s 2>/dev/null | tr -d " ")"\n' "$PPID_READ"
  printf 'cmd="$(ps -o command= -p "$parent")"\n'
} > "$r/scripts/test_identify.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p6 a ppid read used for parent identity must not fire (rc=$RC): $OUT"; fi

# --- P7: a COMMENT naming the helper must not clear a real violation ---------
# The waiver has to be code that consults process state, not a note saying someone
# should. Found by adversarial review of this gate: the window grep read raw text, so a
# TODO beside the violation made the blocking checker print ok for a line it had found.
r=$(mk_root comment_waiver)
{ printf '#!/usr/bin/env bash\n'
  printf '# TODO: use wrapper_state here instead\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_failed'; then ok
else note "p7 a comment mentioning the helper must NOT clear the violation (rc=$RC): $OUT"; fi

# --- P8: parameter expansion carrying '#' must not be mistaken for a comment --
# Stripping trailing comments with a naive `#`-to-end rule would truncate `${var#pre}`
# and could drop the real state consult that follows it, turning the fix into a hit.
r=$(mk_root hash_expansion)
{ printf '#!/usr/bin/env bash\n'
  printf 'rel="${path#"$root"/}"; st="$(ps -o stat= -p "$pid")"\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p8 a '#' inside parameter expansion must not void the state consult (rc=$RC): $OUT"; fi

# --- P9: the NEGATED assertion is the opposite check and must not fire ------
# `!= "1"` asserts a process is NOT reparented. An unrestricted `.*=` in the predicate
# swallowed the `!`, so the gate flagged the very check that does the right thing —
# found by adversarial review, and the false-positive direction this gate must avoid.
r=$(mk_root negated)
{ printf '#!/usr/bin/env bash\n'
  printf '[ "$(%s 2>/dev/null | tr -d " ")" != "1" ] && echo still-parented\n' "$PPID_READ"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p9 a negated ppid assertion must NOT fire (rc=$RC): $OUT"; fi

# --- P9b: the positive oracle still fires with the tightened operator match --
# Guards the tightening itself: narrowing the operator must not blunt the real catch.
r=$(mk_root still_fires)
printf '#!/usr/bin/env bash\n%s\n' "$VIOLATION" > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_failed'; then ok
else note "p9b the real orphan oracle must still fire after tightening (rc=$RC): $OUT"; fi

# --- P10: a bare `stat=` assignment is not a process-state read ---------------
# Found by adversarial review: the waiver grepped bare `stat=`, so an unrelated
# assignment two lines away cleared a genuine hit and the blocking gate printed ok.
r=$(mk_root fake_stat)
{ printf '#!/usr/bin/env bash\n'
  printf 'stat=unknown\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_failed'; then ok
else note "p10 a bare stat= assignment must NOT clear the violation (rc=$RC): $OUT"; fi

# --- P10b: the genuine `ps -o stat=` read still clears it --------------------
r=$(mk_root real_stat)
{ printf '#!/usr/bin/env bash\n'
  printf 'st="$(ps -o stat= -p "$pid")"\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p10b a real ps -o stat= read must still clear the line (rc=$RC): $OUT"; fi

# --- P10c: the same read clears it whatever follows it in the window -----------
# The waiver once piped the window into `grep -q` under `pipefail`: when text followed
# the matched line, `grep` could exit while the writer still had output, the writer died
# of SIGPIPE, and the gate reported this cleared line. p10b's short window hit that only
# sometimes. A 1 MiB line after the read is more than `grep` reads before it exits, so
# the old form fails here on every run instead of by chance.
r=$(mk_root real_stat_long_tail)
{ printf '#!/usr/bin/env bash\n'
  printf 'st="$(ps -o stat= -p "$pid")"\n'
  printf '%s\n' "$VIOLATION"
  printf 'pad="%s"\n' "$(head -c 1048576 /dev/zero | tr '\0' a)"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p10c a real ps -o stat= read must clear the line even with a long window tail (rc=$RC): $OUT"; fi

# --- P11: a HOLLOW helper plus an unrelated state read elsewhere is not a fix --
# Found by adversarial review: "the file defines *_state" and "the file reads process
# state somewhere" were checked independently, so the two were never tied together and a
# do-nothing helper borrowed an unrelated read to clear a real hit.
r=$(mk_root hollow_plus_elsewhere)
{ printf '#!/usr/bin/env bash\n'
  printf 'wrapper_state() {\n  echo unknown\n}\n'
  printf 'other() {\n  ps -o stat= -p "$1"\n}\n'
  printf 'case "$(wrapper_state "$pid")" in live) : ;; esac\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_failed'; then ok
else note "p11 a hollow helper must NOT borrow an unrelated state read (rc=$RC): $OUT"; fi

# --- P12: a ONE-LINE hollow helper must not borrow a later function's read -----
# Found by the adversarial challenge: the awk rule set inbody and ran `next`, so a
# definition that opens and closes on one line never met its `}` and stayed "in body"
# across the following functions, crediting their state read to the hollow helper.
r=$(mk_root oneline_hollow)
{ printf '#!/usr/bin/env bash\n'
  printf 'wrapper_state() { echo live; }\n'
  printf 'other() {\n  ps -o stat= -p "$other_pid"\n}\n'
  printf 'case "$(wrapper_state "$pid")" in live) : ;; esac\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -ne 0 ] && printf '%s' "$OUT" | grep -q 'liveness_predicate_scan_failed'; then ok
else note "p12 a one-line hollow helper must NOT borrow a later read (rc=$RC): $OUT"; fi

# --- P12b: a genuine ONE-LINE helper that does read state still clears it ------
r=$(mk_root oneline_real)
{ printf '#!/usr/bin/env bash\n'
  printf 'wrapper_state() { ps -o stat= -p "$1"; }\n'
  printf 'case "$(wrapper_state "$pid")" in live) : ;; esac\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p12b a real one-line state helper must clear the line (rc=$RC): $OUT"; fi

# --- P13/P14: the DOCUMENTED limit, pinned rather than left in prose -----------
# These two assert the gate does NOT fire, which is a hole, not a feature: a state read
# of a different pid, or one whose result is discarded, still clears the window. Proving
# a read GOVERNS the verdict needs dataflow over a parsed shell, so the mechanical gate
# stops here by design (recurring-anti-patterns-checklist.md, Anti-pattern 28).
# They are here so the limit is exercised, not merely described: if a future change makes
# the gate stricter these go red, and whoever tightened it must update the checklist
# rather than discover the prose had silently gone stale.
r=$(mk_root limit_other_pid)
{ printf '#!/usr/bin/env bash\n'
  printf 'ps -o stat= -p "$other_pid" >/dev/null\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p13 KNOWN LIMIT CHANGED: a different-pid state read now fires — update the checklist (rc=$RC)"; fi

r=$(mk_root limit_discarded)
{ printf '#!/usr/bin/env bash\n'
  printf 'ps -o stat= -p "$pid" >/dev/null\n'
  printf '%s\n' "$VIOLATION"
} > "$r/scripts/test_probe.sh"
run_gate "$r"
if [ "$RC" -eq 0 ]; then ok
else note "p14 KNOWN LIMIT CHANGED: a discarded same-pid state read now fires — update the checklist (rc=$RC)"; fi

printf 'liveness_predicate_gate: pass=%s fail=%s\n' "$pass" "$fail"
[ "$fail" -eq 0 ] || exit 1
echo "liveness_predicate_gate_ok"
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