open-multi-agent-kit 0.79.3 → 0.80.2

package/dist/commands/chat/native-root-loop.js

@@ -1,10 +1,15 @@
 import { style } from "../../util/theme.js";
+import { getRunArtifactPath } from "../../util/run-store.js";
 import { runShell } from "../../util/shell.js";
+import { mkdir, writeFile, appendFile, readFile } from "node:fs/promises";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname } from "node:path";
 import { createDag } from "../../orchestration/dag.js";
 import { applyCapabilityInjectionToRouting, buildCapabilityInjection, } from "../../runtime/capability-injection.js";
 import { capabilityScopesFromRouting } from "../../orchestration/capability-routing.js";
 import { decideToolAuthority, } from "../../safety/tool-authority-gate.js";
-import { resolveToolAuthorityEnforcement } from "../../runtime/tool-dispatch-contracts.js";
+import { resolveToolAuthorityMode } from "../../runtime/tool-dispatch-contracts.js";
 import { compileBloatToNlp, } from "../../runtime/debloat-nlp.js";
 import { buildPromptEnvelope, renderPromptEnvelope, } from "../../runtime/prompt-envelope.js";
 import { buildTaskRunContext } from "../../runtime/worker-manifest.js";
@@ -12,6 +17,7 @@ import { buildInputEnvelope, normalizeMcpScope, } from "../../input/input-envelo
 import { persistInputEnvelope } from "../../input/input-artifacts.js";
 import { buildDagCompileResult } from "../../orchestration/dag-compiler.js";
 import { persistDagCompileArtifacts } from "../../orchestration/dag-artifacts.js";
+import { evidenceObservationsFromResult, evidenceRequirementsFromOutputs } from "../../runtime/contracts/evidence.js";
 import { TerminalOwner } from "../../util/terminal-owner.js";
 import { resumeInteractiveInput } from "../../util/terminal-input.js";
 import { executeHarnessRun } from "../../harness/execute-harness-run.js";
@@ -25,6 +31,8 @@ import { buildNativeChatSlashCommands } from "./slash/commands/index.js";
 import { parseSlashInput } from "./slash/parser.js";
 import { createSlashCommandRegistry } from "./slash/registry.js";
 import { emitSlashResult, okSlashResult, printSlashResult, } from "./slash/result.js";
