forge-fix
Apply fixes from the most recent forge-verify findings document. Use when user runs /feature-forge:forge-fix or asks to apply verification fixes for a forge feature. Do NOT trigger for general code fixes, bug fixes, or repairs outside the forge verification workflow.
- License 许可
- MIT
- 最近更新
- 2026-10-15
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- forge-fix
- metadata
- { "argument-hint": "<feature-name> [--served-stage <production-stage>]" }
- description
- Apply fixes from the most recent forge-verify findings document. Use when user runs /feature-forge:forge-fix or asks to apply verification fixes for a forge feature. Do NOT trigger for general code fixes, bug fixes, or repairs outside the forge verification workflow.
03 SKILL.md 正文
forge-fix — Apply Verification Fixes
Apply fixes from the most recent forge-verify findings document, with step-level tracking for crash recovery.
Usually invoked by the user. An autoFix caller may also dispatch this skill automatically when autoFix: true is configured and its preconditions hold (the findings document has zero unresolved decision points, the working tree is clean, and a mandatory re-verify passes afterward). Two callers drive that chain: an authoring stage's in-stage auto-verify (the primary path — see references/stage-exit-protocol.md, the in-stage verify block) and the /feature-forge:forge navigator's catch-up (§3b). The fix application below is identical either way — this skill is not "auto-aware" about applying findings; it always applies the selected findings document. What differs is branch ownership, and ownership is read from the literal owner: token described under Prerequisites, never inferred from how the invocation happened to be phrased.
Prerequisites
Read and follow references/shared-conventions.md for feature name validation, configuration reading, and force mode handling before proceeding.
Ownership. Determine branch ownership at entry, from the literal owner: nested / owner: direct token in the prompt that dispatched you. Absent the token you are direct — a user-typed /feature-forge:forge-fix is the only path that carries no dispatcher. Judge the token, never the phrasing of the invocation. Preserve that value unchanged through any re-verify and pass it straight through as --owner in Step 7. A direct fix stays the terminal owner through its optional re-verify; a nested fix invokes nested verify and returns its structured result to the outer stage, printing no terminal block at all. references/stage-exit-protocol.md § "Branch ownership: the owner: token" owns this rule.
Turn structure reminder: Text first, then {{ASK_TOOL}} for all questions — never embed one in your text (it stalls). At rung 2/3, see the Interaction Capability Ladder.
Step 1: Locate Findings and Establish the Served Stage
- Read
forge.config.jsonforspecsDir(default:./specs) - Resolve the feature directory via the Feature Directory Resolution block in
references/shared-conventions.md(a standalone feature resolves to its flat{specsDir}/{feature}/path exactly as today; an epic member resolves to its nested path). Then find the most recentVERIFY-*-*.mdfile in{resolvedFeatureDir}/.verification/. - Establish the served production stage before any mutation, in this order:
- An explicit
--served-stage {stage}argument on this invocation is authoritative — that is whatforge-verifyand the scripted exit pass when they route here. - Otherwise read it from the selected report's own mode/header: the
{mode}in itsVERIFY-{mode}-{YYYY-MM-DD}.mdname together with the mode recorded in the report header, mapped asepic→forge-0-epic,prd→forge-1-prd,tech→forge-2-tech,specs→forge-3-specs,backlog→forge-4-backlog,impl→forge-5-loop. - If both are present and disagree, fail closed rather than picking one.
- Never derive the served stage from conversational context, from
currentStage, or from whichever feature stage happens to be newest. The report you are applying decides which stage this diversion serves.
- An explicit
- An unestablishable served stage is a fail-closed error, not a guess. If a report exists but its mode is missing, malformed, or ambiguous (for example two same-day reports for different modes, or a header whose mode does not match the filename) and no explicit
--served-stagewas supplied, mutate nothing: list the reports you found and tell the user to re-invoke as/feature-forge:forge-fix {feature} --served-stage {stage}or to re-run/feature-forge:forge-verify {feature} {stage}. Stop there — with no served stage there is no stage to close against, so do not run Step 7. - No applicable findings →
no-findings. If.verification/holds no findings document, or none whose steps still apply, the outcome isno-findings: mutate nothing and take the served stage from authoritative pipeline state — the production stage whosestages.forge-verify-*entry is unresolved (findings-reported,findings-applied,auto-verify-pending, orpending) — then close through Step 7. If no verification is outstanding either, there is nothing for this pass to serve: tell the user "No verification findings found. Run/feature-forge:forge-verify {feature}first." and stop without closing a stage.
Step 2: Parse Fix Execution Plan
- Read the "Fix Execution Plan" section of the findings document
- Identify all execution steps and their dependencies
- Check for a
## Fix Progresssection at the bottom of the findings document — if present, some steps were already applied in a previous interrupted run - Assert the plan covers every finding before any fix executes. Exit 1 is that assertion firing, not a tool failure; only exit 2 is a tool failure. Run:
R="$(bash -c '[ -z "${FEATURE_FORGE_ROOT:-}" ] || [ -x "$FEATURE_FORGE_ROOT/scripts/forge-root.sh" ] || { echo "feature-forge: FEATURE_FORGE_ROOT=$FEATURE_FORGE_ROOT has no scripts/forge-root.sh" >&2; exit 2; }; for d in "${FEATURE_FORGE_ROOT:-}" "${CLAUDE_PLUGIN_ROOT:-}" "$HOME"/.claude/skills/feature-forge "$HOME"/.claude/plugins/cache/*/feature-forge/* "$HOME"/.claude/plugins/*/feature-forge "$HOME"/.agents/skills/feature-forge ./.agents/skills/feature-forge; do [ -x "$d/scripts/forge-root.sh" ] && exec "$d/scripts/forge-root.sh"; done')"
[ -n "$R" ] || { echo "feature-forge: cannot locate plugin root" >&2; exit 1; }
python3 "$R/scripts/fix-sweep.py" plan-coverage "{resolvedFeatureDir}/.verification/{findingsFile}" --json
Exit 0 with "applicable": false means the document declares no findings set or no plan to assert — proceed silently. Exit 1 → surface the named uncovered findings and any claimed N, actual M total mismatch, then resolve each one through {{ASK_TOOL}} per the Decision Support protocol in references/shared-conventions.md: either author a covering execution step into the Fix Execution Plan and execute it in this pass's Step 4, or record an explicit justification against that finding in the findings document. Never resolve a mismatch by editing the claimed total to match — re-derive which finding is missing and name it. Any finding still uncovered when you stop closes with decisions in Step 7, no advancement. Exit 2 → surface the Error: line verbatim and close with failed.
Step 3: Handle User Decisions
If the "User Decisions Required" section has unresolved items:
- Present each decision to the user with the context from the findings, using {{ASK_TOOL}} for each decision point. Follow the Decision Support protocol in
references/shared-conventions.md: lead with a recommended option and put the trade-off in each option's description. When the findings provide clear evidence, recommend with confidence and cite it. When they don't, still offer a sensible default with the trade-offs, but flag it plainly as a judgment call rather than going neutral — a defaulted recommendation beats an unguided option dump. - Wait for answers before proceeding
- Record decisions in the findings document under the "User Decisions Required" section (mark each as resolved)
If any decision is still unresolved when you stop — the user deferred it, the question mechanism was unavailable, or no answer arrived — do not apply the steps that depend on it. Close with decisions in Step 7: that is the specific outcome for unanswered decisions, it never advances the pipeline, and its resume action names the unresolved work. A user who explicitly defers the whole fix pass is deferred instead; an operational failure that is not merely an unanswered decision is failed (Step 7).
Step 4: Execute Fix Steps
For each step in the "Execution Steps" section, in order:
- Check if already applied: If the step appears in the "Fix Progress" section as
[APPLIED], skip it - Check dependencies: If the step depends on another step, verify that step is marked as applied
- Apply the fix: Execute the change described in the step's "Action" field
- Verify the change: Re-read the modified file and check that the change is correct and consistent with the step's rationale
- Record progress: Append to the
## Fix Progresssection at the bottom of the findings document:- Step {N}: [APPLIED] {date} — {short summary of what was done} - If a step fails or produces unexpected results, STOP. Report the issue to the user. Do not continue to dependent steps. Any applied step stays recorded in
## Fix Progressso a later run resumes rather than repeats, and this run closes withfailedin Step 7 — no advancement.
Shipped comments state intent, never measurement (anti-churn). A fix pass writes no empirical or quantified claims into comments, docstrings, or test narration — no "measured", "probed and confirmed", no counts of what was checked, no blanket claims over enumerated cases. Every such claim is a fresh falsifiable surface for the next verify round; a chain of them is exactly how a fix loop stops converging. Shipped prose states what the code intends and what constraint binds it. The evidence — what was probed, how, with what result — belongs in the findings document's ## Fix Progress entry (and the commit message), which are the sanctioned records for acceptance evidence.
Closing sub-step — sweep for surviving occurrences of what you just corrected. After the last plan step is applied and BEFORE Step 5 commits anything, while the working tree is still dirty, sweep this fix's own delta for text you removed that survives elsewhere. Pass no flags beyond --json — the exclusions the script applies by default are the correct ones in both a plugin repository and a consumer repository. Exit 1 means survivors were found: that is the sweep working, not a tool failure. Run:
R="$(bash -c '[ -z "${FEATURE_FORGE_ROOT:-}" ] || [ -x "$FEATURE_FORGE_ROOT/scripts/forge-root.sh" ] || { echo "feature-forge: FEATURE_FORGE_ROOT=$FEATURE_FORGE_ROOT has no scripts/forge-root.sh" >&2; exit 2; }; for d in "${FEATURE_FORGE_ROOT:-}" "${CLAUDE_PLUGIN_ROOT:-}" "$HOME"/.claude/skills/feature-forge "$HOME"/.claude/plugins/cache/*/feature-forge/* "$HOME"/.claude/plugins/*/feature-forge "$HOME"/.agents/skills/feature-forge ./.agents/skills/feature-forge; do [ -x "$d/scripts/forge-root.sh" ] && exec "$d/scripts/forge-root.sh"; done')"
[ -n "$R" ] || { echo "feature-forge: cannot locate plugin root" >&2; exit 1; }
python3 "$R/scripts/fix-sweep.py" sweep --json
Disposition every hit before Step 5. Each hit names the file, the line, and the removed text it matched, so nothing needs re-deriving. Give every hit exactly one disposition — FIXED (you corrected the survivor now, in this pass, so the edit joins this same delta), JUSTIFIED: {reason} (it stands by decision: a deliberate quote, a historical or audit record), or FALSE-POSITIVE: {reason} (the match is not the corrected claim) — and record the sweep with its dispositions in the ## Fix Progress section of the findings document, in this shape:
- Sweep: {date} — {K} needle(s), {N} survivor(s), {M} disposition(s)
- {file}:{line} — "{matched removed text}" → FIXED {date}
- {file}:{line} — "{matched removed text}" → JUSTIFIED: {reason}
- {file}:{line} — "{matched removed text}" → FALSE-POSITIVE: {reason}
Detection is mechanical; disposition is judgment — a hit is a candidate, not automatically a defect. When you cannot classify a hit confidently, route that hit through {{ASK_TOOL}} following the same Decision Support protocol as Step 3: lead with a recommended disposition and put the trade-off in each option's description. A survivor left awaiting a user decision closes with decisions in Step 7; a survivor you can neither fix nor justify closes with failed; a fully dispositioned sweep leaves this pass on whatever outcome it otherwise maps to.
Re-run the sweep once when a disposition edited files. Those edits joined the same delta, so run the same command again to confirm they introduced no fresh survivors, and append a second - Sweep: block for the re-run. A hit already dispositioned JUSTIFIED or FALSE-POSITIVE — same file, same matched text — legitimately re-appears and needs no second disposition. A re-appearing hit that was dispositioned FIXED means the fix did not remove every occurrence: re-disposition it — correct it now, or close with failed — never leave it recorded as FIXED. One re-run is enough: do not loop. Exit 1 with no JSON payload on stdout is a crash, not survivors — surface the stderr traceback and close with failed.
The sweep is never silent. When the payload reports "skipped": true (exit 0 — no delta was available), append the visible notice - Sweep: NOT RUN — no git delta ({reason}) under ## Fix Progress, using the payload's reason verbatim, and continue on this pass's normal outcome. A skip is not a failure; exit 2 is — surface its Error: line verbatim and close with failed.
Step 5: Record the Fixes Through state-verify and Commit
Never hand-author a verify entry, and never write a verifiedStageVersion value by hand. Record the fix pass with the state-verify verb described in the Pipeline State Protocol in references/shared-conventions.md, which owns its full flag surface, its status matrix, and the exit-2 failure protocol. --stage names the served production stage established in Step 1. findings-applied deliberately clears verifiedStageVersion and refuses --verified-stage-version: applying fixes is not verifying them, so the served stage's verification stays outstanding until a re-verify passes. Add --epic "{epic}" when the feature is an epic member — required, per the Pipeline State Protocol; omitting it for a member is an error and must never fall back to a same-named flat feature.
R="$(bash -c '[ -z "${FEATURE_FORGE_ROOT:-}" ] || [ -x "$FEATURE_FORGE_ROOT/scripts/forge-root.sh" ] || { echo "feature-forge: FEATURE_FORGE_ROOT=$FEATURE_FORGE_ROOT has no scripts/forge-root.sh" >&2; exit 2; }; for d in "${FEATURE_FORGE_ROOT:-}" "${CLAUDE_PLUGIN_ROOT:-}" "$HOME"/.claude/skills/feature-forge "$HOME"/.claude/plugins/cache/*/feature-forge/* "$HOME"/.claude/plugins/*/feature-forge "$HOME"/.agents/skills/feature-forge ./.agents/skills/feature-forge; do [ -x "$d/scripts/forge-root.sh" ] && exec "$d/scripts/forge-root.sh"; done')"
[ -n "$R" ] || { echo "feature-forge: cannot locate plugin root" >&2; exit 1; }
python3 "$R/scripts/forge-session.py" state-verify \
--feature "{feature}" --stage "{servedStage}" --status findings-applied \
--specs-dir "{specsDir}"
Stage every disposition-edited path explicitly. Commit 1's staging scope is the feature directory only, so a survivor you fixed outside it (Step 4's sweep) would otherwise be left uncommitted. Before committing, run one git add <path> per file recorded as FIXED in the sweep record — enumerated, one path at a time, never git add -A and never git add .. Those fixes then ride Commit 1 alongside the findings document that records them, and the tree is left clean for the re-verify and for the next stage's dirty-tree check.
Then follow the Git Commit Protocol in references/shared-conventions.md. If gitCommitAfterStage is true, stage files (git add {resolvedFeatureDir}/ — or {specsDir}/{epic}/ for an epic member so the member-state change commits atomically with the epic subtree) and commit with message "{commitPrefix}({feature}): apply {mode} verification fixes". That is Commit 1, and the write above already recorded commitHash: null for it.
Two-commit provenance — never --amend. Record the provenance of Commit 1 in a second state-verify call, passing the full 40-character hash — an abbreviation is refused rather than expanded, and this call touches nothing but commitHash. Add --epic "{epic}" when the feature is an epic member — required, per the Pipeline State Protocol.
R="$(bash -c '[ -z "${FEATURE_FORGE_ROOT:-}" ] || [ -x "$FEATURE_FORGE_ROOT/scripts/forge-root.sh" ] || { echo "feature-forge: FEATURE_FORGE_ROOT=$FEATURE_FORGE_ROOT has no scripts/forge-root.sh" >&2; exit 2; }; for d in "${FEATURE_FORGE_ROOT:-}" "${CLAUDE_PLUGIN_ROOT:-}" "$HOME"/.claude/skills/feature-forge "$HOME"/.claude/plugins/cache/*/feature-forge/* "$HOME"/.claude/plugins/*/feature-forge "$HOME"/.agents/skills/feature-forge ./.agents/skills/feature-forge; do [ -x "$d/scripts/forge-root.sh" ] && exec "$d/scripts/forge-root.sh"; done')"
[ -n "$R" ] || { echo "feature-forge: cannot locate plugin root" >&2; exit 1; }
python3 "$R/scripts/forge-session.py" state-verify \
--feature "{feature}" --stage "{servedStage}" \
--commit-hash "$(git rev-parse HEAD)" --specs-dir "{specsDir}"
On exit 2 nothing was recorded: surface the Error: line verbatim together with the named feature (and epic), do not claim the fixes were persisted, and close with failed in Step 7 — the verify entry is unchanged, so no success block may be printed. A failed validation or a failed commit is failed for the same reason.
Step 6: Re-verify Gate
Fixes are applied and recorded as findings-applied. That status makes no claim of freshness: the writer clears verifiedStageVersion, so the served stage's verification stays outstanding in the navigator's ledger, and only a re-verify that passes resolves it. Because a re-verify is the one thing that confirms the fixes actually resolved the findings, on a direct invocation prompt for it rather than leaving it as a passive suggestion — this is the same Standard Verify Gate the stage skills stamp (references/stage-exit-protocol.md).
A nested owner presents no gate. Return your structured result (served stage, outcome applied, findings file, steps applied) to the outer caller — it performs the mandatory re-verify itself — and print no terminal block of your own. This follows from the owner: token read at entry; it is never decided by how the invocation was phrased.
On a direct invocation, present the gate with {{ASK_TOOL}} using these three options — but only when your verify capability is interactive (Step 7):
- Re-verify {feature} now (recommended) — dispatch the clean-room
forge-verifiersubagent from this session in require-clean mode to confirm every finding is resolved. The dispatch is scoped per "Re-verify scope and convergence" inreferences/stage-exit-protocol.md: it confirms the prior report's findings against their acceptance evidence and examines this fix's delta — never a fresh full-checklist sweep — a finding with a recorded decision is never re-filed, and only an unresolved prior finding or a new blocking defect the fix introduced may block. The digest returns here so any remaining issue keeps its context. One-time — it does not change config. A clean-or-advisory-only result closes asreverified; unresolved prior findings or new blocking defects close asreverify-findingsfor the same served stage. Escalation: if that would be the second consecutivereverify-findingsfor this served stage (count the round-discriminated reports in.verification/), follow "Escalation (the round ledger)" inreferences/stage-exit-protocol.mdbefore closing — present the digest and offer explicit acceptance of the residual findings; do not recommend another fix pass. - Re-verify now + enable auto-verify going forward — re-verify now and patch
"autoVerify": trueintoforge.config.jsonin place (preserve formatting and every other key) so future stages verify automatically, no prompt. This complements theforge-initopt-in. Do not auto-commit this config change — treat it likenotes: a user-facing edit the user commits on their own cadence, never folded into a stage's artifact commit. Its outcome mapping is identical to the option above. - Skip for now — an explicit deferral of the re-verify. It closes as
deferred, neverreverified: the fixes are recorded but nothing has confirmed them, and the served stage's verification stays outstanding until a re-verify passes, so the pipeline does not advance on this pass. Run/feature-forge:forge {feature}when you want pipeline status.
Manual capability is not a skip, and not a deferral. When your capability is manual (Step 7 — no question mechanism and no permitted dispatch), do not run clean-room and do not fabricate a choice nobody made: close with applied, and the script prints /feature-forge:forge-verify {feature} --served-stage {servedStage} as the primary action for the user to run. Offer the auto-verify enable as plain text only if a config write is possible.
A re-verify that cannot run is an operational failure. If the user chose to re-verify and the dispatch is refused, returns the CLEAN_ROOM_UNAVAILABLE sentinel, or returns no answer, the fixes remain recorded but nothing was confirmed: close with failed. Never report reverified on an unrun verify, and never treat an unavailable tool as an explicit user skip.
Step 7: Close the Stage
Ownership. Pass the owner: nested / owner: direct value read at entry (absent the token: direct) straight through as --owner. As a direct owner you print the script's NEXT-STEPS block verbatim as your absolute final output, with nothing after its sentinel line. As a nested owner the payload carries terminalOwnedBy: "outer" and nextSteps: null: return your structured result to the caller and print no terminal block at all.
Served stage. Pass the stage established in Step 1 as --served-stage, so every branch command carries the diversion's thread forward. Never re-derive it here.
Capability. Determine --verify-capability per Host and capability determination in references/stage-exit-protocol.md (summarized under Verify Capability in references/shared-conventions.md): pass interactive only when a question mechanism equivalent to {{ASK_TOOL}} is available and dispatching a clean-room forge-verifier is permitted right now — otherwise manual. That reference owns the full rule (permission-not-presence, why a consent-only bar is still interactive, and the none-gate consent variant). Applied here: an auto-verify or re-verify directive under a no-unsolicited-dispatch bar is presented through the Step 6 gate and dispatched on the affirmative choice — never skipped, and never resolved by closing with an outcome that advances the pipeline.
Outcome. Derive the --outcome from the settled on-disk record, never by eyeballing conversational state. For a production-stage served stage ({servedStage} is forge-1-prd…forge-5-loop, whether or not --epic also applies), after Step 5's state-verify write run select-outcome --skill fix — it reads the verify entry and the latest report (including its ## Fix Progress) and returns {outcome, reason, evidence}. Three outcomes turn on facts disk cannot record, asserted with flags: --op-failure (a fix step, validation, commit, or state write failed — Steps 4–6; a cancellation or unavailable tool is a failure, never a skip), --user-deferred (the user explicitly deferred the fix pass or the re-verify — Steps 3, 6), and --decisions-open (user decisions remain unresolved — Step 3). Everything else — no-findings, applied, reverified, reverify-findings — is pure disk derivation; on exit 2 the disk names no terminal result and no signal was given, so surface its Error: line rather than guessing. An epic-mode served stage (forge-0-epic, from an epic-mode findings report) is out of the verb's scope — that verification lives in .epic-state.json, so the verb rejects forge-0-epic; choose the --outcome directly per the ### fix mapping. The seven-outcome mapping and each outcome's authoritative downstream action live in references/select-outcome.md.
R="$(bash -c '[ -z "${FEATURE_FORGE_ROOT:-}" ] || [ -x "$FEATURE_FORGE_ROOT/scripts/forge-root.sh" ] || { echo "feature-forge: FEATURE_FORGE_ROOT=$FEATURE_FORGE_ROOT has no scripts/forge-root.sh" >&2; exit 2; }; for d in "${FEATURE_FORGE_ROOT:-}" "${CLAUDE_PLUGIN_ROOT:-}" "$HOME"/.claude/skills/feature-forge "$HOME"/.claude/plugins/cache/*/feature-forge/* "$HOME"/.claude/plugins/*/feature-forge "$HOME"/.agents/skills/feature-forge ./.agents/skills/feature-forge; do [ -x "$d/scripts/forge-root.sh" ] && exec "$d/scripts/forge-root.sh"; done')"
[ -n "$R" ] || { echo "feature-forge: cannot locate plugin root" >&2; exit 1; }
# production-stage served stage only (not forge-0-epic); append --op-failure / --user-deferred / --decisions-open per the paragraph above when they apply
python3 "$R/scripts/forge-session.py" select-outcome --feature "{feature}" --served-stage "{servedStage}" --skill fix --specs-dir "{specsDir}" --json
applied is not reverified: findings-applied cleared the freshness the writer deliberately dropped, so only reverified after a passing verify permits advancement. Pass the returned outcome straight through as the stage-exit --outcome below.
Round-ledger escalation binds this row on every capability. Before closing reverify-findings that is the SECOND consecutive for this served stage (count the round-discriminated reports in .verification/), present the escalation dispositions per "Escalation (the round ledger)" in references/stage-exit-protocol.md — through the question mechanism when interactive, or printed as text (digest + the three dispositions, "Accept the residual findings" first) BEFORE the terminal block when manual. Never recommend another fix pass at this point.
Add --epic "{epic}" when the feature is an epic member. Pass no other flags.
Close this stage with the Scripted Stage Exit (contract: references/stage-exit-protocol.md; do not improvise a "Next steps" list). Run:
R="$(bash -c '[ -z "${FEATURE_FORGE_ROOT:-}" ] || [ -x "$FEATURE_FORGE_ROOT/scripts/forge-root.sh" ] || { echo "feature-forge: FEATURE_FORGE_ROOT=$FEATURE_FORGE_ROOT has no scripts/forge-root.sh" >&2; exit 2; }; for d in "${FEATURE_FORGE_ROOT:-}" "${CLAUDE_PLUGIN_ROOT:-}" "$HOME"/.claude/skills/feature-forge "$HOME"/.claude/plugins/cache/*/feature-forge/* "$HOME"/.claude/plugins/*/feature-forge "$HOME"/.agents/skills/feature-forge ./.agents/skills/feature-forge; do [ -x "$d/scripts/forge-root.sh" ] && exec "$d/scripts/forge-root.sh"; done')"
[ -n "$R" ] || { echo "feature-forge: cannot locate plugin root" >&2; exit 1; }
python3 "$R/scripts/forge-session.py" stage-exit --feature "{feature}" --stage forge-fix --owner "{owner}" --outcome "{FixOutcome}" --served-stage "{servedStage}" --specs-dir "{specsDir}" --host claude --verify-capability "{verify-capability}"
Obey the DIRECTIVES it prints, in the consumption order this protocol fixes: surface invalidAutoVerifyKeys and every warnings entry first; runInStageVerify: true → run the in-stage clean-room verify chain now (honoring autoFixEligible, and asking through the Standard Verify Gate first when you may not dispatch unsolicited); verifyGate: "standard" → present the Standard Verify Gate; verifyGate: "manual-print" → print the verifyCommand for the user and do not dispatch inline. Then, and only when terminalOwnedBy is "self", print the NEXT-STEPS block verbatim as your absolute last output — nothing after its sentinel line. A terminalOwnedBy: "outer" payload carries nextSteps: null: return your structured result to the caller and print no terminal block at all.
04 同仓库更多 Skills
alpha
A valid skill description.
alpha
暂无简介
alpha
This is a folded scalar description.
alpha
A valid skill description.
alpha
foo: bar
alpha
A valid description.