cclaw-cli 0.51.19 → 0.51.22

package/dist/content/templates.js

@@ -143,6 +143,7 @@ ${SEED_SHELF_SECTION}
 | Reversibility cost? |  |  |
 
 ## Dream State Mapping
+- Deep/optional only; omit for compact scope.
 - CURRENT STATE:
 - THIS PLAN:
 - 12-MONTH IDEAL:
@@ -156,6 +157,7 @@ ${SEED_SHELF_SECTION}
 | C (optional) |  |  |  |  |  |  |
 
 ## Temporal Interrogation
+- Deep/optional only; omit for compact scope.
 | Time slice | Likely decision pressure | Lock now or defer? | Reason |
 |---|---|---|---|
 | HOUR 1 (foundations) |  |  |  |
@@ -170,12 +172,11 @@ ${SEED_SHELF_SECTION}
 - [ ] SCOPE REDUCTION — strip to the smallest useful wedge when risk/blast radius is too high.
 
 ## Mode-Specific Analysis
-- **Selected mode:**
-- **Analysis:**
-  - (SCOPE EXPANSION: 10-star opportunities, delight features)
-  - (SELECTIVE EXPANSION: hold-scope baseline, cherry-picked expansions)
-  - (HOLD SCOPE: approved slice with maximum rigor)
-  - (SCOPE REDUCTION: ruthless cuts, follow-up split)
+| Selected mode | Rationale | Depth |
+|---|---|---|
+|  |  | default / deep |
+
+> Default path: one selected-mode row plus rationale. Deep/high-risk scope may expand below with mode-specific analysis.
 
 ## Requirements (stable IDs)
 | ID | Requirement (observable outcome) | Priority | Source (origin doc / prompt line) |
@@ -224,7 +225,7 @@ ${SEED_SHELF_SECTION}
 |---|---|---|---|---|
 | F-1 | premise_fit |  | accept/reject/defer |  |
 
-## Spec Review Loop
+## Scope Outside Voice Loop
 | Iteration | Quality Score | Findings | Stop decision |
 |---|---|---|---|
 | 1 | 0.00 | 0 | continue/stop |
@@ -288,8 +289,13 @@ ${SEED_SHELF_SECTION}
 
 # Design Artifact
 
