intentdna 1.7.5 → 1.8.1

package/dist/hooks/cli.js

@@ -23,10 +23,12 @@ 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, rotateTraces, readTraces, cleanStaleState, readSurgeonAttempts, writeSurgeonAttempts, appendSessionRead, readSessionReads, appendVerifierResult, appendCompletedArtifact, artifactIdentity, buildArtifactKey, readArtifactManifest, resolveArtifactTemplate, safePathComponent, writeArtifactManifest } from "./state.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 { hookEventsForSurface } from "./event-registry.js";
 import { writeAuditEvent } from "../audit/index.js";
-import { RUNTIME_DECISION_EVENT_SCHEMA_VERSION } from "../governance/index.js";
+import { RUNTIME_DECISION_EVENT_SCHEMA_VERSION, trustedEvidenceCaptureAttribution } from "../governance/index.js";
+import { runCodexHook } from "../runtime/codex-adapter.js";
+import { runCheckpointVerifier as runSharedCheckpointVerifier, runCompletionVerifier, toProjectRelativePath, } from "../runtime/verifier.js";
 // ── Constants ──────────────────────────────────────────────
 const DEFAULT_IR_PATH = ".dna/compiled/ir.json";
 const VALID_EVENTS = new Set(hookEventsForSurface("cli"));
@@ -150,6 +152,74 @@ function buildRuntimeDecisionEvent(params) {
         evidence_refs: [{ type: "trace", ref: params.traceId }],
     };
 }