+import { LocalGraphMemoryStore } from "../../memory/local-graph-memory-store.js";
+import { runtimeIsAdvisory } from "../../runtime/authority-matrix.js";
 async function runSlashHandler(handler, parsed, ctx, options = {}) {
     const result = await handler.handler(ctx, parsed.args);
     const normalized = result ?? okSlashResult();
@@ -317,22 +325,15 @@ function nativeTurnRiskToToolOp(risk) {
     }
 }
 /**
- * Shadow-only tool-authority observability at the live turn dispatch
- * checkpoint. The kimi runner executes tools inside a spawned CLI, so per-tool
- * enforcement lives in dispatchToolCallsByContract; here we only compute and
- * record the turn-level verdict for the trace. Default output is byte-identical
- * (emitted only under OMK_DEBUG / OMK_TOOL_AUTHORITY_TRACE); this path never
- * blocks dispatch.
+ * Turn-level tool-authority checkpoint. Shadow mode records only when tracing is
+ * enabled, warn mode emits a diagnostic, and enforce mode fail-closes block/ask
+ * verdicts before dispatching the native turn.
  */
 function recordNativeTurnToolAuthority(input) {
-    const traceEnabled = input.env.OMK_DEBUG === "1" ||
-        /^(1|true|yes|on)$/i.test(input.env.OMK_TOOL_AUTHORITY_TRACE ?? "");
-    if (!traceEnabled)
-        return;
     const routing = input.node.routing;
     const scopes = capabilityScopesFromRouting(routing);
     const op = nativeTurnRiskToToolOp(routing?.risk);
-    const enforce = resolveToolAuthorityEnforcement(input.env);
+    const mode = resolveToolAuthorityMode(input.env);
     const decision = decideToolAuthority({
         op,
         writeAuthority: scopes.writeAuthority,
@@ -341,15 +342,23 @@ function recordNativeTurnToolAuthority(input) {
         sandboxMode: routing?.sandboxMode === "read-only" ? "read-only" : "workspace-write",
         tty: Boolean(process.stdout.isTTY),
     });
-    const line = `  tool-authority(${enforce ? "enforce" : "shadow"}): node=${input.node.id} ` +
-        `op=${op} decision=${decision} write=${scopes.writeAuthority} ` +
-        `shell=${scopes.shellAuthority} sandbox=${routing?.sandboxMode ?? "auto"}\n`;
-    if (input.renderer) {
-        input.renderer.emit({ type: "control:output", text: style.phosphorDim(line) });
-    }
-    else {
-        process.stderr.write(style.phosphorDim(line));
+    const enforced = mode === "enforce" && decision !== "allow";
+    const reason = `tool-authority ${decision} for ${op} op ` +
+        `(write=${scopes.writeAuthority}, shell=${scopes.shellAuthority}, ` +
+        `sandbox=${routing?.sandboxMode ?? "auto"}, mode=${mode})`;
+    const traceEnabled = mode !== "shadow" ||
+        input.env.OMK_DEBUG === "1" ||
+        /^(1|true|yes|on)$/i.test(input.env.OMK_TOOL_AUTHORITY_TRACE ?? "");
+    if (traceEnabled) {
+        const line = `  ${reason}${enforced ? " [enforced]" : ""}\n`;
+        if (input.renderer) {
+            input.renderer.emit({ type: "control:output", text: style.phosphorDim(line) });
+        }
+        else {
+            process.stderr.write(style.phosphorDim(line));
+        }
     }
+    return { mode, op, decision, enforced, reason };
 }
 function emitNativeTurnRoute(input) {
     if (!input.heartbeatEnabled)
@@ -449,30 +458,96 @@ async function persistNativeDagCompileArtifacts(input) {
             process.stderr.write(style.metricsRed(text) + "\n");
     }
 }
-const API_ADVISORY_PROVIDERS = new Set([
-    "deepseek",
-    "kimi",
-    "local-llm",
-    "mimo",
-    "openrouter",
-    "qwen",
-]);
-function hasExplicitReadOnlyIntent(text) {
+function hasExplicitReadOnlyConstraint(text) {
+    return (/\b(without changing|without editing|do not change|don't change|do not edit|don't edit|no edits?|no file changes?|read[- ]only)\b/.test(text) ||
+        /읽기\s*전용|수정하지\s*말|변경하지\s*말|파일\s*(수정|변경)\s*(없이|하지\s*말)|검토만|분석만/.test(text));
+}
+function hasReadOnlyIntent(text) {
     return (/\b(read|inspect|look|show|list|summarize|explain|describe|review|audit|status|diagnose)\b/.test(text) ||
-        /\b(without changing|without editing|do not change|don't change|do not edit|don't edit|no edits?|no file changes?)\b/.test(text) ||
-        /읽기\s*전용|수정하지\s*말|변경하지\s*말|파일\s*(수정|변경)\s*(없이|하지\s*말)|요약|설명|상태|검토만|분석만|읽어|살펴/.test(text));
+        /요약|설명|상태|검토|분석|읽어|살펴/.test(text));
+}
+function detectExcludedOps(text) {
+    const excluded = new Set();
+    const scopes = [];
+    const add = (op, scope) => {
+        excluded.add(op);
+        scopes.push(scope);
+    };
+    const mergeTerms = "push|publish|release|merge|tag|deploy|version|npm publish|릴리즈|머지|배포|태그|푸시|버전|퍼블리시";
+    const shellTerms = "run|test|build|exec|execute|shell|terminal|command|npm|pnpm|yarn|bun|pytest|cargo|tsc|lint|verify|check|테스트|빌드|실행|검증|쉘|터미널|체크|명령";
+    const writeTerms = "fix|edit|write|implement|modify|patch|refactor|add|create|delete|update|change|수정|구현|패치|리팩터|추가|삭제|변경";
+    const englishNegationPrefix = "no|not|without|excluding|exclude|except|skip|skipping|omit|avoid|but not|do not|don't";
+    const englishNegationSuffix = "excluded|excepted|skipped|omitted|disabled|only on explicit request|only when requested";
+    if (new RegExp(`\\b(?:${englishNegationPrefix})\\b.{0,40}\\b(?:${mergeTerms})\\b`, "i").test(text) ||
+        new RegExp(`\\b(?:${mergeTerms})\\b.{0,40}\\b(?:${englishNegationSuffix})\\b`, "i").test(text) ||
+        /(?:릴리즈|머지|배포|태그|푸시|버전|퍼블리시).{0,16}(?:빼고|제외|없이|말고|하지\s*말|금지|명령시(?:에)?만|요청시(?:에)?만)/.test(text) ||
+        /(?:빼고|제외|없이|말고).{0,16}(?:릴리즈|머지|배포|태그|푸시|버전|퍼블리시)/.test(text)) {
+        add("merge", "excluded-merge-scope");
+    }
+    if (new RegExp(`\\b(?:${englishNegationPrefix})\\b.{0,40}\\b(?:${shellTerms})\\b`, "i").test(text) ||
+        new RegExp(`\\b(?:${shellTerms})\\b.{0,40}\\b(?:${englishNegationSuffix})\\b`, "i").test(text) ||
+        /(?:npm|테스트|빌드|실행|검증|체크|명령|쉘|터미널).{0,16}(?:빼고|제외|없이|말고|하지\s*말|금지|명령시(?:에)?만|요청시(?:에)?만)/.test(text) ||
+        /(?:빼고|제외|없이|말고).{0,16}(?:npm|테스트|빌드|실행|검증|체크|명령|쉘|터미널)/.test(text)) {
+        add("shell", "excluded-shell-scope");
+    }
+    if (new RegExp(`\\b(?:${englishNegationPrefix})\\b.{0,40}\\b(?:${writeTerms})\\b`, "i").test(text) ||
+        /(?:수정|구현|패치|리팩터|추가|삭제|변경).{0,16}(?:빼고|제외|없이|말고|하지\s*말|금지)/.test(text)) {
+        add("write", "excluded-write-scope");
+    }
+    return { ops: [...excluded], scopes };
+}
+function nativeRiskTrace(input) {
+    return {
+        risk: input.risk,
+        confidence: input.confidence,
+        matchedSignal: input.matchedSignal,
+        readOnlyOverride: input.readOnlyOverride ?? false,
+        positiveSignals: [...(input.positiveSignals ?? [])],
+        negativeScopes: [...(input.negativeScopes ?? [])],
+        requestedOps: [...(input.requestedOps ?? [])],
+        excludedOps: [...(input.excludedOps ?? [])],
+    };
 }
 export function inferNativeTurnRisk(prompt) {
     const text = prompt.toLowerCase();
-    if (/\b(push|publish|release|merge|tag|deploy)\b|푸시|퍼블리시|릴리즈|머지|배포/.test(text))
-        return "merge";
-    if (/\b(run|test|build|exec|execute|shell|terminal|command|npm|pnpm|yarn|bun|pytest|cargo|go test|tsc|lint|verify|check)\b|테스트|빌드|실행|검증|쉘|터미널/.test(text))
-        return "shell";
-    if (/\b(fix|edit|write|implement|modify|patch|refactor|add|create|delete|update|change)\b|수정|구현|패치|리팩터|추가|삭제|변경/.test(text))
-        return "write";
-    if (hasExplicitReadOnlyIntent(text))
-        return "read";
-    return "write";
+    const excluded = detectExcludedOps(text);
+    if (hasExplicitReadOnlyConstraint(text)) {
+        return nativeRiskTrace({ risk: "read", confidence: 0.95, matchedSignal: "explicit-read-only-constraint", readOnlyOverride: true, negativeScopes: excluded.scopes, excludedOps: excluded.ops });
+    }
+    const candidates = [
+        { risk: "merge", confidence: 0.9, signal: "merge/release-keyword", pattern: /\b(push|publish|release|merge|tag|deploy)\b|푸시|퍼블리시|릴리즈|머지|배포/ },
+        { risk: "shell", confidence: 0.85, signal: "shell/execution-keyword", pattern: /\b(run|test|build|exec|execute|shell|terminal|command|npm|pnpm|yarn|bun|pytest|cargo|go test|tsc|lint|verify|check)\b|테스트|빌드|실행|검증|쉘|터미널/ },
+        { risk: "write", confidence: 0.85, signal: "write/modify-keyword", pattern: /\b(fix|edit|write|implement|modify|patch|refactor|add|create|delete|update|change)\b|수정|구현|패치|리팩터|추가|삭제|변경/ },
+    ];
+    const positive = candidates.filter((candidate) => candidate.pattern.test(text));
+    const requestedOps = positive.map((candidate) => candidate.risk);
+    const selected = positive.find((candidate) => !excluded.ops.includes(candidate.risk));
+    if (selected) {
+        return nativeRiskTrace({
+            risk: selected.risk,
+            confidence: selected.confidence,
+            matchedSignal: selected.signal,
+            positiveSignals: positive.map((candidate) => candidate.signal),
+            negativeScopes: excluded.scopes,
+            requestedOps,
+            excludedOps: excluded.ops,
+        });
+    }
+    if (positive.length > 0) {
+        const risk = hasReadOnlyIntent(text) ? "read" : "ask";
+        return nativeRiskTrace({
+            risk,
+            confidence: risk === "read" ? 0.75 : 0.55,
+            matchedSignal: `all-positive-risk-signals-excluded:${positive.map((candidate) => candidate.signal).join(",")}`,
+            positiveSignals: positive.map((candidate) => candidate.signal),
+            negativeScopes: excluded.scopes,
+            requestedOps,
+            excludedOps: excluded.ops,
+        });
+    }
+    if (hasReadOnlyIntent(text))
+        return nativeRiskTrace({ risk: "read", confidence: 0.75, matchedSignal: "read-only-intent", negativeScopes: excluded.scopes, excludedOps: excluded.ops });
+    return nativeRiskTrace({ risk: "ask", confidence: 0.5, matchedSignal: "no-clear-signal", negativeScopes: excluded.scopes, excludedOps: excluded.ops });
 }
 function nativeTurnRoutingPolicy(provider, risk) {
     if (isApiAdvisoryProvider(provider) && risk !== "read") {
@@ -483,7 +558,7 @@ function nativeTurnRoutingPolicy(provider, risk) {
             providerReasonSuffix: `; ${provider} API is advisory/read-only for ${risk} intent; OMK owns write, shell, MCP, and merge authority`,
         };
     }
-    if (risk === "read") {
+    if (risk === "read" || risk === "ask") {
         return { capabilities: ["read"], readOnly: true, sandboxMode: "read-only" };
     }
     if (risk === "write") {
@@ -507,18 +582,79 @@ function nativeTurnRoutingPolicy(provider, risk) {
     };
 }
 function isApiAdvisoryProvider(provider) {
-    return API_ADVISORY_PROVIDERS.has(provider);
+    return runtimeIsAdvisory({
+        id: `${provider}-api`,
+        providerId: provider,
+        runtimeMode: "api",
+        kind: "api",
+    });
+}
+function hashPrompt(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function redactedPromptLabel(prompt) {
+    const compact = prompt.replace(/\s+/g, " ").trim().replace(/(sk-[A-Za-z0-9_-]+|ghp_[A-Za-z0-9_]+|[A-Za-z0-9+/]{32,}=*)/g, "[redacted]");
+    const summary = compact.length > 80 ? `${compact.slice(0, 77)}...` : compact;
+    return summary ? `native turn: ${summary}` : "native turn";
+}
+function writePrivatePromptArtifact(input) {
+    try {
+        const rel = `private/prompts/${sanitizeRunIdForPath(input.nodeId)}.json`;
+        const artifact = getRunArtifactPath(input.runId, rel);
+        mkdirSync(dirname(artifact), { recursive: true });
+        writeFileSync(artifact, JSON.stringify({
+            schemaVersion: "omk.prompt-envelope.v1",
+            nodeId: input.nodeId,
+            runId: input.runId,
+            promptHash: input.promptHash,
+            userPrompt: input.userPrompt,
+            compiledPrompt: input.compiledPrompt,
+            redaction: "private-run-artifact",
+            timestamp: new Date().toISOString(),
+        }, null, 2), "utf-8");
+        return rel;
+    }
+    catch {
+        return undefined;
+    }
 }
 function debloatRiskFromNativeTurnRisk(risk) {
-    if (risk === "read")
+    if (risk === "read" || risk === "ask")
         return "read";
     if (risk === "write")
         return "write";
     return "dangerous";
 }
+function isStrictGuardrailMode() {
+    const raw = process.env.OMK_STRICT_GUARDRAIL ?? "";
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "on";
+}
+function nativeTurnRequiresEvidence(risk) {
+    if (isStrictGuardrailMode())
+        return risk === "write" || risk === "shell" || risk === "merge";
+    return false;
+}
+function nativeEvidenceOutputForRisk(risk) {
+    if (!nativeTurnRequiresEvidence(risk))
+        return undefined;
+    if (risk === "shell") {
+        return [{ name: "command evidence", gate: "command-pass", required: true }];
+    }
+    if (risk === "merge") {
+        return [{ name: "release evidence", ref: "## Evidence", gate: "summary", required: true }];
+    }
+    return [{ name: "change evidence", ref: "## Evidence", gate: "summary", required: true }];
+}
 export function buildNativeRootLoopTurnNode(input) {
     const id = input.nodeId ?? `turn-${Date.now()}`;
-    const turnRisk = inferNativeTurnRisk(input.prompt);
+    const riskTrace = inferNativeTurnRisk(input.prompt);
+    let turnRisk = riskTrace.risk;
+    // Low-confidence prompts fall back to ask/read-only to preserve safety.
+    if (riskTrace.confidence < 0.6 && turnRisk !== "read") {
+        turnRisk = "ask";
+    }
+    const evidenceRequired = nativeTurnRequiresEvidence(turnRisk);
     const routingPolicy = nativeTurnRoutingPolicy(input.bootstrap.provider, turnRisk);
     const capabilityInjection = buildCapabilityInjection({
         mcpAllowlist: input.mcpAllowlist,
@@ -545,7 +681,7 @@ export function buildNativeRootLoopTurnNode(input) {
         sandbox: routingPolicy.sandboxMode,
         executionSelection: input.executionPrompt,
         role: "coordinator",
-        evidenceRequired: false,
+        evidenceRequired,
         capabilityEnvelope: {
             mcpEnabled: capabilityInjection.mcpServers,
             skillsEnabled: capabilityInjection.skills,
@@ -566,14 +702,19 @@ export function buildNativeRootLoopTurnNode(input) {
             && compiled.runtimeSidecar.requiredMcp.length > 0,
         requiresToolCalling: capabilityInjection.requiresToolCalling,
     });
+    const promptHash = hashPrompt(compiled.modelPrompt);
+    const promptPayloadRef = input.runId
+        ? writePrivatePromptArtifact({ runId: input.runId, nodeId: id, promptHash, userPrompt: input.prompt, compiledPrompt: compiled.modelPrompt })
+        : undefined;
     return {
         id,
-        name: compiled.modelPrompt,
+        name: redactedPromptLabel(input.prompt),
         role: "coordinator",
         dependsOn: [],
         status: "running",
         retries: 0,
         maxRetries: 1,
+        outputs: nativeEvidenceOutputForRisk(turnRisk),
         routing: applyCapabilityInjectionToRouting({
             provider: input.bootstrap.provider,
             providerModel: input.bootstrap.selectedModel,
@@ -582,7 +723,11 @@ export function buildNativeRootLoopTurnNode(input) {
             contextBudget: "normal",
             readOnly: routingPolicy.readOnly,
             risk: turnRisk,
-            promptMode: "dnc-nlp",
+            riskTrace,
+            evidenceRequired,
+            promptMode: promptPayloadRef ? "structured-private" : "dnc-nlp",
+            promptHash,
+            ...(promptPayloadRef && { promptPayloadRef, promptPayloadPrivate: true }),
             runtimeSidecar: {
                 ...compiled.runtimeSidecar,
                 requiredMcp: [...compiled.runtimeSidecar.requiredMcp],
@@ -597,6 +742,137 @@ export function buildNativeRootLoopTurnNode(input) {
         }, selectedCapabilityInjection),
     };
 }
+async function writeTurnRoutingArtifact(runId, node, runContext) {
+    const artifact = getRunArtifactPath(runId, `turns/${sanitizeRunIdForPath(node.id)}-routing.json`);
+    const payload = {
+        schemaVersion: "omk.native-turn.routing.v1",
+        nodeId: node.id,
+        runId,
+        workerRunId: runContext?.runId,
+        workerOwner: runContext?.worker?.owner,
+        routing: node.routing,
+        outputs: node.outputs,
+        timestamp: new Date().toISOString(),
+    };
+    try {
+        await mkdir(dirname(artifact), { recursive: true });
+        await writeFile(artifact, JSON.stringify(payload, null, 2), "utf-8");
+        return undefined;
+    }
+    catch (err) {
+        // Non-fatal: artifact write failures must not block turn execution, but must be observable.
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+async function appendTurnResultArtifact(runId, node, result) {
+    const artifact = getRunArtifactPath(runId, `turns/${sanitizeRunIdForPath(node.id)}-result.jsonl`);
+    const payload = {
+        schemaVersion: "omk.native-turn.result.v1",
+        nodeId: node.id,
+        runId,
+        exitCode: result.exitCode,
+        success: result.success,
+        evidenceRequired: result.metadata?.evidenceRequired,
+        timestamp: new Date().toISOString(),
+    };
+    try {
+        await mkdir(dirname(artifact), { recursive: true });
+        await appendFile(artifact, `${JSON.stringify(payload)}\n`, "utf-8");
+        return { artifact };
+    }
+    catch (err) {
+        // Non-fatal: artifact write failures must not block turn execution, but must be observable.
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function sanitizeRunIdForPath(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 64);
+}
+async function sha256File(path) {
+    try {
+        return createHash("sha256").update(await readFile(path)).digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseReplayIndex(raw, runId) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== "omk.replay-index.v1" || parsed.runId !== runId || !Array.isArray(parsed.artifacts)) {
+            throw new Error("invalid replay index");
+        }
+        return {
+            schemaVersion: "omk.replay-index.v1",
+            runId,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
+            artifacts: parsed.artifacts.filter((artifact) => Boolean(artifact && typeof artifact.path === "string" && typeof artifact.kind === "string")),
+        };
+    }
+    catch {
+        return { schemaVersion: "omk.replay-index.v1", runId, updatedAt: new Date().toISOString(), artifacts: [] };
+    }
+}
+async function upsertReplayIndexArtifact(input) {
+    const now = new Date().toISOString();
+    let existing = { schemaVersion: "omk.replay-index.v1", runId: input.runId, updatedAt: now, artifacts: [] };
+    try {
+        existing = parseReplayIndex(await readFile(input.replayIndexPath, "utf-8"), input.runId);
+    }
+    catch {
+        // Missing replay index is expected for the first turn.
+    }
+    const artifacts = existing.artifacts.filter((artifact) => artifact.path !== input.artifactPath);
+    artifacts.push({ path: input.artifactPath, sha256: input.artifactHash, kind: input.artifactKind, updatedAt: now });
+    await writeFile(input.replayIndexPath, JSON.stringify({
+        schemaVersion: "omk.replay-index.v1",
+        runId: input.runId,
+        updatedAt: now,
+        artifacts,
+    }, null, 2), "utf-8");
+}
+async function recordTurnAuditGraph(input) {
+    try {
+        const artifactHash = input.resultArtifact ? await sha256File(input.resultArtifact) : undefined;
+        const replayIndex = getRunArtifactPath(input.runId, "replay-index.json", input.root);
+        await mkdir(dirname(replayIndex), { recursive: true });
+        if (input.resultArtifact) {
+            await upsertReplayIndexArtifact({
+                replayIndexPath: replayIndex,
+                runId: input.runId,
+                artifactPath: input.resultArtifact,
+                artifactHash,
+                artifactKind: "turn-result",
+            });
+        }
+        const store = await LocalGraphMemoryStore.create({ projectRoot: input.root, sessionId: input.runId, source: "native-root-loop-audit" });
+        await store?.materializeTurnAudit({
+            runId: input.runId,
+            nodeId: input.node.id,
+            provider: String(input.node.routing?.provider ?? "auto"),
+            selectedRuntime: typeof input.result.metadata?.selectedRuntime === "string"
+                ? input.result.metadata.selectedRuntime
+                : typeof input.result.metadata?.runtime === "string"
+                    ? input.result.metadata.runtime
+                    : undefined,
+            fallbackChain: Array.isArray(input.result.metadata?.fallbackChain)
+                ? input.result.metadata.fallbackChain.filter((entry) => typeof entry === "string")
+                : undefined,
+            evidenceKind: input.result.success ? "turn-result-pass" : "turn-result-fail",
+            evidenceArtifactPath: input.resultArtifact,
+            evidenceHash: artifactHash,
+            evidenceRequirements: evidenceRequirementsFromOutputs(input.node.outputs),
+            evidenceObservations: evidenceObservationsFromResult({
+                metadata: input.result.metadata,
+                stdout: input.result.stdout,
+                artifactPaths: input.resultArtifact ? [input.resultArtifact] : [],
+            }),
+        });
+    }
+    catch {
+        // Best-effort audit graph materialization must not block turn completion.
+    }
+}
 function runtimeSidecarIntent(node) {
     const sidecar = node.routing?.runtimeSidecar;
     if (!sidecar || typeof sidecar !== "object")
@@ -617,12 +893,34 @@ function describeNativeTurnActivity(node) {
         : "local ctx";
     return `${intentPart} · ${guardPart} · ${scopePart} · ${provider}`;
 }
-async function executeNativeRootTurn(input) {
+export async function executeNativeRootTurn(input) {
     const startedAt = Date.now();
     const routing = input.node.routing;
     const activity = describeNativeTurnActivity(input.node);
     emitNativeTurnRoute(input);
-    recordNativeTurnToolAuthority({ node: input.node, env: input.env, renderer: input.renderer });
+    const authorityRecord = recordNativeTurnToolAuthority({ node: input.node, env: input.env, renderer: input.renderer });
+    if (authorityRecord.enforced) {
+        const message = `${authorityRecord.reason}; native turn dispatch blocked`;
+        if (input.renderer) {
+            input.renderer.emit({ type: "turn:error", message });
+        }
+        else {
+            process.stderr.write(style.metricsRed(message) + "\n");
+        }
+        return {
+            success: false,
+            exitCode: 78,
+            stdout: "",
+            stderr: message,
+            metadata: {
+                code: "TOOL_AUTHORITY_BLOCKED",
+                nodeId: input.node.id,
+                op: authorityRecord.op,
+                decision: authorityRecord.decision,
+                authorityMode: authorityRecord.mode,
+            },
+        };
+    }
     let heartbeatPrinted = false;
     let heartbeatLineClosed = false;
     const heartbeat = input.heartbeatEnabled
@@ -644,8 +942,29 @@ async function executeNativeRootTurn(input) {
         }, 3000)
         : undefined;
     heartbeat?.unref?.();
+    const diagnostics = {};
     try {
+        const turnRunId = input.env.OMK_RUN_ID ?? input.runContext?.goal.runId ?? input.node.id;
+        const routingWrite = await writeTurnRoutingArtifact(turnRunId, input.node, input.runContext);
+        if (routingWrite?.error)
+            diagnostics.routingWrite = routingWrite.error;
         const result = await input.taskRunner.run(input.node, input.env, input.signal, input.runContext);
+        const resultWrite = await appendTurnResultArtifact(turnRunId, input.node, result);
+        if (resultWrite?.error)
+            diagnostics.resultWrite = resultWrite.error;
+        await recordTurnAuditGraph({
+            root: input.env.OMK_PROJECT_ROOT ?? process.cwd(),
+            runId: turnRunId,
+            node: input.node,
+            result,
+            resultArtifact: resultWrite?.artifact,
+        });
+        if (Object.keys(diagnostics).length > 0) {
+            result.metadata = {
+                ...(result.metadata ?? {}),
+                artifactWriteDiagnostics: diagnostics,
+            };
+        }
         if (input.heartbeatEnabled) {
             const sec = ((Date.now() - startedAt) / 1000).toFixed(1);
             if (input.renderer) {
@@ -690,6 +1009,7 @@ async function buildNativeRootLoopTurnDag(input) {
         skillNames: input.skillNames,
         hookNames: input.hookNames,
         executionPrompt: input.executionPrompt,
+        runId: input.runId,
     });
     return createDag({ nodes: [node] });
 }
@@ -724,6 +1044,7 @@ async function executeNativeRootHarnessTurn(input) {
         hookNames: input.hookNames,
         executionPrompt: input.executionPrompt,
         workers: input.workers,
+        runId: input.runId,
     });
     const completed = [];
     const workerCount = Math.max(1, input.workers ?? 1);

package/dist/commands/dag.js

@@ -5,6 +5,7 @@ import { getProjectRoot, pathExists, readTextFile, getOmkPath, getRunPath, getRu
 import { createDag } from "../orchestration/dag.js";
 import { createStatePersister } from "../orchestration/state-persister.js";
 import { checkEvidenceGates } from "../orchestration/evidence-gate.js";
+import { checkEvidenceGate } from "../runtime/contracts/evidence.js";
 import { createExecutor } from "../orchestration/executor.js";
 import { createExecutableDagFromState, routeRunState } from "../orchestration/run-state.js";
 import { createOmkSessionEnv } from "../util/session.js";
@@ -126,6 +127,16 @@ export async function dagReplayCommand(runId, target, subtarget, options) {
                     case "test-pass":
                         gates.push({ type: "command-pass", command: output.ref ?? "npm test" });
                         break;
+                    case "command-pass":
+                        gates.push({ type: "command-pass", command: output.ref ?? "" });
+                        break;
+                    case "artifact":
+                        if (output.ref)
+                            gates.push({ type: "file-exists", path: output.ref });
+                        break;
+                    case "diff":
+                        gates.push({ type: "diff-nonempty" });
+                        break;
                     case "review-pass":
                     case "summary":
                         gates.push({ type: "summary-present", summaryMarker: output.ref ?? "## Summary" });
@@ -134,6 +145,11 @@ export async function dagReplayCommand(runId, target, subtarget, options) {
                         break;
                 }
             }
+            if (node.routing?.evidenceRequired === true && gates.length === 0) {
+                console.log(style.pink(`  ✗ ${node.id}: evidence-required — no replayable evidence gates declared`));
+                failedCount++;
+                continue;
+            }
             if (gates.length === 0)
                 continue;
             const result = await checkEvidenceGates(gates, {
@@ -141,6 +157,35 @@ export async function dagReplayCommand(runId, target, subtarget, options) {
                 stdout: "",
                 nodeId: node.id,
             });
+            const evidenceGates = [];
+            const artifactPaths = [];
+            const metadata = {};
+            for (const ev of result.evidence) {
+                if (!ev.passed)
+                    continue;
+                if (ev.gate === "command-pass")
+                    evidenceGates.push("command-pass");
+                else if (ev.gate === "summary-present")
+                    evidenceGates.push("summary");
+                else if (ev.gate === "file-exists") {
+                    evidenceGates.push("artifact");
+                    if (ev.ref)
+                        artifactPaths.push(ev.ref);
+                }
+                else if (ev.gate === "diff-nonempty") {
+                    evidenceGates.push("diff");
+                    metadata.diff = true;
+                }
+            }
+            if (evidenceGates.length > 0)
+                metadata.evidenceGates = evidenceGates;
+            const v2 = checkEvidenceGate(true, node.outputs, metadata, "", artifactPaths);
+            if (!v2.satisfied) {
+                for (const gate of v2.missing) {
+                    console.log(style.pink(`  ✗ ${node.id}: ${gate} — ${v2.reason}`));
+                    failedCount++;
+                }
+            }
             for (const ev of result.evidence) {
                 const icon = ev.passed ? "✓" : "✗";
                 const color = ev.passed ? style.mint : style.pink;