intentdna 1.8.3 → 1.8.5

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.3",
+      "version": "1.8.5",
       "author": {
         "name": "Samuel"
       },
@@ -25,5 +25,5 @@
       ]
     }
   ],
-  "version": "1.8.3"
+  "version": "1.8.5"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.8.3",
+  "version": "1.8.5",
   "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.5
 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.5` keeps Claude plugin Hook delivery in `hooks/hooks.json`: plugin sync does not register project `settings.json` Hooks, retracts exact stale bin-mode `dna-hook` entries once, and leaves user settings untouched in steady state. 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/cli/commands/sync.js

@@ -612,6 +612,13 @@ export async function runSync(opts) {
         opts.skillsDir = resolve(projectDir, ".agents", "skills");
         process.stderr.write("Codex workflow projection: .agents/skills\n");
     }
+    const requestedMode = opts.mode ?? (opts.plugin === true ? "plugin" : opts.plugin === false ? "bin" : "auto");
+    let resolvedMode = requestedMode === "auto" ? "bin" : requestedMode;
+    if (!opts.remove && requestedMode === "auto") {
+        resolvedMode = await detectMode();
+        process.stderr.write(`Auto-detect: ${resolvedMode} mode${resolvedMode === "plugin" ? " (intentdna registered as Claude Code plugin)" : ""}\n`);
+    }
+    opts.plugin = resolvedMode === "plugin";
     if (!opts.remove && !opts.inject && !opts.hooksDir && !opts.agentsDir && !opts.workflowDir && !opts.skillsDir && !opts.settingsPath && !opts.codex) {
         // Auto-detect Claude Code environment → fill all outputs
         const hasClaudeDir = await fileExists(resolve(projectDir, ".claude"));
@@ -621,16 +628,11 @@ export async function runSync(opts) {
             opts.agentsDir = resolve(projectDir, ".claude", "agents");
             opts.skillsDir = resolve(projectDir, ".claude", "skills");
             opts.settingsPath = resolve(projectDir, ".claude", "settings.json");
-            process.stderr.write(`Auto-detect: Claude Code → CLAUDE.md + agents + skills + settings\n`);
+            process.stderr.write(resolvedMode === "plugin"
+                ? "Auto-detect: Claude Code → CLAUDE.md + agents + skills; plugin hooks (no settings injection)\n"
+                : "Auto-detect: Claude Code → CLAUDE.md + agents + skills + settings\n");
         }
     }
-    const requestedMode = opts.mode ?? (opts.plugin === true ? "plugin" : opts.plugin === false ? "bin" : "auto");
-    let resolvedMode = requestedMode === "auto" ? "bin" : requestedMode;
-    if (!opts.remove && requestedMode === "auto") {
-        resolvedMode = await detectMode();
-        process.stderr.write(`Auto-detect: ${resolvedMode} mode${resolvedMode === "plugin" ? " (intentdna registered as Claude Code plugin)" : ""}\n`);
-    }
-    opts.plugin = resolvedMode === "plugin";
     // Handle --remove
     if (opts.remove) {
         if (!opts.inject && !opts.hooksDir && !opts.agentsDir && !opts.workflowDir && !opts.skillsDir && !opts.codex) {

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,6 +1171,37 @@ 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, "pre_handoff", sessionId, options));
@@ -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[];