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

references/firing-point-placement.md

View on GitHub
# Firing-point placement — worked recurrence-chain + the owner-dispatch implementation

Companion to the **firing-point-placement corollary** in `SKILL.md` (under *Retrospectives, corrections & auto-triggered learning*, in the repeated-user-corrections rule). The Core Rule carries the gates: under-trigger is a tracked failure class; the self-trigger is recognition-dependent (bootstrap raises salience but is not mechanical); the two mechanical backstops (closeout gate + user-signal escalation); and the red-line — when the same meta-class recurs at a *new* sub-point, move the owning gate's firing point ONTO the transition and sharpen *name→invoke*, not more prose. This file carries the **worked recurrence-chain** (the concrete history that justifies the corollary), the **landed mechanical implementation** for the owner-invoke case, and two expansions relocated from the Core Rule: the self-detect firing point's authority boundary + observed shape, and the record-field corollary's forgery-surface mechanics. The gates themselves stay in the Core Rule.

## The worked recurrence-chain (why "move the firing point", not "add another bullet")

The same meta-class — a rule is precise but is walked past at the routing → pre-code-gate / → first-implementation-edit transition — recurred at a *new* lifecycle sub-point each time, despite prior bootstrap-salience and a completion-time closeout gate:

1. **entry-routing** — landed in the bootstrap layer.
2. **impl-entry** — then recurred at the first-implementation-edit transition; landed in the owner workflow.
3. **design-substance ownership** — design produced by the router + an external/codex review, with no owner stack skill invoked.
4. **impl-mechanics ownership** — the impl-owner skill was **named/known but never invoked**, so its own current mechanical rules (e.g. directory-`AGENTS.md` sync) never fired across a multi-slice loop until the user flagged it.
5. **design-gate ownership** — the visible-UI design-gate owner, named in the coordinator's visible-UI checkpoint clause + the stack owner's body but **never invoked** before a visible-UI slice (even though the impl-mechanics owner WAS invoked), so the page-slice gate never ran until the user asked whether the design skill was used.

The lesson: a repeat at a new sub-point signals the prior firing point was under-specified. **Naming/knowing an owner is not invoking/loading it** — a named-but-unloaded owner's mechanical rules never fire. The durable lever is to move the owning gate's firing point ONTO the transition itself (pre-substance-draft AND pre-first-impl-edit) and sharpen *name→invoke* at the SAME transition, rather than adding a downstream bullet or more prose. And note the honest limit: a completion-time "interim until the map exists" check does not fire if the agent produces+completes the substance without ever building the map — so the closeout gate + user-signal escalation remain the real-world backstops (do not overclaim the moved firing point is mechanical).

- For recurring hand-assembled live-input failures, you must place the executable prevention at the existing request builder's pre-dispatch hook and connect that invocation to the testing owner's live-execution step. Route the recipe to `testing-strategy/references/e2e-real-flow-testing.md` (Runtime input preflight); keep product schemas and state adapters in their repository. A shared prose rule is not evidence that the dispatch hook ran.

## The landed mechanical implementation (owner-invoke case)

For the specific owner-dispatch case, the firing point is now **mechanically enforceable where the plugin hooks are present** (not merely prose):

