open-multi-agent-kit 0.79.3 → 0.80.2

package/dist/runtime/runtime-router.js

@@ -7,9 +7,19 @@
  * 3. Historical evidence pass rates from graph-state memory
  * 4. Fallback chain with runtime.supports() check
  */
+import { createHash } from "crypto";
 import { readFile } from "fs/promises";
 import { join } from "path";
+import { maskSensitiveText } from "../util/secret-mask.js";
 import { createDecisionTraceStore } from "../evidence/decision-trace.js";
+import { runtimeIsAdvisory, runtimeSatisfiesAuthority } from "./authority-matrix.js";
+function isStrictGuardrailMode() {
+    const raw = process.env.OMK_STRICT_GUARDRAIL ?? "";
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "on";
+}
+import { sanitizeRuntimeStderrResult } from "./private-stderr.js";
+import { classifyRuntimeFailure } from "./runtime-failure-classifier.js";
 class UnsupportedRuntimeError extends Error {
     code = "RUNTIME_UNSUPPORTED_TASK";
     nodeId;
@@ -43,6 +53,8 @@ export function createRuntimeRouter(options = {}) {
     let runtimes = options.runtimes ?? [];
     const memoryPath = options.memoryPath;
     let evidenceCache;
+    const healthCache = new Map();
+    const circuitBreakers = new Map();
     function classifyIntent(capsule) {
         const text = `${capsule.nodeId} ${capsule.goal} ${capsule.task} ${capsule.system}`.toLowerCase();
         const role = capsule.node?.role?.toLowerCase() ?? "";
@@ -72,6 +84,8 @@ export function createRuntimeRouter(options = {}) {
             const raw = await readFile(filePath, "utf-8");
             const data = JSON.parse(raw);
             const nodes = (data.nodes ?? []);
+            const edges = (data.edges ?? []);
+            const nodeById = new Map(nodes.map((node) => [String(node.id ?? ""), node]));
             const entries = [];
             for (const n of nodes) {
                 if (n.type !== "Evidence")
@@ -80,7 +94,7 @@ export function createRuntimeRouter(options = {}) {
                 const kind = String(props.kind ?? "");
                 if (kind !== "failure_pattern" && kind !== "successful_fix")
                     continue;
-                entries.push({
+                pushEvidenceHistory(entries, {
                     runtime: String(props.runtime ?? "unknown"),
                     intent: String(props.intent ?? "coding"),
                     passed: kind === "successful_fix",
@@ -88,6 +102,44 @@ export function createRuntimeRouter(options = {}) {
                     nodeId: String(props.sourceNodeId ?? ""),
                 });
             }
+            // Audit graph v2 materializes ProviderRoute -> EVIDENCED_BY -> Evidence
+            // with turn-result-pass/fail evidence. Feed those observations back into
+            // routing scores so successful recent routes become preferred and failed
+            // runtime paths decay without relying on raw logs.
+            const evidenceEdgesByRoute = new Map();
+            for (const edge of edges) {
+                if (edge.type !== "EVIDENCED_BY")
+                    continue;
+                const from = String(edge.from ?? "");
+                const to = String(edge.to ?? "");
+                const evidence = nodeById.get(to);
+                if (!evidence || evidence.type !== "Evidence")
+                    continue;
+                const list = evidenceEdgesByRoute.get(from) ?? [];
+                list.push(evidence);
+                evidenceEdgesByRoute.set(from, list);
+            }
+            for (const route of nodes) {
+                if (route.type !== "ProviderRoute")
+                    continue;
+                const props = (route.properties ?? {});
+                const runtime = routeRuntimeId(props);
+                if (!runtime)
+                    continue;
+                for (const evidence of evidenceEdgesByRoute.get(String(route.id ?? "")) ?? []) {
+                    const evidenceProps = (evidence.properties ?? {});
+                    const pass = auditEvidencePassState(String(evidenceProps.kind ?? ""));
+                    if (pass === undefined)
+                        continue;
+                    pushEvidenceHistory(entries, {
+                        runtime,
+                        intent: String(props.intent ?? props.role ?? "coding"),
+                        passed: pass,
+                        timestamp: String(evidence.updatedAt ?? evidence.createdAt ?? route.updatedAt ?? route.createdAt ?? ""),
+                        nodeId: String(props.nodeId ?? evidenceProps.nodeId ?? ""),
+                    });
+                }
+            }
             evidenceCache = entries;
             return entries;
         }
@@ -95,7 +147,7 @@ export function createRuntimeRouter(options = {}) {
             return [];
         }
     }
-    function computeScores(runtime, intent, history) {
+    function computeScores(runtime, intent, history, health) {
         const runtimeHistory = history.filter((e) => e.runtime === runtime.id);
         const intentHistory = runtimeHistory.filter((e) => e.intent === intent);
         const totalAttempts = runtimeHistory.length;
@@ -114,24 +166,221 @@ export function createRuntimeRouter(options = {}) {
         const latencyScore = runtime.capabilities?.supportsStreaming === true || runtime.capabilities?.streaming === true
             ? 0.7
             : 0.6;
+        const healthScore = runtimeHealthScore(health);
         return {
             runtime: runtime.id,
             qualityScore,
             costScore,
             latencyScore,
+            healthScore,
             evidencePassRate,
             recentFailurePenalty,
+            ...(health && { healthAvailable: health.available }),
+            ...(health?.reason && { healthReason: health.reason }),
+        };
+    }
+    async function collectRuntimeHealth(candidates, probeKind = "static", taskRisk) {
+        const nowMs = Date.now();
+        const entries = await Promise.all(candidates.map(async (runtime) => {
+            const cached = healthCache.get(runtime.id);
+            if (cached?.vector?.expiresAt && Date.parse(cached.vector.expiresAt) > nowMs && probeRank(cached.vector.lastProbeKind) >= probeRank(probeKind)) {
+                return [runtime.id, cached];
+            }
+            if (!runtime.health) {
+                const now = new Date();
+                const health = {
+                    runtimeId: runtime.id,
+                    available: true,
+                    checkedAt: now.toISOString(),
+                    vector: {
+                        runtimeOk: true,
+                        authOk: true,
+                        modelOk: true,
+                        quotaOk: true,
+                        rateLimitOk: true,
+                        runtime: "pass",
+                        auth: "pass",
+                        model: "pass",
+                        quota: "unknown",
+                        rateLimit: "unknown",
+                        lastProbeKind: "none",
+                        checkedAt: now.toISOString(),
+                        expiresAt: new Date(now.getTime() + 30_000).toISOString(),
+                    },
+                };
+                healthCache.set(runtime.id, health);
+                return [runtime.id, health];
+            }
+            try {
+                const health = normalizeRuntimeHealth(await runtime.health({ probeKind, taskRisk, highRisk: probeKind !== "static" }));
+                healthCache.set(runtime.id, health);
+                return [runtime.id, health];
+            }
+            catch (err) {
+                const now = new Date();
+                const reason = maskSensitiveText(err instanceof Error ? err.message : String(err));
+                const health = {
+                    runtimeId: runtime.id,
+                    available: false,
+                    reason,
+                    checkedAt: now.toISOString(),
+                    vector: {
+                        runtimeOk: false,
+                        authOk: true,
+                        modelOk: true,
+                        quotaOk: true,
+                        rateLimitOk: true,
+                        runtime: "fail",
+                        auth: "unknown",
+                        model: "unknown",
+                        quota: "unknown",
+                        rateLimit: "unknown",
+                        lastProbeKind: probeKind,
+                        checkedAt: now.toISOString(),
+                        expiresAt: new Date(now.getTime() + 30_000).toISOString(),
+                    },
+                };
+                healthCache.set(runtime.id, health);
+                return [runtime.id, health];
+            }
+        }));
+        return new Map(entries);
+    }
+    function requiredProbeForTask(task) {
+        const risk = task.safety?.risk;
+        if (risk === "merge")
+            return "live-call";
+        if (risk === "write" || risk === "shell" || task.capabilities.write || task.capabilities.patch || task.capabilities.shell || task.capabilities.merge) {
+            return "cheap-call";
+        }
+        return "static";
+    }
+    function requiredProbeForCapsule(capsule) {
+        const risk = capsule.node.routing?.risk;
+        if (risk === "merge")
+            return "live-call";
+        if (risk === "write" || risk === "shell")
+            return "cheap-call";
+        return "static";
+    }
+    function runtimeHealthy(runtime, healthMap, probeKind = "static") {
+        const health = healthMap.get(runtime.id);
+        if (!health)
+            return true;
+        if (health.available === false)
+            return false;
+        const vector = health.vector;
+        if (!vector)
+            return true;
+        const highRiskProbe = probeRank(probeKind) >= probeRank("cheap-call");
+        const hardDimensionsOk = highRiskProbe
+            ? statePassStrict(vector.runtime, vector.runtimeOk)
+                && statePassStrict(vector.auth, vector.authOk)
+                && statePassStrict(vector.model, vector.modelOk)
+            : statePassOrUnknown(vector.runtime, vector.runtimeOk)
+                && statePassOrUnknown(vector.auth, vector.authOk)
+                && statePassOrUnknown(vector.model, vector.modelOk);
+        return hardDimensionsOk
+            && statePassOrUnknown(vector.quota, vector.quotaOk)
+            && statePassOrUnknown(vector.rateLimit, vector.rateLimitOk);
+    }
+    function runtimeCircuitOpen(runtime) {
+        const state = circuitBreakers.get(runtime.id);
+        if (!state)
+            return undefined;
+        if (state.expiresAt <= Date.now()) {
+            circuitBreakers.delete(runtime.id);
+            return undefined;
+        }
+        return state;
+    }
+    function clearRuntimeCircuit(runtime) {
+        circuitBreakers.delete(runtime.id);
+    }
+    function recordRuntimeFailure(runtime, result) {
+        const classification = classifyRuntimeFailure({
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            metadata: result.metadata,
+        });
+        if (classification.failureClass === "none")
+            return result;
+        const opened = maybeOpenRuntimeCircuit(runtime.id, classification);
+        return {
+            ...result,
+            metadata: {
+                ...(result.metadata ?? {}),
+                failureClass: classification.failureClass,
+                failureRetryable: classification.retryable,
+                failureReason: classification.reason,
+                ...(opened && {
+                    circuitBreaker: {
+                        runtimeId: opened.runtimeId,
+                        failureClass: opened.failureClass,
+                        retryable: opened.retryable,
+                        failureCount: opened.failureCount,
+                        openedAt: new Date(opened.openedAt).toISOString(),
+                        expiresAt: new Date(opened.expiresAt).toISOString(),
+                        reason: opened.reason,
+                    },
+                }),
+            },
         };
     }
-    function selectByIntent(capsule, history) {
+    function maybeOpenRuntimeCircuit(runtimeId, classification) {
+        if (!classification.circuitBreaker || classification.cooldownMs <= 0)
+            return undefined;
+        const now = Date.now();
+        const previous = circuitBreakers.get(runtimeId);
+        const state = {
+            runtimeId,
+            failureClass: classification.failureClass,
+            retryable: classification.retryable,
+            openedAt: now,
+            expiresAt: now + classification.cooldownMs,
+            failureCount: (previous?.failureCount ?? 0) + 1,
+            reason: classification.reason,
+        };
+        circuitBreakers.set(runtimeId, state);
+        return state;
+    }
+    function circuitOpenResult(runtime, state, fallbackChain, intent) {
+        return {
+            success: false,
+            exitCode: 78,
+            stdout: "",
+            stderr: `Runtime ${runtime.id} skipped by circuit breaker: ${state.failureClass}`,
+            metadata: {
+                runtime: runtime.id,
+                selectedRuntime: runtime.id,
+                intent,
+                fallbackChain: fallbackChain.map((candidate) => candidate.id),
+                failureClass: state.failureClass,
+                failureRetryable: state.retryable,
+                circuitBreakerOpen: true,
+                circuitBreaker: {
+                    runtimeId: state.runtimeId,
+                    failureClass: state.failureClass,
+                    retryable: state.retryable,
+                    failureCount: state.failureCount,
+                    openedAt: new Date(state.openedAt).toISOString(),
+                    expiresAt: new Date(state.expiresAt).toISOString(),
+                    reason: state.reason,
+                },
+            },
+        };
+    }
+    function selectByIntent(capsule, history, healthMap, probeKind = "static") {
         const intent = classifyIntent(capsule);
         const sorted = [...runtimes].sort((a, b) => b.priority - a.priority);
         const supporting = sorted.filter((runtime) => runtime.supports(capsule) &&
-            runtimeAllowedByLegacyPolicy(runtime, { preferredProviders: [], fallbackChain: options.fallbackChain }));
+            runtimeAllowedByLegacyPolicy(runtime, { preferredProviders: [], fallbackChain: options.fallbackChain }) &&
+            (healthMap ? runtimeHealthy(runtime, healthMap, probeKind) : true));
         if (supporting.length === 0) {
             throw new UnsupportedRuntimeError(capsule, detectedRuntimeLabels(sorted));
         }
-        const scores = supporting.map((r) => computeScores(r, intent, history));
+        const scores = supporting.map((r) => computeScores(r, intent, history, healthMap?.get(r.id)));
         const scored = supporting.map((r, i) => ({
             runtime: r,
             score: scores[i],
@@ -146,6 +395,7 @@ export function createRuntimeRouter(options = {}) {
             `intent=${intent}`,
             `quality=${bestScore.qualityScore.toFixed(2)}`,
             `evidencePassRate=${bestScore.evidencePassRate.toFixed(2)}`,
+            `health=${bestScore.healthScore.toFixed(2)}`,
             `recentPenalty=${bestScore.recentFailurePenalty.toFixed(2)}`,
         ].join("; ");
         return { runtime: primary, reason, fallbacks, intent, scores };
@@ -178,9 +428,11 @@ export function createRuntimeRouter(options = {}) {
     }
     async function runNode(capsule, signal) {
         const history = await loadEvidenceHistory();
+        const probeKind = requiredProbeForCapsule(capsule);
+        const healthMap = await collectRuntimeHealth(runtimes, probeKind, capsule.node.routing?.risk);
         let decision;
         try {
-            decision = selectByIntent(capsule, history);
+            decision = selectByIntent(capsule, history, healthMap, probeKind);
         }
         catch (err) {
             if (err instanceof UnsupportedRuntimeError) {
@@ -219,30 +471,38 @@ export function createRuntimeRouter(options = {}) {
                     metadata: { runtime: runtime.id, aborted: true },
                 };
             }
+            const openCircuit = runtimeCircuitOpen(runtime);
+            if (openCircuit) {
+                lastError = circuitOpenResult(runtime, openCircuit, allCandidates, decision.intent);
+                continue;
+            }
             try {
                 const result = await runtime.runNode(capsule, signal);
-                if (result.success) {
-                    return {
-                        ...result,
-                        metadata: {
-                            ...result.metadata,
-                            selectedRuntime: runtime.id,
-                            intent: decision.intent,
-                            fallbackChain: allCandidates.map((r) => r.id),
-                            scores: decision.scores,
-                        },
-                    };
+                const routedResult = sanitizeAgentRunResult({
+                    ...result,
+                    metadata: {
+                        ...result.metadata,
+                        selectedRuntime: runtime.id,
+                        intent: decision.intent,
+                        fallbackChain: allCandidates.map((r) => r.id),
+                        scores: decision.scores,
+                    },
+                }, stderrArtifactOptions({ runId: capsule.runId, nodeId: capsule.nodeId, runtimeId: runtime.id, root: process.cwd(), env: process.env }));
+                if (routedResult.success) {
+                    clearRuntimeCircuit(runtime);
+                    return routedResult;
                 }
-                lastError = result;
+                lastError = recordRuntimeFailure(runtime, routedResult);
             }
             catch (err) {
-                lastError = {
+                const error = maskSensitiveText(String(err));
+                lastError = recordRuntimeFailure(runtime, sanitizeAgentRunResult({
                     success: false,
                     exitCode: 1,
                     stdout: "",
-                    stderr: String(err),
-                    metadata: { runtime: runtime.id, error: String(err) },
-                };
+                    stderr: error,
+                    metadata: { runtime: runtime.id, error },
+                }, stderrArtifactOptions({ runId: capsule.runId, nodeId: capsule.nodeId, runtimeId: runtime.id, root: process.cwd(), env: process.env })));
             }
         }
         return (lastError ?? {
@@ -255,9 +515,11 @@ export function createRuntimeRouter(options = {}) {
     }
     async function executeTask(task, capsule, signal) {
         const history = await loadEvidenceHistory();
+        const probeKind = requiredProbeForTask(task);
+        const healthMap = await collectRuntimeHealth(runtimes, probeKind, task.safety?.risk);
         let decision;
         try {
-            decision = selectByIntent(capsule, history);
+            decision = selectByIntent(capsule, history, healthMap, probeKind);
         }
         catch (err) {
             if (err instanceof UnsupportedRuntimeError) {
@@ -266,8 +528,39 @@ export function createRuntimeRouter(options = {}) {
             throw err;
         }
         const allCandidates = [decision.runtime, ...decision.fallbacks];
+        // Record runtime-router decision trace for executeTask, the native runtime pipeline path.
+        const runId = capsule.runId;
+        const attemptNumber = (capsule.node?.attempts?.length ?? 0) + 1;
+        const attemptId = `${capsule.nodeId}__${attemptNumber}`;
+        if (runId && !runId.startsWith("local-")) {
+            const traceStore = createDecisionTraceStore();
+            traceStore.record(runId, {
+                component: "runtime-router",
+                inputSummary: `node=${capsule.nodeId} intent=${decision.intent} path=executeTask`,
+                outputDecision: `runtime=${decision.runtime.id} fallbacks=${decision.fallbacks.map((r) => r.id).join(",")}`,
+                reason: decision.reason,
+                scores: decision.scores.reduce((acc, s) => {
+                    acc[s.runtime] = computeComposite(s, allCandidates.find((candidate) => candidate.id === s.runtime) ?? decision.runtime, decision.intent);
+                    return acc;
+                }, {}),
+                nodeId: capsule.nodeId,
+                attemptId,
+            });
+        }
+        const executionCandidates = allCandidates.filter((runtime) => {
+            const boundary = runtimeSatisfiesAdvisoryBoundary(runtime, task);
+            if (!boundary.ok) {
+                if (decision.reason && !decision.reason.includes("advisory boundary")) {
+                    decision = {
+                        ...decision,
+                        reason: `${decision.reason}; advisory boundary excluded ${runtime.id}`,
+                    };
+                }
+            }
+            return boundary.ok;
+        });
         let lastError;
-        for (const runtime of allCandidates) {
+        for (const runtime of executionCandidates) {
             if (signal.aborted) {
                 return {
                     success: false,
@@ -277,34 +570,54 @@ export function createRuntimeRouter(options = {}) {
                     metadata: { runtime: runtime.id, selectedRuntime: runtime.id, aborted: true },
                 };
             }
+            const openCircuit = runtimeCircuitOpen(runtime);
+            if (openCircuit) {
+                lastError = circuitOpenResult(runtime, openCircuit, executionCandidates, decision.intent);
+                continue;
+            }
             try {
                 const result = runtime.execute
                     ? agentResultToRunResult(await runtime.execute(task), runtime.id)
                     : await runtime.runNode(capsule, signal);
-                const routedResult = {
+                const routedResult = sanitizeAgentRunResult({
                     ...result,
                     metadata: {
                         ...result.metadata,
                         selectedRuntime: runtime.id,
                         intent: decision.intent,
-                        fallbackChain: allCandidates.map((r) => r.id),
+                        fallbackChain: executionCandidates.map((r) => r.id),
                         scores: decision.scores,
                     },
-                };
-                if (routedResult.success)
+                }, stderrArtifactOptions({ runId: task.context.runId, nodeId: task.context.nodeId, runtimeId: runtime.id, root: task.context.cwd, env: task.context.env ?? process.env }));
+                if (routedResult.success) {
+                    clearRuntimeCircuit(runtime);
                     return routedResult;
-                lastError = routedResult;
+                }
+                lastError = recordRuntimeFailure(runtime, routedResult);
             }
             catch (err) {
-                lastError = {
+                const error = maskSensitiveText(String(err));
+                lastError = recordRuntimeFailure(runtime, sanitizeAgentRunResult({
                     success: false,
                     exitCode: 1,
                     stdout: "",
-                    stderr: String(err),
-                    metadata: { runtime: runtime.id, selectedRuntime: runtime.id, error: String(err) },
-                };
+                    stderr: error,
+                    metadata: { runtime: runtime.id, selectedRuntime: runtime.id, error },
+                }, stderrArtifactOptions({ runId: task.context.runId, nodeId: task.context.nodeId, runtimeId: runtime.id, root: task.context.cwd, env: task.context.env ?? process.env })));
             }
         }
+        if (executionCandidates.length === 0 && allCandidates.length > 0) {
+            const advisoryFailures = allCandidates
+                .map((runtime) => runtimeSatisfiesAdvisoryBoundary(runtime, task))
+                .filter((boundary) => !boundary.ok);
+            return {
+                success: false,
+                exitCode: 78,
+                stdout: "",
+                stderr: advisoryFailures.map((boundary) => boundary.reason).join("\n") || "All candidate runtimes are advisory-only for this task",
+                metadata: { authorityMode: "advisory", advisoryBoundaryFailures: advisoryFailures.map((boundary) => boundary.reason) },
+            };
+        }
         return (lastError ?? {
             success: false,
             exitCode: 1,
@@ -332,15 +645,48 @@ export function createRuntimeRouter(options = {}) {
         if (preferredProviders.length > 0) {
             candidates = candidates.filter((runtime) => preferredProviders.some((provider) => runtimeMatchesProvider(runtime, provider)));
         }
+        const probeKind = requiredProbeForTask(task);
+        const healthMap = await collectRuntimeHealth(candidates, probeKind, task.safety?.risk);
+        candidates = candidates.filter((runtime) => runtimeHealthy(runtime, healthMap, probeKind));
+        const advisoryBoundaryFailures = [];
+        const nonAdvisoryCandidates = candidates.filter((runtime) => {
+            const boundary = runtimeSatisfiesAdvisoryBoundary(runtime, task);
+            if (!boundary.ok)
+                advisoryBoundaryFailures.push(`${runtime.id}: ${boundary.reason}`);
+            return boundary.ok;
+        });
+        if (nonAdvisoryCandidates.length > 0) {
+            candidates = nonAdvisoryCandidates;
+        }
+        else if (advisoryBoundaryFailures.length > 0) {
+            return {
+                success: false,
+                exitCode: 78,
+                stdout: "",
+                stderr: `Advisory runtime boundary blocked execution:\n${advisoryBoundaryFailures.join("\n")}`,
+                metadata: { authorityMode: "advisory", advisoryBoundaryFailures },
+            };
+        }
         if (candidates.length === 0) {
             const mcpBlocked = task.capabilities.mcp || task.capabilities.toolCalling;
             if (mcpBlocked && runtimes.length > 0) {
                 const runtime = runtimes[0];
                 throw new Error(`Node requires MCP authority. ${runtimeDisplayName(runtime)} runtime does not receive OMK MCP authority.`);
             }
+            if (advisoryBoundaryFailures.length > 0) {
+                return {
+                    success: false,
+                    exitCode: 78,
+                    stdout: "",
+                    stderr: `Advisory runtime boundary blocked execution:\n${advisoryBoundaryFailures.join("\n")}`,
+                    metadata: { authorityMode: "advisory", advisoryBoundaryFailures },
+                };
+            }
             throw new UnsupportedRuntimeError(capsule, detectedRuntimeLabels(runtimes));
         }
         const preferredRuntimeIds = task.providerPolicy?.fallbackChain ?? options.fallbackChain ?? [];
+        const history = await loadEvidenceHistory();
+        const scoreByRuntime = new Map(candidates.map((runtime) => [runtime, computeScores(runtime, intent, history, healthMap.get(runtime.id))]));
         const capabilityScoreCache = buildCapabilityScoreCache(candidates, intent);
         candidates.sort((a, b) => {
             const runtimeDelta = runtimePreferenceIndex(a.id, preferredRuntimeIds)
@@ -353,7 +699,9 @@ export function createRuntimeRouter(options = {}) {
                 if (providerDelta !== 0)
                     return providerDelta;
             }
-            return compareRuntimeCandidates(a, b, intent, capabilityScoreCache);
+            const aScore = scoreByRuntime.get(a) ?? computeScores(a, intent, history, healthMap.get(a.id));
+            const bScore = scoreByRuntime.get(b) ?? computeScores(b, intent, history, healthMap.get(b.id));
+            return compareScoredRuntimes({ runtime: a, composite: computeComposite(aScore, a, intent) }, { runtime: b, composite: computeComposite(bScore, b, intent) }, intent, capabilityScoreCache);
         });
         let lastError;
         for (const runtime of candidates) {
@@ -366,31 +714,40 @@ export function createRuntimeRouter(options = {}) {
                     metadata: { runtime: runtime.id, selectedRuntime: runtime.id, aborted: true },
                 };
             }
+            const openCircuit = runtimeCircuitOpen(runtime);
+            if (openCircuit) {
+                lastError = circuitOpenResult(runtime, openCircuit, candidates, intent);
+                continue;
+            }
             try {
                 const result = runtime.execute
                     ? agentResultToRunResult(await runtime.execute(task), runtime.id)
                     : await runtime.runNode(capsule, signal);
-                const routedResult = {
+                const routedResult = sanitizeAgentRunResult({
                     ...result,
                     metadata: {
                         ...result.metadata,
                         selectedRuntime: runtime.id,
                         intent,
                         fallbackChain: candidates.map((candidate) => candidate.id),
+                        scores: candidates.map((candidate) => scoreByRuntime.get(candidate)).filter((score) => score !== undefined),
                     },
-                };
-                if (routedResult.success)
+                }, stderrArtifactOptions({ runId: task.context.runId, nodeId: task.context.nodeId, runtimeId: runtime.id, root: task.context.cwd, env: task.context.env ?? process.env }));
+                if (routedResult.success) {
+                    clearRuntimeCircuit(runtime);
                     return routedResult;
-                lastError = routedResult;
+                }
+                lastError = recordRuntimeFailure(runtime, routedResult);
             }
             catch (err) {
-                lastError = {
+                const error = maskSensitiveText(String(err));
+                lastError = recordRuntimeFailure(runtime, sanitizeAgentRunResult({
                     success: false,
                     exitCode: 1,
                     stdout: "",
-                    stderr: String(err),
-                    metadata: { runtime: runtime.id, selectedRuntime: runtime.id, error: String(err) },
-                };
+                    stderr: error,
+                    metadata: { runtime: runtime.id, selectedRuntime: runtime.id, error },
+                }, stderrArtifactOptions({ runId: task.context.runId, nodeId: task.context.nodeId, runtimeId: runtime.id, root: task.context.cwd, env: task.context.env ?? process.env })));
             }
         }
         return lastError ?? {
@@ -423,20 +780,30 @@ export function createRuntimeRouter(options = {}) {
 }
 function capsuleFromTask(task) {
     const nodeId = task.context.nodeId || "runtime-task";
+    const promptHash = createHash("sha256").update(task.prompt).digest("hex");
+    const publicLabel = `runtime task:${promptHash.slice(0, 12)}`;
     return {
         runId: task.context.runId || "local-runtime-router",
         nodeId,
-        goal: task.context.goal || task.prompt,
+        goal: task.context.goal || publicLabel,
         task: task.prompt,
         system: task.context.system || "",
         node: {
             id: nodeId,
-            name: task.prompt,
+            name: publicLabel,
             role: task.context.role || "coder",
             dependsOn: [],
             status: "running",
             retries: 0,
             maxRetries: 1,
+            routing: {
+                promptHash,
+                promptMode: "synthetic-private",
+                risk: task.safety?.risk,
+                approvalPolicy: task.safety?.approvalPolicy,
+                sandboxMode: task.safety?.sandboxMode,
+                evidenceRequired: task.safety?.evidenceRequired,
+            },
         },
         dependencySummaries: [],
         evidenceRequirements: [],
@@ -446,6 +813,25 @@ function capsuleFromTask(task) {
         budget: { maxInputTokens: 0, compression: "small" },
     };
 }
+function pushEvidenceHistory(entries, entry) {
+    if (!entry.runtime || entry.runtime === "unknown")
+        return;
+    entries.push(entry);
+}
+function routeRuntimeId(props) {
+    const selectedRuntime = String(props.selectedRuntime ?? "").trim();
+    if (selectedRuntime && selectedRuntime !== "unknown")
+        return selectedRuntime;
+    const provider = String(props.provider ?? "").trim();
+    return provider && provider !== "unknown" ? provider : undefined;
+}
+function auditEvidencePassState(kind) {
+    if (kind === "turn-result-pass" || kind === "command-pass" || kind === "test-pass")
+        return true;
+    if (kind === "turn-result-fail" || kind === "command-fail" || kind === "test-fail")
+        return false;
+    return undefined;
+}
 function detectedRuntimeLabels(runtimes) {
     return [...new Set(runtimes.map((runtime) => isLegacyRuntime(runtime) ? "legacy-external-runtime" : runtime.id))];
 }
@@ -472,6 +858,37 @@ function runtimeSatisfiesTask(runtime, task) {
         return false;
     return true;
 }
+/**
+ * Detect advisory-only runtimes that claim broad capabilities but are not allowed
+ * to execute write/shell/merge/patch/tool-calling authority. If a non-read-only
+ * task reaches such a runtime, reroute it to the first non-advisory fallback.
+ */
+function runtimeSatisfiesAdvisoryBoundary(runtime, task) {
+    const authority = runtimeSatisfiesAuthority(runtime, task);
+    if (!authority.ok) {
+        return { ok: false, reason: authority.reason };
+    }
+    if (!runtimeIsAdvisory(runtime))
+        return { ok: true };
+    const required = task.capabilities;
+    if (required.write ||
+        required.patch ||
+        required.shell ||
+        required.merge ||
+        required.mcp) {
+        return {
+            ok: false,
+            reason: `advisory runtime ${runtime.id} cannot execute write/shell/merge/patch/MCP authority`,
+        };
+    }
+    if (required.toolCalling && isStrictGuardrailMode()) {
+        return {
+            ok: false,
+            reason: `advisory runtime ${runtime.id} cannot execute tool-calling authority unless agent-freedom mode is enabled`,
+        };
+    }
+    return { ok: true };
+}
 function runtimeMatchesProvider(runtime, provider) {
     const normalizedProvider = normalizeRuntimeToken(provider);
     if (normalizedProvider.length === 0)
@@ -556,7 +973,7 @@ function unsupportedRuntimeResult(err) {
 }
 function agentResultToRunResult(result, runtimeId) {
     const success = result.exitCode === 0;
-    return {
+    return sanitizeAgentRunResult({
         success,
         exitCode: result.exitCode,
         stdout: result.output,
@@ -568,16 +985,121 @@ function agentResultToRunResult(result, runtimeId) {
         },
         tokenUsage: result.tokenUsage,
         toolCalls: result.toolCalls,
-    };
+    });
+}
+function stderrArtifactOptions(input) {
+    return input;
+}
+function sanitizeAgentRunResult(result, options = {}) {
+    return sanitizeRuntimeStderrResult(result, options);
 }
+const NORMALIZED_COMPOSITE_WEIGHTS = {
+    quality: 0.28,
+    evidence: 0.18,
+    health: 0.16,
+    cost: 0.10,
+    latency: 0.08,
+    recentSuccess: 0.10,
+    capability: 0.07,
+    priority: 0.03,
+};
 function computeComposite(score, runtime, intent) {
-    return (0.35 * score.qualityScore +
-        0.25 * score.evidencePassRate +
-        0.15 * score.costScore +
-        0.1 * score.latencyScore +
-        0.15 * (1 - score.recentFailurePenalty) +
-        0.15 * computeRuntimeCapabilityScore(runtime, intent) +
-        0.05 * runtimePriorityScore(runtime));
+    return (NORMALIZED_COMPOSITE_WEIGHTS.quality * score.qualityScore +
+        NORMALIZED_COMPOSITE_WEIGHTS.evidence * score.evidencePassRate +
+        NORMALIZED_COMPOSITE_WEIGHTS.health * score.healthScore +
+        NORMALIZED_COMPOSITE_WEIGHTS.cost * score.costScore +
+        NORMALIZED_COMPOSITE_WEIGHTS.latency * score.latencyScore +
+        NORMALIZED_COMPOSITE_WEIGHTS.recentSuccess * (1 - score.recentFailurePenalty) +
+        NORMALIZED_COMPOSITE_WEIGHTS.capability * computeRuntimeCapabilityScore(runtime, intent) +
+        NORMALIZED_COMPOSITE_WEIGHTS.priority * runtimePriorityScore(runtime));
+}
+function normalizeRuntimeHealth(health) {
+    const now = new Date();
+    const checkedAt = health.checkedAt ?? now.toISOString();
+    const vector = health.vector;
+    if (!vector) {
+        return {
+            ...health,
+            vector: {
+                runtimeOk: health.available,
+                authOk: health.available,
+                modelOk: health.available,
+                quotaOk: true,
+                rateLimitOk: true,
+                runtime: health.available ? "pass" : "fail",
+                auth: health.available ? "pass" : "fail",
+                model: health.available ? "pass" : "fail",
+                quota: "unknown",
+                rateLimit: "unknown",
+                lastProbeKind: "none",
+                checkedAt,
+                expiresAt: new Date(Date.parse(checkedAt) + 30_000).toISOString(),
+            },
+        };
+    }
+    return {
+        ...health,
+        vector: {
+            ...vector,
+            runtime: vector.runtime ?? legacyBoolToState(vector.runtimeOk),
+            auth: vector.auth ?? legacyBoolToState(vector.authOk),
+            model: vector.model ?? legacyBoolToState(vector.modelOk),
+            quota: vector.quota ?? legacyBoolToState(vector.quotaOk),
+            rateLimit: vector.rateLimit ?? legacyBoolToState(vector.rateLimitOk),
+            lastProbeKind: vector.lastProbeKind ?? "static",
+            checkedAt: vector.checkedAt ?? checkedAt,
+            expiresAt: vector.expiresAt ?? new Date(Date.parse(checkedAt) + 60_000).toISOString(),
+        },
+    };
+}
+function probeRank(kind) {
+    switch (kind) {
+        case "live-call":
+            return 3;
+        case "cheap-call":
+            return 2;
+        case "static":
+            return 1;
+        default:
+            return 0;
+    }
+}
+function legacyBoolToState(value) {
+    if (value === true)
+        return "pass";
+    if (value === false)
+        return "fail";
+    return "unknown";
+}
+function statePassOrUnknown(state, legacy) {
+    const normalized = state ?? legacyBoolToState(legacy);
+    return normalized !== "fail";
+}
+function statePassStrict(state, legacy) {
+    const normalized = state ?? legacyBoolToState(legacy);
+    return normalized === "pass";
+}
+function healthStatePenalty(state, legacy, failWeight, unknownWeight) {
+    const normalized = state ?? legacyBoolToState(legacy);
+    if (normalized === "fail")
+        return failWeight;
+    if (normalized === "unknown")
+        return unknownWeight;
+    return 0;
+}
+function runtimeHealthScore(health) {
+    if (!health)
+        return 1;
+    const vector = health.vector;
+    if (!vector)
+        return health.available ? 1 : 0;
+    let score = 1;
+    score -= healthStatePenalty(vector.runtime, vector.runtimeOk, 0.25, 0.08);
+    score -= healthStatePenalty(vector.auth, vector.authOk, 0.25, 0.08);
+    score -= healthStatePenalty(vector.model, vector.modelOk, 0.2, 0.05);
+    score -= healthStatePenalty(vector.quota, vector.quotaOk, 0.2, 0.05);
+    score -= healthStatePenalty(vector.rateLimit, vector.rateLimitOk, 0.1, 0.03);
+    return Math.max(0, score);
 }
 function compareScoredRuntimes(a, b, intent, scoreCache) {
     const compositeDelta = b.composite - a.composite;