+function captureResultForHook(rawInput, decision) {
+    if (decision === "block")
+        return "blocked";
+    if (typeof rawInput.result === "string" && ["success", "failure", "blocked", "skipped", "unknown", "unsupported"].includes(rawInput.result)) {
+        return rawInput.result;
+    }
+    if (typeof rawInput.exit_code === "number")
+        return rawInput.exit_code === 0 ? "success" : "failure";
+    return "unknown";
+}
+function captureFactForHook(rawInput, decision, event) {
+    if (decision === "block")
+        return "blocker";
+    if (event === "PostToolUse" || event === "Stop" || rawInput.result || rawInput.exit_code !== undefined)
+        return "result";
+    const toolInput = typeof rawInput.tool_input === "object" && rawInput.tool_input !== null
+        ? rawInput.tool_input
+        : {};
+    if (typeof rawInput.command === "string" || typeof toolInput.command === "string")
+        return "command";
+    return "result";
+}
+function commandForHook(rawInput) {
+    const toolInput = typeof rawInput.tool_input === "object" && rawInput.tool_input !== null
+        ? rawInput.tool_input
+        : {};
+    const command = rawInput.command ?? toolInput.command;
+    return typeof command === "string" && command.trim().length > 0 ? command : undefined;
+}
+function buildClaudeEvidenceCaptureEvent(params) {
+    const fact = captureFactForHook(params.rawInput, params.decision, params.event);
+    const result = captureResultForHook(params.rawInput, params.decision);
+    const command = commandForHook(params.rawInput);
+    const toolName = typeof params.rawInput.tool_name === "string" ? params.rawInput.tool_name : "unknown tool";
+    const subject = command ?? `${toolName} ${params.event}`;
+    const attribution = trustedEvidenceCaptureAttribution(params.ir, {
+        workflowAsset: params.wfState?.workflow_asset,
+        workflowId: params.wfState?.workflow,
+        stepId: params.wfState?.current_step ?? params.runtimeEvent.step_id,
+    });
+    return {
+        schema_version: EVIDENCE_CAPTURE_SCHEMA_VERSION,
+        event_id: `c5:${params.runtimeEvent.event_id}`,
+        captured_at: params.runtimeEvent.timestamp,
+        project_root: params.projectDir,
+        source: "claude_code",
+        workflow_asset: attribution.workflowAsset,
+        workflow_id: attribution.workflowId,
+        run_id: params.runtimeEvent.run_id || params.runtimeEvent.session_id || "unknown",
+        step_id: attribution.stepId === "unknown" && !params.wfState
+            ? `${params.event}:direct`
+            : attribution.stepId,
+        fact,
+        summary: `Claude hook observed ${fact} for ${subject}: ${result}`,
+        command,
+        result,
+        exit_code: typeof params.rawInput.exit_code === "number" ? params.rawInput.exit_code : undefined,
+        duration_ms: typeof params.rawInput.duration_ms === "number" ? params.rawInput.duration_ms : undefined,
+        manual_intervention: fact === "manual_intervention"
+            ? { required: true, reason: params.reason, actor: "human" }
+            : undefined,
+        evidence_refs: [
+            { type: "runtime_decision_event", ref: params.runtimeEvent.event_id },
+            ...params.runtimeEvent.evidence_refs.map((ref) => ({ type: ref.type, ref: ref.ref })),
+        ],
+        redaction: "intentdna.c5.claude_hook_secret_redaction.v1",
+    };
+}
 export function computeSummary(traces) {
     let blocks = 0, warns = 0;
     const toolCounts = new Map();
@@ -193,7 +263,12 @@ export function formatSummary(s) {
 async function main() {
     // Parse args
     const args = process.argv.slice(2);
-    const event = args[0];
+    const eventArg = args[0];
+    if (eventArg === "CodexHook") {
+        await runCodexHookCli(args);
+        return;
+    }
+    const event = eventArg;
     if (!event || !VALID_EVENTS.has(event)) {
         writeOutput(silentOutput());
         return;
@@ -245,7 +320,7 @@ export async function runHookEvent(options) {
     const writeRuntimeDecision = async (output, result, wfState, traceId = randomUUID()) => {
         const decision = normalizeDecision(output);
         const reason = decision !== "allow" ? (output.reason ?? output.hookSpecificOutput?.additionalContext ?? "unknown") : "allowed by active policy";
-        await appendRuntimeDecisionEvent(projectDir, buildRuntimeDecisionEvent({
+        const runtimeEvent = buildRuntimeDecisionEvent({
             ir,
             rawInput,
             output,
@@ -257,7 +332,18 @@ export async function runHookEvent(options) {
             decision,
             reason,
             wfState,
-        }), sessionId);
+        });
+        await appendRuntimeDecisionEvent(projectDir, runtimeEvent, sessionId);
+        await appendEvidenceCaptureEvent(projectDir, buildClaudeEvidenceCaptureEvent({
+            ir,
+            rawInput,
+            event,
+            projectDir,
+            decision,
+            reason,
+            runtimeEvent,
+            wfState,
+        }));
     };
     let wfStateRaw = null;
     // Load workflow state for events that need it (handoff context + PreCompact preservation)
@@ -272,6 +358,7 @@ export async function runHookEvent(options) {
             state.workflowState = {
                 current_step: wfStateRaw.current_step,
                 workflow: wfStateRaw.workflow,
+                workflow_asset: wfStateRaw.workflow_asset,
                 current_role: wfStateRaw.current_role,
                 completed_artifacts: wfStateRaw.completed_artifacts,
                 iteration: wfStateRaw.iteration, // G4: pass iteration for state-driven rules
@@ -337,6 +424,8 @@ export async function runHookEvent(options) {
             current_step: wfState.current_step,
             current_role: wfState.current_role,
             started_at: wfState.started_at,
+            inputs: wfState.inputs,
+            resolved_variables: wfState.resolved_variables,
             completed_artifacts: wfState.completed_artifacts,
             artifact_facts: stopArtifactFacts,
         } : null;
@@ -421,6 +510,8 @@ export async function runHookEvent(options) {
                     workflow: wfStateRaw.workflow,
                     current_step: wfStateRaw.current_step,
                     current_role: wfStateRaw.current_role,
+                    inputs: wfStateRaw.inputs,
+                    resolved_variables: wfStateRaw.resolved_variables,
                 }, "post_tool_use", sessionId);
                 const failingResults = verifierResults.filter((result) => result.status === "fail");
                 if (failingResults.length > 0) {
@@ -554,6 +645,62 @@ function dispatch(event, ir, input, state, roles) {
             return null;
     }
 }
+// ── Codex Hook Entry ───────────────────────────────────────
+function argValue(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function codexInstallMode(value) {
+    return value === "plugin_scoped" || value === "managed" || value === "none" ? value : "project_fallback";
+}
+export function codexHookEventForInput(rawInput, args) {
+    return argValue(args, "--codex-event") ?? rawInput.event;
+}
+function inferWorkflowAssetFromIr(ir, workflowId) {
+    const attribution = trustedEvidenceCaptureAttribution(ir, { workflowId });
+    return attribution.workflowAsset === "unknown" ? undefined : attribution.workflowAsset;
+}
+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 workflowAsset = inferWorkflowAssetFromIr(ir, workflowState?.workflow);
+    return runCodexHook({ ...rawInput, event: codexHookEventForInput(rawInput, args) }, {
+        ir,
+        projectDir,
+        hookInstallMode: codexInstallMode(argValue(args, "--codex-install-mode")),
+        hookTrusted: true,
+        codexVersion: process.env.CODEX_VERSION,
+        workflowAsset,
+        workflowId: workflowState?.workflow,
+        stepId: workflowState?.current_step,
+        appendEvent: true,
+    });
+}
+async function runCodexHookCli(args) {
+    try {
+        const rawInput = await readStdin(5000);
+        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));
+        if (!ir) {
+            writeOutput(silentOutput());
+            return;
+        }
+        const result = await runCodexHookWithLoadedIr(rawInput, projectDir, args, ir);
+        writeOutput(result.output);
+    }
+    catch (err) {
+        process.stderr.write(`\n  Intent DNA: CodexHook failed open — ${err instanceof Error ? err.message : String(err)}\n`);
+        writeOutput(silentOutput());
+    }
+}
 // ── IR Loading ─────────────────────────────────────────────
 /** Expected IR schema version — must match plugin-adapter.ts */
 const EXPECTED_IR_VERSION = 1;
@@ -777,6 +924,8 @@ function appendArtifactResolverTrace(projectDir, event, wfState, output, session
 export const recordProducedArtifactsForTest = recordProducedArtifacts;
 export const resolveWorkflowArtifactFactsForTest = resolveWorkflowArtifactFacts;
 export const readWorkflowStateForHookTest = readWorkflowStateForHook;
+export const runCodexHookWithLoadedIrForTest = runCodexHookWithLoadedIr;
+export const inferWorkflowAssetFromIrForTest = inferWorkflowAssetFromIr;
 export const resolveWorkflowArtifactFactsForHookTest = resolveWorkflowArtifactFactsForHook;
 export const finalizeAndResolveArtifactsForHookTest = finalizeAndResolveArtifactsForHook;
 function clearBlockingVerifierCheckpoints(ir, workflowState) {
@@ -807,8 +956,6 @@ function clearBlockingVerifierCheckpoints(ir, workflowState) {
             }),
     };
 }
-const DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS = 30_000;
-const MAX_VERIFIER_EVIDENCE_BYTES = 4096;
 function appendOutputText(output, text, hookEventName) {
     if (!text)
         return output;
@@ -855,316 +1002,6 @@ export function appendStopVerifierWarnings(output, verifierResults, currentStep)
         "\nFix the warning above before relying on this step, or rerun the verifier after repair.";
     return appendOutputText(output, warningText, "Stop");
 }
-function trimEvidence(raw) {
-    if (!raw)
-        return undefined;
-    const trimmed = raw.trim();
-    if (!trimmed)
-        return undefined;
-    return trimmed.length > MAX_VERIFIER_EVIDENCE_BYTES
-        ? trimmed.slice(0, MAX_VERIFIER_EVIDENCE_BYTES)
-        : trimmed;
-}
-function hasUnsafeShellControl(command) {
-    let inSingle = false;
-    let inDouble = false;
-    let escaped = false;
-    for (let i = 0; i < command.length; i++) {
-        const ch = command[i];
-        const next = command[i + 1] ?? "";
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (ch === "\\" && !inSingle) {
-            escaped = true;
-            continue;
-        }
-        if (ch === "'" && !inDouble) {
-            inSingle = !inSingle;
-            continue;
-        }
-        if (ch === '"' && !inSingle) {
-            inDouble = !inDouble;
-            continue;
-        }
-        if (!inSingle && !inDouble) {
-            if (ch === ";" || ch === "`" || ch === "\n" || ch === "\r")
-                return true;
-            if ((ch === "&" || ch === "|" || ch === "<" || ch === ">") && next === ch)
-                return true;
-            if (ch === "$" && next === "(")
-                return true;
-            if ((ch === "<" || ch === ">") && next === "(")
-                return true;
-            if (ch === "|" || ch === "&" || ch === "<" || ch === ">")
-                return true;
-        }
-        if (inDouble) {
-            if (ch === "`")
-                return true;
-            if (ch === "$" && next === "(")
-                return true;
-        }
-    }
-    return false;
-}
-function isVerifierCommandAllowed(ir, command) {
-    const normalized = command.trim();
-    const policy = ir.verifier_policy;
-    if (!policy)
-        return false;
-    if (policy.allow_commands?.includes(normalized))
-        return true;
-    if (hasUnsafeShellControl(normalized))
-        return false;
-    return policy.allow_command_prefixes?.some((prefix) => normalized.startsWith(prefix)) ?? false;
-}
-function verifierCommandPolicyMessage(command) {
-    return `Verifier command not allowed by verifier_policy: ${command}`;
-}
-function isBuiltinAssertAllowed(ir, assertName) {
-    const policy = ir.verifier_policy;
-    return policy?.allow_builtin_asserts?.includes(assertName) ?? false;
-}
-function verifierAssertPolicyMessage(assertName) {
-    return `Verifier assert not allowed by verifier_policy: ${assertName}`;
-}
-function summarizeCommandEvidence(stdout, stderr) {
-    const stdoutBytes = Buffer.byteLength(stdout, "utf8");
-    const stderrBytes = Buffer.byteLength(stderr, "utf8");
-    if (stdoutBytes === 0 && stderrBytes === 0)
-        return undefined;
-    return trimEvidence(`stdout_bytes=${stdoutBytes} stderr_bytes=${stderrBytes}`);
-}
-async function execVerifierCommand(projectDir, command, timeoutMs = DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS) {
-    return new Promise((resolvePromise) => {
-        const child = spawn("bash", ["-lc", command], { cwd: projectDir, stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        let settled = false;
-        const settle = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            resolvePromise(result);
-        };
-        const timeoutId = setTimeout(() => {
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 1000).unref();
-            settle({ passed: false, timedOut: true, exitCode: 124, evidence: summarizeCommandEvidence(stdout, stderr) });
-        }, timeoutMs);
-        child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-            if (stdout.length > MAX_VERIFIER_EVIDENCE_BYTES) {
-                stdout = stdout.slice(0, MAX_VERIFIER_EVIDENCE_BYTES);
-            }
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-            if (stderr.length > MAX_VERIFIER_EVIDENCE_BYTES) {
-                stderr = stderr.slice(0, MAX_VERIFIER_EVIDENCE_BYTES);
-            }
-        });
-        child.on("error", (_error) => settle({
-            passed: false,
-            timedOut: false,
-            exitCode: 1,
-            evidence: summarizeCommandEvidence(stdout, stderr),
-        }));
-        child.on("close", (code) => settle({
-            passed: code === 0,
-            timedOut: false,
-            exitCode: code ?? 1,
-            evidence: summarizeCommandEvidence(stdout, stderr),
-        }));
-    });
-}
-async function runCheckpointVerifier(projectDir, ir, checkpoint, commandTimeoutMs = DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS) {
-    const assertCommands = {
-        clean_working_tree: "git status --porcelain",
-        lint_passing: "npm run lint --silent 2>/dev/null",
-        build_passing: "npm run build --silent 2>/dev/null",
-    };
-    if (checkpoint.command) {
-        if (!isVerifierCommandAllowed(ir, checkpoint.command)) {
-            return {
-                passed: false,
-                target: checkpoint.command,
-                evidence: "policy_denied",
-                exit_code: 126,
-                message: verifierCommandPolicyMessage(checkpoint.command),
-            };
-        }
-        const commandResult = await execVerifierCommand(projectDir, checkpoint.command, commandTimeoutMs);
-        return {
-            passed: commandResult.passed,
-            target: checkpoint.command,
-            evidence: commandResult.evidence,
-            exit_code: commandResult.exitCode,
-            message: commandResult.passed
-                ? checkpoint.message
-                : commandResult.timedOut
-                    ? `Verifier command timed out after ${commandTimeoutMs}ms: ${checkpoint.command}`
-                    : `Verifier command failed: ${checkpoint.command}`,
-        };
-    }
-    if (checkpoint.assert === "clean_working_tree") {
-        if (!isBuiltinAssertAllowed(ir, checkpoint.assert)) {
-            return {
-                passed: false,
-                target: checkpoint.assert,
-                evidence: "policy_denied",
-                exit_code: 126,
-                message: verifierAssertPolicyMessage(checkpoint.assert),
-            };
-        }
-        try {
-            const raw = await new Promise((resolvePromise, rejectPromise) => {
-                const child = spawn("git", ["status", "--porcelain"], { cwd: projectDir, stdio: ["ignore", "pipe", "ignore"] });
-                let stdout = "";
-                child.stdout.on("data", (chunk) => { stdout += String(chunk); });
-                child.on("error", rejectPromise);
-                child.on("close", (code) => code === 0 ? resolvePromise(stdout) : rejectPromise(new Error("git status failed")));
-            });
-            const changedEntries = raw.split("\n").filter(Boolean).length;
-            return {
-                passed: raw.trim() === "",
-                target: checkpoint.assert,
-                evidence: `changed_entries=${changedEntries}`,
-                exit_code: 0,
-                message: checkpoint.message,
-            };
-        }
-        catch {
-            return { passed: false, target: checkpoint.assert, exit_code: 1, message: checkpoint.message };
-        }
-    }
-    if (checkpoint.assert === "no_test_regression") {
-        if (!isBuiltinAssertAllowed(ir, checkpoint.assert)) {
-            return {
-                passed: false,
-                target: checkpoint.assert,
-                evidence: "policy_denied",
-                exit_code: 126,
-                message: verifierAssertPolicyMessage(checkpoint.assert),
-            };
-        }
-        try {
-            const baseline = parseInt(await readFile(resolve(projectDir, ".dna/test-baseline"), "utf-8").catch(() => "0"), 10);
-            const current = parseInt(await readFile(resolve(projectDir, ".dna/test-current"), "utf-8").catch(() => "0"), 10);
-            return {
-                passed: current <= baseline,
-                target: checkpoint.assert,
-                evidence: `baseline=${baseline} current=${current}`,
-                exit_code: 0,
-                message: checkpoint.message,
-            };
-        }
-        catch {
-            return { passed: false, target: checkpoint.assert, exit_code: 1, message: checkpoint.message };
-        }
-    }
-    if (assertCommands[checkpoint.assert]) {
-        if (!isBuiltinAssertAllowed(ir, checkpoint.assert)) {
-            return {
-                passed: false,
-                target: checkpoint.assert,
-                evidence: "policy_denied",
-                exit_code: 126,
-                message: verifierAssertPolicyMessage(checkpoint.assert),
-            };
-        }
-        const commandResult = await execVerifierCommand(projectDir, assertCommands[checkpoint.assert], commandTimeoutMs);
-        return {
-            passed: commandResult.passed,
-            target: checkpoint.assert,
-            evidence: commandResult.evidence,
-            exit_code: commandResult.exitCode,
-            message: commandResult.passed
-                ? checkpoint.message
-                : commandResult.timedOut
-                    ? `Verifier command timed out after ${commandTimeoutMs}ms: ${assertCommands[checkpoint.assert]}`
-                    : checkpoint.message,
-        };
-    }
-    return { passed: false, target: checkpoint.assert, exit_code: 1, message: checkpoint.message };
-}
-function isWithinProjectRoot(projectRoot, targetPath) {
-    const relPath = relative(projectRoot, targetPath);
-    return relPath === "" || (!relPath.startsWith("..") && !isAbsolute(relPath));
-}
-async function resolveVerifierTarget(projectDir, targetPath) {
-    const projectRoot = await realpath(projectDir).catch(() => resolve(projectDir));
-    const resolvedPath = resolve(projectDir, targetPath);
-    if (!isWithinProjectRoot(projectRoot, resolvedPath)) {
-        return null;
-    }
-    const canonicalParent = await realpath(dirname(resolvedPath)).catch(() => null);
-    if (canonicalParent && !isWithinProjectRoot(projectRoot, canonicalParent)) {
-        return null;
-    }
-    const canonicalTarget = await realpath(resolvedPath).catch(() => null);
-    if (canonicalTarget && !isWithinProjectRoot(projectRoot, canonicalTarget)) {
-        return null;
-    }
-    return canonicalTarget ?? resolvedPath;
-}
-async function toProjectRelativePath(projectDir, filePath) {
-    const projectRoot = await realpath(projectDir).catch(() => resolve(projectDir));
-    const resolvedPath = resolve(projectDir, filePath);
-    const canonicalPath = await realpath(resolvedPath).catch(() => resolvedPath);
-    const targetPath = isWithinProjectRoot(projectRoot, canonicalPath) ? canonicalPath : resolvedPath;
-    const relPath = relative(projectRoot, targetPath);
-    return relPath === "" ? "." : relPath;
-}
-function getCompletionCheckFields(completion) {
-    if (typeof completion !== "object" || completion === null || Array.isArray(completion))
-        return [];
-    const fields = [];
-    if (completion.file_exists !== undefined)
-        fields.push("file_exists");
-    if (completion.file_not_empty !== undefined)
-        fields.push("file_not_empty");
-    if (completion.file_contains !== undefined)
-        fields.push("file_contains");
-    if (completion.command_success !== undefined)
-        fields.push("command_success");
-    return fields;
-}
-function validateCompletionVerifier(completion) {
-    const fields = getCompletionCheckFields(completion);
-    if (fields.length !== 1) {
-        return {
-            message: "Completion verifier must define exactly one check",
-            evidence: `fields:${fields.join(",") || "none"}`,
-        };
-    }
-    const field = fields[0];
-    if (field === "file_exists" && (typeof completion.file_exists !== "string" || !completion.file_exists)) {
-        return { message: "Completion verifier file_exists must be a non-empty string", evidence: "invalid:file_exists" };
-    }
-    if (field === "file_not_empty" && (typeof completion.file_not_empty !== "string" || !completion.file_not_empty)) {
-        return { message: "Completion verifier file_not_empty must be a non-empty string", evidence: "invalid:file_not_empty" };
-    }
-    if (field === "command_success" && (typeof completion.command_success !== "string" || !completion.command_success)) {
-        return { message: "Completion verifier command_success must be a non-empty string", evidence: "invalid:command_success" };
-    }
-    if (field === "file_contains") {
-        const fileContains = completion.file_contains;
-        if (typeof fileContains !== "object" || fileContains === null) {
-            return { message: "Completion verifier file_contains must define path and pattern", evidence: "invalid:file_contains" };
-        }
-        if (typeof fileContains.path !== "string" || !fileContains.path) {
-            return { message: "Completion verifier file_contains.path must be a non-empty string", evidence: "invalid:file_contains.path" };
-        }
-        if (typeof fileContains.pattern !== "string" || !fileContains.pattern) {
-            return { message: "Completion verifier file_contains.pattern must be a non-empty string", evidence: "invalid:file_contains.pattern" };
-        }
-    }
-    return null;
-}
 function getAuditCheckType(spec) {
     if (spec.completion?.file_exists !== undefined)
         return "file_exists";
@@ -1209,7 +1046,11 @@ async function runVerifierSpec(projectDir, ir, spec, workflowState, sessionId, o
     let artifact;
     let message = spec.checkpoint?.message;
     if (spec.kind === "checkpoint" && spec.checkpoint) {
-        const checkpointResult = await runCheckpointVerifier(projectDir, ir, spec.checkpoint, options?.commandTimeoutMs);
+        const checkpointResult = await runSharedCheckpointVerifier(spec.checkpoint, ir, {
+            projectDir,
+            variables: { ...(workflowState.resolved_variables ?? {}), ...(workflowState.inputs ?? {}) },
+            commandTimeoutMs: options?.commandTimeoutMs,
+        });
         passed = checkpointResult.passed;
         target = checkpointResult.target;
         evidence = checkpointResult.evidence;
@@ -1225,99 +1066,17 @@ async function runVerifierSpec(projectDir, ir, spec, workflowState, sessionId, o
             message = "Completion verifier must define exactly one check";
         }
         else {
-            const invalidCompletion = validateCompletionVerifier(completion);
-            if (invalidCompletion) {
-                passed = false;
-                evidence = invalidCompletion.evidence;
-                message = invalidCompletion.message;
-            }
-            else if (completion.file_exists) {
-                target = completion.file_exists;
-                const resolvedTarget = await resolveVerifierTarget(projectDir, completion.file_exists);
-                artifact = resolvedTarget ?? undefined;
-                evidence = resolvedTarget ? `exists:${resolvedTarget}` : "path_escape";
-                if (!resolvedTarget) {
-                    passed = false;
-                    message = `Verifier target escapes project root: ${completion.file_exists}`;
-                }
-                else {
-                    try {
-                        await stat(resolvedTarget);
-                    }
-                    catch {
-                        passed = false;
-                        message = `Required file missing: ${completion.file_exists}`;
-                    }
-                }
-            }
-            else if (completion.file_not_empty) {
-                target = completion.file_not_empty;
-                const resolvedTarget = await resolveVerifierTarget(projectDir, completion.file_not_empty);
-                artifact = resolvedTarget ?? undefined;
-                evidence = resolvedTarget ? `not_empty:${resolvedTarget}` : "path_escape";
-                if (!resolvedTarget) {
-                    passed = false;
-                    message = `Verifier target escapes project root: ${completion.file_not_empty}`;
-                }
-                else {
-                    try {
-                        const raw = await readFile(resolvedTarget, "utf-8");
-                        evidence = `bytes=${Buffer.byteLength(raw, "utf8")}`;
-                        if (raw.trim().length === 0) {
-                            passed = false;
-                            message = `Required file is empty: ${completion.file_not_empty}`;
-                        }
-                    }
-                    catch {
-                        passed = false;
-                        message = `Required file missing: ${completion.file_not_empty}`;
-                    }
-                }
-            }
-            else if (completion.file_contains) {
-                target = completion.file_contains.path;
-                const resolvedTarget = await resolveVerifierTarget(projectDir, completion.file_contains.path);
-                artifact = resolvedTarget ?? undefined;
-                evidence = `pattern:${completion.file_contains.pattern}`;
-                if (!resolvedTarget) {
-                    passed = false;
-                    message = `Verifier target escapes project root: ${completion.file_contains.path}`;
-                }
-                else {
-                    try {
-                        const raw = await readFile(resolvedTarget, "utf-8");
-                        const re = new RegExp(completion.file_contains.pattern);
-                        if (!re.test(raw)) {
-                            passed = false;
-                            message = `Required pattern missing in ${completion.file_contains.path}`;
-                        }
-                    }
-                    catch {
-                        passed = false;
-                        message = `Required file missing: ${completion.file_contains.path}`;
-                    }
-                }
-            }
-            else if (completion.command_success) {
-                target = completion.command_success;
-                if (!isVerifierCommandAllowed(ir, completion.command_success)) {
-                    passed = false;
-                    evidence = "policy_denied";
-                    exit_code = 126;
-                    message = verifierCommandPolicyMessage(completion.command_success);
-                }
-                else {
-                    const commandResult = await execVerifierCommand(projectDir, completion.command_success, options?.commandTimeoutMs);
-                    passed = commandResult.passed;
-                    evidence = commandResult.evidence;
-                    exit_code = commandResult.exitCode;
-                    if (!passed) {
-                        message = commandResult.timedOut
-                            ? `Verifier command timed out after ${options?.commandTimeoutMs ?? DEFAULT_VERIFIER_COMMAND_TIMEOUT_MS}ms: ${completion.command_success}`
-                            : `Verifier command failed: ${completion.command_success}`;
-                    }
-                }
-            }
+            const completionResult = await runCompletionVerifier(completion, ir, {
+                projectDir,
+                variables: { ...(workflowState.resolved_variables ?? {}), ...(workflowState.inputs ?? {}) },
+                commandTimeoutMs: options?.commandTimeoutMs,
+            });
+            passed = completionResult.passed;
+            target = completionResult.target;
+            evidence = completionResult.evidence;
+            exit_code = completionResult.exit_code;
+            artifact = completionResult.artifact;
+            message = completionResult.message;
         }
     }
     const entry = {