+## Compact-First Scaffold
+- Default to the compact design spine unless risk requires Standard/Deep add-ons.
+- Compact required spine: Codebase Investigation, Architecture Boundaries, Architecture Diagram, Data Flow, Failure Mode Table, Test Strategy, and Completion Dashboard.
+- Mark optional Standard/Deep sections as \`Omitted - compact design\` when they do not apply; do not expand the scaffold just to fill empty tables.
+
 ## Upstream Handoff
-- Source artifacts: \`02-scope-<slug>.md\`, \`02a-research.md\` when present
+- Source artifacts: \`02-scope-<slug>.md\`, \`02a-research.md\` only when present for deep/high-risk research
 - Decisions carried forward:
 - Constraints carried forward:
 - Open questions:
@@ -308,12 +314,11 @@ ${SEED_SHELF_SECTION}
 | Layer 3 |  |  |
 
 ## Research Fleet Synthesis
-| Lens | Key findings | Design impact | Evidence |
+| Lens actually run | Key findings | Design impact | Evidence |
 |---|---|---|---|
-| stack-researcher |  |  |  |
-| features-researcher |  |  |  |
-| architecture-researcher |  |  |  |
-| pitfalls-researcher |  |  |  |
+| compact inline synthesis |  |  |  |
+
+> Default path: compact inline synthesis here. Deep/high-risk work may also write \`.cclaw/artifacts/02a-research.md\`.
 
 ## Architecture Boundaries
 | Component | Responsibility | Requirement Refs (R#) | Decision Refs (LD#hash) | Owner |
@@ -329,12 +334,14 @@ ${MARKDOWN_CODE_FENCE}
 ${MARKDOWN_CODE_FENCE}
 
 ## Data-Flow Shadow Paths
+- Standard/Deep add-on; omit when compact design does not need a shadow path.
 <!-- diagram: data-flow-shadow-paths -->
 | Path | Trigger | Fallback/Degrade behavior |
 |---|---|---|
 |  |  |  |
 
 ## Error Flow Diagram
+- Standard/Deep add-on; omit when the Failure Mode Table is sufficient.
 
 <!-- diagram: error-flow -->
 
@@ -343,6 +350,7 @@ ${MARKDOWN_CODE_FENCE}
 ${MARKDOWN_CODE_FENCE}
 
 ## State Machine Diagram
+- Deep add-on; omit for compact design.
 
 <!-- diagram: state-machine -->
 
@@ -351,6 +359,7 @@ ${MARKDOWN_CODE_FENCE}
 ${MARKDOWN_CODE_FENCE}
 
 ## Rollback Flowchart
+- Deep add-on; omit for compact design.
 
 <!-- diagram: rollback-flowchart -->
 
@@ -359,6 +368,7 @@ ${MARKDOWN_CODE_FENCE}
 ${MARKDOWN_CODE_FENCE}
 
 ## Deployment Sequence Diagram
+- Deep add-on; omit for compact design.
 
 <!-- diagram: deployment-sequence -->
 
@@ -426,7 +436,7 @@ ${MARKDOWN_CODE_FENCE}
 |---|---|---|---|---|
 | F-1 | architecture_fit |  | accept/reject/defer |  |
 
-## Spec Review Loop
+## Design Outside Voice Loop
 | Iteration | Quality Score | Findings | Stop decision |
 |---|---|---|---|
 | 1 | 0.00 | 0 | continue/stop |
@@ -439,6 +449,7 @@ ${MARKDOWN_CODE_FENCE}
 - 
 
 ## Parallelization Strategy
+- Standard/Deep add-on when multi-module; omit for compact sequential work.
 - Parallel lanes:
 - Conflict risks:
 
@@ -448,11 +459,13 @@ ${MARKDOWN_CODE_FENCE}
 |  |  |  |
 
 ## Interface Contracts
+- Standard/Deep add-on when module boundaries or APIs change; omit for compact local changes.
 | Module | Produces | Consumes |
 |---|---|---|
 |  |  |  |
 
 ## Unresolved Decisions
+- Standard/Deep add-on; use \`None\` for compact design with no unresolved decisions.
 | Decision | Missing info | Owner | Default |
 |---|---|---|---|
 |  |  |  |  |
@@ -481,7 +494,7 @@ ${SEED_SHELF_SECTION}
 # Specification Artifact
 
 ## Upstream Handoff
-- Source artifacts: \`02-scope-<slug>.md\`, \`03-design-<slug>.md\`
+- Source artifacts: standard uses \`02-scope-<slug>.md\` + \`03-design-<slug>.md\`; medium uses \`01-brainstorm-<slug>.md\` when present; quick uses \`00-idea.md\` plus reproduction context.
 - Decisions carried forward:
 - Constraints carried forward:
 - Open questions:
@@ -492,9 +505,14 @@ ${SEED_SHELF_SECTION}
 |---|---|---|---|
 | AC-1 | R1 |  |  |
 
-> Every AC must reference at least one \`R#\` from \`02-scope.md\`. ACs are
-> stable (never renumber): dropped ACs stay with Priority \`DROPPED\`; new
-> ones append with the next free \`AC-#\`.
+> Standard ACs reference at least one \`R#\` from \`02-scope.md\`. Quick-track ACs may instead put \`Quick Reproduction Contract\` / bug-slice refs in the Requirement Ref column and \`N/A\` for Design Decision Ref. ACs are stable (never renumber): dropped ACs stay with Priority \`DROPPED\`; new ones append with the next free \`AC-#\`.
+
+## Quick Reproduction Contract
+> Required for quick bug-fix specs; use \`N/A\` for non-bugfix or standard/medium tracks. TDD turns this contract into the RED reproduction test.
+
+| Bug slice | Symptom | Repro steps | Expected RED test behavior | Linked acceptance criterion |
+|---|---|---|---|---|
+| QS-1 |  |  |  | AC-1 |
 
 ## Edge Cases
 | Criterion ID | Boundary case | Error case |
@@ -510,7 +528,7 @@ ${SEED_SHELF_SECTION}
 |---|---|---|---|
 |  |  |  | accepted/rejected/open |
 
-## Testability Map
+## Acceptance Mapping
 | Criterion ID | Verification approach | Command/manual steps |
 |---|---|---|
 | AC-1 |  |  |
@@ -627,7 +645,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 # TDD Artifact
 
 ## Upstream Handoff
-- Source artifacts: \`04-spec.md\`, \`05-plan.md\`
+- Source artifacts: \`04-spec.md\`; \`05-plan.md\` when present. Quick track uses spec acceptance items / bug reproduction slices instead of nonexistent plan tasks.
 - Decisions carried forward:
 - Constraints carried forward:
 - Open questions:
@@ -654,9 +672,11 @@ Execution rule: complete and verify each batch before starting the next batch.
 | S-1 |  |  |  |
 
 ## Acceptance Mapping
-| Slice | Plan task ID | Spec criterion ID |
+| Slice | Plan task ID or quick source | Spec criterion ID |
 |---|---|---|
-| S-1 | T-1 | AC-1 |
+| S-1 | T-1 / QS-1 | AC-1 |
+
+> On quick track, map to the \`Quick Reproduction Contract\` bug slice or spec acceptance item. Do not invent a plan task just to satisfy this table.
 
 ## Failure Analysis
 | Slice | Expected missing behavior | Actual failure reason |
@@ -709,7 +729,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 # Review Artifact
 
 ## Upstream Handoff
-- Source artifacts: \`04-spec.md\`, \`05-plan.md\`, \`06-tdd.md\`
+- Source artifacts: \`04-spec.md\`, \`06-tdd.md\`; \`05-plan.md\` only when present. Quick track reviews spec acceptance items / bug reproduction slices without requiring plan-task coverage.
 - Decisions carried forward:
 - Constraints carried forward:
 - Open questions:
@@ -723,7 +743,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 ## Layer 2 Findings
 | ID | Severity | Category | Description | Status |
 |---|---|---|---|---|
-| R-1 | Critical/Important/Suggestion | correctness/security/performance/architecture |  | open/resolved |
+| R-1 | Critical/Important/Suggestion | correctness/security/performance/architecture/external-safety |  | open/resolved |
 - NO_CHANGE_ATTESTATION: <required when Category=security has no entries; explain why no security-relevant changes were detected>
 
 ## Incoming Feedback Queue
@@ -746,15 +766,15 @@ Execution rule: complete and verify each batch before starting the next batch.
 
 ## Completeness Snapshot
 - AC coverage: <N>/<M> (<percent>%)
-- Task coverage (tasks backed by ≥1 test slice): <N>/<M>
-- Slice coverage (slices linked to ≥1 AC): <N>/<M>
+- Task coverage (tasks backed by ≥1 test slice): <N>/<M> or \`N/A - quick track has no plan artifact\`
+- Slice coverage (slices linked to ≥1 AC or bug reproduction slice): <N>/<M>
 - Adversarial review: not triggered | pass | fail
 - Overall: complete | concerns | blocked
 
 ## Trace Matrix Check
-- Command: \`cclaw internal trace-matrix\`
+- Command: \`cclaw internal trace-matrix\` when plan artifacts exist or the active track enforces it; quick track may record direct AC/reproduction-slice coverage instead.
 - Orphaned criteria: 0
-- Orphaned tasks: 0
+- Orphaned tasks: 0 or \`N/A - quick track\`
 - Orphaned tests: 0
 - Evidence ref:
 
@@ -955,7 +975,7 @@ Track-specific skips are allowed only when \`flow-state.track\` + \`skippedStage
 | Class | Route |
 |---|---|
 | non-trivial software work | \`/cc <idea>\` |
-| trivial software fix | \`/cc <idea>\` (quick or medium track) |
+| trivial software fix | \`/cc <idea>\` (quick track) |
 | bugfix with repro | \`/cc <idea>\` and enforce RED-first in tdd |
 | pure question / non-software | direct answer (no stage flow) |
 

package/dist/content/view-command.js

@@ -37,9 +37,11 @@ ${conversationLanguagePolicyMarkdown()}
 For machine orchestration, emit one JSON envelope:
 
 \`\`\`json
-{"version":"1","kind":"stage-output","stage":"non-flow","payload":{"command":"/cc-view","subcommand":"status","summary":"<short>"},"emittedAt":"<ISO-8601>"}
+{"version":"1","kind":"stage-output","stage":"non-flow","payload":{"command":"/cc-view <status|tree|diff>","subcommand":"<status|tree|diff>","summary":"<short>"},"emittedAt":"<ISO-8601>"}
 \`\`\`
 
+Use the parsed/defaulted subcommand in both \`payload.command\` and \`payload.subcommand\`; do not collapse \`tree\` or \`diff\` responses to \`status\`.
+
 Validate envelopes with:
 \`cclaw internal envelope-validate --stdin\`
 

package/dist/delegation.d.ts

@@ -93,7 +93,6 @@ export declare function checkMandatoryDelegations(projectRoot: string, stage: Fl
     satisfied: boolean;
     missing: string[];
     waived: string[];
-    autoWaived: string[];
     staleIgnored: string[];
     /** Delegation rows missing required evidence under a role-switch fallback. */
     missingEvidence: string[];

package/dist/delegation.js

@@ -103,6 +103,9 @@ async function detectReviewTriggers(projectRoot) {
         return empty;
     }
 }
+function hasValidWaiverReason(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
 function isDelegationTokenUsage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -130,6 +133,7 @@ function isDelegationEntry(value) {
             Number.isFinite(o.retryCount) &&
             Number.isInteger(o.retryCount) &&
             o.retryCount >= 0);
+    const waiverOk = o.status !== "waived" || hasValidWaiverReason(o.waiverReason);
     return (typeof o.stage === "string" &&
         typeof o.agent === "string" &&
         modeOk &&
@@ -141,6 +145,7 @@ function isDelegationEntry(value) {
         (o.endTs === undefined || typeof o.endTs === "string") &&
         (o.taskId === undefined || typeof o.taskId === "string") &&
         (o.waiverReason === undefined || typeof o.waiverReason === "string") &&
+        waiverOk &&
         (o.runId === undefined || typeof o.runId === "string") &&
         (o.fulfillmentMode === undefined ||
             o.fulfillmentMode === "isolated" ||
@@ -165,8 +170,10 @@ function parseLedger(raw, runId) {
         for (const item of entriesRaw) {
             if (isDelegationEntry(item)) {
                 const ts = item.startTs ?? item.ts ?? new Date().toISOString();
-                const inferredFulfillmentMode = item.fulfillmentMode
-                    ?? (item.status === "completed" ? "isolated" : undefined);
+                const isLegacyCompletion = item.fulfillmentMode === undefined &&
+                    item.schemaVersion === undefined &&
+                    item.status === "completed";
+                const inferredFulfillmentMode = item.fulfillmentMode ?? (isLegacyCompletion ? "isolated" : undefined);
                 entries.push({
                     ...item,
                     spanId: item.spanId ?? createSpanId(),
@@ -205,6 +212,9 @@ export async function appendDelegation(projectRoot, entry) {
         const filePath = delegationLogPath(projectRoot);
         const prior = await readDelegationLedger(projectRoot);
         const startTs = entry.startTs ?? entry.ts ?? new Date().toISOString();
+        if (entry.status === "waived" && !hasValidWaiverReason(entry.waiverReason)) {
+            throw new Error("waived delegation entries require a non-empty waiverReason");
+        }
         const stamped = { ...entry, runId: entry.runId ?? activeRunId };
         stamped.spanId = entry.spanId ?? createSpanId();
         stamped.startTs = startTs;
@@ -219,10 +229,19 @@ export async function appendDelegation(projectRoot, entry) {
             stamped.evidenceRefs = [];
         }
         if (stamped.status === "completed" && stamped.fulfillmentMode === undefined) {
-            const config = await readConfig(projectRoot).catch(() => null);
-            const harnesses = config?.harnesses ?? [];
-            const fallbacks = harnesses.map((h) => HARNESS_ADAPTERS[h].capabilities.subagentFallback);
-            stamped.fulfillmentMode = expectedFulfillmentMode(fallbacks);
+            const activeFallback = process.env.CCLAW_ACTIVE_HARNESS
+                ? HARNESS_ADAPTERS[process.env.CCLAW_ACTIVE_HARNESS]
+                    ?.capabilities.subagentFallback
+                : undefined;
+            if (activeFallback) {
+                stamped.fulfillmentMode = expectedFulfillmentMode([activeFallback]);
+            }
+            else {
+                const config = await readConfig(projectRoot).catch(() => null);
+                const harnesses = config?.harnesses ?? [];
+                const fallbacks = harnesses.map((h) => HARNESS_ADAPTERS[h].capabilities.subagentFallback);
+                stamped.fulfillmentMode = expectedFulfillmentMode(fallbacks);
+            }
         }
         // Idempotency: if a caller (or a retried hook) tries to append a row
         // with a spanId that already exists in the ledger, treat it as a no-op
@@ -256,10 +275,11 @@ export function expectedFulfillmentMode(fallbacks) {
     return "harness-waiver";
 }
 export async function checkMandatoryDelegations(projectRoot, stage, options = {}) {
-    const mandatory = stageSchema(stage).mandatoryDelegations;
-    const { activeRunId } = await readFlowState(projectRoot, {
+    const flowState = await readFlowState(projectRoot, {
         repairFeatureSystem: options.repairFeatureSystem
     });
+    const mandatory = stageSchema(stage, flowState.track).mandatoryDelegations;
+    const { activeRunId } = flowState;
     const ledger = await readDelegationLedger(projectRoot);
     const forStage = ledger.entries.filter((e) => e.stage === stage);
     const forRun = forStage.filter((e) => e.runId === activeRunId);
@@ -268,7 +288,6 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
         .map((e) => `${e.agent}(runId=${e.runId ?? "unknown"})`);
     const missing = [];
     const waived = [];
-    const autoWaived = [];
     const missingEvidence = [];
     const config = await readConfig(projectRoot).catch(() => null);
     const harnesses = config?.harnesses ?? [];
@@ -277,7 +296,7 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
     for (const agent of mandatory) {
         const rows = forRun.filter((e) => e.agent === agent);
         const completedRows = rows.filter((e) => e.status === "completed");
-        const waivedRows = rows.filter((e) => e.status === "waived");
+        const waivedRows = rows.filter((e) => e.status === "waived" && e.mode === "mandatory");
         const hasCompleted = completedRows.length >= 1;
         const hasWaived = waivedRows.length > 0;
         const ok = hasWaived || hasCompleted;
@@ -301,7 +320,6 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
         satisfied: missing.length === 0 && missingEvidence.length === 0,
         missing,
         waived,
-        autoWaived,
         staleIgnored,
         missingEvidence,
         expectedMode

package/dist/doctor.js

@@ -25,6 +25,7 @@ import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LEGACY_LANGUAGE_RULE_
 import { validateHookDocument } from "./hook-schema.js";
 import { validateKnowledgeEntry } from "./knowledge-store.js";
 import { readSeedShelf } from "./content/seed-shelf.js";
+import { evaluateRetroGate } from "./retro-gate.js";
 const execFileAsync = promisify(execFile);
 async function isGitRepo(projectRoot) {
     try {
@@ -149,18 +150,30 @@ function knowledgeRoutingSurfaceIsDiscoverable(content) {
     return ["trigger", "action", "origin_run"].every((term) => normalized.includes(term));
 }
 async function commandAvailable(command) {
+    const version = await commandVersion(command);
+    return version.available;
+}
+async function commandVersion(command, args = ["--version"]) {
     try {
         if (process.platform === "win32") {
             await execFileAsync("where", [command]);
-            return true;
         }
-        await execFileAsync(command, ["--version"]);
-        return true;
+        const { stdout, stderr } = await execFileAsync(command, args);
+        return { available: true, output: `${stdout}${stderr}`.trim() };
     }
     catch {
-        return false;
+        return { available: false, output: "" };
     }
 }
+function parseNodeMajor(versionOutput) {
+    const match = /v?(\d+)\./u.exec(versionOutput);
+    if (!match)
+        return null;
+    return Number(match[1]);
+}
+function gitVersionLooksUsable(versionOutput) {
+    return /git version \d+\.\d+/iu.test(versionOutput);
+}
 function stripJsonCommentsOutsideStrings(input) {
     let out = "";
     let i = 0;
@@ -308,6 +321,87 @@ async function opencodeRegistrationCheck(projectRoot) {
     }
     return { ok: false, details: `No opencode.json/opencode.jsonc found with plugin ${expected}` };
 }
+async function initRecoveryCheck(projectRoot) {
+    const sentinelPath = path.join(projectRoot, RUNTIME_ROOT, "state", ".init-in-progress");
+    if (!(await exists(sentinelPath))) {
+        return { ok: true, details: "no partial init/sync sentinel found" };
+    }
+    let summary = `${RUNTIME_ROOT}/state/.init-in-progress sentinel present`;
+    try {
+        const parsed = JSON.parse(await fs.readFile(sentinelPath, "utf8"));
+        const operation = typeof parsed.operation === "string" ? parsed.operation : "unknown";
+        const startedAt = typeof parsed.startedAt === "string" ? parsed.startedAt : "unknown";
+        summary = `${summary} (operation=${operation}, startedAt=${startedAt})`;
+    }
+    catch {
+        summary = `${summary} (unreadable sentinel payload)`;
+    }
+    return {
+        ok: false,
+        details: `${summary}. Fix: inspect generated runtime files, then rerun cclaw sync or remove the sentinel only after confirming the runtime is complete.`
+    };
+}
+async function archiveIntegrityCheck(projectRoot) {
+    const runsDir = path.join(projectRoot, RUNTIME_ROOT, "runs");
+    if (!(await exists(runsDir))) {
+        return { ok: true, details: `${RUNTIME_ROOT}/runs is absent; no archives to inspect yet` };
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(runsDir, { withFileTypes: true });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { ok: false, details: `unable to inspect ${RUNTIME_ROOT}/runs (${reason})` };
+    }
+    const problems = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const runId = entry.name;
+        const runPath = path.join(runsDir, runId);
+        const relRunPath = `${RUNTIME_ROOT}/runs/${runId}`;
+        if (await exists(path.join(runPath, ".archive-in-progress"))) {
+            problems.push(`${relRunPath}/.archive-in-progress sentinel present`);
+        }
+        const manifestPath = path.join(runPath, "archive-manifest.json");
+        if (!(await exists(manifestPath))) {
+            problems.push(`${relRunPath} missing archive-manifest.json`);
+            continue;
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            problems.push(`${relRunPath}/archive-manifest.json unreadable (${reason})`);
+            continue;
+        }
+        const stateFiles = Array.isArray(manifest.snapshottedStateFiles)
+            ? manifest.snapshottedStateFiles.filter((value) => typeof value === "string")
+            : [];
+        const stateDir = path.join(runPath, "state");
+        if (stateFiles.length > 0 && !(await exists(stateDir))) {
+            problems.push(`${relRunPath} manifest lists state snapshot files but state/ is missing`);
+            continue;
+        }
+        for (const stateFile of stateFiles) {
+            if (stateFile.endsWith("/"))
+                continue;
+            if (!(await exists(path.join(stateDir, stateFile)))) {
+                problems.push(`${relRunPath}/state missing ${stateFile} listed in manifest`);
+            }
+        }
+    }
+    if (problems.length === 0) {
+        return { ok: true, details: "no partial archive sentinels or incomplete archive snapshots found" };
+    }
+    return {
+        ok: false,
+        details: `${problems.join("; ")}. Fix: inspect the archive directory, retry archive if the active run was restored, or recover/rollback artifacts and state from the snapshot before removing the sentinel.`
+    };
+}
 async function opencodePluginRuntimeShapeCheck(projectRoot) {
     const pluginPath = path.join(projectRoot, ".opencode/plugins/cclaw-plugin.mjs");
     if (!(await exists(pluginPath))) {
@@ -981,11 +1075,36 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: registration.details
         });
     }
-    const hasNode = await commandAvailable("node");
+    const nodeVersion = await commandVersion("node");
+    const nodeMajor = parseNodeMajor(nodeVersion.output);
     checks.push({
         name: "capability:required:node",
-        ok: hasNode,
-        details: "node is required for cclaw runtime scripts and CLI wiring"
+        ok: nodeVersion.available,
+        details: nodeVersion.available
+            ? `node binary available (${nodeVersion.output || "version unknown"})`
+            : "node is required for cclaw runtime scripts and CLI wiring"
+    });
+    checks.push({
+        name: "capability:required:node_version",
+        ok: nodeVersion.available && nodeMajor !== null && nodeMajor >= 20,
+        details: nodeVersion.available
+            ? `node >=20 required; detected ${nodeVersion.output || "unknown version"}`
+            : "node version check skipped because node binary is unavailable"
+    });
+    const gitVersion = await commandVersion("git");
+    checks.push({
+        name: "capability:required:git",
+        ok: gitVersion.available,
+        details: gitVersion.available
+            ? `git binary available (${gitVersion.output || "version unknown"})`
+            : "git is required for repository detection, hook setup, and doctor checks"
+    });
+    checks.push({
+        name: "capability:required:git_version",
+        ok: gitVersion.available && gitVersionLooksUsable(gitVersion.output),
+        details: gitVersion.available
+            ? `git version output: ${gitVersion.output || "unknown version"}`
+            : "git version check skipped because git binary is unavailable"
     });
     const windowsHookConfigCandidates = [
         path.join(projectRoot, ".claude/hooks/hooks.json"),
@@ -1083,12 +1202,7 @@ export async function doctorChecks(projectRoot, options = {}) {
                         const key = `${trigger} => ${action}`;
                         triggerActionCounts.set(key, (triggerActionCounts.get(key) ?? 0) + 1);
                     }
-                    const missing = requiredV2Fields.some((field) => {
-                        if (field === "origin_run" && Object.prototype.hasOwnProperty.call(parsed, "origin_feature")) {
-                            return false;
-                        }
-                        return !Object.prototype.hasOwnProperty.call(parsed, field);
-                    });
+                    const missing = requiredV2Fields.some((field) => !Object.prototype.hasOwnProperty.call(parsed, field));
                     if (missing) {
                         missingSchemaV2Fields += 1;
                     }
@@ -1388,17 +1502,17 @@ export async function doctorChecks(projectRoot, options = {}) {
             ? "no stale stages pending acknowledgement"
             : `stale stages pending acknowledgement: ${staleStages.join(", ")}`
     });
-    const retroRequired = flowState.completedStages.includes("ship");
-    const retroComplete = !retroRequired ||
-        (typeof flowState.retro.completedAt === "string" && flowState.retro.compoundEntries > 0);
+    const retroGateStatus = await evaluateRetroGate(projectRoot, flowState);
     checks.push({
         name: "state:retro_gate",
-        ok: retroComplete,
-        details: retroComplete
-            ? retroRequired
-                ? `retro gate complete (${flowState.retro.compoundEntries} compound entries)`
+        ok: retroGateStatus.completed,
+        details: retroGateStatus.completed
+            ? retroGateStatus.required
+                ? retroGateStatus.skipped
+                    ? "retro gate complete (retro skipped with recorded closeout decision)"
+                    : `retro gate complete (${retroGateStatus.compoundEntries} compound entries)`
                 : "retro gate not required yet (ship not completed)"
-            : "retro gate incomplete: ship flow requires recorded retrospective evidence."
+            : "retro gate incomplete: ship flow requires recorded retrospective evidence or an explicit retro skip."
     });
     const tddLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-cycle-log.jsonl");
     const tddLogExists = await exists(tddLogPath);
@@ -1444,6 +1558,18 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "runs")),
         details: `${RUNTIME_ROOT}/runs must exist for archived run snapshots`
     });
+    const initRecovery = await initRecoveryCheck(projectRoot);
+    checks.push({
+        name: "state:init_recovery",
+        ok: initRecovery.ok,
+        details: initRecovery.details
+    });
+    const archiveIntegrity = await archiveIntegrityCheck(projectRoot);
+    checks.push({
+        name: "runs:archive_integrity",
+        ok: archiveIntegrity.ok,
+        details: archiveIntegrity.details
+    });
     const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage, {
         repairFeatureSystem: false
     });
@@ -1461,9 +1587,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         name: "warning:delegation:waived",
         ok: true,
         details: delegation.waived.length > 0
-            ? `warning: waived mandatory delegations for stage "${flowState.currentStage}": ${delegation.waived.join(", ")}${delegation.autoWaived.length > 0
-                ? ` (auto-waived due to harness limitation: ${delegation.autoWaived.join(", ")})`
-                : ""}`
+            ? `warning: waived mandatory delegations for stage "${flowState.currentStage}": ${delegation.waived.join(", ")}`
             : "no waived mandatory delegations for current stage"
     });
     checks.push({

package/dist/gate-evidence.js

@@ -336,11 +336,27 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
         if (stage === "design") {
             const researchGateRequired = schema.requiredGates.some((gate) => gate.id === "design_research_complete" && gate.tier === "required");
             if (researchGateRequired) {
+                const designMarkdown = await readArtifactMarkdown(projectRoot, "03-design.md");
+                const inlineResearchBody = designMarkdown
+                    ? extractMarkdownSectionBody(designMarkdown, "Research Fleet Synthesis")
+                    : null;
+                const inlineResearchLines = inlineResearchBody
+                    ? inlineResearchBody
+                        .split(/\r?\n/gu)
+                        .map((line) => line.trim())
+                        .filter((line) => line.length > 0)
+                        .filter((line) => !/^\|?(?:[-:\s|])+$/u.test(line))
+                        .filter((line) => !/\b(?:TODO|TBD|FIXME|pending)\b/iu.test(line) &&
+                        !/<fill-in>/iu.test(line) &&
+                        !/^>\s*Default path:/iu.test(line) &&
+                        !/^\|\s*compact inline synthesis\s*\|\s*\|\s*\|\s*\|?\s*$/iu.test(line))
+                    : [];
+                const inlineResearchComplete = inlineResearchLines.length > 0;
                 const researchMarkdown = await readArtifactMarkdown(projectRoot, "02a-research.md");
-                if (!researchMarkdown) {
-                    issues.push("design research gate blocked (design_research_complete): missing `.cclaw/artifacts/02a-research.md`.");
+                if (!inlineResearchComplete && !researchMarkdown) {
+                    issues.push("design research gate blocked (design_research_complete): fill `Research Fleet Synthesis` in `.cclaw/artifacts/03-design.md`, or write `.cclaw/artifacts/02a-research.md` for deep/high-risk research.");
                 }
-                else {
+                else if (researchMarkdown) {
                     const missingSections = [];
                     for (const section of DESIGN_RESEARCH_REQUIRED_SECTIONS) {
                         const body = extractMarkdownSectionBody(researchMarkdown, section);
@@ -353,10 +369,6 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
                             .map((line) => line.trim())
                             .filter((line) => line.length > 0)
                             .filter((line) => !/^\|?(?:[-:\s|])+$/u.test(line));
-                        // `<fill-in>` needs its own check because `\b` does not match
-                        // around `<`/`>` (non-word characters), so the previous combined
-                        // pattern `\b(?:...|<fill-in>)\b` silently never matched placeholder
-                        // templates that used angle-bracket form.
                         const nonPlaceholder = meaningfulLines.filter((line) => !/\b(?:TODO|TBD|FIXME|pending)\b/iu.test(line) &&
                             !/<fill-in>/iu.test(line));
                         if (nonPlaceholder.length === 0) {