intentdna 1.8.2 → 1.8.4

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "intentdna",
       "description": "Declarative policy layer for AI agent behavior with plugin-managed hook runtime for Claude Code.",
-      "version": "1.8.2",
+      "version": "1.8.4",
       "author": {
         "name": "Samuel"
       },
@@ -25,5 +25,5 @@
       ]
     }
   ],
-  "version": "1.8.2"
+  "version": "1.8.4"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Declarative policy layer for AI agent behavior",
   "author": {
     "name": "Samuel"

package/README.md

@@ -17,11 +17,11 @@ IntentDNA is not a model company, generic agent framework, prompt library, canva
 ## Install or update
 
 ```bash
-npm install --global intentdna@1.8.0
+npm install --global intentdna@1.8.4
 dna --version
 ```
 
-Version `1.8.0` adds the passive evidence-to-review improvement path and the Online `/create` C3 authoring guide. Online generates copyable local commands only; you still run and review them in your own project.
+Version `1.8.4` makes delegated workflow completion gates enforceable at the real Claude handoff boundary, returns bounded validator diagnostics to retries, and links C5-backed suggestions to concrete capture event IDs. Online generates copyable local commands only; you still run and review them in your own project.
 
 ## Product Shape
 

package/dist/cli/commands/assets.d.ts

@@ -20,6 +20,7 @@ export interface AssetImprovementSuggestion {
         type: string;
         ref: string;
     }>;
+    targetWorkflow?: string;
     rationale: string;
     sourceModules: string[];
     nextAction: string;

package/dist/cli/commands/assets.js

@@ -644,7 +644,7 @@ function suggestionAction(params) {
             asset: params.asset,
             suggestionId: params.suggestion.id,
             saveTemplate: params.saveTemplate,
-            workflow: params.workflow,
+            workflow: params.workflow ?? params.suggestion.targetWorkflow,
         }),
     };
 }
@@ -667,7 +667,7 @@ function buildSuggestionImprovementRoute(params) {
         ? suggestionReviewCommand({
             asset: params.asset.name,
             suggestionId: params.draftSuggestion.id,
-            workflow: "fix",
+            workflow: params.draftSuggestion.targetWorkflow ?? "fix",
             decision: "accept",
         })
         : undefined;
@@ -722,8 +722,8 @@ function buildSuggestionImprovementRoute(params) {
     ];
 }
 function firstDraftableSuggestion(suggestions) {
-    return suggestions.find((suggestion) => suggestion.type === "template_improvement" ||
-        suggestion.id === WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts);
+    return suggestions.find((suggestion) => suggestion.id === WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts && suggestion.targetWorkflow) ??
+        suggestions.find((suggestion) => suggestion.type === "template_improvement");
 }
 function evidenceSuggestionDraftCommand(asset, evidence, saveTemplate) {
     if (!evidence || asset.status.evidencePosture !== "dogfood_linked")
@@ -753,7 +753,10 @@ function c5GapCaptures(index) {
 }
 function c5EvidenceRefs(captures) {
     const refs = captures.flatMap((capture) => [
+        { type: "capture_event_id", ref: capture.eventId },
         { type: "capture_event", ref: capture.path },
+        ...(capture.workflowAsset !== "unknown" ? [{ type: "workflow_asset", ref: capture.workflowAsset }] : []),
+        ...(capture.workflowId !== "unknown" ? [{ type: "workflow", ref: capture.workflowId }] : []),
         ...capture.evidenceRefs,
     ]);
     const seen = new Set();
@@ -765,6 +768,31 @@ function c5EvidenceRefs(captures) {
         return true;
     });
 }
