intentdna 1.8.7 → 1.9.0-rc.2

package/dist/hooks/cli.js

@@ -24,7 +24,7 @@ import { readStdinResult, writeOutput, silentOutput, allowOutput, blockOutput, s
 import { validateHookInput } from "./schema.js";
 import { hookFailureOutput } from "./enforcement-boundary.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, updateSurgeonAttempts, appendSessionRead, readSessionReads, appendVerifierResult, readVerifierResults, appendCompletedArtifact, artifactIdentity, buildArtifactKey, readArtifactManifest, resolveArtifactTemplate, safePathComponent, writeArtifactManifest, EVIDENCE_CAPTURE_SCHEMA_VERSION } from "./state.js";
+import { appendAudit, readWorkflowState, appendTrace, appendRuntimeDecisionEvent, appendEvidenceCaptureEvent, rotateTraces, readTraces, cleanStaleState, readSurgeonAttempts, updateSurgeonAttempts, appendSessionRead, readSessionReads, appendVerifierResult, readVerifierResults, appendCompletedArtifact, artifactIdentity, buildArtifactKey, readArtifactManifest, resolveArtifactTemplate, safePathComponent, workflowTemplateVariables, 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";
@@ -33,6 +33,90 @@ import { runCheckpointVerifier as runSharedCheckpointVerifier, runCompletionVeri
 // ── Constants ──────────────────────────────────────────────
 const DEFAULT_IR_PATH = ".dna/compiled/ir.json";
 const VALID_EVENTS = new Set(hookEventsForSurface("cli"));
+function workflowRuntimeRevisionMismatch(ir, state) {
+    if (!state?.active || state.resolved_variables_source !== "compiled_manifest")
+        return null;
+    const pinnedHash = state.workflow_runtime_compiled_ir_hash;
+    if (!pinnedHash)
+        return "Active workflow is missing its pinned compiled IR hash; restart it after running dna sync.";
+    if (!ir.compiled_ir_hash)
+        return "Current compiled IR is missing its hash; run dna sync and restart the active workflow.";
+    if (pinnedHash !== ir.compiled_ir_hash) {
+        return "Compiled IR changed during the active workflow; restart it before executing more tools.";
+    }
+    return null;
+}
+function isTerminalWorkflowDeactivation(event, rawInput, state) {
+    if (event !== "PreToolUse" || !state?.active)
+        return false;
+    const toolName = typeof rawInput.tool_name === "string" ? rawInput.tool_name : "";
+    const toolInput = rawInput.tool_input;
+    if (!toolName.endsWith("dna_workflow_write") || !toolInput || typeof toolInput !== "object")
+        return false;
+    const args = toolInput;
+    return args.active === false && args.workflow === state.workflow;
+}
+async function hookProjectBoundaryExists(projectDir) {
+    for (const marker of [".dna", ".git"]) {
+        try {
+            await stat(resolve(projectDir, marker));
+            return true;
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error
+                ? error.code
+                : undefined;
+            if (code !== "ENOENT" && code !== "ENOTDIR")
+                return true;
+        }
+    }
+    return false;
+}
+async function resolveHookRuntimePaths(cwd, irPath = DEFAULT_IR_PATH, explicitIRPath = false) {
+    const initialDir = resolve(cwd);
+    if (explicitIRPath) {
+        return {
+            projectDir: initialDir,
+            irPath: resolve(initialDir, irPath),
+        };
+    }
+    let candidateDir = initialDir;
+    while (true) {
+        const candidateIRPath = resolve(candidateDir, DEFAULT_IR_PATH);
+        try {
+            await stat(candidateIRPath);
+            return {
+                projectDir: candidateDir,
+                irPath: candidateIRPath,
+            };
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error
+                ? error.code
+                : undefined;
+            if (code !== "ENOENT" && code !== "ENOTDIR") {
+                return {
+                    projectDir: candidateDir,
+                    irPath: candidateIRPath,
+                };
+            }
+        }
+        if (await hookProjectBoundaryExists(candidateDir)) {
+            return {
+                projectDir: candidateDir,
+                irPath: candidateIRPath,
+            };
+        }
+        const parentDir = dirname(candidateDir);
+        if (parentDir === candidateDir) {
+            return {
+                projectDir: initialDir,
+                irPath: resolve(initialDir, DEFAULT_IR_PATH),
+            };
+        }
+        candidateDir = parentDir;
+    }
+}
 // ── Runtime Decision Evidence ────────────────────────────
 function normalizeDecision(output) {
     if (output.continue === false)
@@ -150,7 +234,12 @@ function buildRuntimeDecisionEvent(params) {
         tool_name: typeof params.rawInput.tool_name === "string" ? params.rawInput.tool_name : "unknown",
         action_kind: actionKind(params.rawInput),
         resource_ref: resourceRef(params.rawInput),
-        evidence_refs: [{ type: "trace", ref: params.traceId }],
+        evidence_refs: [
+            { type: "trace", ref: params.traceId },
+            ...(params.wfState?.workflow_runtime_manifest_hash
+                ? [{ type: "artifact", ref: params.wfState.workflow_runtime_manifest_hash }]
+                : []),
+        ],
     };
 }
 function captureResultForHook(rawInput, decision) {
@@ -277,9 +366,11 @@ async function main() {
         return;
     }
     let irPath = DEFAULT_IR_PATH;
+    let explicitIRPath = false;
     const irFlagIdx = args.indexOf("--ir");
     if (irFlagIdx !== -1 && args[irFlagIdx + 1]) {
         irPath = args[irFlagIdx + 1];
+        explicitIRPath = true;
     }
     // Read stdin
     const stdin = await readStdinResult(5000);
@@ -297,10 +388,12 @@ async function main() {
     }
     const rawInput = validation.normalized;
     // Resolve project directory from input or cwd
-    const projectDir = typeof rawInput.cwd === "string" ? rawInput.cwd : process.cwd();
+    const cwd = typeof rawInput.cwd === "string" ? rawInput.cwd : process.cwd();
+    const runtimePaths = await resolveHookRuntimePaths(cwd, irPath, explicitIRPath);
+    const { projectDir } = runtimePaths;
     const sessionId = typeof rawInput.sessionId === "string" ? rawInput.sessionId : undefined;
     // Load compiled IR
-    const resolvedIRPath = resolve(projectDir, irPath);
+    const resolvedIRPath = runtimePaths.irPath;
     const ir = await loadIR(resolvedIRPath);
     if (!ir) {
         writeOutput(hookFailureOutput(event, "missing_ir", `Compiled IR is missing, unreadable, invalid, or version-incompatible at ${resolvedIRPath}.`));
@@ -361,6 +454,12 @@ export async function runHookEvent(options) {
             return finish(workflowState.output);
         }
         wfStateRaw = workflowState.state;
+        const revisionMismatch = workflowRuntimeRevisionMismatch(ir, wfStateRaw);
+        if (revisionMismatch && !isTerminalWorkflowDeactivation(event, rawInput, wfStateRaw)) {
+            const mismatch = hookFailureOutput(event, "runtime_revision_mismatch", revisionMismatch);
+            await writeRuntimeDecision(mismatch, { output: mismatch, trace: { matched_rule: "workflow_runtime_revision", step_id: wfStateRaw?.current_step } }, wfStateRaw);
+            return finish(mismatch);
+        }
         if (wfStateRaw?.active
             && typeof rawInput.agent_type === "string"
             && !subagentMatchesWorkflowRole(rawInput, wfStateRaw)) {
@@ -463,6 +562,12 @@ export async function runHookEvent(options) {
             return finish(workflowState.output);
         }
         const wfState = workflowState.state;
+        const revisionMismatch = workflowRuntimeRevisionMismatch(ir, wfState);
+        if (revisionMismatch) {
+            const mismatch = hookFailureOutput(event, "runtime_revision_mismatch", revisionMismatch);
+            await writeRuntimeDecision(mismatch, { output: mismatch, trace: { matched_rule: "workflow_runtime_revision", step_id: wfState?.current_step } }, wfState);
+            return finish(mismatch);
+        }
         let stopArtifactFacts = [];
         if (wfState?.active) {
             const artifactFacts = await finalizeAndResolveArtifactsForHook(projectDir, ir, wfState, event, sessionId);
@@ -759,11 +864,13 @@ async function runCodexHookCli(args) {
             return;
         }
         const rawInput = stdin.data;
-        const projectDir = typeof rawInput.cwd === "string" ? rawInput.cwd : process.cwd();
-        const irPath = argValue(args, "--ir") ?? DEFAULT_IR_PATH;
-        const ir = await loadIR(resolve(projectDir, irPath));
+        const cwd = typeof rawInput.cwd === "string" ? rawInput.cwd : process.cwd();
+        const explicitIRPath = argValue(args, "--ir");
+        const runtimePaths = await resolveHookRuntimePaths(cwd, explicitIRPath ?? DEFAULT_IR_PATH, explicitIRPath !== undefined);
+        const { projectDir, irPath } = runtimePaths;
+        const ir = await loadIR(irPath);
         if (!ir) {
-            writeOutput(hookFailureOutput(policyEvent, "missing_ir", `Compiled IR is missing, unreadable, invalid, or version-incompatible at ${resolve(projectDir, irPath)}.`));
+            writeOutput(hookFailureOutput(policyEvent, "missing_ir", `Compiled IR is missing, unreadable, invalid, or version-incompatible at ${irPath}.`));
             return;
         }
         const result = await runCodexHookWithLoadedIr(rawInput, projectDir, args, ir);
@@ -1014,6 +1121,7 @@ export const recordProducedArtifactsForTest = recordProducedArtifacts;
 export const resolveWorkflowArtifactFactsForTest = resolveWorkflowArtifactFacts;
 export const readWorkflowStateForHookTest = readWorkflowStateForHook;
 export const runCodexHookWithLoadedIrForTest = runCodexHookWithLoadedIr;
+export const resolveHookRuntimePathsForTest = resolveHookRuntimePaths;
 export const inferWorkflowAssetFromIrForTest = inferWorkflowAssetFromIr;
 export const resolveWorkflowArtifactFactsForHookTest = resolveWorkflowArtifactFactsForHook;
 export const finalizeAndResolveArtifactsForHookTest = finalizeAndResolveArtifactsForHook;
@@ -1137,7 +1245,7 @@ async function runVerifierSpec(projectDir, ir, spec, workflowState, sessionId, o
     if (spec.kind === "checkpoint" && spec.checkpoint) {
         const checkpointResult = await runSharedCheckpointVerifier(spec.checkpoint, ir, {
             projectDir,
-            variables: { ...(workflowState.resolved_variables ?? {}), ...(workflowState.inputs ?? {}) },
+            variables: workflowTemplateVariables(workflowState),
             commandTimeoutMs: options?.commandTimeoutMs,
         });
         passed = checkpointResult.passed;
@@ -1157,7 +1265,7 @@ async function runVerifierSpec(projectDir, ir, spec, workflowState, sessionId, o
         else {
             const completionResult = await runCompletionVerifier(completion, ir, {
                 projectDir,
-                variables: { ...(workflowState.resolved_variables ?? {}), ...(workflowState.inputs ?? {}) },
+                variables: workflowTemplateVariables(workflowState),
                 commandTimeoutMs: options?.commandTimeoutMs,
             });
             passed = completionResult.passed;

package/dist/hooks/enforcement-boundary.d.ts

@@ -1,6 +1,6 @@
 import type { HookEvent } from "./event-registry.js";
 import { type HookOutput } from "./protocol.js";
-export type HookFailureKind = "malformed_input" | "missing_ir" | "role_mismatch" | "gate_evaluation" | "bash_write_scope";
+export type HookFailureKind = "malformed_input" | "missing_ir" | "runtime_revision_mismatch" | "role_mismatch" | "gate_evaluation" | "bash_write_scope";
 export type HookFailureDisposition = "advisory" | "blocking";
 /**
  * Foundation Hook failure policy.

package/dist/hooks/protocol.d.ts

@@ -59,7 +59,7 @@ export interface HookOutput {
         permissionDecision?: "ask" | "allow" | "deny";
     };
 }
-export type MatchedRule = "scope" | "filter" | "gate" | "schema" | "validator" | "handoff" | "step_rule" | "output_schema" | "context_gate" | "reflection_gate" | "workflow_boundary";
+export type MatchedRule = "scope" | "filter" | "gate" | "schema" | "validator" | "handoff" | "step_rule" | "output_schema" | "context_gate" | "reflection_gate" | "workflow_runtime_revision" | "workflow_boundary";
 export interface TraceMetadata {
     matched_rule: MatchedRule;
     gene_id?: string;

package/dist/hooks/state.d.ts

@@ -30,6 +30,10 @@ export interface DNAWorkflowState {
     started_at: string;
     inputs?: Record<string, string>;
     resolved_variables?: Record<string, string>;
+    resolved_variables_source?: "compiled_manifest" | "legacy_skill";
+    workflow_runtime_manifest_hash?: string;
+    workflow_runtime_compiled_ir_hash?: string;
+    workflow_inputs_pinned?: boolean;
     completed_artifacts?: CompletedArtifactEntry[];
 }
 /** Audit log entry (one per line in JSON Lines format) */
@@ -117,6 +121,7 @@ export declare function buildArtifactKey(params: {
 }): ArtifactKey;
 export declare function artifactManifestPath(projectDir: string, key: ArtifactKey): string;
 export declare function resolveArtifactTemplate(template: string, state?: Pick<DNAWorkflowState, "inputs" | "resolved_variables">): string | null;
+export declare function workflowTemplateVariables(state?: Pick<DNAWorkflowState, "inputs" | "resolved_variables">): Record<string, string>;
 export declare function writeArtifactManifest(projectDir: string, manifest: Omit<ArtifactManifest, "id" | "recorded_at" | "resolver_version">): Promise<ArtifactFact>;
 export declare function readArtifactManifest(projectDir: string, key: ArtifactKey): Promise<ArtifactFact | null>;
 /**

package/dist/hooks/state.js

@@ -78,16 +78,19 @@ export function resolveArtifactTemplate(template, state) {
     const resolvedVariables = state?.resolved_variables ?? {};
     resolved = resolved.replace(/\{\{(\w+)\}\}/g, (_match, name) => {
         const inputValue = inputs[name];
-        if (inputValue !== undefined) {
+        const resolvedValue = resolvedVariables[name];
+        if (USER_ARTIFACT_PATH_ARGUMENTS.has(name) && inputValue !== undefined) {
             return safeUserArtifactPathArgument(inputValue, name) ?? `{{${name}}}`;
         }
-        const resolvedValue = resolvedVariables[name];
-        if (resolvedValue === undefined)
-            return `{{${name}}}`;
-        if (USER_ARTIFACT_PATH_ARGUMENTS.has(name)) {
+        if (resolvedValue !== undefined) {
+            if (!USER_ARTIFACT_PATH_ARGUMENTS.has(name))
+                return resolvedValue;
             return safeUserArtifactPathArgument(resolvedValue, name) ?? `{{${name}}}`;
         }
-        return resolvedValue;
+        if (inputValue !== undefined) {
+            return safeUserArtifactPathArgument(inputValue, name) ?? `{{${name}}}`;
+        }
+        return `{{${name}}}`;
     });
     const args = inputs.ARGUMENTS ?? inputs.arguments ?? inputs.task_id ?? resolvedVariables.ARGUMENTS ?? resolvedVariables.arguments ?? resolvedVariables.task_id;
     if (resolved.includes("$ARGUMENTS")) {
@@ -102,6 +105,18 @@ export function resolveArtifactTemplate(template, state) {
         return null;
     return resolved;
 }
+export function workflowTemplateVariables(state) {
+    const variables = { ...(state?.inputs ?? {}) };
+    const argumentsValue = variables.ARGUMENTS ?? variables.arguments ?? variables.task_id;
+    for (const [name, value] of Object.entries(state?.resolved_variables ?? {})) {
+        if (!USER_ARTIFACT_PATH_ARGUMENTS.has(name) || variables[name] === undefined) {
+            variables[name] = argumentsValue === undefined
+                ? value
+                : value.replace(/(^|[^\\])\$ARGUMENTS/g, (_match, prefix) => `${prefix}${argumentsValue}`);
+        }
+    }
+    return variables;
+}
 export async function writeArtifactManifest(projectDir, manifest) {
     const id = artifactHash(manifest.key);
     const full = {

package/dist/mcp/tools-state.js

@@ -10,12 +10,111 @@
 import { resolve } from "node:path";
 import { readWorkflowState, writeWorkflowState, readRuntimeDecisionEvents, readTraces, listSessions } from "../hooks/state.js";
 import { validateRuntimeDecisionEvent } from "../governance/index.js";
-import { loadCompiledIR } from "../runtime/plugin-adapter.js";
-import { textResult } from "./server.js";
+import { loadCompiledIR, loadCompiledIRResult } from "../runtime/plugin-adapter.js";
+import { validateWorkflowRuntimeManifest } from "../runtime/workflow-runtime-manifest.js";
+import { errorResult, textResult } from "./server.js";
 function isStringRecord(value) {
-    return typeof value === "object" && value !== null &&
+    return typeof value === "object" && value !== null && !Array.isArray(value) &&
         Object.values(value).every(v => typeof v === "string");
 }
+function sameStringRecord(a, b) {
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+    return aKeys.length === bKeys.length && aKeys.every((key, index) => key === bKeys[index] && a[key] === b[key]);
+}
+const RUNTIME_ARGUMENT_NAMES = ["ARGUMENTS", "arguments", "task_id"];
+function compatibleManifestInputCandidate(binding, candidate) {
+    if (!candidate)
+        return { ignored: [] };
+    const allowed = new Set([...binding.runtime_input_refs, ...RUNTIME_ARGUMENT_NAMES]);
+    const entries = Object.entries(candidate);
+    return {
+        candidate: Object.fromEntries(entries.filter(([name]) => allowed.has(name))),
+        ignored: entries.filter(([name]) => !allowed.has(name)).map(([name]) => name).sort(),
+    };
+}
+async function lookupRuntimeBinding(projectDir, workflow) {
+    const result = await loadCompiledIRResult(resolve(projectDir, ".dna", "compiled", "ir.json"));
+    if (result.status === "missing") {
+        return { status: "error", kind: "invalid_ir", message: "No compiled IR found. Run `dna sync` before starting or continuing this workflow." };
+    }
+    if (result.status === "invalid") {
+        return { status: "error", kind: "invalid_ir", message: `Invalid compiled IR: ${result.reason}. Run \`dna sync\` before starting or continuing this workflow.` };
+    }
+    const compiled = result.compiled;
+    if (!Object.prototype.hasOwnProperty.call(compiled, "workflow_runtime")) {
+        return { status: "legacy", compiledIrHash: compiled.compiled_ir_hash };
+    }
+    if (typeof compiled.compiled_ir_hash !== "string" ||
+        typeof compiled.ir.compiled_ir_hash !== "string" ||
+        compiled.compiled_ir_hash !== compiled.ir.compiled_ir_hash) {
+        return {
+            status: "error",
+            kind: "invalid_ir",
+            message: "Invalid compiled IR: workflow runtime bindings require matching wrapper and IR hashes. Run `dna sync` before starting or continuing this workflow.",
+        };
+    }
+    const validation = validateWorkflowRuntimeManifest(compiled.workflow_runtime, compiled.compiled_ir_hash);
+    if (!validation.valid) {
+        return {
+            status: "error",
+            kind: "invalid_manifest",
+            compiledIrHash: compiled.compiled_ir_hash,
+            message: `Invalid compiled workflow runtime manifest: ${validation.reason}. Run \`dna sync\` before starting or continuing this workflow.`,
+        };
+    }
+    if (!Object.prototype.hasOwnProperty.call(validation.manifest.workflows, workflow)) {
+        return {
+            status: "error",
+            kind: "workflow_missing",
+            compiledIrHash: validation.manifest.compiled_ir_hash,
+            message: `Workflow ${workflow} is not present in the compiled workflow runtime manifest. Run \`dna sync\` to refresh generated runtime artifacts.`,
+        };
+    }
+    const binding = validation.manifest.workflows[workflow];
+    return {
+        status: "found",
+        binding,
+        manifestHash: validation.manifest.manifest_hash,
+        compiledIrHash: validation.manifest.compiled_ir_hash,
+    };
+}
+function normalizeManifestInputs(binding, candidate) {
+    const rawInputs = { ...(candidate ?? {}) };
+    const allowed = new Set([...binding.runtime_input_refs, ...RUNTIME_ARGUMENT_NAMES]);
+    const unexpected = Object.keys(rawInputs).filter((name) => !allowed.has(name));
+    if (unexpected.length > 0) {
+        return { valid: false, message: `Workflow inputs are not declared by the compiled runtime binding: ${unexpected.join(", ")}` };
+    }
+    const argumentValues = RUNTIME_ARGUMENT_NAMES
+        .map((name) => rawInputs[name])
+        .filter((value) => value !== undefined);
+    const distinctArgumentValues = [...new Set(argumentValues)];
+    if (distinctArgumentValues.length > 1) {
+        return { valid: false, message: "ARGUMENTS, arguments, and task_id must identify the same runtime input." };
+    }
+    const argumentValue = distinctArgumentValues[0];
+    if (!binding.requires_arguments && argumentValue !== undefined) {
+        return { valid: true, note: "Ignored legacy argument input for an argument-free workflow." };
+    }
+    if (binding.requires_arguments && (!argumentValue || argumentValue.trim() === "")) {
+        return { valid: false, message: "This workflow requires a non-empty ARGUMENTS input." };
+    }
+    const inputs = {};
+    for (const name of binding.runtime_input_refs) {
+        if (RUNTIME_ARGUMENT_NAMES.includes(name)) {
+            if (argumentValue !== undefined)
+                inputs[name] = argumentValue;
+        }
+        else if (rawInputs[name] !== undefined) {
+            inputs[name] = rawInputs[name];
+        }
+        else {
+            return { valid: false, message: `This workflow requires runtime input ${name}.` };
+        }
+    }
+    return { valid: true, inputs: Object.keys(inputs).length > 0 ? inputs : undefined };
+}
 export function createStateTools(projectDir) {
     return [
         // ── dna_status ────────────────────────────────────────
@@ -39,6 +138,15 @@ export function createStateTools(projectDir) {
                     if (ir.workflows_ir?.length) {
                         lines.push(`  Workflows: ${ir.workflows_ir.map(w => w.workflow_name).join(", ")}`);
                     }
+                    if (!Object.prototype.hasOwnProperty.call(compiled, "workflow_runtime")) {
+                        lines.push("  Workflow runtime: legacy; workflow starts are blocked until `dna sync` regenerates deterministic bindings");
+                    }
+                    else {
+                        const runtimeValidation = validateWorkflowRuntimeManifest(compiled.workflow_runtime, compiled.compiled_ir_hash);
+                        lines.push(runtimeValidation.valid
+                            ? `  Workflow runtime: ${runtimeValidation.manifest.schema_version}`
+                            : `  Workflow runtime: invalid (${runtimeValidation.reason}); run \`dna sync\``);
+                    }
                 }
                 else {
                     lines.push("IR: not found (run `dna sync` to compile)");
@@ -99,40 +207,168 @@ export function createStateTools(projectDir) {
         // ── dna_workflow_write ────────────────────────────────
         {
             name: "dna_workflow_write",
-            description: "Update workflow state (set current step, role, iteration, or deactivate)",
+            description: "Update workflow state. Template variables and workflow asset identity are initialized from the compiled runtime manifest.",
             inputSchema: {
                 type: "object",
                 properties: {
                     workflow: { type: "string", description: "Workflow name" },
-                    workflow_asset: { type: "string", description: "Workflow asset id/name for local evidence attribution" },
+                    workflow_asset: { type: "string", description: "Deprecated Skill input; ignored because the compiled runtime manifest owns workflow attribution" },
                     current_step: { type: "string", description: "Current step ID" },
                     current_role: { type: "string", description: "Current role name" },
                     iteration: { type: "number", description: "Current iteration number" },
                     active: { type: "boolean", description: "Whether workflow is active (false to deactivate)" },
                     session_id: { type: "string", description: "Session ID for isolation" },
                     inputs: { type: "object", description: "Workflow runtime inputs such as ARGUMENTS" },
-                    resolved_variables: { type: "object", description: "Resolved template variables for artifact paths" },
+                    resolved_variables: { type: "object", description: "Deprecated Skill input; ignored when a manifest exists and never accepted as compiled configuration" },
                 },
                 required: ["workflow", "current_step", "current_role"],
             },
             handler: async (args) => {
                 const sessionId = typeof args.session_id === "string" ? args.session_id : undefined;
                 const existing = await readWorkflowState(projectDir, sessionId, 0);
+                const workflow = String(args.workflow);
+                if (existing?.active && existing.workflow !== workflow) {
+                    return errorResult(`Workflow ${existing.workflow} is already active. Deactivate it before starting or writing state for ${workflow}.`);
+                }
+                const sameActiveWorkflow = existing?.active === true && existing.workflow === workflow;
+                const closingWorkflow = args.active === false;
+                if (sameActiveWorkflow && closingWorkflow) {
+                    const state = {
+                        ...existing,
+                        active: false,
+                        current_step: String(args.current_step),
+                        current_role: String(args.current_role),
+                        iteration: typeof args.iteration === "number" ? args.iteration : existing.iteration,
+                    };
+                    await writeWorkflowState(projectDir, state, sessionId);
+                    return textResult(`Workflow state updated: ${state.workflow} step=${state.current_step} role=${state.current_role} iteration=${state.iteration}\n`
+                        + "Terminal deactivation preserved the run's pinned state and ignored replacement runtime bindings.");
+                }
+                const runtimeBinding = await lookupRuntimeBinding(projectDir, workflow);
+                const hasPinnedRuntimeBinding = sameActiveWorkflow &&
+                    existing?.resolved_variables_source === "compiled_manifest" &&
+                    typeof existing.workflow_runtime_manifest_hash === "string" &&
+                    typeof existing.workflow_runtime_compiled_ir_hash === "string";
+                if (runtimeBinding.status === "error" && !hasPinnedRuntimeBinding) {
+                    return errorResult(runtimeBinding.message);
+                }
+                const currentCompiledIrHash = runtimeBinding.compiledIrHash;
+                if (hasPinnedRuntimeBinding &&
+                    currentCompiledIrHash !== existing.workflow_runtime_compiled_ir_hash &&
+                    !closingWorkflow) {
+                    return errorResult("The compiled IR changed during this active workflow. Restart the workflow so one run cannot execute against multiple policy revisions.");
+                }
+                if (args.inputs !== undefined && !isStringRecord(args.inputs)) {
+                    return errorResult("Workflow inputs must be an object whose values are strings.");
+                }
+                const providedInputs = isStringRecord(args.inputs) ? args.inputs : undefined;
+                let inputs;
+                let workflowInputsPinned = sameActiveWorkflow ? existing?.workflow_inputs_pinned : undefined;
+                let workflowAsset;
+                let resolvedVariables;
+                let resolvedVariablesSource;
+                let workflowRuntimeManifestHash;
+                let workflowRuntimeCompiledIrHash;
+                const notes = [];
+                if (hasPinnedRuntimeBinding) {
+                    workflowAsset = existing.workflow_asset;
+                    resolvedVariables = existing.resolved_variables;
+                    resolvedVariablesSource = "compiled_manifest";
+                    workflowRuntimeManifestHash = existing.workflow_runtime_manifest_hash;
+                    workflowRuntimeCompiledIrHash = existing.workflow_runtime_compiled_ir_hash;
+                    workflowInputsPinned = true;
+                    if (providedInputs) {
+                        const normalized = runtimeBinding.status === "found"
+                            ? normalizeManifestInputs(runtimeBinding.binding, providedInputs)
+                            : { valid: true, inputs: providedInputs };
+                        if (!normalized.valid)
+                            return errorResult(normalized.message);
+                        if (!sameStringRecord(existing.inputs ?? {}, normalized.inputs ?? {})) {
+                            return errorResult("Workflow inputs are pinned for an active run and cannot be changed. Finish or restart the workflow to use different inputs.");
+                        }
+                    }
+                    inputs = existing.inputs;
+                    if (args.resolved_variables !== undefined) {
+                        notes.push("Deprecated resolved_variables input ignored; active workflow bindings are pinned.");
+                    }
+                    if (runtimeBinding.status === "found" && runtimeBinding.manifestHash !== workflowRuntimeManifestHash) {
+                        notes.push("A newer compiled workflow runtime manifest exists; this active workflow remains pinned to its start-time bindings.");
+                    }
+                    else if (runtimeBinding.status === "error") {
+                        notes.push("The compiled workflow manifest is invalid or unavailable; this run remains pinned to the same compiled IR revision. Run `dna sync` before the next workflow.");
+                    }
+                    else if (runtimeBinding.status === "legacy") {
+                        notes.push("The compiled runtime manifest is unavailable; this active workflow remains pinned, but `dna sync` is required before the next workflow.");
+                    }
+                }
+                else if (runtimeBinding.status === "found") {
+                    let candidateInputs = providedInputs ?? (sameActiveWorkflow ? existing?.inputs : undefined);
+                    if (sameActiveWorkflow && existing?.resolved_variables_source !== "compiled_manifest") {
+                        const existingCandidate = compatibleManifestInputCandidate(runtimeBinding.binding, existing.inputs);
+                        const providedCandidate = compatibleManifestInputCandidate(runtimeBinding.binding, providedInputs);
+                        const normalizedExisting = normalizeManifestInputs(runtimeBinding.binding, existingCandidate.candidate);
+                        const normalizedProvided = providedInputs
+                            ? normalizeManifestInputs(runtimeBinding.binding, providedCandidate.candidate)
+                            : null;
+                        if (normalizedExisting.valid && normalizedExisting.inputs) {
+                            if (normalizedProvided?.valid && normalizedProvided.inputs &&
+                                !sameStringRecord(normalizedExisting.inputs, normalizedProvided.inputs)) {
+                                return errorResult("Workflow inputs are pinned for an active legacy run and cannot be changed during migration.");
+                            }
+                            candidateInputs = existingCandidate.candidate;
+                        }
+                        else {
+                            candidateInputs = { ...existingCandidate.candidate, ...providedCandidate.candidate };
+                        }
+                        const ignored = [...new Set([...existingCandidate.ignored, ...providedCandidate.ignored])];
+                        if (ignored.length > 0) {
+                            notes.push(`Ignored legacy workflow input metadata during migration: ${ignored.join(", ")}.`);
+                        }
+                    }
+                    const normalizedInputs = normalizeManifestInputs(runtimeBinding.binding, candidateInputs);
+                    if (!normalizedInputs.valid)
+                        return errorResult(normalizedInputs.message);
+                    inputs = normalizedInputs.inputs;
+                    workflowInputsPinned = true;
+                    workflowAsset = runtimeBinding.binding.workflow_asset;
+                    resolvedVariables = runtimeBinding.binding.resolved_variables;
+                    resolvedVariablesSource = "compiled_manifest";
+                    workflowRuntimeManifestHash = runtimeBinding.manifestHash;
+                    workflowRuntimeCompiledIrHash = runtimeBinding.compiledIrHash;
+                    if (normalizedInputs.note)
+                        notes.push(normalizedInputs.note);
+                    if (args.resolved_variables !== undefined) {
+                        notes.push("Deprecated resolved_variables input ignored; compiled workflow runtime manifest is authoritative.");
+                    }
+                    if (sameActiveWorkflow && existing?.resolved_variables_source !== "compiled_manifest") {
+                        notes.push("Legacy workflow state upgraded to compiled workflow runtime bindings.");
+                    }
+                }
+                else {
+                    return errorResult("This project has a legacy compiled IR without deterministic workflow runtime bindings. Run `dna sync` with the upgraded IntentDNA CLI, then retry the workflow. Model-supplied workflow_asset and resolved_variables are not trusted.");
+                }
                 const state = {
                     active: typeof args.active === "boolean" ? args.active : true,
-                    workflow_asset: typeof args.workflow_asset === "string" ? args.workflow_asset : existing?.workflow_asset,
-                    workflow: String(args.workflow),
+                    workflow_asset: workflowAsset,
+                    workflow,
                     current_step: String(args.current_step),
                     current_role: String(args.current_role),
-                    iteration: typeof args.iteration === "number" ? args.iteration : (existing?.iteration ?? 1),
-                    session_id: sessionId ?? existing?.session_id ?? "",
-                    started_at: existing?.started_at ?? new Date().toISOString(),
-                    inputs: isStringRecord(args.inputs) ? args.inputs : existing?.inputs,
-                    resolved_variables: isStringRecord(args.resolved_variables) ? args.resolved_variables : existing?.resolved_variables,
-                    completed_artifacts: existing?.completed_artifacts,
+                    iteration: typeof args.iteration === "number" ? args.iteration : (sameActiveWorkflow ? existing?.iteration ?? 1 : 1),
+                    session_id: sessionId ?? (sameActiveWorkflow ? existing?.session_id : undefined) ?? "",
+                    started_at: sameActiveWorkflow ? existing.started_at : new Date().toISOString(),
+                    inputs,
+                    resolved_variables: resolvedVariables,
+                    resolved_variables_source: resolvedVariablesSource,
+                    workflow_runtime_manifest_hash: workflowRuntimeManifestHash,
+                    workflow_runtime_compiled_ir_hash: workflowRuntimeCompiledIrHash,
+                    workflow_inputs_pinned: workflowInputsPinned,
+                    completed_artifacts: sameActiveWorkflow ? existing?.completed_artifacts : undefined,
                 };
                 await writeWorkflowState(projectDir, state, sessionId);
-                return textResult(`Workflow state updated: ${state.workflow} step=${state.current_step} role=${state.current_role} iteration=${state.iteration}`);
+                return textResult([
+                    `Workflow state updated: ${state.workflow} step=${state.current_step} role=${state.current_role} iteration=${state.iteration}`,
+                    ...notes,
+                ].join("\n"));
             },
         },
         // ── dna_trace_query ──────────────────────────────────

package/dist/runtime/claude-sync-target.d.ts

@@ -1,6 +1,7 @@
 import type { ConstraintIR, RoleDef } from "../schema/types.js";
 import type { SyncOutputArtifactId } from "./output-artifact-registry.js";
 import { type CompiledIRFile } from "./plugin-adapter.js";
+import type { WorkflowRuntimeManifest } from "./workflow-runtime-manifest.js";
 import { type DNASettings, type HookEventKey, type IntentDNASettingsHookCleanupResult } from "./settings-adapter.js";
 import type { AdapterCapabilityReport, CapabilityReportEntry, PlannedArtifact, SyncTargetPlan } from "./sync-target-plan.js";
 export type ClaudeSyncMode = "plugin" | "bin";
@@ -21,6 +22,7 @@ export interface ClaudeCoreSyncTargetPlanOptions {
     projectDir: string;
     ir: ConstraintIR;
     roles?: Record<string, RoleDef>;
+    workflowRuntime?: WorkflowRuntimeManifest;
     mode: ClaudeSyncMode;
     settingsPath?: string;
 }

package/dist/runtime/claude-sync-target.js

@@ -43,7 +43,7 @@ function createSettingsHookRegistration(ir, mode, settingsPath) {
     };
 }
 export function createClaudeCoreSyncTargetPlan(options) {
-    const compiledIR = createCompiledIR(options.ir, options.roles);
+    const compiledIR = createCompiledIR(options.ir, options.roles, options.workflowRuntime);
     const compiledIRPath = resolve(options.projectDir, ".dna", "compiled", "ir.json");
     const legacyHooksDir = resolve(options.projectDir, ".claude", "hooks");
     const mcpConfigPath = resolve(options.projectDir, ".mcp.json");

package/dist/runtime/evaluator.d.ts

@@ -0,0 +1,13 @@
+export declare const MAX_EVALUATOR_RESULT_BYTES = 65536;
+export interface EvaluatorResult {
+    readonly pass: boolean;
+    readonly score?: number;
+}
+export interface ParseEvaluatorResultOptions {
+    readonly require_score?: boolean;
+    readonly max_bytes?: number;
+}
+export declare class EvaluatorResultError extends Error {
+    constructor(message: string);
+}
+export declare function parseEvaluatorResult(raw: string, options?: ParseEvaluatorResultOptions): EvaluatorResult;