- `owner-dispatch` PreToolUse/Stop hooks (`hooks/owner-dispatch-guard.sh`, `hooks/owner-dispatch-stop.sh`) gate the first product-code edit and session close.
- **Subagent extension** (delegated workers are a separate firing surface — SessionStart routing is NOT inherited by subagents, so a cold worker never sees the gate): `SubagentStart` (`hooks/subagent-start.sh`) injects a slim self-gating routing pointer, and `SubagentStop` reuses `owner-dispatch-stop.sh` (PreToolUse already fires inside subagents) with `agent_id`-scoped, actor-precise markers/cap so the invoke-owner backstop applies one level down for a worker's **path-attributable** gated Edit/Write (Bash-only and missing-baseline cases stay advisory under the session Stop, not SubagentStop). This closes the recurrence where `multi-agent-delegation` had to *manually* inject owners into every worker prompt (`skills/multi-agent-delegation/SKILL.md` Core Rules) and the user reminded when it was forgotten.
- **Extraction owner at the first shared-skill edit:** the default source-edit checkpoint (`hooks/skill-loading.py`) recognises a target on a ccl-skills checkout's `skills/`, `hooks/` or root `scripts/` surface (markdown included there only; the marker is probed at every such component, so a checkout under an ancestor carrying one of those names still counts; plugin-cache and `.codex` install copies excluded — the stop backstop's scope, which this round aligned) and, while `skill-extraction-workflow` is not loaded in the current context, names it and the charter-before-editing step in its one replan. Observed miss it answers: a shared-gate bug routed to its debugging owner satisfied the generic checkpoint, and the extraction backstop in `hooks/skill-extraction-gate-stop.sh` fired only at Stop, after commit, push and pull request. A `Bash` command that writes a markdown or source file on that surface reaches the same checkpoint, while the extraction owner is not loaded. It shares the edit tools' attempt, so a context still gets one replan in total. The write targets come from literal words of known write forms: redirection, `tee`, in-place `sed`/`perl`, `cp`/`mv`/`install`/`ln`/`rsync`, `touch`/`rm`, `git mv`/`git rm`, and inline interpreter writes. Read-only commands, writes elsewhere and quoted metacharacters never spend the attempt. Limits: one replan per actor/context. Shell detection is best effort: variables, `find -exec`, `xargs` and scripts that write internally still reach only the Stop backstop. It cannot prove the charter was written.
- No merge-time backstop. A `ci` subcommand once required every gated change to update one committed map file. Requests that each appended a section to that file then conflicted with each other, and the check proved only that the file changed, never that an owner was loaded. A transcript measurement found the Stop check on declared owners was the layer with effect: a declared but unloaded owner was then loaded after most such blocks. Engine: `scripts/owner-dispatch/owner-dispatch.sh`; rationale and safety posture: `scripts/owner-dispatch/README.md`.

This is the worked example of moving an already-precise recognition-dependent gate ONTO the transition. **Honesty preserved — enforcement is partial, not total:** opt-in per product repo (`.owner-dispatch.json`), default `ask`, fail-open, Claude-hook-hard / Codex-advisory, in-session Bash-write detection is best-effort and nothing else gates what it misses, and the whole thing is a no-op on the generic Agent-Skills channel. So it raises enforcement where the plugin hooks load, but the closeout gate + user-signal escalation remain the backstop everywhere they do not. The opt-in gap itself is now narrowed by a **closeout-acquire check** in `product-rd-workflow` (a gated multi-owner delivery whose repo lacks `.owner-dispatch.json` installs the backstop or records exempt at closeout) — so "silently absent" is caught, though still recognition-dependent at closeout, not a hard gate.

When a future recognition-dependent gate recurs:

- Prefer an in-session hook over more prose.
- A backstop beside that hook must check a property the agent cannot satisfy just by writing a declaration; a check that only sees an agent-written record exist or change proves only that it was written.

## Recursive worked example: the gate's own agent-facing guidance must also sit at the seen surface

The same placement principle applies to the *guidance about the gate*, not only the gate. The clarification — *a `deny`/`ask`/`Stop` is the agent's to clear by invoking owners + `record`, **not** a user-authorization prompt (it clears only this gate; merge/push/destructive/scope/product decisions still need the user); and `strict:true` is a maintainer/committed-config decision, not an agent prompt-reduction knob* — originally lived only as `scripts/owner-dispatch/README.md` prose. An agent does not auto-read reference files, so it misread the runtime `ask` prompts as per-edit *user* authorization and pushed the approvals onto the user. Fix: move that one-liner onto the surfaces the agent actually reads at the firing moment — the `deny`/`ask`/`Stop` **message text** and the always-on `agent-context/session-start.md` — keeping the full rationale in the README. Same lesson, one level up: a precise clarification in an unread doc does not fire; place it where it is seen when it matters.

## The self-detect firing point — authority boundary and observed shape (relocated from `SKILL.md`)

When the self-detect firing point fires (your own output names 沉淀 / 提炼 / 复盘 / "distil this into a skill" as a recommended or deferred next action), concretely: invoke the workflow and do the read-only part (charter, RCA, owner map) rather than parking it as a low-priority follow-up; but **shared-skill edits still need the authority you already have** — when the user's request covered only a status review or a narrow fix, record the extraction as `pending` with the owner named and ask, instead of self-authorising a shared-skill change off your own suggestion. Observed shape: the agent proposes "沉淀方法论" as one of several optional next steps, the user answers "是应该沉淀", and only then is the workflow invoked — so recognition was owed one turn earlier, while the edit authority arrived with the user's answer.

### The output-shape sibling — your own deliverable names the owner the entry phrasing did not

The self-detect firing point above triggers on what your output *mentions*; this one triggers on what your output *has become*. Entry phrasing and deliverable shape diverge routinely — the request reads as a narrow how-to ("how do I configure X"), and the answer grows into candidate comparison, rejection rationale, and a recommendation. At that point the deliverable is a selection/assessment artifact regardless of how the request was worded, and the owner that governs it never entered.