+function assetWorkflowTarget(asset, runtimeWorkflowId) {
+    if (!runtimeWorkflowId || runtimeWorkflowId === "unknown")
+        return undefined;
+    const workflowIds = new Set(asset.workflows.map((workflow) => workflow.id));
+    if (workflowIds.has(runtimeWorkflowId))
+        return runtimeWorkflowId;
+    if (asset.namespace && runtimeWorkflowId.startsWith(`${asset.namespace}_`)) {
+        const unprefixed = runtimeWorkflowId.slice(asset.namespace.length + 1);
+        if (workflowIds.has(unprefixed))
+            return unprefixed;
+    }
+    return undefined;
+}
+function c5TargetWorkflow(asset, captures) {
+    const targets = new Set();
+    for (const capture of captures) {
+        const target = assetWorkflowTarget(asset, capture.workflowId);
+        if (!target)
+            return undefined;
+        targets.add(target);
+        if (targets.size > 1)
+            return undefined;
+    }
+    return targets.size === 1 ? [...targets][0] : undefined;
+}
 function c5CaptureBootstrapCommands(assetName) {
     return [
         `dna init --template ${assetName}`,
@@ -836,7 +864,7 @@ function defaultSuggestionCommands(params) {
         const reviewCommand = suggestionReviewCommand({
             asset: params.asset.name,
             suggestionId: params.suggestion.id,
-            workflow: "fix",
+            workflow: params.suggestion.targetWorkflow ?? "fix",
             decision: "accept",
         });
         return [
@@ -846,7 +874,7 @@ function defaultSuggestionCommands(params) {
                 asset: params.asset.name,
                 suggestionId: params.suggestion.id,
                 saveTemplate: `${params.asset.name}-v2`,
-                workflow: "fix",
+                workflow: params.suggestion.targetWorkflow ?? "fix",
             }),
             `dna assets diff ${params.asset.name} ${params.asset.name}-v2`,
             `dna assets adoption ${params.asset.name}-v2`,
@@ -926,20 +954,21 @@ export function buildAssetSuggestions(asset, index, assets = [asset]) {
         });
     }
     if (c5Gaps.length > 0) {
+        const targetWorkflow = c5TargetWorkflow(asset, c5Gaps);
         const evidenceCommand = `dna assets evidence ${asset.name} --json`;
         const suggestionsCommand = `dna workflow suggestions ${asset.name} --json`;
-        const reviewCommand = suggestionReviewCommand({
+        const reviewCommand = targetWorkflow ? suggestionReviewCommand({
             asset: asset.name,
             suggestionId: WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts,
-            workflow: "fix",
+            workflow: targetWorkflow,
             decision: "accept",
-        });
-        const draftCommand = suggestionDraftCommand({
+        }) : undefined;
+        const draftCommand = targetWorkflow ? suggestionDraftCommand({
             asset: asset.name,
             suggestionId: WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts,
             saveTemplate: `${asset.name}-v2`,
-            workflow: "fix",
-        });
+            workflow: targetWorkflow,
+        }) : undefined;
         suggestions.push({
             id: WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts,
             type: "evidence_improvement",
@@ -947,14 +976,17 @@ export function buildAssetSuggestions(asset, index, assets = [asset]) {
             title: "Review captured local run facts before changing the workflow asset",
             evidence: c5Gaps.slice(0, 5).map(compactEvidenceCapture).join("; "),
             evidenceRefs: c5EvidenceRefs(c5Gaps),
+            targetWorkflow,
             rationale: "C5 hook evidence shows blocked, failed, retry, unsupported, or human-intervention facts. Evidence can suggest a reviewed change, but it must not mutate policy or templates automatically.",
             sourceModules: [],
-            nextAction: `Review and accept the C5-backed suggestion before drafting: ${reviewCommand}`,
+            nextAction: reviewCommand
+                ? `Review and accept the C5-backed suggestion before drafting: ${reviewCommand}`
+                : `Inspect the C5 evidence and choose one matching workflow before review; mixed or unknown workflow attribution cannot be routed automatically.`,
             nextCommands: [
                 evidenceCommand,
                 suggestionsCommand,
-                reviewCommand,
-                draftCommand,
+                ...(reviewCommand ? [reviewCommand] : []),
+                ...(draftCommand ? [draftCommand] : []),
                 `record explicit manager rationale for any C5-derived change to ${asset.name}`,
             ],
             mutationBoundary: "C5 captured facts are local review evidence only; they do not edit templates, mutate policy, adopt assets, bind organizations, sync runtime artifacts, upload cloud reports, or create runtime authority.",
@@ -1055,8 +1087,10 @@ export function buildAssetSuggestions(asset, index, assets = [asset]) {
         index,
         suggestion,
     }));
-    const activeFollowup = active.length > 0 ? activeEvidenceFollowupReviewRoute(asset.name, assets, index) : undefined;
     const draftSuggestion = firstDraftableSuggestion(completedSuggestions);
+    const activeFollowup = active.length > 0 && draftSuggestion?.id !== WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts
+        ? activeEvidenceFollowupReviewRoute(asset.name, assets, index)
+        : undefined;
     const nextCommands = [
         `dna assets evidence ${asset.name}`,
     ];
@@ -1075,7 +1109,7 @@ export function buildAssetSuggestions(asset, index, assets = [asset]) {
             nextCommands.push(suggestionReviewCommand({
                 asset: asset.name,
                 suggestionId: draftSuggestion.id,
-                workflow: "fix",
+                workflow: draftSuggestion.targetWorkflow ?? "fix",
                 decision: "accept",
             }));
         }

package/dist/hooks/cli.d.ts

@@ -99,10 +99,13 @@ export declare function runVerifiersForTest(projectDir: string, ir: ConstraintIR
     workflow: string;
     current_step: string;
     current_role: string;
+    iteration?: number;
+    started_at?: string;
     inputs?: Record<string, string>;
     resolved_variables?: Record<string, string>;
 }, when: VerifierSpec["when"], sessionId?: string, options?: {
     commandTimeoutMs?: number;
+    triggerEvent?: HookEvent;
 }): Promise<VerifierResultEntry[]>;
 export declare function runStopVerifiersForTest(projectDir: string, ir: ConstraintIR, workflowState: {
     workflow: string;

package/dist/hooks/cli.js

@@ -23,7 +23,7 @@ import { fileURLToPath } from "node:url";
 import { readStdin, writeOutput, silentOutput, allowOutput, blockOutput, stopOutput } from "./protocol.js";
 import { validateHookInput } from "./schema.js";
 import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, extractBashWritePaths, checkReflectionLimit, checkContextReadiness, checkWorkflowBoundary, } from "./enforce.js";
-import { appendAudit, readWorkflowState, appendTrace, appendRuntimeDecisionEvent, appendEvidenceCaptureEvent, rotateTraces, readTraces, cleanStaleState, readSurgeonAttempts, writeSurgeonAttempts, appendSessionRead, readSessionReads, appendVerifierResult, appendCompletedArtifact, artifactIdentity, buildArtifactKey, readArtifactManifest, resolveArtifactTemplate, safePathComponent, writeArtifactManifest, EVIDENCE_CAPTURE_SCHEMA_VERSION } from "./state.js";
+import { appendAudit, readWorkflowState, appendTrace, appendRuntimeDecisionEvent, appendEvidenceCaptureEvent, rotateTraces, readTraces, cleanStaleState, readSurgeonAttempts, writeSurgeonAttempts, appendSessionRead, readSessionReads, appendVerifierResult, readVerifierResults, appendCompletedArtifact, artifactIdentity, buildArtifactKey, readArtifactManifest, resolveArtifactTemplate, safePathComponent, writeArtifactManifest, EVIDENCE_CAPTURE_SCHEMA_VERSION } from "./state.js";
 import { hookEventsForSurface } from "./event-registry.js";
 import { writeAuditEvent } from "../audit/index.js";
 import { RUNTIME_DECISION_EVENT_SCHEMA_VERSION, trustedEvidenceCaptureAttribution } from "../governance/index.js";
@@ -347,13 +347,16 @@ export async function runHookEvent(options) {
     };
     let wfStateRaw = null;
     // Load workflow state for events that need it (handoff context + PreCompact preservation)
-    if (event === "PreToolUse" || event === "PostToolUse" || event === "PreCompact") {
+    if (event === "PreToolUse" || event === "PostToolUse" || event === "PreCompact" || event === "SubagentStop") {
         const workflowState = await readWorkflowStateForHook(projectDir, event, sessionId);
         if ("output" in workflowState) {
             await writeRuntimeDecision(workflowState.output, { output: workflowState.output, trace: { matched_rule: "workflow_boundary" } }, null);
             return finish(workflowState.output);
         }
         wfStateRaw = workflowState.state;
+        if (event === "SubagentStop" && wfStateRaw && !subagentMatchesWorkflowRole(rawInput, wfStateRaw)) {
+            wfStateRaw = null;
+        }
         if (wfStateRaw && wfStateRaw.active) {
             state.workflowState = {
                 current_step: wfStateRaw.current_step,
@@ -363,13 +366,15 @@ export async function runHookEvent(options) {
                 completed_artifacts: wfStateRaw.completed_artifacts,
                 iteration: wfStateRaw.iteration, // G4: pass iteration for state-driven rules
             };
-            const artifactFacts = await resolveWorkflowArtifactFactsForHook(projectDir, ir, wfStateRaw, event, sessionId);
-            if ("output" in artifactFacts) {
-                appendArtifactResolverTrace(projectDir, event, wfStateRaw, artifactFacts.output, sessionId);
-                await writeRuntimeDecision(artifactFacts.output, { output: artifactFacts.output, trace: { matched_rule: "handoff", step_id: wfStateRaw.current_step } }, wfStateRaw);
-                return finish(artifactFacts.output);
+            if (event !== "SubagentStop") {
+                const artifactFacts = await resolveWorkflowArtifactFactsForHook(projectDir, ir, wfStateRaw, event, sessionId);
+                if ("output" in artifactFacts) {
+                    appendArtifactResolverTrace(projectDir, event, wfStateRaw, artifactFacts.output, sessionId);
+                    await writeRuntimeDecision(artifactFacts.output, { output: artifactFacts.output, trace: { matched_rule: "handoff", step_id: wfStateRaw.current_step } }, wfStateRaw);
+                    return finish(artifactFacts.output);
+                }
+                state.artifactFacts = artifactFacts.facts;
             }
-            state.artifactFacts = artifactFacts.facts;
         }
     }
     if (event === "PreToolUse" && wfStateRaw?.active) {
@@ -400,6 +405,46 @@ export async function runHookEvent(options) {
             return finish(gateResult.output);
         }
     }
+    if (event === "SubagentStop" && wfStateRaw?.active && subagentMatchesWorkflowRole(rawInput, wfStateRaw)) {
+        const artifactFacts = await finalizeAndResolveArtifactsForHook(projectDir, ir, wfStateRaw, event, sessionId);
+        if ("output" in artifactFacts) {
+            appendArtifactResolverTrace(projectDir, event, wfStateRaw, artifactFacts.output, sessionId);
+            await writeRuntimeDecision(artifactFacts.output, { output: artifactFacts.output, trace: { matched_rule: "handoff", step_id: wfStateRaw.current_step } }, wfStateRaw);
+            return finish(artifactFacts.output);
+        }
+        const verifierContext = {
+            workflow: wfStateRaw.workflow,
+            current_step: wfStateRaw.current_step,
+            current_role: wfStateRaw.current_role,
+            iteration: wfStateRaw.iteration,
+            started_at: wfStateRaw.started_at,
+            inputs: wfStateRaw.inputs,
+            resolved_variables: wfStateRaw.resolved_variables,
+            artifact_facts: artifactFacts.facts,
+        };
+        const verifierResults = [
+            ...await runVerifiersForTest(projectDir, ir, verifierContext, "pre_handoff", sessionId, { triggerEvent: "SubagentStop" }),
+            ...await runVerifiersForTest(projectDir, ir, verifierContext, "post_step", sessionId, { triggerEvent: "SubagentStop" }),
+        ];
+        const blockingVerifierFailures = verifierResults.filter((result) => result.status === "fail" && result.severity === "block");
+        if (blockingVerifierFailures.length > 0) {
+            const output = blockOutput(`[Intent DNA] SubagentStop verifier failures at step '${wfStateRaw.current_step}':\n` +
+                blockingVerifierFailures.map((result) => `  - ${result.message ?? result.verifier_id}`).join("\n"));
+            const traceId = randomUUID();
+            appendTrace(projectDir, {
+                trace_id: traceId,
+                event,
+                workflow: wfStateRaw.workflow,
+                step: wfStateRaw.current_step,
+                decision: "block",
+                reason: output.reason,
+                duration_ms: 0,
+                timestamp: new Date().toISOString(),
+            }, sessionId).catch(() => { });
+            await writeRuntimeDecision(output, { output, trace: { matched_rule: "validator", step_id: wfStateRaw.current_step } }, wfStateRaw, traceId);
+            return finish(output);
+        }
+    }
     // Special handling for Stop — needs async workflow state read + session summary
     if (event === "Stop") {
         const workflowState = await readWorkflowStateForHook(projectDir, event, sessionId);
@@ -423,6 +468,7 @@ export async function runHookEvent(options) {
             workflow: wfState.workflow,
             current_step: wfState.current_step,
             current_role: wfState.current_role,
+            iteration: wfState.iteration,
             started_at: wfState.started_at,
             inputs: wfState.inputs,
             resolved_variables: wfState.resolved_variables,
@@ -430,7 +476,7 @@ export async function runHookEvent(options) {
             artifact_facts: stopArtifactFacts,
         } : null;
         const verifierResults = stopContext?.active
-            ? await runStopVerifiersForTest(projectDir, ir, stopContext, sessionId)
+            ? await runStopVerifiersForHook(projectDir, ir, stopContext, sessionId)
             : [];
         const blockingVerifierFailures = verifierResults.filter((result) => result.status === "fail" && result.severity === "block");
         let stopOutput = blockingVerifierFailures.length > 0
@@ -660,16 +706,21 @@ function inferWorkflowAssetFromIr(ir, workflowId) {
     const attribution = trustedEvidenceCaptureAttribution(ir, { workflowId });
     return attribution.workflowAsset === "unknown" ? undefined : attribution.workflowAsset;
 }
+function agentTypeForWorkflowRole(role) {
+    if (!role)
+        return undefined;
+    return `dna-${role.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase()}`;
+}
+function subagentMatchesWorkflowRole(rawInput, wfState) {
+    return typeof rawInput.agent_type === "string" && rawInput.agent_type === agentTypeForWorkflowRole(wfState.current_role);
+}
 async function runCodexHookWithLoadedIr(rawInput, projectDir, args, ir) {
     const sessionId = typeof rawInput.session_id === "string"
         ? rawInput.session_id
         : typeof rawInput.sessionId === "string"
             ? rawInput.sessionId
             : undefined;
-    const sessionWorkflowState = sessionId
-        ? await readWorkflowState(projectDir, sessionId)
-        : null;
-    const workflowState = sessionWorkflowState ?? await readWorkflowState(projectDir);
+    const workflowState = await readWorkflowStateWithRootFallback(projectDir, sessionId);
     const workflowAsset = inferWorkflowAssetFromIr(ir, workflowState?.workflow);
     return runCodexHook({ ...rawInput, event: codexHookEventForInput(rawInput, args) }, {
         ir,
@@ -887,12 +938,21 @@ function artifactResolverErrorOutput(event, error) {
 }
 async function readWorkflowStateForHook(projectDir, event, sessionId) {
     try {
-        return { state: await readWorkflowState(projectDir, sessionId) };
+        const state = event === "SubagentStop"
+            ? await readWorkflowStateWithRootFallback(projectDir, sessionId)
+            : await readWorkflowState(projectDir, sessionId);
+        return { state };
     }
     catch (error) {
         return { output: artifactResolverErrorOutput(event, error) };
     }
 }
+async function readWorkflowStateWithRootFallback(projectDir, sessionId) {
+    if (!sessionId)
+        return readWorkflowState(projectDir);
+    const sessionState = await readWorkflowState(projectDir, sessionId);
+    return sessionState ?? readWorkflowState(projectDir);
+}
 async function resolveWorkflowArtifactFactsForHook(projectDir, ir, wfState, event, sessionId) {
     try {
         return { facts: await resolveWorkflowArtifactFacts(projectDir, ir, wfState, sessionId) };
@@ -1082,6 +1142,8 @@ async function runVerifierSpec(projectDir, ir, spec, workflowState, sessionId, o
     const entry = {
         verifier_id: spec.id,
         when: spec.when,
+        iteration: workflowState.iteration,
+        trigger_event: options?.triggerEvent,
         severity: spec.severity,
         kind: spec.kind,
         workflow: workflowState.workflow,
@@ -1109,10 +1171,41 @@ export async function runVerifiersForTest(projectDir, ir, workflowState, when, s
     }
     return results;
 }
+async function reusableSubagentStopResults(projectDir, ir, workflowState, when, sessionId) {
+    if (!sessionId)
+        return null;
+    const specs = (ir.verifier_specs ?? []).filter((spec) => spec.when === when &&
+        spec.workflow_name === workflowState.workflow &&
+        spec.step_id === workflowState.current_step);
+    if (specs.length === 0)
+        return [];
+    const startedAt = workflowState.started_at ? Date.parse(workflowState.started_at) : Number.NaN;
+    const prior = (await readVerifierResults(projectDir, sessionId)).filter((result) => result.trigger_event === "SubagentStop" &&
+        result.workflow === workflowState.workflow &&
+        result.step_id === workflowState.current_step &&
+        result.when === when &&
+        (workflowState.iteration === undefined || result.iteration === workflowState.iteration) &&
+        (Number.isNaN(startedAt) || Date.parse(result.timestamp) >= startedAt));
+    const latestByVerifier = new Map();
+    for (const result of prior)
+        latestByVerifier.set(result.verifier_id, result);
+    if (!specs.every((spec) => latestByVerifier.has(spec.id)))
+        return null;
+    return specs.map((spec) => latestByVerifier.get(spec.id));
+}
+async function runStopVerifiersForHook(projectDir, ir, workflowState, sessionId) {
+    const results = [];
+    for (const when of ["pre_handoff", "post_step"]) {
+        const reusable = await reusableSubagentStopResults(projectDir, ir, workflowState, when, sessionId);
+        results.push(...(reusable ?? await runVerifiersForTest(projectDir, ir, workflowState, when, sessionId, { triggerEvent: "Stop" })));
+    }
+    results.push(...await runVerifiersForTest(projectDir, ir, workflowState, "stop", sessionId, { triggerEvent: "Stop" }));
+    return results;
+}
 export async function runStopVerifiersForTest(projectDir, ir, workflowState, sessionId, options) {
     const results = [];
-    results.push(...await runVerifiersForTest(projectDir, ir, workflowState, "post_step", sessionId, options));
     results.push(...await runVerifiersForTest(projectDir, ir, workflowState, "pre_handoff", sessionId, options));
+    results.push(...await runVerifiersForTest(projectDir, ir, workflowState, "post_step", sessionId, options));
     results.push(...await runVerifiersForTest(projectDir, ir, workflowState, "stop", sessionId, options));
     return results;
 }
@@ -1229,7 +1322,7 @@ async function handleSurgeonReflection(ir, input, projectDir, sessionId) {
     if (!wfState || !wfState.active)
         return null;
     // Match agent_type to current role in workflow
-    const expectedAgentType = `dna-${wfState.current_role.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase()}`;
+    const expectedAgentType = agentTypeForWorkflowRole(wfState.current_role);
     if (agentType !== expectedAgentType)
         return null;
     // Look up step config from the compiled IR's workflow

package/dist/hooks/event-registry.js

@@ -39,7 +39,7 @@ export const HOOK_EVENT_REGISTRY = [
     {
         event: "SubagentStop",
         settingsKey: "subagentStop",
-        manifestTimeout: 3,
+        manifestTimeout: 45,
         surfaces: { protocol: true, cli: true, settings: true, manifest: true, mcp: true },
     },
     {

package/dist/hooks/state.d.ts

@@ -180,6 +180,8 @@ export interface VerifierResultEntry {
     result_id?: string;
     verifier_id: string;
     when: VerifierWhen;
+    iteration?: number;
+    trigger_event?: string;
     severity: VerifierSeverity;
     kind: VerifierKind;
     workflow?: string;

package/dist/hooks/state.js

@@ -338,6 +338,8 @@ export function verifierResultId(result) {
         .update(JSON.stringify({
         verifier_id: result.verifier_id,
         when: result.when,
+        iteration: result.iteration ?? 0,
+        trigger_event: result.trigger_event ?? "",
         severity: result.severity,
         kind: result.kind,
         workflow: result.workflow ?? "",
@@ -370,6 +372,8 @@ function verifierResultKey(result) {
     return [
         result.verifier_id,
         result.when,
+        result.iteration ?? 0,
+        result.trigger_event ?? "",
         result.severity,
         result.kind,
         result.workflow ?? "",

package/dist/mcp/index.js

@@ -16,6 +16,7 @@ import { createCompileTools } from "./tools-compile.js";
 import { createEnforceTools } from "./tools-enforce.js";
 import { createObservabilityTools } from "./tools-observability.js";
 import { createContextTools } from "./tools-context.js";
+import { createArtifactTools } from "./tools-artifacts.js";
 // Parse args
 const args = process.argv.slice(2);
 let projectDir = process.cwd();
@@ -38,6 +39,7 @@ const tools = [
     ...createStateTools(projectDir),
     ...createCompileTools(projectDir),
     ...createContextTools(projectDir),
+    ...createArtifactTools(projectDir),
     ...createEnforceTools(projectDir),
     ...createObservabilityTools(projectDir),
 ];

package/dist/mcp/tools-artifacts.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDef } from "./server.js";
+export declare function createArtifactTools(projectDir: string): ToolDef[];

package/dist/mcp/tools-artifacts.js

@@ -0,0 +1,137 @@
+import { createHash } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { errorResult, textResult } from "./server.js";
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function isContained(root, target) {
+    return target === root || target.startsWith(`${root}${sep}`);
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+function decodeJsonPointer(pointer) {
+    if (!pointer.startsWith("/") || /~(?:[^01]|$)/.test(pointer)) {
+        throw new Error("exclude_json_pointers must contain valid non-root JSON pointers");
+    }
+    return pointer.slice(1).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function omitJsonPointer(value, pointer) {
+    const segments = decodeJsonPointer(pointer);
+    let cursor = value;
+    for (const segment of segments.slice(0, -1)) {
+        if (!cursor || typeof cursor !== "object" || Array.isArray(cursor) || !Object.hasOwn(cursor, segment)) {
+            throw new Error(`JSON pointer does not identify an object member: ${pointer}`);
+        }
+        cursor = cursor[segment];
+    }
+    const leaf = segments.at(-1);
+    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor) || !Object.hasOwn(cursor, leaf)) {
+        throw new Error(`JSON pointer does not identify an object member: ${pointer}`);
+    }
+    delete cursor[leaf];
+}
+async function resolveArtifact(projectDir, requestedPath) {
+    if (!requestedPath || requestedPath.includes("\0") || isAbsolute(requestedPath)) {
+        throw new Error("path must be a non-empty project-relative path");
+    }
+    const root = await realpath(projectDir);
+    const lexicalTarget = resolve(root, requestedPath);
+    if (!isContained(root, lexicalTarget))
+        throw new Error("path escapes project directory");
+    let absolutePath;
+    try {
+        absolutePath = await realpath(lexicalTarget);
+    }
+    catch {
+        throw new Error("artifact is not a readable regular file");
+    }
+    if (!isContained(root, absolutePath))
+        throw new Error("path resolves outside project directory");
+    const artifactStat = await stat(absolutePath);
+    if (!artifactStat.isFile())
+        throw new Error("artifact is not a readable regular file");
+    return {
+        absolutePath,
+        projectRelativePath: relative(root, lexicalTarget).split(sep).join("/"),
+    };
+}
+export function createArtifactTools(projectDir) {
+    return [
+        {
+            name: "dna_artifact_digest",
+            description: "Read-only SHA-256 digest for one project-relative regular file. Supports raw bytes, whitespace-normalized text, and canonical JSON with explicit object-member exclusions; refuses project escapes and writes nothing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Project-relative path to a regular file" },
+                    mode: {
+                        type: "string",
+                        enum: ["bytes", "whitespace_normalized_text", "canonical_json"],
+                        description: "Digest representation (default: bytes)",
+                    },
+                    exclude_json_pointers: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "For canonical_json only, object members to omit using RFC 6901 JSON pointers",
+                    },
+                },
+                required: ["path"],
+            },
+            handler: async (args) => {
+                try {
+                    const requestedPath = typeof args.path === "string" ? args.path : "";
+                    const mode = (args.mode ?? "bytes");
+                    if (!["bytes", "whitespace_normalized_text", "canonical_json"].includes(mode)) {
+                        return errorResult("mode must be bytes, whitespace_normalized_text, or canonical_json");
+                    }
+                    const excluded = args.exclude_json_pointers === undefined
+                        ? []
+                        : Array.isArray(args.exclude_json_pointers) && args.exclude_json_pointers.every((item) => typeof item === "string")
+                            ? args.exclude_json_pointers
+                            : undefined;
+                    if (!excluded)
+                        return errorResult("exclude_json_pointers must be an array of strings");
+                    if (mode !== "canonical_json" && excluded.length > 0) {
+                        return errorResult("exclude_json_pointers is only valid with canonical_json mode");
+                    }
+                    const artifact = await resolveArtifact(projectDir, requestedPath);
+                    const content = await readFile(artifact.absolutePath);
+                    const artifactStat = await stat(artifact.absolutePath);
+                    const contentSha256 = sha256(content);
+                    let digest = contentSha256;
+                    if (mode === "whitespace_normalized_text") {
+                        digest = sha256(content.toString("utf-8").replace(/\s+/g, " ").trim());
+                    }
+                    else if (mode === "canonical_json") {
+                        const parsed = JSON.parse(content.toString("utf-8"));
+                        for (const pointer of excluded)
+                            omitJsonPointer(parsed, pointer);
+                        digest = sha256(canonicalJson(parsed));
+                    }
+                    return textResult(JSON.stringify({
+                        schema_version: "intentdna.artifact_digest.v1",
+                        path: artifact.projectRelativePath,
+                        mode,
+                        sha256: digest,
+                        content_sha256: contentSha256,
+                        size_bytes: content.byteLength,
+                        modified_at: artifactStat.mtime.toISOString(),
+                        excluded_json_pointers: excluded,
+                        read_only: true,
+                    }, null, 2));
+                }
+                catch (error) {
+                    return errorResult(error instanceof Error ? error.message : "artifact digest failed");
+                }
+            },
+        },
+    ];
+}

package/dist/runtime/settings-adapter.js

@@ -46,6 +46,7 @@ export function recommendHookTimeouts(ir, baseTimeout = 10) {
             spec.checkpoint?.assert === "no_test_regression")) ?? false;
     if (hasStopCommandVerifiers) {
         timeouts.stop = Math.max(baseTimeout, 45);
+        timeouts.subagentStop = Math.max(baseTimeout, 45);
     }
     return timeouts;
 }
@@ -70,7 +71,7 @@ export function detectEnabledEvents(ir) {
     if (ir.prompt_directives.some(d => d.priority === "high")) {
         events.push("userPromptSubmit");
     }
-    if (hasRoleScope) {
+    if (hasRoleScope || hasStopVerifiers) {
         events.push("subagentStop");
     }
     if (ir.prompt_directives.length > 0) {

package/dist/runtime/skill-adapter.js

@@ -448,10 +448,19 @@ function workflowSkillMapEntry(skillName, dirName, plan) {
         produces,
     };
 }
+function inferredWorkflowAsset(ir) {
+    const sourceIds = [...new Set(ir?.source_dna_ids ?? [])]
+        .filter((sourceId) => sourceId.length > 0)
+        .filter((sourceId) => !sourceId.startsWith("species:"))
+        .filter((sourceId) => !sourceId.startsWith("enterprise:"));
+    return sourceIds.length === 1 ? sourceIds[0] : undefined;
+}
 export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
     const lines = [];
     const skillName = `dna-${toKebabCase(plan.name)}`;
     const surface = options?.surface ?? "claude_code";
+    const workflowId = plan.workflow_key ?? plan.source_workflow;
+    const workflowAsset = inferredWorkflowAsset(ir);
     assertSafeGeneratedName(skillName, "skill name");
     // Frontmatter
     lines.push("---");
@@ -478,9 +487,20 @@ export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
         lines.push("");
     }
     lines.push("<Workflow_State>");
-    lines.push("At workflow start, persist runtime inputs in DNA workflow state before executing steps.");
+    lines.push("At workflow start, call the MCP tool `dna_workflow_write` before any step or hook-triggering action so hook verifier evidence is attributed to this workflow instead of `*:direct`.");
+    lines.push(`Use workflow id \`${workflowId}\`.`);
+    if (workflowAsset) {
+        lines.push(`Use workflow_asset \`${workflowAsset}\`; it is the single non-species/non-enterprise IR source id.`);
+    }
+    else {
+        lines.push("Do not set workflow_asset: IR does not provide exactly one non-species/non-enterprise source id, so the asset cannot be inferred safely.");
+    }
+    const firstStep = plan.steps[0];
+    lines.push(`Initial state write: workflow=${workflowId}, current_step=${firstStep.id}, current_role=${firstStep.role}, iteration=1, active=true.`);
     lines.push("Record the invocation argument as inputs.ARGUMENTS so handoff artifact paths like $ARGUMENTS can be resolved deterministically.");
     lines.push("If template variables are shown below, persist their resolved values as resolved_variables.");
+    lines.push("Before each workflow step, call `dna_workflow_write` again with workflow, workflow_asset only when safely inferred above, current_step, current_role, iteration, active=true, inputs.ARGUMENTS, and resolved_variables.");
+    lines.push("At workflow completion or terminal failure, call `dna_workflow_write` with active=false using the same workflow id and safe workflow_asset value.");
     lines.push("</Workflow_State>");
     lines.push("");
     // Required Context — context files that must be read before any work
@@ -607,6 +627,7 @@ export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
             const agentPrompt = escapePrompt(promptParts.join(" "));
             lines.push(`${stepNumber}. **${step.id}**${optional}`);
             lines.push(`   ${step.description}${runIf}`);
+            lines.push(`   Before this step, call \`dna_workflow_write\` with workflow=${workflowId}, current_step=${step.id}, current_role=${step.role}, iteration=<current iteration>, active=true, inputs.ARGUMENTS, resolved_variables, and ${workflowAsset ? `workflow_asset=${workflowAsset}` : "no workflow_asset unless one has been explicitly supplied by trusted workflow state"}.`);
             lines.push("");
             if (humanOwned) {
                 lines.push("   **Human-owned gate (`model: human`)**");
@@ -640,6 +661,11 @@ export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
                 const artifacts = step.handoff.produces.map(p => p.description).join(", ");
                 lines.push(`   Verify produced artifacts: ${artifacts}`);
             }
+            pushWorkflowStepVerifierLines(lines, step, "   ");
+            if (step.completion?.length || step.checkpoints?.length) {
+                lines.push("   If any completion/checkpoint gate fails, preserve the exact verifier diagnostics verbatim: id, check/assert or command, message, evidence, target/artifact, and exit_code when available.");
+                lines.push(`   Feed those exact diagnostics to ${step.on_fail === "retry_with_feedback" ? "this step's on_fail retry" : "the retry_from/on_fail step"} before any retry, reanalysis, or downstream transition.`);
+            }
             lines.push("");
             // Reflection gate: inject Reflection_Gate after steps with max_attempts
             if (step.max_attempts) {
@@ -648,8 +674,9 @@ export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
                 const blockedPath = step.blocked_items_path ?? "blocked_items.md";
                 lines.push(`<Reflection_Gate>`);
                 lines.push(`max_attempts=${step.max_attempts}, handoff_to=${handoffStep}, max_handoffs=${maxH}`);
-                lines.push(`No test progress after ${step.max_attempts} attempts → handoff to ${handoffStep} for re-analysis.`);
-                lines.push(`After ${maxH} handoffs with no progress → SKIP and record to ${blockedPath}.`);
+                lines.push(`No declared completion progress after ${step.max_attempts} attempts → handoff to ${handoffStep} for re-analysis.`);
+                lines.push(`When the declared gates are test or no_test_regression gates, preserve the existing test-progress meaning as part of declared completion progress.`);
+                lines.push(`After ${maxH} handoffs with no declared completion progress → SKIP and record to ${blockedPath}.`);
                 lines.push(`</Reflection_Gate>`);
                 lines.push("");
             }
@@ -662,7 +689,9 @@ export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
         lines.push(`- max_retries: ${plan.retry.max_retries}`);
         lines.push(`- retry_from: ${plan.retry.retry_from ?? "first_failed_step"}`);
         lines.push(`- backoff: ${plan.retry.backoff}`);
-        lines.push("- On a blocking checkpoint or validator failure, preserve the exact diagnostics and return them to the retry_from step.");
+        lines.push("- On a blocking completion, checkpoint, or validator failure, preserve the exact diagnostics and return them verbatim to the retry_from/on_fail step.");
+        lines.push("- Exact diagnostics means every available id/result_id, check/assert or command, message, evidence, target/artifact, and exit_code. Do not paraphrase away failed paths, command output, or policy-denied exit codes.");
+        lines.push("- Retry prompts must include the prior failed step id, the declared gates that failed, and the exact verifier diagnostics before asking for another attempt.");
         lines.push("- Repeat only the retry slice and its dependent steps; do not continue to save, adoption, or sync while validation is red.");
         lines.push("- Stop and report the remaining diagnostics when the retry budget is exhausted.");
         lines.push("</Retry_Policy>");
@@ -797,6 +826,7 @@ export function compileWorkflowToSkill(plan, roles, ir, variables, options) {
     }
     // Workflow Boundary — prevent cross-workflow execution
     lines.push("<Workflow_Boundary>");
+    lines.push(`Before reporting final success, terminal failure, or exhaustion, call \`dna_workflow_write\` with workflow=${workflowId}, current_step=workflow_complete, current_role=workflow, active=false, and ${workflowAsset ? `workflow_asset=${workflowAsset}` : "no workflow_asset unless one has been explicitly supplied by trusted workflow state"}.`);
     lines.push("This workflow is COMPLETE. Do NOT proceed to any other workflow.");
     lines.push("Report your results and STOP. The user will decide the next step.");
     lines.push("</Workflow_Boundary>");

package/dist/runtime/verifier.d.ts

@@ -1,6 +1,8 @@
 import type { CompletionCheck, ConstraintIR, StepCheckpoint, VerifierCommandPolicy } from "../schema/types.js";
 export declare const DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS = 30000;
 export declare const MAX_VERIFIER_EVIDENCE_BYTES = 4096;
+export declare const VERIFIER_DIAGNOSTIC_PREFIX = "INTENTDNA_DIAGNOSTIC:";
+export declare const MAX_VERIFIER_DIAGNOSTIC_BYTES = 2048;
 export interface VerifierRuntimeContext {
     projectDir: string;
     variables?: Record<string, string>;
@@ -29,7 +31,7 @@ export declare function hasUnresolvedVerifierTemplate(value: string): boolean;
 export declare function unresolvedVerifierTemplateMessage(value: string): string;
 export declare function hasUnsafeShellControl(command: string): boolean;
 export declare function isVerifierCommandAllowed(policy: VerifierCommandPolicy | undefined, command: string): boolean;
-export declare function verifierCommandPolicyMessage(command: string): string;
+export declare function verifierCommandPolicyMessage(_command: string): string;
 export declare function isBuiltinAssertAllowed(policy: VerifierCommandPolicy | undefined, assertName: string): boolean;
 export declare function verifierAssertPolicyMessage(assertName: string): string;
 export declare function trimVerifierEvidence(raw: string | undefined): string | undefined;

package/dist/runtime/verifier.js

@@ -3,6 +3,9 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 export const DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS = 30_000;
 export const MAX_VERIFIER_EVIDENCE_BYTES = 4096;
+export const VERIFIER_DIAGNOSTIC_PREFIX = "INTENTDNA_DIAGNOSTIC:";
+export const MAX_VERIFIER_DIAGNOSTIC_BYTES = 2048;
+const VERIFIER_DIAGNOSTIC_CODE = /^INTENTDNA_DIAGNOSTIC:[A-Za-z0-9][A-Za-z0-9_.:-]{0,255}$/;
 const SAFE_COMMAND_VARIABLE_RE = /^[A-Za-z0-9_-]+$/;
 const SAFE_PATH_VARIABLE_RE = /^[-A-Za-z0-9_./]+$/;
 export function resolveVerifierTemplate(template, variables) {
@@ -59,7 +62,7 @@ function resolveVerifierCommand(rawCommand, policy, variables) {
         return { target: declaredCommand, evidence: "policy_denied", exit_code: 126, message: verifierCommandPolicyMessage(declaredCommand) };
     }
     const safeVariables = validateVerifierTemplateVariables(declaredCommand, variables, "command");
-    if (!safeVariables.valid) {
+    if (safeVariables.valid === false) {
         return { target: declaredCommand, evidence: safeVariables.evidence, exit_code: 126, message: safeVariables.message };
     }
     const command = resolveVerifierTemplate(declaredCommand, variables).trim();
@@ -137,8 +140,8 @@ export function isVerifierCommandAllowed(policy, command) {
         return false;
     return policy.allow_command_prefixes?.some((prefix) => normalized.startsWith(prefix)) ?? false;
 }
-export function verifierCommandPolicyMessage(command) {
-    return `Verifier command not allowed by verifier_policy: ${command}`;
+export function verifierCommandPolicyMessage(_command) {
+    return "Verifier command not allowed by verifier_policy";
 }
 export function isBuiltinAssertAllowed(policy, assertName) {
     return policy?.allow_builtin_asserts?.includes(assertName) ?? false;
@@ -156,12 +159,52 @@ export function trimVerifierEvidence(raw) {
         ? trimmed.slice(0, MAX_VERIFIER_EVIDENCE_BYTES)
         : trimmed;
 }
+function sanitizeVerifierDiagnosticLine(raw) {
+    return raw
+        .replace(/[\u0000-\u0008\u000B\u000C\u000D\u000E-\u001F\u007F]/g, "")
+        .trim();
+}
+function trimDiagnosticBytes(raw) {
+    const marker = "...[truncated]";
+    if (Buffer.byteLength(raw, "utf8") <= MAX_VERIFIER_DIAGNOSTIC_BYTES)
+        return raw;
+    let trimmed = raw;
+    while (trimmed.length > 0 && Buffer.byteLength(`${trimmed}${marker}`, "utf8") > MAX_VERIFIER_DIAGNOSTIC_BYTES) {
+        trimmed = trimmed.slice(0, -1);
+    }
+    return `${trimmed}${marker}`;
+}
+function extractVerifierDiagnostics(raw) {
+    return raw
+        .split(/\r?\n/)
+        .map((line) => sanitizeVerifierDiagnosticLine(line))
+        .filter((line) => VERIFIER_DIAGNOSTIC_CODE.test(line));
+}
+function collectVerifierDiagnostics(pendingLine, chunk, diagnostics) {
+    const lines = `${pendingLine}${chunk}`.split("\n");
+    const nextPendingLine = lines.pop() ?? "";
+    diagnostics.push(...extractVerifierDiagnostics(lines.join("\n")));
+    return nextPendingLine.length > MAX_VERIFIER_EVIDENCE_BYTES
+        ? nextPendingLine.slice(0, MAX_VERIFIER_EVIDENCE_BYTES)
+        : nextPendingLine;
+}
+function summarizeCommandEvidenceFromStats(stdoutBytes, stderrBytes, diagnostics = []) {
+    const summary = stdoutBytes === 0 && stderrBytes === 0
+        ? undefined
+        : `stdout_bytes=${stdoutBytes} stderr_bytes=${stderrBytes}`;
+    const diagnostic = diagnostics.length > 0
+        ? trimDiagnosticBytes(diagnostics.join("\n"))
+        : undefined;
+    return trimVerifierEvidence([summary, diagnostic].filter(Boolean).join("\n"));
+}
 export function summarizeCommandEvidence(stdout, stderr) {
     const stdoutBytes = Buffer.byteLength(stdout, "utf8");
     const stderrBytes = Buffer.byteLength(stderr, "utf8");
-    if (stdoutBytes === 0 && stderrBytes === 0)
-        return undefined;
-    return trimVerifierEvidence(`stdout_bytes=${stdoutBytes} stderr_bytes=${stderrBytes}`);
+    return summarizeCommandEvidenceFromStats(stdoutBytes, stderrBytes, extractVerifierDiagnostics(`${stdout}\n${stderr}`));
+}
+function appendFailureDiagnostic(message, evidence) {
+    const diagnostics = extractVerifierDiagnostics(evidence ?? "").join("\n");
+    return diagnostics ? `${message}\n${diagnostics}` : message;
 }
 export async function execVerifierCommand(projectDir, command, timeoutMs = DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS, env) {
     return new Promise((resolvePromise) => {
@@ -170,9 +213,12 @@ export async function execVerifierCommand(projectDir, command, timeoutMs = DEFAU
             stdio: ["ignore", "pipe", "pipe"],
             env: { ...process.env, ...(env ?? {}) },
         });
-        let stdout = "";
-        let stderr = "";
+        let stdoutPendingLine = "";
+        let stderrPendingLine = "";
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
         let settled = false;
+        const diagnostics = [];
         const settle = (result) => {
             if (settled)
                 return;
@@ -183,29 +229,36 @@ export async function execVerifierCommand(projectDir, command, timeoutMs = DEFAU
         const timeoutId = setTimeout(() => {
             child.kill("SIGTERM");
             setTimeout(() => child.kill("SIGKILL"), 1000).unref();
-            settle({ passed: false, timedOut: true, exitCode: 124, evidence: summarizeCommandEvidence(stdout, stderr) });
+            diagnostics.push(...extractVerifierDiagnostics(`${stdoutPendingLine}\n${stderrPendingLine}`));
+            settle({ passed: false, timedOut: true, exitCode: 124, evidence: summarizeCommandEvidenceFromStats(stdoutBytes, stderrBytes, diagnostics) });
         }, timeoutMs);
         child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-            if (stdout.length > MAX_VERIFIER_EVIDENCE_BYTES)
-                stdout = stdout.slice(0, MAX_VERIFIER_EVIDENCE_BYTES);
+            const text = String(chunk);
+            stdoutBytes += Buffer.byteLength(text, "utf8");
+            stdoutPendingLine = collectVerifierDiagnostics(stdoutPendingLine, text, diagnostics);
         });
         child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-            if (stderr.length > MAX_VERIFIER_EVIDENCE_BYTES)
-                stderr = stderr.slice(0, MAX_VERIFIER_EVIDENCE_BYTES);
+            const text = String(chunk);
+            stderrBytes += Buffer.byteLength(text, "utf8");
+            stderrPendingLine = collectVerifierDiagnostics(stderrPendingLine, text, diagnostics);
         });
         child.on("error", () => settle({
             passed: false,
             timedOut: false,
             exitCode: 1,
-            evidence: summarizeCommandEvidence(stdout, stderr),
+            evidence: summarizeCommandEvidenceFromStats(stdoutBytes, stderrBytes, [
+                ...diagnostics,
+                ...extractVerifierDiagnostics(`${stdoutPendingLine}\n${stderrPendingLine}`),
+            ]),
         }));
         child.on("close", (code) => settle({
             passed: code === 0,
             timedOut: false,
             exitCode: code ?? 1,
-            evidence: summarizeCommandEvidence(stdout, stderr),
+            evidence: summarizeCommandEvidenceFromStats(stdoutBytes, stderrBytes, [
+                ...diagnostics,
+                ...extractVerifierDiagnostics(`${stdoutPendingLine}\n${stderrPendingLine}`),
+            ]),
         }));
     });
 }
@@ -296,7 +349,7 @@ export async function runCompletionVerifier(completion, ir, context) {
     }
     if (completion.file_exists) {
         const safeVariables = validateVerifierTemplateVariables(completion.file_exists, context.variables, "path");
-        if (!safeVariables.valid)
+        if (safeVariables.valid === false)
             return { passed: false, target: completion.file_exists, evidence: safeVariables.evidence, message: safeVariables.message };
         const target = resolveVerifierTemplate(completion.file_exists, context.variables);
         if (hasUnresolvedVerifierTemplate(target))
@@ -316,7 +369,7 @@ export async function runCompletionVerifier(completion, ir, context) {
     }
     if (completion.file_not_empty) {
         const safeVariables = validateVerifierTemplateVariables(completion.file_not_empty, context.variables, "path");
-        if (!safeVariables.valid)
+        if (safeVariables.valid === false)
             return { passed: false, target: completion.file_not_empty, evidence: safeVariables.evidence, message: safeVariables.message };
         const target = resolveVerifierTemplate(completion.file_not_empty, context.variables);
         if (hasUnresolvedVerifierTemplate(target))
@@ -338,10 +391,10 @@ export async function runCompletionVerifier(completion, ir, context) {
     }
     if (completion.file_contains) {
         const safeTargetVariables = validateVerifierTemplateVariables(completion.file_contains.path, context.variables, "path");
-        if (!safeTargetVariables.valid)
+        if (safeTargetVariables.valid === false)
             return { passed: false, target: completion.file_contains.path, evidence: safeTargetVariables.evidence, message: safeTargetVariables.message };
         const safePatternVariables = validateVerifierTemplateVariables(completion.file_contains.pattern, context.variables);
-        if (!safePatternVariables.valid)
+        if (safePatternVariables.valid === false)
             return { passed: false, target: completion.file_contains.pattern, evidence: safePatternVariables.evidence, message: safePatternVariables.message };
         const target = resolveVerifierTemplate(completion.file_contains.path, context.variables);
         const pattern = resolveVerifierTemplate(completion.file_contains.pattern, context.variables);
@@ -379,8 +432,8 @@ export async function runCompletionVerifier(completion, ir, context) {
         message: commandResult.passed
             ? undefined
             : commandResult.timedOut
-                ? `Verifier command timed out after ${context.commandTimeoutMs ?? DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS}ms: ${command}`
-                : `Verifier command failed: ${command}`,
+                ? `Verifier command timed out after ${context.commandTimeoutMs ?? DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS}ms`
+                : appendFailureDiagnostic("Verifier command failed", commandResult.evidence),
     };
 }
 export async function runCheckpointVerifier(checkpoint, ir, context) {
@@ -405,8 +458,8 @@ export async function runCheckpointVerifier(checkpoint, ir, context) {
             message: commandResult.passed
                 ? checkpoint.message
                 : commandResult.timedOut
-                    ? `Verifier command timed out after ${context.commandTimeoutMs ?? DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS}ms: ${command}`
-                    : `Verifier command failed: ${command}`,
+                    ? `Verifier command timed out after ${context.commandTimeoutMs ?? DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS}ms`
+                    : appendFailureDiagnostic("Verifier command failed", commandResult.evidence),
         };
     }
     if (checkpoint.assert === "clean_working_tree") {
@@ -454,8 +507,10 @@ export async function runCheckpointVerifier(checkpoint, ir, context) {
             message: commandResult.passed
                 ? checkpoint.message
                 : commandResult.timedOut
-                    ? `Verifier command timed out after ${context.commandTimeoutMs ?? DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS}ms: ${assertCommands[checkpoint.assert]}`
-                    : checkpoint.message,
+                    ? `Verifier command timed out after ${context.commandTimeoutMs ?? DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS}ms`
+                    : checkpoint.message
+                        ? appendFailureDiagnostic(checkpoint.message, commandResult.evidence)
+                        : appendFailureDiagnostic("Verifier command failed", commandResult.evidence),
         };
     }
     return { passed: false, target: checkpoint.assert, exit_code: 1, message: checkpoint.message };

package/dist/templates/flutter-rewrite.dna.yaml

@@ -166,7 +166,8 @@ context_files:
 
 verifier_policy:
   allow_commands:
-    - "node -e \"const fs=require('node:fs');const crypto=require('node:crypto');const path=require('node:path');const mod=process.env.ARGUMENTS||'$ARGUMENTS';const allowed=['BUG','UNIMPLEMENTED','INFRA','REMOVED','TEST_BUG'];const action=['BUG','UNIMPLEMENTED','INFRA','TEST_BUG'];const fail=m=>{throw new Error(m)};const same=(a,b)=>Array.isArray(a)&&a.length===b.length&&a.every((v,i)=>v===b[i]);const snapSame=(a,b)=>a&&b&&a.baseline_source_sha256===b.baseline_source_sha256&&a.diagnosis_artifact_sha256===b.diagnosis_artifact_sha256&&a.observed_failure_count===b.observed_failure_count&&a.work_item_count===b.work_item_count&&same(a.allowed_kinds,b.allowed_kinds);const root=process.cwd();const inside=p=>{if(typeof p!=='string'||!p||path.isAbsolute(p))fail('path_invalid');const r=path.resolve(root,p);if(r!==root&&!r.startsWith(root+path.sep))fail('path_escape');return r};const readJson=p=>JSON.parse(fs.readFileSync(inside(p),'utf8'));if(!/^[A-Za-z0-9_-]+$/.test(mod))fail('module');const contractPath='.dna/specs/diagnosis-'+mod+'.contract.json';const reviewPath='.dna/specs/diagnosis-'+mod+'.review.json';const diagnosisPath='.dna/specs/diagnosis-'+mod+'.md';const data=readJson(contractPath);if(data.contract_version!=='diagnosis-contract/v1')fail('contract_version');if(data.module!==mod)fail('module_mismatch');if(data.diagnosis_artifact!==diagnosisPath)fail('diagnosis_artifact_path');if(!same(data.allowed_kinds,allowed))fail('allowed_kinds');const observed=Array.isArray(data.observed_failures)?data.observed_failures:fail('observed_failures');const work=Array.isArray(data.work_items)?data.work_items:fail('work_items');if(!observed.length)fail('empty_observed_failures');if(!work.length)fail('empty_work_items');const ids=new Set(observed.map(x=>x&&x.id).filter(Boolean));if(ids.size!==observed.length)fail('observed_failure_ids');const failureById=new Map();for(const f of observed){if(typeof f.test_name!=='string'||!f.test_name.trim())fail('observed_failure_test_name');if(typeof f.symptom!=='string'||!f.symptom.trim())fail('observed_failure_symptom');if(!Array.isArray(f.evidence_paths)||!f.evidence_paths.length)fail('observed_failure_evidence');for(const p of f.evidence_paths)inside(p);if(f.kind!==undefined)fail('observed_failure_kind_forbidden');failureById.set(f.id,f)}const mapped=new Set();for(const item of work){if(!allowed.includes(item.kind))fail('invalid_kind');if(item.kind==='PLACEHOLDER_CONTRACT')fail('placeholder_kind');if(!Array.isArray(item.observed_failure_ids)||!item.observed_failure_ids.length)fail('work_item_observed_failure_ids');if(!Array.isArray(item.evidence_paths)||!item.evidence_paths.length)fail('work_item_evidence');for(const p of item.evidence_paths)inside(p);if(action.includes(item.kind)){if(!Array.isArray(item.v1_evidence_paths)||!item.v1_evidence_paths.length)fail('work_item_v1_evidence');if(!Array.isArray(item.v2_evidence_paths)||!item.v2_evidence_paths.length)fail('work_item_v2_evidence');for(const p of item.v1_evidence_paths)inside(p);for(const p of item.v2_evidence_paths)inside(p)}for(const id of item.observed_failure_ids){const f=failureById.get(id);if(!f)fail('unknown_observed_failure_id');if(action.includes(item.kind)&&(!f.test_name||!String(f.test_name).trim()))fail('action_test_evidence');mapped.add(id)}}if(mapped.size!==ids.size)fail('unmapped_observed_failures');for(const f of observed.filter(x=>String(x.symptom).includes('PLACEHOLDER_CONTRACT'))){const kinds=new Set(work.filter(i=>i.observed_failure_ids.includes(f.id)).map(i=>i.kind));if(![...kinds].every(k=>k==='TEST_BUG'||k==='UNIMPLEMENTED')||kinds.size===0)fail('placeholder_mapping')}const counts=data.baseline&&data.baseline.counts;if(!data.baseline||!data.baseline.source_path||!counts)fail('baseline');inside(data.baseline.source_path);for(const k of ['failed','skipped','hung']){if(!Number.isInteger(counts[k])||counts[k]<0)fail('baseline_count_'+k)}const total=counts.failed+counts.skipped+counts.hung;if(total!==observed.length)fail('baseline_count_mismatch');const summary=data.summary_counts||{};for(const kind of allowed){if(!Number.isInteger(summary[kind])||summary[kind]!==work.filter(x=>x.kind===kind).length)fail('summary_count_'+kind)}const sha=p=>crypto.createHash('sha256').update(fs.readFileSync(inside(p))).digest('hex');const snap=data.contract_snapshot||{};if(snap.observed_failure_count!==observed.length||snap.work_item_count!==work.length||!same(snap.allowed_kinds,allowed))fail('contract_snapshot');if(snap.baseline_source_sha256!==sha(data.baseline.source_path))fail('baseline_sha256');if(snap.diagnosis_artifact_sha256!==sha(diagnosisPath))fail('diagnosis_sha256');if(!data.staleness||data.staleness.is_stale!==false)fail('stale_contract');const review=readJson(reviewPath);if(review.contract_version!=='diagnosis-contract-review/v1')fail('review_contract_version');if(review.contract_valid!==true)fail('review_contract_valid');if(review.verdict!=='APPROVE')fail('review_verdict');if(review.contract_artifact_reviewed!==contractPath)fail('review_contract_artifact_path');if(review.artifact_reviewed!==diagnosisPath)fail('review_artifact_path');if(!snapSame(review.contract_snapshot,snap))fail('review_contract_snapshot');if(!review.updated_at||Number.isNaN(Date.parse(review.updated_at)))fail('review_updated_at');if(!Array.isArray(review.evidence_paths)||!review.evidence_paths.length)fail('review_evidence_paths');for(const p of review.evidence_paths)inside(p);const cm=fs.statSync(inside(contractPath)).mtimeMs;const dm=fs.statSync(inside(diagnosisPath)).mtimeMs;const rm=fs.statSync(inside(reviewPath)).mtimeMs;if(rm<cm||rm<dm)fail('review_stale');\""
+    - "node -e \"const fs=require('node:fs');const crypto=require('node:crypto');const path=require('node:path');const mod=process.env.ARGUMENTS||'$ARGUMENTS';const allowed=['BUG','UNIMPLEMENTED','INFRA','REMOVED','TEST_BUG'];const action=['BUG','UNIMPLEMENTED','INFRA','TEST_BUG'];const fail=m=>{console.error('INTENTDNA_DIAGNOSTIC:'+m);process.exit(1)};const same=(a,b)=>Array.isArray(a)&&a.length===b.length&&a.every((v,i)=>v===b[i]);const legacySame=(a,b)=>a&&b&&a.baseline_source_sha256===b.baseline_source_sha256&&a.diagnosis_artifact_sha256===b.diagnosis_artifact_sha256&&a.observed_failure_count===b.observed_failure_count&&a.work_item_count===b.work_item_count&&same(a.allowed_kinds,b.allowed_kinds);const modern=s=>s&&typeof s.sidecar_semantic_sha256==='string'&&typeof s.diagnosis_semantic_sha256==='string';const root=fs.realpathSync(process.cwd());const inside=p=>{if(typeof p!=='string'||!p||path.isAbsolute(p))fail('path_invalid');const r=path.resolve(root,p);if(r!==root&&!r.startsWith(root+path.sep))fail('path_escape');if(fs.existsSync(r)){const real=fs.realpathSync(r);if(real!==root&&!real.startsWith(root+path.sep))fail('path_escape')}return r};const readJson=p=>JSON.parse(fs.readFileSync(inside(p),'utf8'));const hash=v=>crypto.createHash('sha256').update(v).digest('hex');const fileHash=p=>hash(fs.readFileSync(inside(p)));const normalizedDiagnosisHash=p=>hash(fs.readFileSync(inside(p),'utf8').replace(/\\s+/g,' ').trim());const canon=v=>Array.isArray(v)?'['+v.map(canon).join(',')+']':v&&typeof v==='object'?'{'+Object.keys(v).sort().map(k=>JSON.stringify(k)+':'+canon(v[k])).join(',')+'}':JSON.stringify(v);if(!/^[A-Za-z0-9_-]+$/.test(mod))fail('module');const contractPath='.dna/specs/diagnosis-'+mod+'.contract.json';const reviewPath='.dna/specs/diagnosis-'+mod+'.review.json';const diagnosisPath='.dna/specs/diagnosis-'+mod+'.md';const behaviorPath='docs/behavior/'+mod+'.md';const data=readJson(contractPath);if(data.contract_version!=='diagnosis-contract/v1')fail('contract_version');if(data.module!==mod)fail('module_mismatch');if(data.diagnosis_artifact!==diagnosisPath)fail('diagnosis_artifact_path');if(!same(data.allowed_kinds,allowed))fail('allowed_kinds');const observed=Array.isArray(data.observed_failures)?data.observed_failures:fail('observed_failures');const work=Array.isArray(data.work_items)?data.work_items:fail('work_items');if(!observed.length)fail('empty_observed_failures');if(!work.length)fail('empty_work_items');const idOk=id=>typeof id==='string'&&/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(id);const ids=new Set();for(const f of observed){if(!idOk(f&&f.id)||ids.has(f.id))fail('observed_failure_ids');ids.add(f.id)}const workIds=new Set();for(const item of work){if(!idOk(item&&item.id)||workIds.has(item.id))fail('work_item_ids');workIds.add(item.id)}const failureById=new Map();for(const f of observed){if(typeof f.test_name!=='string'||!f.test_name.trim())fail('observed_failure_test_name');if(typeof f.symptom!=='string'||!f.symptom.trim())fail('observed_failure_symptom');if(!Array.isArray(f.evidence_paths)||!f.evidence_paths.length)fail('observed_failure_evidence');for(const p of f.evidence_paths)inside(p);if(f.kind!==undefined)fail('observed_failure_kind_forbidden');failureById.set(f.id,f)}const mapped=new Set();for(const item of work){if(!allowed.includes(item.kind))fail('invalid_kind');if(item.kind==='PLACEHOLDER_CONTRACT')fail('placeholder_kind');if(!Array.isArray(item.observed_failure_ids)||!item.observed_failure_ids.length)fail('work_item_observed_failure_ids');if(!Array.isArray(item.evidence_paths)||!item.evidence_paths.length)fail('work_item_evidence');for(const p of item.evidence_paths)inside(p);if(action.includes(item.kind)){if(!Array.isArray(item.v1_evidence_paths)||!item.v1_evidence_paths.length)fail('work_item_v1_evidence');if(!Array.isArray(item.v2_evidence_paths)||!item.v2_evidence_paths.length)fail('work_item_v2_evidence');for(const p of item.v1_evidence_paths)inside(p);for(const p of item.v2_evidence_paths)inside(p)}for(const id of item.observed_failure_ids){const f=failureById.get(id);if(!f)fail('unknown_observed_failure_id');if(action.includes(item.kind)&&(!f.test_name||!String(f.test_name).trim()))fail('action_test_evidence');mapped.add(id)}}if(mapped.size!==ids.size)fail('unmapped_observed_failures');for(const f of observed.filter(x=>String(x.symptom).includes('PLACEHOLDER_CONTRACT'))){const kinds=new Set(work.filter(i=>i.observed_failure_ids.includes(f.id)).map(i=>i.kind));if(![...kinds].every(k=>k==='TEST_BUG'||k==='UNIMPLEMENTED')||kinds.size===0)fail('placeholder_mapping')}const counts=data.baseline&&data.baseline.counts;if(!data.baseline||!data.baseline.source_path||!counts)fail('baseline');for(const k of ['failed','skipped','hung']){if(!Number.isInteger(counts[k])||counts[k]<0)fail('baseline_count_'+k)}if(counts.failed+counts.skipped+counts.hung!==observed.length)fail('baseline_count_mismatch');const summary=data.summary_counts||{};for(const kind of allowed){if(!Number.isInteger(summary[kind])||summary[kind]!==work.filter(x=>x.kind===kind).length)fail('summary_count_'+kind)}const snap=data.contract_snapshot||{};const baselineHash=fileHash(data.baseline.source_path);const diagnosisHash=fileHash(diagnosisPath);if(snap.observed_failure_count!==observed.length||snap.work_item_count!==work.length||!same(snap.allowed_kinds,allowed))fail('contract_snapshot');if(snap.baseline_source_sha256!==baselineHash)fail('baseline_sha256');if(snap.diagnosis_artifact_sha256!==diagnosisHash)fail('diagnosis_sha256');const stale=data.staleness;if(!stale||stale.is_stale!==false)fail('stale_contract');const source=(entry,p,n,expected)=>{if(!entry||entry.path!==p)fail('staleness_'+n+'_path');if(entry.sha256!==expected)fail('staleness_'+n+'_sha256')};source(stale.behavior_doc,behaviorPath,'behavior_doc',fileHash(behaviorPath));source(stale.baseline,data.baseline.source_path,'baseline',baselineHash);source(stale.diagnosis_artifact,diagnosisPath,'diagnosis_artifact',diagnosisHash);const semantic=JSON.parse(JSON.stringify(data));delete semantic.contract_snapshot.sidecar_semantic_sha256;delete semantic.contract_snapshot.diagnosis_artifact_sha256;delete semantic.staleness.diagnosis_artifact;const sidecarSemanticHash=hash(canon(semantic));const diagnosisSemanticHash=normalizedDiagnosisHash(diagnosisPath);if(snap.sidecar_semantic_sha256!==sidecarSemanticHash||snap.diagnosis_semantic_sha256!==diagnosisSemanticHash)fail('contract_snapshot_semantic');if(fs.existsSync(inside(reviewPath))){const prev=readJson(reviewPath);if(prev.verdict==='REQUEST_REANALYSIS'){const ps=prev.contract_snapshot||{};const unchanged=modern(ps)?ps.sidecar_semantic_sha256===sidecarSemanticHash&&ps.diagnosis_semantic_sha256===diagnosisSemanticHash:legacySame(ps,snap);if(unchanged)fail('reanalysis_unchanged');const cm=fs.statSync(inside(contractPath)).mtimeMs;const dm=fs.statSync(inside(diagnosisPath)).mtimeMs;const rm=fs.statSync(inside(reviewPath)).mtimeMs;if(cm<=rm||dm<=rm)fail('reanalysis_not_rewritten')}}\""
+    - "node -e \"const fs=require('node:fs');const crypto=require('node:crypto');const path=require('node:path');const mod=process.env.ARGUMENTS||'$ARGUMENTS';const allowed=['BUG','UNIMPLEMENTED','INFRA','REMOVED','TEST_BUG'];const action=['BUG','UNIMPLEMENTED','INFRA','TEST_BUG'];const fail=m=>{console.error('INTENTDNA_DIAGNOSTIC:'+m);process.exit(1)};const same=(a,b)=>Array.isArray(a)&&a.length===b.length&&a.every((v,i)=>v===b[i]);const snapSame=(a,b)=>a&&b&&a.baseline_source_sha256===b.baseline_source_sha256&&a.diagnosis_artifact_sha256===b.diagnosis_artifact_sha256&&a.sidecar_semantic_sha256===b.sidecar_semantic_sha256&&a.diagnosis_semantic_sha256===b.diagnosis_semantic_sha256&&a.observed_failure_count===b.observed_failure_count&&a.work_item_count===b.work_item_count&&same(a.allowed_kinds,b.allowed_kinds);const root=fs.realpathSync(process.cwd());const inside=p=>{if(typeof p!=='string'||!p||path.isAbsolute(p))fail('path_invalid');const r=path.resolve(root,p);if(r!==root&&!r.startsWith(root+path.sep))fail('path_escape');if(fs.existsSync(r)){const real=fs.realpathSync(r);if(real!==root&&!real.startsWith(root+path.sep))fail('path_escape')}return r};const readJson=p=>JSON.parse(fs.readFileSync(inside(p),'utf8'));const hash=v=>crypto.createHash('sha256').update(v).digest('hex');const fileHash=p=>hash(fs.readFileSync(inside(p)));const normalizedDiagnosisHash=p=>hash(fs.readFileSync(inside(p),'utf8').replace(/\\s+/g,' ').trim());const canon=v=>Array.isArray(v)?'['+v.map(canon).join(',')+']':v&&typeof v==='object'?'{'+Object.keys(v).sort().map(k=>JSON.stringify(k)+':'+canon(v[k])).join(',')+'}':JSON.stringify(v);if(!/^[A-Za-z0-9_-]+$/.test(mod))fail('module');const contractPath='.dna/specs/diagnosis-'+mod+'.contract.json';const reviewPath='.dna/specs/diagnosis-'+mod+'.review.json';const diagnosisPath='.dna/specs/diagnosis-'+mod+'.md';const behaviorPath='docs/behavior/'+mod+'.md';const data=readJson(contractPath);if(data.contract_version!=='diagnosis-contract/v1')fail('contract_version');if(data.module!==mod)fail('module_mismatch');if(data.diagnosis_artifact!==diagnosisPath)fail('diagnosis_artifact_path');if(!same(data.allowed_kinds,allowed))fail('allowed_kinds');const observed=Array.isArray(data.observed_failures)?data.observed_failures:fail('observed_failures');const work=Array.isArray(data.work_items)?data.work_items:fail('work_items');if(!observed.length)fail('empty_observed_failures');if(!work.length)fail('empty_work_items');const idOk=id=>typeof id==='string'&&/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(id);const ids=new Set();for(const f of observed){if(!idOk(f&&f.id)||ids.has(f.id))fail('observed_failure_ids');ids.add(f.id)}const workIds=new Set();for(const item of work){if(!idOk(item&&item.id)||workIds.has(item.id))fail('work_item_ids');workIds.add(item.id)}const failureById=new Map();for(const f of observed){if(typeof f.test_name!=='string'||!f.test_name.trim())fail('observed_failure_test_name');if(typeof f.symptom!=='string'||!f.symptom.trim())fail('observed_failure_symptom');if(!Array.isArray(f.evidence_paths)||!f.evidence_paths.length)fail('observed_failure_evidence');for(const p of f.evidence_paths)inside(p);if(f.kind!==undefined)fail('observed_failure_kind_forbidden');failureById.set(f.id,f)}const mapped=new Set();for(const item of work){if(!allowed.includes(item.kind))fail('invalid_kind');if(item.kind==='PLACEHOLDER_CONTRACT')fail('placeholder_kind');if(!Array.isArray(item.observed_failure_ids)||!item.observed_failure_ids.length)fail('work_item_observed_failure_ids');if(!Array.isArray(item.evidence_paths)||!item.evidence_paths.length)fail('work_item_evidence');for(const p of item.evidence_paths)inside(p);if(action.includes(item.kind)){if(!Array.isArray(item.v1_evidence_paths)||!item.v1_evidence_paths.length)fail('work_item_v1_evidence');if(!Array.isArray(item.v2_evidence_paths)||!item.v2_evidence_paths.length)fail('work_item_v2_evidence');for(const p of item.v1_evidence_paths)inside(p);for(const p of item.v2_evidence_paths)inside(p)}for(const id of item.observed_failure_ids){const f=failureById.get(id);if(!f)fail('unknown_observed_failure_id');if(action.includes(item.kind)&&(!f.test_name||!String(f.test_name).trim()))fail('action_test_evidence');mapped.add(id)}}if(mapped.size!==ids.size)fail('unmapped_observed_failures');for(const f of observed.filter(x=>String(x.symptom).includes('PLACEHOLDER_CONTRACT'))){const kinds=new Set(work.filter(i=>i.observed_failure_ids.includes(f.id)).map(i=>i.kind));if(![...kinds].every(k=>k==='TEST_BUG'||k==='UNIMPLEMENTED')||kinds.size===0)fail('placeholder_mapping')}const counts=data.baseline&&data.baseline.counts;if(!data.baseline||!data.baseline.source_path||!counts)fail('baseline');for(const k of ['failed','skipped','hung']){if(!Number.isInteger(counts[k])||counts[k]<0)fail('baseline_count_'+k)}if(counts.failed+counts.skipped+counts.hung!==observed.length)fail('baseline_count_mismatch');const summary=data.summary_counts||{};for(const kind of allowed){if(!Number.isInteger(summary[kind])||summary[kind]!==work.filter(x=>x.kind===kind).length)fail('summary_count_'+kind)}const snap=data.contract_snapshot||{};const baselineHash=fileHash(data.baseline.source_path);const diagnosisHash=fileHash(diagnosisPath);if(snap.observed_failure_count!==observed.length||snap.work_item_count!==work.length||!same(snap.allowed_kinds,allowed))fail('contract_snapshot');if(snap.baseline_source_sha256!==baselineHash)fail('baseline_sha256');if(snap.diagnosis_artifact_sha256!==diagnosisHash)fail('diagnosis_sha256');const stale=data.staleness;if(!stale||stale.is_stale!==false)fail('stale_contract');const source=(entry,p,n,expected)=>{if(!entry||entry.path!==p)fail('staleness_'+n+'_path');if(entry.sha256!==expected)fail('staleness_'+n+'_sha256')};source(stale.behavior_doc,behaviorPath,'behavior_doc',fileHash(behaviorPath));source(stale.baseline,data.baseline.source_path,'baseline',baselineHash);source(stale.diagnosis_artifact,diagnosisPath,'diagnosis_artifact',diagnosisHash);const semantic=JSON.parse(JSON.stringify(data));delete semantic.contract_snapshot.sidecar_semantic_sha256;delete semantic.contract_snapshot.diagnosis_artifact_sha256;delete semantic.staleness.diagnosis_artifact;const sidecarSemanticHash=hash(canon(semantic));const diagnosisSemanticHash=normalizedDiagnosisHash(diagnosisPath);if(snap.sidecar_semantic_sha256!==sidecarSemanticHash||snap.diagnosis_semantic_sha256!==diagnosisSemanticHash)fail('contract_snapshot_semantic');const review=readJson(reviewPath);if(review.contract_version!=='diagnosis-contract-review/v1')fail('review_contract_version');if(review.contract_valid!==true)fail('review_contract_valid');if(review.verdict!=='APPROVE')fail('review_verdict');if(review.contract_artifact_reviewed!==contractPath)fail('review_contract_artifact_path');if(review.artifact_reviewed!==diagnosisPath)fail('review_artifact_path');if(!snapSame(review.contract_snapshot,snap))fail('review_contract_snapshot');if(!review.updated_at||Number.isNaN(Date.parse(review.updated_at)))fail('review_updated_at');if(!Array.isArray(review.evidence_paths)||!review.evidence_paths.length)fail('review_evidence_paths');for(const p of review.evidence_paths)inside(p);const cm=fs.statSync(inside(contractPath)).mtimeMs;const dm=fs.statSync(inside(diagnosisPath)).mtimeMs;const rm=fs.statSync(inside(reviewPath)).mtimeMs;if(rm<cm||rm<dm)fail('review_stale');\""
   allow_builtin_asserts:
     - clean_working_tree
 
@@ -248,7 +249,7 @@ roles:
   analyzer:
     description: "Reads code and classifies failing tests. Writes diagnosis spec only."
     tool_permissions:
-      allow: [Read, Grep, Glob, Write]
+      allow: [Read, Grep, Glob, Write, mcp__intentdna__dna_artifact_digest]
       deny: [Bash, Edit, NotebookEdit]
     scope:
       read: ["**/*"]
@@ -263,13 +264,14 @@ roles:
       - "The sidecar allowed_kinds array must be exactly BUG, UNIMPLEMENTED, INFRA, REMOVED, TEST_BUG in that order; PLACEHOLDER_CONTRACT is never a kind"
       - "A placeholder-contract symptom may appear only in observed_failures.symptom and must map to concrete TEST_BUG and/or UNIMPLEMENTED work_items with evidence"
       - "If reanalyzing after REQUEST_REANALYSIS, update every reviewer sections_to_fix item and report sections_updated"
+      - "Use mcp__intentdna__dna_artifact_digest for every exact contract SHA-256; never guess a digest or use Bash to compute one"
       - "DO NOT include fix prescriptions, implementation order, call-site instructions, or Notes for Surgeon"
       - "DO NOT run tests. DO NOT edit app code. Analysis only."
 
   analysis_reviewer:
     description: "Reviews analyzer output quality and writes durable diagnosis review verdict."
     tool_permissions:
-      allow: [Read, Grep, Glob, Write]
+      allow: [Read, Grep, Glob, Write, mcp__intentdna__dna_artifact_digest]
       deny: [Bash, Edit, NotebookEdit]
     scope:
       read: ["**/*"]
@@ -278,6 +280,7 @@ roles:
       - "REQUIRED FIRST: Read all context files listed in SKILL.md"
       - "Verify analyzer spec: v1 references exist? Classifications sound?"
       - "Independently validate .dna/specs/diagnosis-$ARGUMENTS.contract.json against the template sidecar contract; do not use Bash"
+      - "Use mcp__intentdna__dna_artifact_digest to independently verify exact raw, normalized-text, and canonical-JSON SHA-256 values"
       - "Check missing: any failing test not covered?"
       - "Verify diagnosis remains evidence-only: no fix prescriptions, implementation order, call-site instructions, or Notes for Surgeon"
       - "Output a structured verdict block with contract_version, contract_valid, failure_reason, contract_artifact_reviewed, contract_snapshot, verdict, artifact_reviewed, sections_to_fix, evidence_paths, confidence, summary, and updated_at"
@@ -486,16 +489,20 @@ workflows:
              - observed_failures: one entry per failing/skipped/hung test with id, test_name, symptom, evidence_paths, and no kind field
              - work_items: one or more entries mapping observed_failure_ids to kind, evidence_paths, v1_evidence_paths, and v2_evidence_paths
              - summary_counts: exact count of work_items by BUG / UNIMPLEMENTED / INFRA / REMOVED / TEST_BUG
-             - contract_snapshot: baseline_source_sha256, diagnosis_artifact_sha256, observed_failure_count, work_item_count, allowed_kinds
-             - staleness: source mtimes or hashes for behavior_doc, baseline, diagnosis_artifact, and is_stale false
+             - contract_snapshot: baseline_source_sha256, diagnosis_artifact_sha256, sidecar_semantic_sha256, diagnosis_semantic_sha256, observed_failure_count, work_item_count, allowed_kinds
+             - staleness: behavior_doc, baseline, and diagnosis_artifact entries each contain the exact project-relative path and current sha256; is_stale is false
+             - Obtain hashes with mcp__intentdna__dna_artifact_digest, which is read-only and project-relative: bytes mode for behavior/baseline/diagnosis, whitespace_normalized_text for diagnosis_semantic_sha256, and canonical_json for the sidecar with exclude_json_pointers=["/contract_snapshot/sidecar_semantic_sha256", "/contract_snapshot/diagnosis_artifact_sha256", "/staleness/diagnosis_artifact"] for sidecar_semantic_sha256. Write the returned values back to the sidecar and re-run the canonical digest to confirm it is stable. Never guess hashes.
           7. Contract rules:
              - observed_failures must not be empty; work_items must not be empty.
              - Every observed_failure id must be mapped by at least one work_item.
              - Every work_item kind must be one of the five allowed kinds exactly.
              - PLACEHOLDER_CONTRACT is forbidden as a kind. If a placeholder-contract symptom exists, keep it in observed_failures.symptom and map it to concrete TEST_BUG and/or UNIMPLEMENTED work_items with evidence.
              - REMOVED may be diagnosed but must be marked manual/user-approved before any future fix can execute it.
-             - Mixed unknown kinds, missing evidence, count mismatches, missing/changed contract_snapshot, and stale baseline/diagnosis snapshots make the contract invalid.
+             - Mixed unknown kinds, missing evidence, count mismatches, missing/changed contract_snapshot, and stale behavior/baseline/diagnosis snapshots make the contract invalid.
           8. If this is a reanalysis after REQUEST_REANALYSIS or DIAGNOSIS_CONTRACT_INVALID, read the reviewer verdict first, update every section listed in sections_to_fix plus the summary table and contract sidecar, and report sections_updated in your final response. Reanalysis is not successful unless both the spec artifact and contract sidecar are rewritten.
+          9. Before handing off to review, the producer-side diagnosis contract completion gate must pass. It rejects grouped observations that hide per-test failures, duplicate/bad ids, unmapped observed_failures, missing evidence, count mismatches, bad hashes, stale state, and no-material-change reanalysis after REQUEST_REANALYSIS. Reanalysis compares the canonical sidecar with its self-digest and raw diagnosis snapshot fields omitted, plus a whitespace-normalized diagnosis hash, so a real sidecar-only correction is allowed while formatting-only Markdown changes are not.
+        completion:
+          - command_success: "node -e \"const fs=require('node:fs');const crypto=require('node:crypto');const path=require('node:path');const mod=process.env.ARGUMENTS||'$ARGUMENTS';const allowed=['BUG','UNIMPLEMENTED','INFRA','REMOVED','TEST_BUG'];const action=['BUG','UNIMPLEMENTED','INFRA','TEST_BUG'];const fail=m=>{console.error('INTENTDNA_DIAGNOSTIC:'+m);process.exit(1)};const same=(a,b)=>Array.isArray(a)&&a.length===b.length&&a.every((v,i)=>v===b[i]);const legacySame=(a,b)=>a&&b&&a.baseline_source_sha256===b.baseline_source_sha256&&a.diagnosis_artifact_sha256===b.diagnosis_artifact_sha256&&a.observed_failure_count===b.observed_failure_count&&a.work_item_count===b.work_item_count&&same(a.allowed_kinds,b.allowed_kinds);const modern=s=>s&&typeof s.sidecar_semantic_sha256==='string'&&typeof s.diagnosis_semantic_sha256==='string';const root=fs.realpathSync(process.cwd());const inside=p=>{if(typeof p!=='string'||!p||path.isAbsolute(p))fail('path_invalid');const r=path.resolve(root,p);if(r!==root&&!r.startsWith(root+path.sep))fail('path_escape');if(fs.existsSync(r)){const real=fs.realpathSync(r);if(real!==root&&!real.startsWith(root+path.sep))fail('path_escape')}return r};const readJson=p=>JSON.parse(fs.readFileSync(inside(p),'utf8'));const hash=v=>crypto.createHash('sha256').update(v).digest('hex');const fileHash=p=>hash(fs.readFileSync(inside(p)));const normalizedDiagnosisHash=p=>hash(fs.readFileSync(inside(p),'utf8').replace(/\\s+/g,' ').trim());const canon=v=>Array.isArray(v)?'['+v.map(canon).join(',')+']':v&&typeof v==='object'?'{'+Object.keys(v).sort().map(k=>JSON.stringify(k)+':'+canon(v[k])).join(',')+'}':JSON.stringify(v);if(!/^[A-Za-z0-9_-]+$/.test(mod))fail('module');const contractPath='.dna/specs/diagnosis-'+mod+'.contract.json';const reviewPath='.dna/specs/diagnosis-'+mod+'.review.json';const diagnosisPath='.dna/specs/diagnosis-'+mod+'.md';const behaviorPath='docs/behavior/'+mod+'.md';const data=readJson(contractPath);if(data.contract_version!=='diagnosis-contract/v1')fail('contract_version');if(data.module!==mod)fail('module_mismatch');if(data.diagnosis_artifact!==diagnosisPath)fail('diagnosis_artifact_path');if(!same(data.allowed_kinds,allowed))fail('allowed_kinds');const observed=Array.isArray(data.observed_failures)?data.observed_failures:fail('observed_failures');const work=Array.isArray(data.work_items)?data.work_items:fail('work_items');if(!observed.length)fail('empty_observed_failures');if(!work.length)fail('empty_work_items');const idOk=id=>typeof id==='string'&&/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(id);const ids=new Set();for(const f of observed){if(!idOk(f&&f.id)||ids.has(f.id))fail('observed_failure_ids');ids.add(f.id)}const workIds=new Set();for(const item of work){if(!idOk(item&&item.id)||workIds.has(item.id))fail('work_item_ids');workIds.add(item.id)}const failureById=new Map();for(const f of observed){if(typeof f.test_name!=='string'||!f.test_name.trim())fail('observed_failure_test_name');if(typeof f.symptom!=='string'||!f.symptom.trim())fail('observed_failure_symptom');if(!Array.isArray(f.evidence_paths)||!f.evidence_paths.length)fail('observed_failure_evidence');for(const p of f.evidence_paths)inside(p);if(f.kind!==undefined)fail('observed_failure_kind_forbidden');failureById.set(f.id,f)}const mapped=new Set();for(const item of work){if(!allowed.includes(item.kind))fail('invalid_kind');if(item.kind==='PLACEHOLDER_CONTRACT')fail('placeholder_kind');if(!Array.isArray(item.observed_failure_ids)||!item.observed_failure_ids.length)fail('work_item_observed_failure_ids');if(!Array.isArray(item.evidence_paths)||!item.evidence_paths.length)fail('work_item_evidence');for(const p of item.evidence_paths)inside(p);if(action.includes(item.kind)){if(!Array.isArray(item.v1_evidence_paths)||!item.v1_evidence_paths.length)fail('work_item_v1_evidence');if(!Array.isArray(item.v2_evidence_paths)||!item.v2_evidence_paths.length)fail('work_item_v2_evidence');for(const p of item.v1_evidence_paths)inside(p);for(const p of item.v2_evidence_paths)inside(p)}for(const id of item.observed_failure_ids){const f=failureById.get(id);if(!f)fail('unknown_observed_failure_id');if(action.includes(item.kind)&&(!f.test_name||!String(f.test_name).trim()))fail('action_test_evidence');mapped.add(id)}}if(mapped.size!==ids.size)fail('unmapped_observed_failures');for(const f of observed.filter(x=>String(x.symptom).includes('PLACEHOLDER_CONTRACT'))){const kinds=new Set(work.filter(i=>i.observed_failure_ids.includes(f.id)).map(i=>i.kind));if(![...kinds].every(k=>k==='TEST_BUG'||k==='UNIMPLEMENTED')||kinds.size===0)fail('placeholder_mapping')}const counts=data.baseline&&data.baseline.counts;if(!data.baseline||!data.baseline.source_path||!counts)fail('baseline');for(const k of ['failed','skipped','hung']){if(!Number.isInteger(counts[k])||counts[k]<0)fail('baseline_count_'+k)}if(counts.failed+counts.skipped+counts.hung!==observed.length)fail('baseline_count_mismatch');const summary=data.summary_counts||{};for(const kind of allowed){if(!Number.isInteger(summary[kind])||summary[kind]!==work.filter(x=>x.kind===kind).length)fail('summary_count_'+kind)}const snap=data.contract_snapshot||{};const baselineHash=fileHash(data.baseline.source_path);const diagnosisHash=fileHash(diagnosisPath);if(snap.observed_failure_count!==observed.length||snap.work_item_count!==work.length||!same(snap.allowed_kinds,allowed))fail('contract_snapshot');if(snap.baseline_source_sha256!==baselineHash)fail('baseline_sha256');if(snap.diagnosis_artifact_sha256!==diagnosisHash)fail('diagnosis_sha256');const stale=data.staleness;if(!stale||stale.is_stale!==false)fail('stale_contract');const source=(entry,p,n,expected)=>{if(!entry||entry.path!==p)fail('staleness_'+n+'_path');if(entry.sha256!==expected)fail('staleness_'+n+'_sha256')};source(stale.behavior_doc,behaviorPath,'behavior_doc',fileHash(behaviorPath));source(stale.baseline,data.baseline.source_path,'baseline',baselineHash);source(stale.diagnosis_artifact,diagnosisPath,'diagnosis_artifact',diagnosisHash);const semantic=JSON.parse(JSON.stringify(data));delete semantic.contract_snapshot.sidecar_semantic_sha256;delete semantic.contract_snapshot.diagnosis_artifact_sha256;delete semantic.staleness.diagnosis_artifact;const sidecarSemanticHash=hash(canon(semantic));const diagnosisSemanticHash=normalizedDiagnosisHash(diagnosisPath);if(snap.sidecar_semantic_sha256!==sidecarSemanticHash||snap.diagnosis_semantic_sha256!==diagnosisSemanticHash)fail('contract_snapshot_semantic');if(fs.existsSync(inside(reviewPath))){const prev=readJson(reviewPath);if(prev.verdict==='REQUEST_REANALYSIS'){const ps=prev.contract_snapshot||{};const unchanged=modern(ps)?ps.sidecar_semantic_sha256===sidecarSemanticHash&&ps.diagnosis_semantic_sha256===diagnosisSemanticHash:legacySame(ps,snap);if(unchanged)fail('reanalysis_unchanged');const cm=fs.statSync(inside(contractPath)).mtimeMs;const dm=fs.statSync(inside(diagnosisPath)).mtimeMs;const rm=fs.statSync(inside(reviewPath)).mtimeMs;if(cm<=rm||dm<=rm)fail('reanalysis_not_rewritten')}}\""
         handoff:
           produces:
             - type: file
@@ -527,8 +534,9 @@ workflows:
              - summary_counts match work_items by kind
              - every work_item has evidence_paths and only allowed kinds
              - PLACEHOLDER_CONTRACT is rejected as a kind but placeholder-contract symptoms are allowed when mapped to TEST_BUG and/or UNIMPLEMENTED
-             - contract_snapshot includes diagnosis_artifact_sha256, baseline_source_sha256, observed_failure_count, work_item_count, and allowed_kinds
-             - staleness.is_stale is false; stale baseline/diagnosis/contract snapshots are invalid
+             - contract_snapshot includes diagnosis_artifact_sha256, baseline_source_sha256, sidecar_semantic_sha256, diagnosis_semantic_sha256, observed_failure_count, work_item_count, and allowed_kinds
+             - staleness.is_stale is false and behavior_doc, baseline, and diagnosis_artifact path+sha256 entries match current project files; stale source snapshots are invalid
+             - independently recompute hashes with mcp__intentdna__dna_artifact_digest using the same bytes, whitespace_normalized_text, and canonical_json modes; canonical_json must omit /contract_snapshot/sidecar_semantic_sha256, /contract_snapshot/diagnosis_artifact_sha256, and /staleness/diagnosis_artifact
              - REMOVED work_items are reviewable diagnosis facts only and must not authorize automatic fix execution
 
           Output exactly one structured verdict block:
@@ -541,6 +549,8 @@ workflows:
             "contract_snapshot": {
               "baseline_source_sha256": "sha256 from contract sidecar",
               "diagnosis_artifact_sha256": "sha256 from contract sidecar",
+              "sidecar_semantic_sha256": "canonical routing sidecar sha256 from contract sidecar",
+              "diagnosis_semantic_sha256": "whitespace-normalized diagnosis sha256 from contract sidecar",
               "observed_failure_count": 0,
               "work_item_count": 0,
               "allowed_kinds": ["BUG", "UNIMPLEMENTED", "INFRA", "REMOVED", "TEST_BUG"]
@@ -560,7 +570,7 @@ workflows:
           APPROVE → diagnosis complete.
           REQUEST_REANALYSIS → sections_to_fix must be passed back to analyze. If contract_valid is false, set failure_reason to DIAGNOSIS_CONTRACT_INVALID and include the exact invalid rule in sections_to_fix. docs/behavior/blocked_items.md is historical context only and must not be treated as the current run verdict.
         completion:
-          - command_success: "node -e \"const fs=require('node:fs');const crypto=require('node:crypto');const path=require('node:path');const mod=process.env.ARGUMENTS||'$ARGUMENTS';const allowed=['BUG','UNIMPLEMENTED','INFRA','REMOVED','TEST_BUG'];const action=['BUG','UNIMPLEMENTED','INFRA','TEST_BUG'];const fail=m=>{throw new Error(m)};const same=(a,b)=>Array.isArray(a)&&a.length===b.length&&a.every((v,i)=>v===b[i]);const snapSame=(a,b)=>a&&b&&a.baseline_source_sha256===b.baseline_source_sha256&&a.diagnosis_artifact_sha256===b.diagnosis_artifact_sha256&&a.observed_failure_count===b.observed_failure_count&&a.work_item_count===b.work_item_count&&same(a.allowed_kinds,b.allowed_kinds);const root=process.cwd();const inside=p=>{if(typeof p!=='string'||!p||path.isAbsolute(p))fail('path_invalid');const r=path.resolve(root,p);if(r!==root&&!r.startsWith(root+path.sep))fail('path_escape');return r};const readJson=p=>JSON.parse(fs.readFileSync(inside(p),'utf8'));if(!/^[A-Za-z0-9_-]+$/.test(mod))fail('module');const contractPath='.dna/specs/diagnosis-'+mod+'.contract.json';const reviewPath='.dna/specs/diagnosis-'+mod+'.review.json';const diagnosisPath='.dna/specs/diagnosis-'+mod+'.md';const data=readJson(contractPath);if(data.contract_version!=='diagnosis-contract/v1')fail('contract_version');if(data.module!==mod)fail('module_mismatch');if(data.diagnosis_artifact!==diagnosisPath)fail('diagnosis_artifact_path');if(!same(data.allowed_kinds,allowed))fail('allowed_kinds');const observed=Array.isArray(data.observed_failures)?data.observed_failures:fail('observed_failures');const work=Array.isArray(data.work_items)?data.work_items:fail('work_items');if(!observed.length)fail('empty_observed_failures');if(!work.length)fail('empty_work_items');const ids=new Set(observed.map(x=>x&&x.id).filter(Boolean));if(ids.size!==observed.length)fail('observed_failure_ids');const failureById=new Map();for(const f of observed){if(typeof f.test_name!=='string'||!f.test_name.trim())fail('observed_failure_test_name');if(typeof f.symptom!=='string'||!f.symptom.trim())fail('observed_failure_symptom');if(!Array.isArray(f.evidence_paths)||!f.evidence_paths.length)fail('observed_failure_evidence');for(const p of f.evidence_paths)inside(p);if(f.kind!==undefined)fail('observed_failure_kind_forbidden');failureById.set(f.id,f)}const mapped=new Set();for(const item of work){if(!allowed.includes(item.kind))fail('invalid_kind');if(item.kind==='PLACEHOLDER_CONTRACT')fail('placeholder_kind');if(!Array.isArray(item.observed_failure_ids)||!item.observed_failure_ids.length)fail('work_item_observed_failure_ids');if(!Array.isArray(item.evidence_paths)||!item.evidence_paths.length)fail('work_item_evidence');for(const p of item.evidence_paths)inside(p);if(action.includes(item.kind)){if(!Array.isArray(item.v1_evidence_paths)||!item.v1_evidence_paths.length)fail('work_item_v1_evidence');if(!Array.isArray(item.v2_evidence_paths)||!item.v2_evidence_paths.length)fail('work_item_v2_evidence');for(const p of item.v1_evidence_paths)inside(p);for(const p of item.v2_evidence_paths)inside(p)}for(const id of item.observed_failure_ids){const f=failureById.get(id);if(!f)fail('unknown_observed_failure_id');if(action.includes(item.kind)&&(!f.test_name||!String(f.test_name).trim()))fail('action_test_evidence');mapped.add(id)}}if(mapped.size!==ids.size)fail('unmapped_observed_failures');for(const f of observed.filter(x=>String(x.symptom).includes('PLACEHOLDER_CONTRACT'))){const kinds=new Set(work.filter(i=>i.observed_failure_ids.includes(f.id)).map(i=>i.kind));if(![...kinds].every(k=>k==='TEST_BUG'||k==='UNIMPLEMENTED')||kinds.size===0)fail('placeholder_mapping')}const counts=data.baseline&&data.baseline.counts;if(!data.baseline||!data.baseline.source_path||!counts)fail('baseline');inside(data.baseline.source_path);for(const k of ['failed','skipped','hung']){if(!Number.isInteger(counts[k])||counts[k]<0)fail('baseline_count_'+k)}const total=counts.failed+counts.skipped+counts.hung;if(total!==observed.length)fail('baseline_count_mismatch');const summary=data.summary_counts||{};for(const kind of allowed){if(!Number.isInteger(summary[kind])||summary[kind]!==work.filter(x=>x.kind===kind).length)fail('summary_count_'+kind)}const sha=p=>crypto.createHash('sha256').update(fs.readFileSync(inside(p))).digest('hex');const snap=data.contract_snapshot||{};if(snap.observed_failure_count!==observed.length||snap.work_item_count!==work.length||!same(snap.allowed_kinds,allowed))fail('contract_snapshot');if(snap.baseline_source_sha256!==sha(data.baseline.source_path))fail('baseline_sha256');if(snap.diagnosis_artifact_sha256!==sha(diagnosisPath))fail('diagnosis_sha256');if(!data.staleness||data.staleness.is_stale!==false)fail('stale_contract');const review=readJson(reviewPath);if(review.contract_version!=='diagnosis-contract-review/v1')fail('review_contract_version');if(review.contract_valid!==true)fail('review_contract_valid');if(review.verdict!=='APPROVE')fail('review_verdict');if(review.contract_artifact_reviewed!==contractPath)fail('review_contract_artifact_path');if(review.artifact_reviewed!==diagnosisPath)fail('review_artifact_path');if(!snapSame(review.contract_snapshot,snap))fail('review_contract_snapshot');if(!review.updated_at||Number.isNaN(Date.parse(review.updated_at)))fail('review_updated_at');if(!Array.isArray(review.evidence_paths)||!review.evidence_paths.length)fail('review_evidence_paths');for(const p of review.evidence_paths)inside(p);const cm=fs.statSync(inside(contractPath)).mtimeMs;const dm=fs.statSync(inside(diagnosisPath)).mtimeMs;const rm=fs.statSync(inside(reviewPath)).mtimeMs;if(rm<cm||rm<dm)fail('review_stale');\""
+          - command_success: "node -e \"const fs=require('node:fs');const crypto=require('node:crypto');const path=require('node:path');const mod=process.env.ARGUMENTS||'$ARGUMENTS';const allowed=['BUG','UNIMPLEMENTED','INFRA','REMOVED','TEST_BUG'];const action=['BUG','UNIMPLEMENTED','INFRA','TEST_BUG'];const fail=m=>{console.error('INTENTDNA_DIAGNOSTIC:'+m);process.exit(1)};const same=(a,b)=>Array.isArray(a)&&a.length===b.length&&a.every((v,i)=>v===b[i]);const snapSame=(a,b)=>a&&b&&a.baseline_source_sha256===b.baseline_source_sha256&&a.diagnosis_artifact_sha256===b.diagnosis_artifact_sha256&&a.sidecar_semantic_sha256===b.sidecar_semantic_sha256&&a.diagnosis_semantic_sha256===b.diagnosis_semantic_sha256&&a.observed_failure_count===b.observed_failure_count&&a.work_item_count===b.work_item_count&&same(a.allowed_kinds,b.allowed_kinds);const root=fs.realpathSync(process.cwd());const inside=p=>{if(typeof p!=='string'||!p||path.isAbsolute(p))fail('path_invalid');const r=path.resolve(root,p);if(r!==root&&!r.startsWith(root+path.sep))fail('path_escape');if(fs.existsSync(r)){const real=fs.realpathSync(r);if(real!==root&&!real.startsWith(root+path.sep))fail('path_escape')}return r};const readJson=p=>JSON.parse(fs.readFileSync(inside(p),'utf8'));const hash=v=>crypto.createHash('sha256').update(v).digest('hex');const fileHash=p=>hash(fs.readFileSync(inside(p)));const normalizedDiagnosisHash=p=>hash(fs.readFileSync(inside(p),'utf8').replace(/\\s+/g,' ').trim());const canon=v=>Array.isArray(v)?'['+v.map(canon).join(',')+']':v&&typeof v==='object'?'{'+Object.keys(v).sort().map(k=>JSON.stringify(k)+':'+canon(v[k])).join(',')+'}':JSON.stringify(v);if(!/^[A-Za-z0-9_-]+$/.test(mod))fail('module');const contractPath='.dna/specs/diagnosis-'+mod+'.contract.json';const reviewPath='.dna/specs/diagnosis-'+mod+'.review.json';const diagnosisPath='.dna/specs/diagnosis-'+mod+'.md';const behaviorPath='docs/behavior/'+mod+'.md';const data=readJson(contractPath);if(data.contract_version!=='diagnosis-contract/v1')fail('contract_version');if(data.module!==mod)fail('module_mismatch');if(data.diagnosis_artifact!==diagnosisPath)fail('diagnosis_artifact_path');if(!same(data.allowed_kinds,allowed))fail('allowed_kinds');const observed=Array.isArray(data.observed_failures)?data.observed_failures:fail('observed_failures');const work=Array.isArray(data.work_items)?data.work_items:fail('work_items');if(!observed.length)fail('empty_observed_failures');if(!work.length)fail('empty_work_items');const idOk=id=>typeof id==='string'&&/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(id);const ids=new Set();for(const f of observed){if(!idOk(f&&f.id)||ids.has(f.id))fail('observed_failure_ids');ids.add(f.id)}const workIds=new Set();for(const item of work){if(!idOk(item&&item.id)||workIds.has(item.id))fail('work_item_ids');workIds.add(item.id)}const failureById=new Map();for(const f of observed){if(typeof f.test_name!=='string'||!f.test_name.trim())fail('observed_failure_test_name');if(typeof f.symptom!=='string'||!f.symptom.trim())fail('observed_failure_symptom');if(!Array.isArray(f.evidence_paths)||!f.evidence_paths.length)fail('observed_failure_evidence');for(const p of f.evidence_paths)inside(p);if(f.kind!==undefined)fail('observed_failure_kind_forbidden');failureById.set(f.id,f)}const mapped=new Set();for(const item of work){if(!allowed.includes(item.kind))fail('invalid_kind');if(item.kind==='PLACEHOLDER_CONTRACT')fail('placeholder_kind');if(!Array.isArray(item.observed_failure_ids)||!item.observed_failure_ids.length)fail('work_item_observed_failure_ids');if(!Array.isArray(item.evidence_paths)||!item.evidence_paths.length)fail('work_item_evidence');for(const p of item.evidence_paths)inside(p);if(action.includes(item.kind)){if(!Array.isArray(item.v1_evidence_paths)||!item.v1_evidence_paths.length)fail('work_item_v1_evidence');if(!Array.isArray(item.v2_evidence_paths)||!item.v2_evidence_paths.length)fail('work_item_v2_evidence');for(const p of item.v1_evidence_paths)inside(p);for(const p of item.v2_evidence_paths)inside(p)}for(const id of item.observed_failure_ids){const f=failureById.get(id);if(!f)fail('unknown_observed_failure_id');if(action.includes(item.kind)&&(!f.test_name||!String(f.test_name).trim()))fail('action_test_evidence');mapped.add(id)}}if(mapped.size!==ids.size)fail('unmapped_observed_failures');for(const f of observed.filter(x=>String(x.symptom).includes('PLACEHOLDER_CONTRACT'))){const kinds=new Set(work.filter(i=>i.observed_failure_ids.includes(f.id)).map(i=>i.kind));if(![...kinds].every(k=>k==='TEST_BUG'||k==='UNIMPLEMENTED')||kinds.size===0)fail('placeholder_mapping')}const counts=data.baseline&&data.baseline.counts;if(!data.baseline||!data.baseline.source_path||!counts)fail('baseline');for(const k of ['failed','skipped','hung']){if(!Number.isInteger(counts[k])||counts[k]<0)fail('baseline_count_'+k)}if(counts.failed+counts.skipped+counts.hung!==observed.length)fail('baseline_count_mismatch');const summary=data.summary_counts||{};for(const kind of allowed){if(!Number.isInteger(summary[kind])||summary[kind]!==work.filter(x=>x.kind===kind).length)fail('summary_count_'+kind)}const snap=data.contract_snapshot||{};const baselineHash=fileHash(data.baseline.source_path);const diagnosisHash=fileHash(diagnosisPath);if(snap.observed_failure_count!==observed.length||snap.work_item_count!==work.length||!same(snap.allowed_kinds,allowed))fail('contract_snapshot');if(snap.baseline_source_sha256!==baselineHash)fail('baseline_sha256');if(snap.diagnosis_artifact_sha256!==diagnosisHash)fail('diagnosis_sha256');const stale=data.staleness;if(!stale||stale.is_stale!==false)fail('stale_contract');const source=(entry,p,n,expected)=>{if(!entry||entry.path!==p)fail('staleness_'+n+'_path');if(entry.sha256!==expected)fail('staleness_'+n+'_sha256')};source(stale.behavior_doc,behaviorPath,'behavior_doc',fileHash(behaviorPath));source(stale.baseline,data.baseline.source_path,'baseline',baselineHash);source(stale.diagnosis_artifact,diagnosisPath,'diagnosis_artifact',diagnosisHash);const semantic=JSON.parse(JSON.stringify(data));delete semantic.contract_snapshot.sidecar_semantic_sha256;delete semantic.contract_snapshot.diagnosis_artifact_sha256;delete semantic.staleness.diagnosis_artifact;const sidecarSemanticHash=hash(canon(semantic));const diagnosisSemanticHash=normalizedDiagnosisHash(diagnosisPath);if(snap.sidecar_semantic_sha256!==sidecarSemanticHash||snap.diagnosis_semantic_sha256!==diagnosisSemanticHash)fail('contract_snapshot_semantic');const review=readJson(reviewPath);if(review.contract_version!=='diagnosis-contract-review/v1')fail('review_contract_version');if(review.contract_valid!==true)fail('review_contract_valid');if(review.verdict!=='APPROVE')fail('review_verdict');if(review.contract_artifact_reviewed!==contractPath)fail('review_contract_artifact_path');if(review.artifact_reviewed!==diagnosisPath)fail('review_artifact_path');if(!snapSame(review.contract_snapshot,snap))fail('review_contract_snapshot');if(!review.updated_at||Number.isNaN(Date.parse(review.updated_at)))fail('review_updated_at');if(!Array.isArray(review.evidence_paths)||!review.evidence_paths.length)fail('review_evidence_paths');for(const p of review.evidence_paths)inside(p);const cm=fs.statSync(inside(contractPath)).mtimeMs;const dm=fs.statSync(inside(diagnosisPath)).mtimeMs;const rm=fs.statSync(inside(reviewPath)).mtimeMs;if(rm<cm||rm<dm)fail('review_stale');\""
         handoff:
           consumes:
             - type: file

package/hooks/hooks.json

@@ -3,7 +3,7 @@
     "PreToolUse": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook PreToolUse", "timeout": 5 }] }],
     "PostToolUse": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook PostToolUse", "timeout": 3 }] }],
     "UserPromptSubmit": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook UserPromptSubmit", "timeout": 5 }] }],
-    "SubagentStop": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook SubagentStop", "timeout": 3 }] }],
+    "SubagentStop": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook SubagentStop", "timeout": 45 }] }],
     "PreCompact": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook PreCompact", "timeout": 3 }] }],
     "Notification": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook Notification", "timeout": 3 }] }],
     "Stop": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook Stop", "timeout": 45 }] }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",