@openclawbrain/cli 0.4.14 → 0.4.15

package/dist/src/proof-command.js

@@ -255,6 +255,134 @@ function extractStatusSignals(statusText) {
         proofError: statusText.match(/proofError=([^\s]+)/)?.[1] ?? null,
     };
 }
+function extractDetailedStatusLine(statusText, prefix) {
+    const normalizedPrefix = `${prefix} `;
+    return statusText.split(/\r?\n/).find((line) => line.startsWith(normalizedPrefix)) ?? null;
+}
+function extractKeyValuePairs(line) {
+    if (typeof line !== "string") {
+        return {};
+    }
+    const pairs = {};
+    for (const match of line.matchAll(/([A-Za-z][A-Za-z0-9]*)=([^\s]+)/g)) {
+        pairs[match[1]] = match[2];
+    }
+    return pairs;
+}
+function extractAttachedProfileCoverageEntries(line) {
+    if (typeof line !== "string") {
+        return [];
+    }
+    const normalized = line.replace(/^attachedSet\s+/, "");
+    const proofPathIndex = normalized.indexOf(" proofPath=");
+    const entriesText = (proofPathIndex === -1 ? normalized : normalized.slice(0, proofPathIndex)).trim();
+    if (entriesText.length === 0 || entriesText === "none") {
+        return [];
+    }
+    const entries = [];
+    let index = 0;
+    while (index < entriesText.length) {
+        while (index < entriesText.length && entriesText[index] === " ") {
+            index += 1;
+        }
+        if (index >= entriesText.length) {
+            break;
+        }
+        const bracketStart = entriesText.indexOf("[", index);
+        if (bracketStart === -1) {
+            break;
+        }
+        const bracketEnd = entriesText.indexOf("]", bracketStart + 1);
+        if (bracketEnd === -1) {
+            break;
+        }
+        const rawLabel = entriesText.slice(index, bracketStart).trim();
+        const fields = extractKeyValuePairs(entriesText.slice(bracketStart + 1, bracketEnd));
+        entries.push({
+            label: rawLabel.replace(/^\*/, "").trim(),
+            current: rawLabel.startsWith("*"),
+            hookFiles: fields.hook ?? "unknown",
+            configLoad: fields.config ?? "unknown",
+            runtimeLoad: fields.runtime ?? "unknown",
+            loadedAt: fields.loadedAt ?? null,
+            coverageState: fields.hook === "present" && fields.config === "allows_load" && fields.runtime === "proven"
+                ? "covered"
+                : "attention"
+        });
+        index = bracketEnd + 1;
+    }
+    return entries;
+}
+function buildCoverageSnapshot({ attachedSetLine, runtimeLoadProofSnapshot, openclawHome }) {
+    const parsedEntries = extractAttachedProfileCoverageEntries(attachedSetLine);
+    const proofProfiles = Array.isArray(runtimeLoadProofSnapshot?.value?.profiles)
+        ? runtimeLoadProofSnapshot.value.profiles
+        : [];
+    const profiles = parsedEntries.length > 0
+        ? parsedEntries
+        : proofProfiles.map((profile) => ({
+            label: `${profile?.profileId ?? "current_profile"}@${canonicalizeExistingProofPath(profile?.openclawHome ?? "")}`,
+            current: canonicalizeExistingProofPath(profile?.openclawHome ?? "") === canonicalizeExistingProofPath(openclawHome),
+            hookFiles: "unknown",
+            configLoad: "unknown",
+            runtimeLoad: "proven",
+            loadedAt: profile?.loadedAt ?? null,
+            coverageState: "covered"
+        }));
+    const runtimeProvenCount = profiles.filter((entry) => entry.runtimeLoad === "proven").length;
+    return {
+        contract: "openclaw_operator_profile_coverage_snapshot.v1",
+        generatedAt: new Date().toISOString(),
+        openclawHome: canonicalizeExistingProofPath(openclawHome),
+        attachedProfileCount: profiles.length,
+        runtimeProofProfileCount: proofProfiles.length,
+        hookReadyCount: profiles.filter((entry) => entry.hookFiles === "present").length,
+        configReadyCount: profiles.filter((entry) => entry.configLoad === "allows_load").length,
+        runtimeProvenCount,
+        coverageRate: profiles.length === 0 ? null : runtimeProvenCount / profiles.length,
+        profiles
+    };
+}
+function buildHardeningSnapshot({ attachTruthLine, serveLine, routeFnLine, verdict, statusSignals }) {
+    const attachTruth = extractKeyValuePairs(attachTruthLine);
+    const serve = extractKeyValuePairs(serveLine);
+    const routeFn = extractKeyValuePairs(routeFnLine);
+    return {
+        contract: "openclaw_operator_hardening_snapshot.v1",
+        generatedAt: new Date().toISOString(),
+        statusSignals: {
+            statusOk: statusSignals.statusOk,
+            loadProofReady: statusSignals.loadProofReady,
+            runtimeProven: statusSignals.runtimeProven,
+            serveActivePack: statusSignals.serveActivePack,
+            routeFnAvailable: statusSignals.routeFnAvailable,
+        },
+        attachTruth: {
+            current: attachTruth.current ?? null,
+            hook: attachTruth.hook ?? null,
+            config: attachTruth.config ?? null,
+            runtime: attachTruth.runtime ?? null,
+            watcher: attachTruth.watcher ?? null,
+        },
+        serve: {
+            state: serve.state ?? null,
+            failOpen: serve.failOpen ?? null,
+            hardFail: serve.hardFail ?? null,
+            usedRouteFn: serve.usedRouteFn ?? null,
+            awaitingFirstExport: serve.awaitingFirstExport ?? null,
+        },
+        routeFn: {
+            available: routeFn.available ?? null,
+            freshness: routeFn.freshness ?? null,
+        },
+        verdict: {
+            verdict: verdict.verdict,
+            severity: verdict.severity,
+            missingProofCount: Array.isArray(verdict.missingProofs) ? verdict.missingProofs.length : 0,
+            warningCount: Array.isArray(verdict.warnings) ? verdict.warnings.length : 0,
+        }
+    };
+}
 
 function hasPackagedHookSource(pluginInspectText) {
     return /Source:\s+.*(?:@openclawbrain[\\/]+openclaw|openclawbrain)[\\/]+dist[\\/]+extension[\\/]+index\.js/m.test(pluginInspectText);
@@ -357,7 +485,7 @@ function buildVerdict({ steps, gatewayStatus, pluginInspect, statusSignals, brea
     };
 }
 
-function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot }) {
+function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, guardLine, attributionLine, learningPathLine, coverageSnapshot, hardeningSnapshot }) {
     const passed = [];
     const missing = [];
     const warnings = Array.isArray(verdict.warnings) ? verdict.warnings : [];
@@ -413,6 +541,33 @@ function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspec
         "## Warnings",
         ...(warnings.length === 0 ? ["- none"] : warnings.map((item) => `- ${item}`)),
         "",
+        "## Runtime Guard",
+        ...(guardLine === null
+            ? ["- runtime guard line not reported by detailed status"]
+            : [`- ${guardLine}`]),
+        "",
+        "## Learning Attribution",
+        ...(attributionLine === null
+            ? ["- attribution line not reported by detailed status"]
+            : [`- ${attributionLine}`]),
+        ...(learningPathLine === null
+            ? []
+            : [`- ${learningPathLine}`]),
+        "",
+        "## Coverage snapshot",
+        `- attached profiles: ${coverageSnapshot.attachedProfileCount}`,
+        `- runtime-proven profiles: ${coverageSnapshot.runtimeProvenCount}/${coverageSnapshot.attachedProfileCount}`,
+        `- coverage rate: ${coverageSnapshot.coverageRate === null ? "none" : coverageSnapshot.coverageRate.toFixed(3)}`,
+        ...(coverageSnapshot.profiles.length === 0
+            ? ["- per-profile: none"]
+            : coverageSnapshot.profiles.map((entry) => `- ${entry.current ? "*" : ""}${entry.label} coverage=${entry.coverageState} hook=${entry.hookFiles} config=${entry.configLoad} runtime=${entry.runtimeLoad} loadedAt=${entry.loadedAt ?? "none"}`)),
+        "",
+        "## Hardening snapshot",
+        `- status signals: statusOk=${hardeningSnapshot.statusSignals.statusOk} loadProofReady=${hardeningSnapshot.statusSignals.loadProofReady} runtimeProven=${hardeningSnapshot.statusSignals.runtimeProven} serveActivePack=${hardeningSnapshot.statusSignals.serveActivePack} routeFnAvailable=${hardeningSnapshot.statusSignals.routeFnAvailable}`,
+        `- serve: state=${hardeningSnapshot.serve.state ?? "none"} failOpen=${hardeningSnapshot.serve.failOpen ?? "none"} hardFail=${hardeningSnapshot.serve.hardFail ?? "none"} usedRouteFn=${hardeningSnapshot.serve.usedRouteFn ?? "none"}`,
+        `- attachTruth: current=${hardeningSnapshot.attachTruth.current ?? "none"} hook=${hardeningSnapshot.attachTruth.hook ?? "none"} config=${hardeningSnapshot.attachTruth.config ?? "none"} runtime=${hardeningSnapshot.attachTruth.runtime ?? "none"}`,
+        `- proof verdict: ${hardeningSnapshot.verdict.verdict} severity=${hardeningSnapshot.verdict.severity} warnings=${hardeningSnapshot.verdict.warningCount}`,
+        "",
         "## Step ledger",
         ...steps.map((step) => `- ${step.stepId}: ${step.skipped ? "skipped" : `${step.resultClass} (${step.captureState})`} - ${step.summary}`),
     ];