Walk these three shapes against your own draft — holding them as one conjunction is what fails, so check them one at a time. Any single hit means the deliverable is a selection/assessment artifact regardless of how the request was worded:

Throughout, **candidate** means a component, service, product, library, vendor, or replacement that is actually up for selection — never a configuration value, parameter, or technique when nothing is being selected. Comparing fixed delay with exponential backoff inside a how-to is not a candidate comparison.

- Named candidates compared side by side.
- An adopt / reject / replace verdict on a named candidate — "just use X" counts, with or without a comparison.
- As-is evidence gathered across several artifacts to support such a verdict.

- **On any hit, re-judge the entry owner before writing further** — you must not keep writing under the initial narrow classification, because the gates that would have constrained the work (research routing before a selection verdict, named-source-plus-freshness discipline on as-is claims) hang off that owner; with no owner in play, none of them fire, and the output looks complete while resting on unexamined evidence.

A fourth trigger on recommendation *wording* was tried and removed: it kept firing on ordinary how-to advice that prefers one configuration value or technique over another ("enable jitter", "prefer exponential backoff over fixed delay") while adding no coverage, because recommending a named candidate is already an adopt verdict. The three that remain key on the deliverable's SHAPE, which is what this section is about; a wording-keyed trigger drifts back toward matching phrases.

Observed shape: an entry judged as configuration how-to produced several rounds of candidate comparison and a recommendation; the current-state evidence discipline and the research-routing rule both stayed dormant for the whole stretch, surfacing only when the user challenged what the conclusion rested on. Same honesty bound as the rest of this section — this is recognition-dependent and must not be overclaimed as a mechanical gate; what is self-checkable is the shape of your own output, not the intent behind the request.

## The record-field corollary — expansion (the forgery surface, relocated from `SKILL.md`)

When you land an owner gate as a *field in a record* — a checklist row, a boundary-record line, a CLI flag taking owner names, a "decision:" slot — that field is fillable without invoking the owner, and filling it is what *feels* like discharging the gate, so the record reads complete while none of the owner's mechanical rules fired. Any field naming an owner therefore carries an explicit invoke bar on its triggered values, and the coverage question is a **set-diff over every owner-naming field in that record**, not a fix for the one owner that just failed (the recurrence shape: a record whose salient fields carry the bar while its siblings silently do not). Prefer a firing point the controller cannot route around: when the gated action produces no local artifact — delegation dispatch being the worked case, where substance is produced by a worker and the controller edits nothing — every edit-triggered and dirty-tree-triggered backstop stays silent, so the gate must hang on the action itself (`hooks/guard-delegation-owner.sh` asks once per session at dispatch when the delegation owner was never invoked).

### The option-set sibling (a menu whose every choice violates a standing gate)

Same forgery surface, one step earlier: instead of filling a field, the agent **asks the user to choose** — and every option it drafted violates a rule that was already mandatory. The user's selection then reads as authorization, so the violation lands wearing a decision it never needed. This is strictly worse than filling a field alone, because the record now carries a human's name on it.

Observed shape (round 059): a distillation round asked the user how a reusable cross-line lesson should land and offered three options — write it into per-line memory, build a sync mechanism, merge the two stores. The Core Rules already required a **shared** artifact and explicitly classify a memory-only landing as insufficient, so no option on the menu could be chosen legally. The user caught it by asking "不是到共享技能么"; nothing in the workflow would have.

The bar: **before offering the user a choice, check each drafted option against the standing gates for that decision, and drop or relabel any option that a rule already forbids.** A menu is a claim that every item on it is permissible. If the gates leave only one legal option, that is not a decision to delegate — do it and say why the alternatives were unavailable; if they leave none, the gate itself is what needs the user's ruling, and that is the question to ask instead. The recurrence signal is a user correction that names a rule rather than a preference ("shouldn't this go to X?"), which is a gate-violation report, not a change of mind — classify it as `failure/correction` and run the correction RCA rather than simply re-asking with a better menu.

### The IMPOSSIBLE-invocation value (a bar with no legal third value forges itself)

An invoke bar — or a mandatory-read/mandatory-load gate ("read `X.md` before answering") — **that names no legal value for the case where the invocation is IMPOSSIBLE (no file tool in this session, artifact absent, load fails) forges itself.** Such gates are usually written as a pair: skipping the read is forbidden AND answering from memory is *also* a violation. When the read is unavailable, every action the agent can take is a violation, so the cheapest exit is to assert the gate was satisfied — and if the gate's evidence is a fixed attestation string, that string is emitted by an agent that read nothing and the record reads compliant to every downstream consumer.

