cclaw-cli 0.51.24 → 0.51.26

package/dist/content/templates.js

@@ -29,6 +29,11 @@ export const ARTIFACT_TEMPLATES = {
 ### Discovered context
 - (paths, prior artifacts, seeds, prompt fragments — referenced by downstream stages, or \`- None.\`)
 
+## Reference Pattern Candidates
+| Pattern / source | Reusable invariant | Disposition (accept/reject/defer) | Why |
+|---|---|---|---|
+|  |  |  |  |
+
 ## Problem Decision Record
 - **Depth:** lite | standard | deep
 - **Frame type:** product | technical-maintenance
@@ -60,6 +65,12 @@ export const ARTIFACT_TEMPLATES = {
 ## How Might We
 - *How might we …?* — one line naming the user, the desired outcome, and the binding constraint.
 
+## Clarity Gate
+- Ambiguity score (0.00-1.00):
+- Decision boundaries (what this stage will decide):
+- Reaffirmed non-goals:
+- Residual-risk handoff to scope:
+
 ## Sharpening Questions
 > Ask one decision-changing question at a time. For concrete early exits, record \`None - early exit\` with rationale.
 | # | Question | Answer / Assumption | Decision impact |
@@ -81,7 +92,7 @@ export const ARTIFACT_TEMPLATES = {
 - Scope handoff:
 
 ## Approaches
-| Approach | Role | Upside | Architecture | Trade-offs | Reuses | Recommendation |
+| Approach | Role | Upside | Architecture | Trade-offs | Reuses / reference pattern | Recommendation |
 |---|---|---|---|---|---|---|
 | A | baseline | modest |  |  |  |  |
 | B | challenger | high |  |  |  |  |
@@ -195,6 +206,20 @@ ${SEED_SHELF_SECTION}
 - **Success definition:**
 - **Design handoff:**
 
+## Decision Drivers
+| Driver | Weight (1-5) | Option A | Option B | Option C | Notes |
+|---|---|---|---|---|---|
+| Value impact |  |  |  |  |  |
+| Risk reduction |  |  |  |  |  |
+| Reversibility |  |  |  |  |  |
+| Delivery effort |  |  |  |  |  |
+| Timeline fit |  |  |  |  |  |
+
+## Scope Completeness Score
+- Score (0.00-1.00):
+- What is still uncertain:
+- Blockers requiring escalation:
+
 ## Scope Mode
 - [ ] SCOPE EXPANSION — explore ambitious alternatives; user explicitly opts into the larger product slice.
 - [ ] SELECTIVE EXPANSION — hold baseline scope and cherry-pick one high-leverage addition.
@@ -214,6 +239,11 @@ ${SEED_SHELF_SECTION}
 ## Taste Calibration
 - Optional quality-bar references from in-repo modules/files.
 
+## Reference Pattern Registry
+| Pattern / source | Invariant to preserve | Disposition (accepted/rejected/deferred) | Scope boundary impact |
+|---|---|---|---|
+|  |  |  |  |
+
 ## Reference Pull
 - Optional evidence from \`/Users/zuevrs/Downloads/references\`; list accepted/rejected ideas or \`Not needed - compact scope\`.
 
@@ -359,6 +389,11 @@ ${SEED_SHELF_SECTION}
 |---|---|---|---|---|---|---|
 |  |  |  |  |  |  |  |
 
+## Architecture Decision Record (ADR)
+| ADR ID | Context | Decision | Alternatives considered | Consequences | Reversal trigger |
+|---|---|---|---|---|---|
+| ADR-1 |  |  |  |  |  |
+
 ## Search Before Building
 | Layer | Label | What to reuse first |
 |---|---|---|
@@ -466,11 +501,21 @@ ${MARKDOWN_CODE_FENCE}
 |---|---|---|---|
 |  |  |  |  |
 
+## Pre-mortem
+| Scenario | Earliest warning signal | Mitigation owner | Containment action |
+|---|---|---|---|
+|  |  |  |  |
+
 ## Test Strategy
 - Unit:
 - Integration:
 - E2E:
 
+## Test-Diagram Mapping
+| Critical flow | Test coverage (ID/command) | Diagram anchor | Gap status |
+|---|---|---|---|
+|  |  |  | covered/gap |
+
 ## Performance Budget
 | Critical path | Metric | Target | Measurement method |
 |---|---|---|---|
@@ -530,6 +575,11 @@ ${MARKDOWN_CODE_FENCE}
 |---|---|---|
 |  |  |  |
 
+## Reference-Grade Contracts
+| Pattern / source | Reusable invariant | Local adaptation | Rejection boundary | Verification signal |
+|---|---|---|---|---|
+|  |  |  |  |  |
+
 ## Interface Contracts
 - Standard/Deep add-on when module boundaries or APIs change; omit for compact local changes.
 | Module | Produces | Consumes |
@@ -558,6 +608,9 @@ ${SEED_SHELF_SECTION}
 
 **Decisions made:** 0 | **Unresolved:** 0
 
+## Learning Capture Hint
+For meaningful design work, replace the Learnings sentinel with 1-3 JSON learning bullets, for example: \`- {"type":"lesson","trigger":"when design chooses a risky fallback path","action":"record the switch trigger and rollback signal in Spec Handoff","confidence":"medium","domain":"architecture","stage":"design"}\`
+
 ## Learnings
 - None this stage.
 `,
@@ -735,7 +788,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 
 ## Execution Posture
 - Posture: sequential | dependency-batched | blocked
-- RED/GREEN/REFACTOR checkpoint plan:
+- Vertical-slice RED/GREEN/REFACTOR checkpoint plan:
 - Incremental commits: yes/no/deferred because
 
 ## RED Evidence
@@ -744,7 +797,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 | S-1 |  |  |  |
 
 ## Acceptance Mapping
-| Slice | Source item ID | Spec criterion ID |
+| Vertical slice | Source item ID | Spec criterion ID |
 |---|---|---|
 | S-1 | SRC-1 | AC-1 |
 
@@ -793,6 +846,9 @@ Execution rule: complete and verify each batch before starting the next batch.
 |---|---|---|---|---|
 | S-1 |  |  |  |  |
 
+## Learning Capture Hint
+For meaningful TDD work, replace the Learnings sentinel with 1-3 JSON learning bullets, for example: \`- {"type":"pattern","trigger":"when a regression only fails after state rewind","action":"keep the RED fixture and add a cycle-log assertion before GREEN","confidence":"medium","domain":"testing","stage":"tdd"}\`
+
 ## Learnings
 - None this stage.
 `,
@@ -853,6 +909,7 @@ Execution rule: complete and verify each batch before starting the next batch.
 
 ## Review Readiness Snapshot
 
+- Victory Detector: pass | fail (Layer 1, Layer 2, security sweep, structured findings, trace evidence, unresolved-critical status)
 - Completed checks: Layer 1, Layer 2 tags, security sweep, schema validation
 - Delegation log: \`.cclaw/state/delegation-log.json\` required/completed/waived/pending
 - Staleness signal: commit at last review pass vs current commit
@@ -893,6 +950,9 @@ Execution rule: complete and verify each batch before starting the next batch.
 ## Final Verdict
 - APPROVED | APPROVED_WITH_CONCERNS | BLOCKED
 
+## Learning Capture Hint
+For meaningful review work, replace the Learnings sentinel with 1-3 JSON learning bullets, for example: \`- {"type":"lesson","trigger":"when security sweep finds no issues but touches trust boundaries","action":"record NO_SECURITY_IMPACT with inspected surfaces and rationale","confidence":"medium","domain":"security","stage":"review"}\`
+
 ## Learnings
 - None this stage.
 `,
@@ -961,6 +1021,7 @@ ${SHIP_FINALIZATION_ENUM_LINES}
 - NO_VCS handoff target + artifact path (if FINALIZE_NO_VCS):
 
 ## Completion Status
+- Victory Detector: pass | fail (review verdict valid, preflight fresh, rollback ready, one finalization enum selected, execution result present)
 - SHIPPED | SHIPPED_WITH_EXCEPTIONS | BLOCKED
 - Exceptions (if any):
 

package/dist/content/tree-command.js

@@ -5,6 +5,12 @@ function flowStatePath() {
 function delegationLogPath() {
     return `${RUNTIME_ROOT}/state/delegation-log.json`;
 }
+function delegationEventsPath() {
+    return `${RUNTIME_ROOT}/state/delegation-events.jsonl`;
+}
+function subagentsPath() {
+    return `${RUNTIME_ROOT}/state/subagents.json`;
+}
 function artifactsPath() {
     return `${RUNTIME_ROOT}/artifacts`;
 }
@@ -30,7 +36,7 @@ Do not modify state in this command. It is a pure read/render operation.
    - stage marker: passed/current/pending/skipped/stale,
    - gates summary,
    - artifact summary,
-   - delegation branch for current stage with fulfillmentMode labels,
+   - delegation branch for current stage with fulfillmentMode, dispatchSurface, proof status, and active tracker labels,
 6. When \`closeout.shipSubstate !== "idle"\` or \`currentStage === "ship"\`, add
    a closeout sub-tree:
    - \`retro:\` line derived from \`closeout.retroDraftedAt\` /

package/dist/delegation.d.ts

@@ -1,7 +1,9 @@
 import { type SubagentFallback } from "./harness-adapters.js";
 import type { FlowStage } from "./types.js";
 export type DelegationMode = "mandatory" | "proactive";
-export type DelegationStatus = "scheduled" | "completed" | "failed" | "waived";
+export type DelegationStatus = "scheduled" | "launched" | "acknowledged" | "completed" | "failed" | "waived" | "stale";
+export type DelegationDispatchSurface = "claude-task" | "cursor-task" | "opencode-agent" | "codex-agent" | "generic-task" | "role-switch" | "manual";
+export type DelegationEventType = DelegationStatus;
 /**
  * How a delegation was actually fulfilled. Advisory — mirrors the harness
  * `subagentFallback` that was in effect when the entry was recorded.
@@ -53,6 +55,20 @@ export type DelegationEntry = {
     retryCount?: number;
     /** Optional references to evidence anchors in artifacts. */
     evidenceRefs?: string[];
+    /** Dispatch proof id from the parent/controller side. */
+    dispatchId?: string;
+    /** Worker-reported run id or task id returned by the harness. */
+    workerRunId?: string;
+    /** Concrete runtime surface used to launch the worker. */
+    dispatchSurface?: DelegationDispatchSurface;
+    /** Path to the generated or canonical agent definition used for dispatch. */
+    agentDefinitionPath?: string;
+    /** ISO timestamp when the worker was acknowledged by the harness/worker. */
+    ackTs?: string;
+    /** ISO timestamp when the worker was launched. */
+    launchedTs?: string;
+    /** ISO timestamp when the worker completed. */
+    completedTs?: string;
     /** Optional skill marker used for role-specific mandatory checks. */
     skill?: string;
     /**
@@ -68,6 +84,11 @@ export type DelegationLedger = {
     runId: string;
     entries: DelegationEntry[];
 };
+export type DelegationEvent = DelegationEntry & {
+    event: DelegationEventType;
+    eventTs: string;
+    schemaVersion: 1;
+};
 /**
  * Heuristic: does a changed file path strongly imply a trust-boundary
  * surface? Used by tests and prompt guidance for risk-triggered review.
@@ -79,6 +100,10 @@ export type DelegationLedger = {
  */
 export declare function isTrustBoundaryPath(filePath: string): boolean;
 export declare function readDelegationLedger(projectRoot: string): Promise<DelegationLedger>;
+export declare function readDelegationEvents(projectRoot: string): Promise<{
+    events: DelegationEvent[];
+    corruptLines: number[];
+}>;
 export declare function appendDelegation(projectRoot: string, entry: DelegationEntry): Promise<void>;
 /**
  * Aggregate the fulfillment mode cclaw expects for the active harness set.
@@ -96,6 +121,14 @@ export declare function checkMandatoryDelegations(projectRoot: string, stage: Fl
     staleIgnored: string[];
     /** Delegation rows missing required evidence under a role-switch fallback. */
     missingEvidence: string[];
+    /** Native isolated completion rows that lack dispatch proof. */
+    missingDispatchProof: string[];
+    /** Legacy inferred isolated completions accepted only as migration warnings. */
+    legacyInferredCompletions: string[];
+    /** Current-run event log lines that could not be parsed. */
+    corruptEventLines: number[];
+    /** Current-run scheduled rows with no terminal row sharing the same spanId. */
+    staleWorkers: string[];
     /** Expected fulfillment mode for the active harness set. */
     expectedMode: DelegationFulfillmentMode;
 }>;

package/dist/delegation.js

@@ -9,12 +9,19 @@ import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { readFlowState } from "./runs.js";
 import { stageSchema } from "./content/stage-schema.js";
 const execFileAsync = promisify(execFile);
+const TERMINAL_DELEGATION_STATUSES = new Set(["completed", "failed", "waived", "stale"]);
 function delegationLogPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", "delegation-log.json");
 }
 function delegationLockPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", ".delegation.lock");
 }
+function delegationEventsPath(projectRoot) {
+    return path.join(projectRoot, RUNTIME_ROOT, "state", "delegation-events.jsonl");
+}
+function subagentsStatePath(projectRoot) {
+    return path.join(projectRoot, RUNTIME_ROOT, "state", "subagents.json");
+}
 function createSpanId() {
     return `dspan-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -130,11 +137,19 @@ function isDelegationEntry(value) {
     const o = value;
     const modeOk = o.mode === "mandatory" || o.mode === "proactive";
     const statusOk = o.status === "scheduled" ||
+        o.status === "launched" ||
+        o.status === "acknowledged" ||
         o.status === "completed" ||
         o.status === "failed" ||
-        o.status === "waived";
+        o.status === "waived" ||
+        o.status === "stale";
     const timestampOk = typeof o.ts === "string" ||
         typeof o.startTs === "string";
+    const terminalStatus = o.status === "completed" || o.status === "failed" || o.status === "waived" || o.status === "stale";
+    const lifecycleOk = (o.status !== "scheduled" && o.status !== "launched" && o.status !== "acknowledged") || o.endTs === undefined;
+    const terminalLifecycleOk = !terminalStatus ||
+        o.endTs === undefined ||
+        typeof o.endTs === "string";
     const retryOk = o.retryCount === undefined ||
         (typeof o.retryCount === "number" &&
             Number.isFinite(o.retryCount) &&
@@ -146,6 +161,8 @@ function isDelegationEntry(value) {
         modeOk &&
         statusOk &&
         timestampOk &&
+        lifecycleOk &&
+        terminalLifecycleOk &&
         (o.spanId === undefined || typeof o.spanId === "string") &&
         (o.parentSpanId === undefined || typeof o.parentSpanId === "string") &&
         (o.startTs === undefined || typeof o.startTs === "string") &&
@@ -160,12 +177,53 @@ function isDelegationEntry(value) {
             o.fulfillmentMode === "role-switch" ||
             o.fulfillmentMode === "harness-waiver") &&
         (o.conditionTrigger === undefined || typeof o.conditionTrigger === "string") &&
+        (o.dispatchId === undefined || typeof o.dispatchId === "string") &&
+        (o.workerRunId === undefined || typeof o.workerRunId === "string") &&
+        (o.dispatchSurface === undefined || isDelegationDispatchSurface(o.dispatchSurface)) &&
+        (o.agentDefinitionPath === undefined || typeof o.agentDefinitionPath === "string") &&
+        (o.ackTs === undefined || typeof o.ackTs === "string") &&
+        (o.launchedTs === undefined || typeof o.launchedTs === "string") &&
+        (o.completedTs === undefined || typeof o.completedTs === "string") &&
         (o.tokens === undefined || isDelegationTokenUsage(o.tokens)) &&
         retryOk &&
         (o.evidenceRefs === undefined || (Array.isArray(o.evidenceRefs) && o.evidenceRefs.every((item) => typeof item === "string"))) &&
         (o.skill === undefined || typeof o.skill === "string") &&
         (o.schemaVersion === undefined || o.schemaVersion === 1));
 }
+function isDelegationDispatchSurface(value) {
+    return (value === "claude-task" ||
+        value === "cursor-task" ||
+        value === "opencode-agent" ||
+        value === "codex-agent" ||
+        value === "generic-task" ||
+        value === "role-switch" ||
+        value === "manual");
+}
+function statusTimestampPatch(entry, ts) {
+    const patch = { ...entry };
+    if (patch.status === "launched")
+        patch.launchedTs = patch.launchedTs ?? ts;
+    if (patch.status === "acknowledged")
+        patch.ackTs = patch.ackTs ?? ts;
+    if (patch.status === "completed")
+        patch.completedTs = patch.completedTs ?? patch.endTs ?? ts;
+    return patch;
+}
+function eventFromEntry(entry) {
+    const eventTs = entry.completedTs ?? entry.ackTs ?? entry.launchedTs ?? entry.endTs ?? entry.startTs ?? entry.ts ?? new Date().toISOString();
+    return {
+        ...entry,
+        event: entry.status,
+        eventTs,
+        schemaVersion: 1
+    };
+}
+function isDelegationEvent(value) {
+    if (!isDelegationEntry(value))
+        return false;
+    const o = value;
+    return o.event === o.status && typeof o.eventTs === "string";
+}
 function parseLedger(raw, runId) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return { runId, entries: [] };
@@ -185,7 +243,11 @@ function parseLedger(raw, runId) {
                     ...item,
                     spanId: item.spanId ?? createSpanId(),
                     startTs: ts,
+                    endTs: TERMINAL_DELEGATION_STATUSES.has(item.status) ? (item.endTs ?? ts) : undefined,
                     ts,
+                    launchedTs: item.launchedTs ?? (item.status === "launched" ? ts : undefined),
+                    ackTs: item.ackTs ?? (item.status === "acknowledged" ? ts : undefined),
+                    completedTs: item.completedTs ?? (item.status === "completed" ? (item.endTs ?? ts) : undefined),
                     retryCount: typeof item.retryCount === "number" && Number.isInteger(item.retryCount) && item.retryCount >= 0
                         ? item.retryCount
                         : 0,
@@ -213,6 +275,57 @@ export async function readDelegationLedger(projectRoot) {
         return { runId: activeRunId, entries: [] };
     }
 }
+export async function readDelegationEvents(projectRoot) {
+    const filePath = delegationEventsPath(projectRoot);
+    if (!(await exists(filePath))) {
+        return { events: [], corruptLines: [] };
+    }
+    const events = [];
+    const corruptLines = [];
+    const text = await fs.readFile(filePath, "utf8").catch(() => "");
+    const lines = text.split(/\r?\n/gu);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index]?.trim() ?? "";
+        if (line.length === 0)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (isDelegationEvent(parsed)) {
+                events.push(parsed);
+            }
+            else {
+                corruptLines.push(index + 1);
+            }
+        }
+        catch {
+            corruptLines.push(index + 1);
+        }
+    }
+    return { events, corruptLines };
+}
+async function appendDelegationEvent(projectRoot, event) {
+    const filePath = delegationEventsPath(projectRoot);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.appendFile(filePath, `${JSON.stringify(event)}\n`, { encoding: "utf8", mode: 0o600 });
+}
+async function writeSubagentTracker(projectRoot, entries) {
+    const active = entries
+        .filter((entry) => entry.status === "scheduled" || entry.status === "launched" || entry.status === "acknowledged")
+        .map((entry) => ({
+        spanId: entry.spanId,
+        dispatchId: entry.dispatchId,
+        workerRunId: entry.workerRunId,
+        stage: entry.stage,
+        agent: entry.agent,
+        status: entry.status,
+        dispatchSurface: entry.dispatchSurface,
+        agentDefinitionPath: entry.agentDefinitionPath,
+        startedAt: entry.startTs,
+        launchedAt: entry.launchedTs,
+        acknowledgedAt: entry.ackTs
+    }));
+    await writeFileSafe(subagentsStatePath(projectRoot), `${JSON.stringify({ active, updatedAt: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
+}
 export async function appendDelegation(projectRoot, entry) {
     const { activeRunId } = await readFlowState(projectRoot);
     await withDirectoryLock(delegationLockPath(projectRoot), async () => {
@@ -222,10 +335,19 @@ export async function appendDelegation(projectRoot, entry) {
         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 };
+        const stamped = statusTimestampPatch({ ...entry, runId: entry.runId ?? activeRunId }, startTs);
         stamped.spanId = entry.spanId ?? createSpanId();
         stamped.startTs = startTs;
         stamped.ts = startTs;
+        if (TERMINAL_DELEGATION_STATUSES.has(stamped.status) && !stamped.endTs) {
+            stamped.endTs = new Date().toISOString();
+        }
+        if (stamped.status === "completed") {
+            stamped.completedTs = stamped.completedTs ?? stamped.endTs ?? new Date().toISOString();
+        }
+        if (stamped.status === "scheduled") {
+            delete stamped.endTs;
+        }
         stamped.schemaVersion = 1;
         if (stamped.retryCount === undefined ||
             !Number.isInteger(stamped.retryCount) ||
@@ -247,18 +369,19 @@ export async function appendDelegation(projectRoot, entry) {
                 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
-        // instead of growing the log with duplicate entries that subsequent
-        // delegation checks would mis-count.
-        if (prior.entries.some((existing) => existing.spanId === stamped.spanId)) {
+        // Idempotency: a retried hook may replay the same lifecycle row. Allow a
+        // terminal row to close an existing scheduled span, but drop exact same
+        // span/status duplicates so checks do not mis-count repeated writes.
+        if (prior.entries.some((existing) => existing.spanId === stamped.spanId && existing.status === stamped.status)) {
             return;
         }
+        await appendDelegationEvent(projectRoot, eventFromEntry(stamped));
         const ledger = {
             runId: activeRunId,
             entries: [...prior.entries, stamped]
         };
         await writeFileSafe(filePath, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
+        await writeSubagentTracker(projectRoot, ledger.entries);
     });
 }
 /**
@@ -285,6 +408,7 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
     const mandatory = stageSchema(stage, flowState.track).mandatoryDelegations;
     const { activeRunId } = flowState;
     const ledger = await readDelegationLedger(projectRoot);
+    const events = await readDelegationEvents(projectRoot);
     const forStage = ledger.entries.filter((e) => e.stage === stage);
     const forRun = forStage.filter((e) => e.runId === activeRunId);
     const staleIgnored = forStage
@@ -293,6 +417,14 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
     const missing = [];
     const waived = [];
     const missingEvidence = [];
+    const missingDispatchProof = [];
+    const legacyInferredCompletions = [];
+    const terminalSpanIds = new Set(forRun
+        .filter((entry) => TERMINAL_DELEGATION_STATUSES.has(entry.status) && entry.spanId)
+        .map((entry) => entry.spanId));
+    const staleWorkers = forRun
+        .filter((entry) => entry.status === "scheduled" && entry.spanId && !terminalSpanIds.has(entry.spanId))
+        .map((entry) => `${entry.agent}(spanId=${entry.spanId})`);
     const config = await readConfig(projectRoot).catch(() => null);
     const harnesses = config?.harnesses ?? [];
     const configuredFallbacks = harnesses.map((h) => HARNESS_ADAPTERS[h].capabilities.subagentFallback);
@@ -322,13 +454,41 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
             !completedRows.some((e) => Array.isArray(e.evidenceRefs) && e.evidenceRefs.length > 0)) {
             missingEvidence.push(agent);
         }
+        for (const row of completedRows) {
+            const mode = row.fulfillmentMode ?? "isolated";
+            if (mode === "isolated") {
+                const spanEvents = events.events.filter((event) => event.runId === activeRunId &&
+                    event.stage === stage &&
+                    event.agent === agent &&
+                    event.spanId === row.spanId);
+                const dispatchId = row.dispatchId ?? row.workerRunId ?? spanEvents.find((event) => event.dispatchId || event.workerRunId)?.dispatchId ?? spanEvents.find((event) => event.workerRunId)?.workerRunId;
+                const dispatchSurface = row.dispatchSurface ?? spanEvents.find((event) => event.dispatchSurface)?.dispatchSurface;
+                const agentDefinitionPath = row.agentDefinitionPath ?? spanEvents.find((event) => event.agentDefinitionPath)?.agentDefinitionPath;
+                const hasAck = Boolean(row.ackTs || spanEvents.some((event) => event.event === "acknowledged" && event.ackTs));
+                const hasCompleted = Boolean(row.completedTs || spanEvents.some((event) => event.event === "completed" && event.completedTs));
+                const hasDispatchProof = Boolean(row.spanId && dispatchId && dispatchSurface && agentDefinitionPath && hasAck && hasCompleted);
+                if (!hasDispatchProof) {
+                    const proofEraSignal = Boolean(row.dispatchId || row.workerRunId || row.dispatchSurface || row.agentDefinitionPath || spanEvents.some((event) => event.dispatchId || event.workerRunId || event.dispatchSurface || event.agentDefinitionPath || event.event === "acknowledged" || event.event === "launched"));
+                    if (proofEraSignal) {
+                        missingDispatchProof.push(agent);
+                    }
+                    else {
+                        legacyInferredCompletions.push(`${agent}(spanId=${row.spanId ?? "unknown"})`);
+                    }
+                }
+            }
+        }
     }
     return {
-        satisfied: missing.length === 0 && missingEvidence.length === 0,
+        satisfied: missing.length === 0 && missingEvidence.length === 0 && missingDispatchProof.length === 0 && staleWorkers.length === 0 && events.corruptLines.length === 0,
         missing,
         waived,
         staleIgnored,
         missingEvidence,
+        missingDispatchProof,
+        legacyInferredCompletions,
+        corruptEventLines: events.corruptLines,
+        staleWorkers,
         expectedMode
     };
 }

package/dist/doctor-registry.js

@@ -107,6 +107,15 @@ const RULES = [
             docRef: ref("harnesses.md")
         }
     },
+    {
+        test: /^harness:reality:/,
+        metadata: {
+            severity: "info",
+            summary: "Harness reality label for dispatch/proof support.",
+            fix: "No action required; use this label to interpret native/generic/role-switch proof requirements.",
+            docRef: ref("harnesses.md")
+        }
+    },
     {
         test: /^delegation:/,
         metadata: {