@@ -634,15 +789,28 @@ export function captureOperatorProofBundle(options) {
     const gatewayLogPath = extractGatewayLogPath(gatewayStatusCapture.stdout);
     const activationRoot = extractActivationRoot(statusCapture.stdout, options.activationRoot ?? null);
     const statusSignals = extractStatusSignals(statusCapture.stdout);
+    const attachTruthLine = extractDetailedStatusLine(statusCapture.stdout, "attachTruth");
+    const attachedSetLine = extractDetailedStatusLine(statusCapture.stdout, "attachedSet");
+    const serveLine = extractDetailedStatusLine(statusCapture.stdout, "serve");
+    const routeFnLine = extractDetailedStatusLine(statusCapture.stdout, "routeFn");
+    const guardLine = extractDetailedStatusLine(statusCapture.stdout, "guard");
+    const attributionLine = extractDetailedStatusLine(statusCapture.stdout, "attribution");
+    const learningPathLine = extractDetailedStatusLine(statusCapture.stdout, "path");
     const runtimeLoadProofPath = normalizeReportedProofPath(statusSignals.proofPath)
         ?? path.join(activationRoot, "attachment-truth", "runtime-load-proofs.json");
     const runtimeLoadProofSnapshot = readJsonSnapshot(runtimeLoadProofPath);
     const gatewayLogText = readTextIfExists(gatewayLogPath);
     const breadcrumbs = extractStartupBreadcrumbs(gatewayLogText, bundleStartedAt);
+    const coverageSnapshot = buildCoverageSnapshot({
+        attachedSetLine,
+        runtimeLoadProofSnapshot,
+        openclawHome: options.openclawHome,
+    });
     writeText(path.join(bundleDir, "extracted-startup-breadcrumbs.log"), breadcrumbs.all.length === 0
         ? "<no matching breadcrumbs found>\n"
         : `${breadcrumbs.all.map((entry) => entry.line).join("\n")}\n`);
     writeJson(path.join(bundleDir, "runtime-load-proof.json"), runtimeLoadProofSnapshot);
+    writeJson(path.join(bundleDir, "coverage-snapshot.json"), coverageSnapshot);
     const verdict = buildVerdict({
         steps,
         gatewayStatus: gatewayStatusCapture.stdout,
@@ -652,6 +820,13 @@ export function captureOperatorProofBundle(options) {
         runtimeLoadProofSnapshot,
         openclawHome: options.openclawHome,
     });
+    const hardeningSnapshot = buildHardeningSnapshot({
+        attachTruthLine,
+        serveLine,
+        routeFnLine,
+        verdict,
+        statusSignals,
+    });
     writeJson(path.join(bundleDir, "steps.json"), {
         bundleStartedAt,
         openclawHome: canonicalizeExistingProofPath(options.openclawHome),
@@ -664,6 +839,8 @@ export function captureOperatorProofBundle(options) {
         bundleStartedAt,
         verdict,
         statusSignals,
+        coverageSnapshot,
+        hardeningSnapshot,
         breadcrumbs: {
             allCount: breadcrumbs.all.length,
             postBundleCount: breadcrumbs.afterBundleStart.length,
@@ -671,7 +848,11 @@ export function captureOperatorProofBundle(options) {
         },
         runtimeLoadProofPath,
         runtimeLoadProofError: runtimeLoadProofSnapshot.error,
+        guardLine,
+        attributionLine,
+        learningPathLine,
     });
+    writeJson(path.join(bundleDir, "hardening-snapshot.json"), hardeningSnapshot);
     writeText(path.join(bundleDir, "summary.md"), buildSummary({
         options,
         steps,
@@ -681,6 +862,11 @@ export function captureOperatorProofBundle(options) {
         statusSignals,
         breadcrumbs,
         runtimeLoadProofSnapshot,
+        guardLine,
+        attributionLine,
+        learningPathLine,
+        coverageSnapshot,
+        hardeningSnapshot,
     }));
     return {
         ok: true,
@@ -691,14 +877,21 @@ export function captureOperatorProofBundle(options) {
         gatewayLogPath,
         runtimeLoadProofPath,
         runtimeLoadProofSnapshot,
+        coverageSnapshot,
+        hardeningSnapshot,
         verdict,
         statusSignals,
+        guardLine,
+        attributionLine,
+        learningPathLine,
         steps,
         summaryPath: path.join(bundleDir, "summary.md"),
         stepsPath: path.join(bundleDir, "steps.json"),
         verdictPath: path.join(bundleDir, "verdict.json"),
         breadcrumbPath: path.join(bundleDir, "extracted-startup-breadcrumbs.log"),
         runtimeLoadProofSnapshotPath: path.join(bundleDir, "runtime-load-proof.json"),
+        coverageSnapshotPath: path.join(bundleDir, "coverage-snapshot.json"),
+        hardeningSnapshotPath: path.join(bundleDir, "hardening-snapshot.json"),
     };
 }
 
@@ -713,6 +906,8 @@ export function formatOperatorProofResult(result) {
         `  Verdict: ${result.verdictPath}`,
         `  Breadcrumbs: ${result.breadcrumbPath}`,
         `  Runtime proof: ${result.runtimeLoadProofSnapshotPath}`,
+        `  Coverage snapshot: ${result.coverageSnapshotPath}`,
+        `  Hardening snapshot: ${result.hardeningSnapshotPath}`,
     ];
     return lines.join("\n");
 }

package/dist/src/runtime-core.js

@@ -39,8 +39,75 @@ function normalizeNonNegativeInteger(value, fieldName, fallbackValue) {
   return value;
 }
 
-function normalizeMode(value) {
-  return value ?? "heuristic";
+const RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG = {
+  vector_only: {
+    routeMode: "heuristic",
+    selectionMode: "flat_rank_v1",
+  },
+  graph_prior_only: {
+    routeMode: "heuristic",
+    selectionMode: "graph_walk_v1",
+  },
+  learned_route: {
+    routeMode: "learned",
+    selectionMode: "graph_walk_v1",
+  },
+};
+
+function resolveRuntimeComparativeReplayMode(value) {
+  return Object.prototype.hasOwnProperty.call(RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG, value)
+    ? value
+    : null;
+}
+
+function resolveCompileModePlan(modeValue, selectionModeValue) {
+  const requestedSelectionMode = normalizeCompileSelectionMode(selectionModeValue);
+  const comparativeMode = resolveRuntimeComparativeReplayMode(modeValue);
+
+  if (comparativeMode === null) {
+    if (modeValue === undefined) {
+      return {
+        comparativeMode: null,
+        routeMode: "heuristic",
+        selectionMode: requestedSelectionMode,
+      };
+    }
+
+    if (modeValue === "heuristic" || modeValue === "learned") {
+      return {
+        comparativeMode: null,
+        routeMode: modeValue,
+        selectionMode: requestedSelectionMode,
+      };
+    }
+
+    throw new Error(
+      "mode must be heuristic, learned, vector_only, graph_prior_only, or learned_route",
+    );
+  }
+
+  const plan = RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG[comparativeMode];
+
+  if (requestedSelectionMode !== undefined && requestedSelectionMode !== plan.selectionMode) {
+    throw new Error(
+      `selectionMode ${requestedSelectionMode} conflicts with comparative mode ${comparativeMode}, expected ${plan.selectionMode}`,
+    );
+  }
+
+  return {
+    comparativeMode,
+    routeMode: plan.routeMode,
+    selectionMode: plan.selectionMode,
+  };
+}
+
+function resolveSyntheticTurnMode(value) {
+  const comparativeMode = resolveRuntimeComparativeReplayMode(value);
+  if (comparativeMode !== null) {
+    return RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG[comparativeMode].routeMode;
+  }
+
+  return value === "heuristic" || value === "learned" ? value : undefined;
 }
 
 function normalizeCompileSelectionMode(value) {
@@ -83,7 +150,7 @@ function formatPromptContext(compileResponse) {
   }
 
   for (const block of compileResponse.selectedContext) {
-    lines.push(`SOURCE: ${block.source}`);
+    lines.push(`PROVENANCE_REF: ctx_${block.id}`);
     lines.push(`BLOCK_ID: ${block.id}`);
     lines.push(block.text.trim());
     lines.push("");
@@ -273,8 +340,10 @@ function appendCompileServeRouteDecisionLog(input) {
     syntheticTurn.budgetStrategy = input.compileInput.budgetStrategy;
   }
 
-  if (input.compileInput.mode === "heuristic" || input.compileInput.mode === "learned") {
-    syntheticTurn.mode = input.compileInput.mode;
+  const syntheticTurnMode = resolveSyntheticTurnMode(input.compileInput.mode);
+
+  if (syntheticTurnMode !== undefined) {
+    syntheticTurn.mode = syntheticTurnMode;
   }
 
   if (input.compileInput.runtimeHints !== undefined) {
@@ -456,6 +525,7 @@ export function compileRuntimeContext(input) {
   let activationRoot = fallbackActivationRoot;
   let agentId = process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
   let runtimeHints = [];
+  let comparativeMode = null;
   let selectionMode;
   let userMessage = "";
   let maxContextChars;
@@ -470,13 +540,15 @@ export function compileRuntimeContext(input) {
     activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
     agentId = normalizeOptionalString(input.agentId) ?? process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
     runtimeHints = normalizeRuntimeHints(input.runtimeHints);
-    selectionMode = normalizeCompileSelectionMode(input.selectionMode);
     userMessage = normalizeNonEmptyString(input.message, "message");
     maxContextChars =
       input.maxContextChars !== undefined
         ? normalizeNonNegativeInteger(input.maxContextChars, "maxContextChars", input.maxContextChars)
         : undefined;
-    mode = normalizeMode(input.mode);
+    const compileModePlan = resolveCompileModePlan(input.mode, input.selectionMode);
+    comparativeMode = compileModePlan.comparativeMode;
+    mode = compileModePlan.routeMode;
+    selectionMode = compileModePlan.selectionMode;
   } catch (error) {
     result = failOpenCompileResult(
       error,
@@ -518,6 +590,7 @@ export function compileRuntimeContext(input) {
       },
     );
     routeSelectionMs = elapsedMsFrom(routeSelectionStartedAtNs);
+    const selectionEngine = selectionMode ?? "flat_rank_v1";
     const compileResponse = {
       ...compile.response,
       diagnostics: {
@@ -525,6 +598,13 @@ export function compileRuntimeContext(input) {
         notes: uniqueNotes([
           ...compile.response.diagnostics.notes,
           ...resolvedBudget.notes,
+          `selection_engine=${selectionEngine}`,
+          ...(comparativeMode === null
+            ? []
+            : [
+                `comparative_mode=${comparativeMode}`,
+                `comparative_mode_plan=${mode}+${selectionEngine}`,
+              ]),
           "OpenClaw remains the runtime owner",
         ]),
       },

package/dist/src/status-learning-path.js

@@ -7,14 +7,43 @@ function isSeedAwaitingFirstPromotion(status) {
 function normalizeOptionalString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function formatOperatorLearningAttributionSummary({ status }) {
+    const attribution = status?.learningAttribution ?? null;
+    if (!attribution) {
+        return "quality=unavailable source=unavailable detail=no_learning_attribution_surface";
+    }
+    const source = [normalizeOptionalString(attribution.source), normalizeOptionalString(attribution.snapshotKind)]
+        .filter((value) => value !== null)
+        .join("/");
+    if (attribution.available !== true) {
+        return `quality=${normalizeOptionalString(attribution.quality) ?? "unavailable"} source=${source || "unavailable"} detail=${normalizeOptionalString(attribution.detail) ?? "unavailable"}`;
+    }
+    const matchedByMode = attribution.matchedByMode ?? {};
+    return [
+        `quality=${normalizeOptionalString(attribution.quality) ?? "unavailable"}`,
+        `source=${source || "latest_materialization"}`,
+        `nonZero=${attribution.nonZeroObservationCount ?? 0}`,
+        `exact=${attribution.exactMatchCount ?? 0}`,
+        `heuristic=${attribution.heuristicMatchCount ?? 0}`,
+        `unmatched=${attribution.unmatchedCount ?? 0}`,
+        `ambiguous=${attribution.ambiguousCount ?? 0}`,
+        `modes=decision:${matchedByMode.exactDecisionId ?? 0}|digest:${matchedByMode.exactSelectionDigest ?? 0}|compile:${matchedByMode.turnCompileEventId ?? 0}|heuristic:${matchedByMode.legacyHeuristic ?? 0}`
+    ].join(" ");
+}
 export function formatOperatorLearningPathSummary({ status, learningPath, tracedLearning }) {
+    const attribution = status?.learningAttribution ?? null;
     if (!isSeedAwaitingFirstPromotion(status)) {
-        return formatRawLearningPathSummary(learningPath);
+        const rawSummary = formatRawLearningPathSummary(learningPath);
+        const bindingQuality = normalizeOptionalString(attribution?.quality);
+        return bindingQuality === null || bindingQuality === "unavailable"
+            ? rawSummary
+            : `${rawSummary} bindingQuality=${bindingQuality}`;
     }
     const detailParts = [
         "detail=seed_state_awaiting_first_promotion",
         `tracedPg=${normalizeOptionalString(tracedLearning?.pgVersionUsed) ?? "none"}`,
-        `tracedPack=${normalizeOptionalString(tracedLearning?.materializedPackId) ?? "none"}`
+        `tracedPack=${normalizeOptionalString(tracedLearning?.materializedPackId) ?? "none"}`,
+        `bindingQuality=${normalizeOptionalString(attribution?.quality) ?? "unavailable"}`
     ];
     return [
         "source=seed_state",
@@ -26,3 +55,4 @@ export function formatOperatorLearningPathSummary({ status, learningPath, traced
         ...detailParts
     ].join(" ");
 }
+export { formatOperatorLearningAttributionSummary };

package/dist/src/teacher-decision-match.js

@@ -80,6 +80,14 @@ function readInteractionActivePackGraphChecksum(interaction) {
         ?? undefined;
 }
 
+function readInteractionExplicitTurnCompileEventId(interaction) {
+    return normalizeOptionalString(interaction?.turnCompileEventId)
+        ?? normalizeOptionalString(toRecord(interaction?.routeMetadata)?.turnCompileEventId)
+        ?? normalizeOptionalString(toRecord(interaction?.decisionProvenance)?.turnCompileEventId)
+        ?? normalizeOptionalString(toRecord(interaction?.metadata)?.turnCompileEventId)
+        ?? undefined;
+}
+
 function buildDecisionTimestamps(decision) {
     const timestamps = [];
     const turnCreatedAt = toTimestamp(decision.turnCreatedAt);
@@ -139,8 +147,10 @@ export function createServeTimeDecisionMatcher(decisions, options = {}) {
     const decisionsByRecordId = new Map();
     const decisionsBySelectionDigest = new Map();
     const ambiguousSelectionDigests = new Set();
-    const exactDecisions = new Map();
+    const decisionsByTurnCompileEventId = new Map();
+    const ambiguousTurnCompileEventIds = new Set();
     const fallbackDecisions = new Map();
+    const ambiguousFallbackDecisionKeys = new Set();
     const decisionsBySessionChannel = new Map();
     const globalFallbackDecisions = [];
 
@@ -164,15 +174,27 @@ export function createServeTimeDecisionMatcher(decisions, options = {}) {
             }
         }
         const turnCompileEventId = normalizeOptionalString(decision.turnCompileEventId);
-        if (turnCompileEventId !== undefined && !exactDecisions.has(turnCompileEventId)) {
-            exactDecisions.set(turnCompileEventId, decision);
+        if (turnCompileEventId !== undefined) {
+            if (decisionsByTurnCompileEventId.has(turnCompileEventId)) {
+                decisionsByTurnCompileEventId.delete(turnCompileEventId);
+                ambiguousTurnCompileEventIds.add(turnCompileEventId);
+            }
+            else if (!ambiguousTurnCompileEventIds.has(turnCompileEventId)) {
+                decisionsByTurnCompileEventId.set(turnCompileEventId, decision);
+            }
         }
         for (const candidateKey of [
             buildCandidateKey(decision.sessionId, decision.channel, decision.turnCreatedAt),
             buildCandidateKey(decision.sessionId, decision.channel, decision.recordedAt),
         ]) {
-            if (candidateKey !== null && !fallbackDecisions.has(candidateKey)) {
-                fallbackDecisions.set(candidateKey, decision);
+            if (candidateKey !== null) {
+                if (fallbackDecisions.has(candidateKey)) {
+                    fallbackDecisions.delete(candidateKey);
+                    ambiguousFallbackDecisionKeys.add(candidateKey);
+                }
+                else if (!ambiguousFallbackDecisionKeys.has(candidateKey)) {
+                    fallbackDecisions.set(candidateKey, decision);
+                }
             }
         }
         const sessionChannelKey = buildSessionChannelKey(decision.sessionId, decision.channel);
@@ -203,22 +225,37 @@ export function createServeTimeDecisionMatcher(decisions, options = {}) {
         if (decisionRecordId !== undefined) {
             return decisionsByRecordId.get(decisionRecordId) ?? null;
         }
-        const selectionDigestKey = buildSelectionDigestKey(
-            readInteractionSelectionDigest(interaction),
-            readInteractionActivePackGraphChecksum(interaction),
-        );
+        const interactionSelectionDigest = readInteractionSelectionDigest(interaction);
+        const interactionGraphChecksum = readInteractionActivePackGraphChecksum(interaction);
+        const selectionDigestKey = buildSelectionDigestKey(interactionSelectionDigest, interactionGraphChecksum);
         if (selectionDigestKey !== null) {
             if (ambiguousSelectionDigests.has(selectionDigestKey)) {
                 return null;
             }
             return decisionsBySelectionDigest.get(selectionDigestKey) ?? null;
         }
-        const exact = exactDecisions.get(interaction.eventId);
+        if (interactionSelectionDigest !== undefined || interactionGraphChecksum !== undefined) {
+            return null;
+        }
+        const explicitTurnCompileEventId = readInteractionExplicitTurnCompileEventId(interaction);
+        if (explicitTurnCompileEventId !== undefined) {
+            if (ambiguousTurnCompileEventIds.has(explicitTurnCompileEventId)) {
+                return null;
+            }
+            return decisionsByTurnCompileEventId.get(explicitTurnCompileEventId) ?? null;
+        }
+        const softTurnCompileEventId = normalizeOptionalString(interaction.eventId);
+        const exact = softTurnCompileEventId === undefined || ambiguousTurnCompileEventIds.has(softTurnCompileEventId)
+            ? undefined
+            : decisionsByTurnCompileEventId.get(softTurnCompileEventId);
         if (exact !== undefined) {
             return exact;
         }
         const exactFallbackKey = buildCandidateKey(interaction.sessionId, interaction.channel, interaction.createdAt);
         if (exactFallbackKey !== null) {
+            if (ambiguousFallbackDecisionKeys.has(exactFallbackKey)) {
+                return null;
+            }
             const fallback = fallbackDecisions.get(exactFallbackKey);
             if (fallback !== undefined) {
                 return fallback;

package/dist/src/traced-learning-bridge.js

@@ -18,6 +18,22 @@ function normalizeOptionalString(value) {
 function normalizeSource(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function summarizeBridgeSource(value) {
+    const source = normalizeSource(value);
+    if (source === null) {
+        return null;
+    }
+    const summarized = {
+        command: normalizeOptionalString(source.command),
+        bridge: normalizeOptionalString(source.bridge),
+        brainRoot: normalizeOptionalString(source.brainRoot),
+        stateDbPath: normalizeOptionalString(source.stateDbPath),
+        persistedKey: normalizeOptionalString(source.persistedKey),
+        candidatePackVersion: Number.isFinite(source.candidatePackVersion) ? Math.trunc(source.candidatePackVersion) : undefined,
+        candidateUpdateCount: normalizeCount(source.candidateUpdateCount)
+    };
+    return Object.fromEntries(Object.entries(summarized).filter(([, candidate]) => candidate !== null && candidate !== undefined));
+}
 function normalizeBridgePayload(payload) {
     if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
         throw new Error("expected traced-learning bridge payload object");
@@ -579,7 +595,7 @@ export function mergeTracedLearningBridgePayload(payload, persisted) {
                 supervisionCount: persistedBridge.supervisionCount,
                 routerUpdateCount: persistedBridge.routerUpdateCount,
                 teacherArtifactCount: persistedBridge.teacherArtifactCount,
-                source: persistedBridge.source
+                source: summarizeBridgeSource(persistedBridge.source)
             }
         }
     });