So every such gate defines a **third legal value — an unavailable form textually distinct from the satisfied form** (`依据: 不可得(<reason>)` vs the satisfied `依据: <path>`). Two placement rules make it real:

- The unavailable value must sit on a surface still reachable when the artifact is not — the `SKILL.md` or always-on layer; a branch written only into the file you cannot read never fires.
- The gap that value records is the risk owner's to close: the agent must not self-accept it, and the requesting party must not either — a requester who can self-accept can trigger or claim a read failure and bypass the gate entirely.

Honest scope, from the eval that landed this (2 arms x 5 fixtures x 6 samples in a genuinely tool-restricted environment, oracle canary-validated): adding the third value moved the **record form** (legal unavailable record 0/30 -> 29/30; ad-hoc refuse-and-leave-blank 18/30 -> 0/30), and did **not** demonstrate a drop in fabrication — the motivating "agent claims it read the file" did not reproduce at all (0/30 in the unpatched arm, where an always-on no-evidence-no-completion-claim layer was present). Claim the auditability gain, not a forgery-prevention gain; if a true 10% fabrication rate is suspected, 0/30 is only ~4% likely under it, so the premise is weakened for that configuration, not refuted for every host.


## The tool-skill-masks-deliverable-owner variant — a loaded platform/tool skill is not the deliverable owner

Observed shape: a session produces a reader-facing deliverable end-to-end through a platform/tool skill pack (a collaborative-doc platform, spreadsheet, or browser pack), and the loaded tool skill supplies enough "already being guided" feeling that nobody ever asks which skill owns the DELIVERABLE's quality bar — so the finalization owner's gates (doc charter, completeness audit, closeout sweep, structural-reference re-resolution) stay dormant for the whole effort, surfacing only when the user asks "did you run the doc-optimization skill". This is the behavioral twin of the digest-masks-corpus trap: the tool layer's presence masks the owner layer's absence.

Firing point: **producing or first-publishing a reader-facing deliverable is an owner-check transition** — before the first publish to a collaborative or reader-visible surface, answer "which skill owns this deliverable's quality bar" as a separate question from "which tool writes it"; a tool-skill invocation never discharges that check, and a deliverable with no matching owner routes to the finalization skill's Draft mode rather than proceeding ownerless. Mechanical anchors: the no-owner-deliverable triggers on the finalization skill's routing surface (`tighten-doc` description), and this workflow's closeout gate when the session later lands skill changes. Honesty bound as elsewhere in this section: between those anchors the check is recognition-dependent — do not overclaim it as a mechanical gate.

## gap-list 形态为什么最易滑过

自检触发点列举的是「沉淀 / 提炼 / 复盘 / distil」这类**自述措辞**。但一轮提炼最常见的第一个产出不是这些词,而是**一张缺口清单**——「外部源有 X、Y、Z,我们没有」。它读起来像在**答一个覆盖问题**,不像在提炼,所以 charter-before-findings 那条规则从不觉得被触发。

但按该规则自己的定义,**针对外部源的缺口清单就是它所说的 findings 回合**:一旦产出,charter 就只能事后补写。

观测实例:一轮里先产出四条「外部有我们没有」的缺口,之后才 invoke 提炼工作流;改前的触发词表逐字检索该轮实际措辞得零命中。

## The review-chain case — the owning skill is not loaded where the situation arises

The same-class-recurrence rule is owned by this workflow, but the situation it governs —
findings coming back round after round — arises inside a `code-review` chain, where this
skill is typically never loaded. Naming the owner in prose therefore never made it fire.
The trigger sits at the transition instead:

- **The controller must raise it, not the reader:** when a round returns findings and the
  history it carries already holds one, the gate adds `recurring_findings_design_check` to
  that round's required self-review triggers and `decide_keep_delete_narrow_replace` to its
  allowed actions, in the round's own envelope
  (`../../code-review/references/staged-review-contract.md`). What discharges it is the
  `keep` / `delete` / `narrow` / `replace` decision the owning rule defines, ratified by a
  risk owner other than the one proposing it.
- **What it counts is bounded by what a receipt carries:** the chain the controller is
  handed, plus the predecessor a succession names. Succession does not compose, so a third
  chain opened fresh carries no history and the controller claims none; from there the
  recurrence is the round's own record to keep.
- **It over-fires by design:** two findings rounds need not share a risk class, so the
  question is sometimes inapplicable. Answering an inapplicable question costs a line; the
  round a missed design question costs does not.
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: 472kUpdated 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