@openclawbrain/cli 0.4.13 → 0.4.15

package/dist/src/index.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { compileRuntimeFromActivation } from "@openclawbrain/compiler";
@@ -27,6 +28,27 @@ export const RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT = {
     manifest: "manifest.json",
     payload: "normalized-event-export.json"
 };
+const RECORDED_SESSION_REPLAY_PROOF_MANIFEST_CONTRACT = "recorded_session_replay_proof_manifest.v1";
+const RECORDED_SESSION_REPLAY_PROOF_ENVIRONMENT_CONTRACT = "recorded_session_replay_environment.v1";
+const RECORDED_SESSION_REPLAY_PROOF_SUMMARY_TABLES_CONTRACT = "recorded_session_replay_summary_tables.v1";
+const RECORDED_SESSION_REPLAY_PROOF_COVERAGE_SNAPSHOT_CONTRACT = "recorded_session_replay_coverage_snapshot.v1";
+const RECORDED_SESSION_REPLAY_PROOF_HARDENING_SNAPSHOT_CONTRACT = "recorded_session_replay_hardening_snapshot.v1";
+const RECORDED_SESSION_REPLAY_PROOF_HASHES_CONTRACT = "recorded_session_replay_hashes.v1";
+const RECORDED_SESSION_REPLAY_PROOF_VALIDATION_CONTRACT = "recorded_session_replay_proof_validation.v1";
+const RECORDED_SESSION_REPLAY_MODE_ORDER = ["no_brain", "vector_only", "graph_prior_only", "learned_route"];
+export const RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT = {
+    manifest: "manifest.json",
+    trace: "trace.json",
+    fixture: "fixture.json",
+    bundle: "bundle.json",
+    environment: "environment.json",
+    summary: "summary.md",
+    summaryTables: "summary-tables.json",
+    coverageSnapshot: "coverage-snapshot.json",
+    hardeningSnapshot: "hardening-snapshot.json",
+    hashes: "hashes.json",
+    modeDir: "modes"
+};
 function normalizeRuntimeProfileSelector(value, fieldName, fallback = "current_profile") {
     if (value === undefined || value === null) {
         return fallback;
@@ -1058,6 +1080,24 @@ export function scanLiveEventExport(input) {
 function readJsonFile(filePath) {
     return JSON.parse(readFileSync(filePath, "utf8"));
 }
+function checksumTextPayload(value) {
+    return `sha256-${createHash("sha256").update(value).digest("hex")}`;
+}
+function orderedRecordedSessionReplayModes(modes) {
+    const byMode = new Map(modes.map((mode) => [mode.mode, mode]));
+    return RECORDED_SESSION_REPLAY_MODE_ORDER
+        .map((mode) => byMode.get(mode))
+        .filter(isPresent);
+}
+function recordedSessionReplayModeOutputPath(mode) {
+    return path.posix.join(RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.modeDir, `${mode}.json`);
+}
+function resolveRecordedSessionReplayProofPath(rootDir, relativePath, fieldName) {
+    return resolveBundlePayloadPath(rootDir, normalizeNonEmptyString(relativePath, fieldName));
+}
+function readRecordedSessionReplayProofText(rootDir, relativePath, fieldName) {
+    return readFileSync(resolveRecordedSessionReplayProofPath(rootDir, relativePath, fieldName), "utf8");
+}
 export function resolveAsyncTeacherLiveLoopSnapshotPath(activationRoot) {
     return path.join(path.resolve(normalizeNonEmptyString(activationRoot, "activationRoot")), "async-teacher-live-loop.snapshot.json");
 }
@@ -2340,8 +2380,61 @@ function normalizeIsoTimestamp(value, fieldName, fallbackValue) {
     }
     return new Date(candidate).toISOString();
 }
-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) {
     if (value === undefined) {
@@ -2681,8 +2774,9 @@ function appendCompileServeRouteDecisionLog(input) {
     if (input.compileInput.budgetStrategy === "fixed_v1" || input.compileInput.budgetStrategy === "empirical_v1") {
         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) {
         syntheticTurn.runtimeHints = input.compileInput.runtimeHints;
@@ -2936,16 +3030,42 @@ export function resolveActivePackForCompile(activationRoot) {
         inspection: inspection.active
     };
 }
+function normalizeFrozenReplayEvalIdentity(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "object") {
+        throw new Error("_frozenReplayEvalIdentity must be an object");
+    }
+    const frozenIdentity = value;
+    return {
+        packId: normalizeNonEmptyString(frozenIdentity.packId, "_frozenReplayEvalIdentity.packId"),
+        routerIdentity: normalizeOptionalString(frozenIdentity.routerIdentity) ?? null
+    };
+}
+function validateFrozenReplayEvalIdentity(target, frozenReplayEvalIdentity) {
+    if (frozenReplayEvalIdentity === null) {
+        return;
+    }
+    const actualRouterIdentity = target.inspection.routerIdentity ?? null;
+    if (target.activePointer.packId === frozenReplayEvalIdentity.packId &&
+        actualRouterIdentity === frozenReplayEvalIdentity.routerIdentity) {
+        return;
+    }
+    throw new Error(`Frozen replay eval identity mismatch: expected pack ${frozenReplayEvalIdentity.packId} (routerIdentity=${frozenReplayEvalIdentity.routerIdentity ?? "null"}), received pack ${target.activePointer.packId} (routerIdentity=${actualRouterIdentity ?? "null"})`);
+}
 export function compileRuntimeContext(input) {
     const totalStartedAtNs = monotonicClockNs();
     const fallbackActivationRoot = resolveActivationRootForFailure(input.activationRoot);
     let activationRoot = fallbackActivationRoot;
     let agentId = process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
     let runtimeHints = [];
+    let comparativeMode = null;
     let selectionMode;
     let userMessage = "";
     let maxContextChars;
     let mode = "heuristic";
+    let frozenReplayEvalIdentity = null;
     let routeSelectionStartedAtNs = null;
     let routeSelectionMs = null;
     let promptAssemblyStartedAtNs = null;
@@ -2955,13 +3075,16 @@ 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;
+        frozenReplayEvalIdentity = normalizeFrozenReplayEvalIdentity(input._frozenReplayEvalIdentity);
     }
     catch (error) {
         result = failOpenCompileResult(error, fallbackActivationRoot, buildBrainServeHotPathTiming({
@@ -2979,6 +3102,7 @@ export function compileRuntimeContext(input) {
     }
     try {
         const target = resolveActivePackForCompile(activationRoot);
+        validateFrozenReplayEvalIdentity(target, frozenReplayEvalIdentity);
         const resolvedBudget = resolveCompileBudget(target, input);
         routeSelectionStartedAtNs = monotonicClockNs();
         const compile = compileRuntimeFromActivation(activationRoot, {
@@ -2995,11 +3119,29 @@ export function compileRuntimeContext(input) {
             ...(selectionMode !== undefined ? { selectionMode } : {})
         });
         routeSelectionMs = elapsedMsFrom(routeSelectionStartedAtNs);
+        const selectionEngine = selectionMode ?? "flat_rank_v1";
         const compileResponse = {
             ...compile.response,
             diagnostics: {
                 ...compile.response.diagnostics,
-                notes: uniqueNotes([...compile.response.diagnostics.notes, ...resolvedBudget.notes, "OpenClaw remains the runtime owner"])
+                notes: uniqueNotes([
+                    ...compile.response.diagnostics.notes,
+                    ...resolvedBudget.notes,
+                    `selection_engine=${selectionEngine}`,
+                    ...(comparativeMode === null
+                        ? []
+                        : [
+                            `comparative_mode=${comparativeMode}`,
+                            `comparative_mode_plan=${mode}+${selectionEngine}`
+                        ]),
+                    ...(frozenReplayEvalIdentity === null
+                        ? []
+                        : [
+                            `replay_eval_pack_id=${frozenReplayEvalIdentity.packId}`,
+                            `replay_eval_router_identity=${frozenReplayEvalIdentity.routerIdentity ?? "null"}`
+                        ]),
+                    "OpenClaw remains the runtime owner"
+                ])
             }
         };
         promptAssemblyStartedAtNs = monotonicClockNs();
@@ -3882,6 +4024,7 @@ export function runRuntimeTurn(turn, options = {}) {
         ...(turn.mode !== undefined ? { mode: turn.mode } : {}),
         ...(turn.selectionMode !== undefined ? { selectionMode: turn.selectionMode } : {}),
         ...(turn.runtimeHints !== undefined ? { runtimeHints: turn.runtimeHints } : {}),
+        ...(options._frozenReplayEvalIdentity !== undefined ? { _frozenReplayEvalIdentity: options._frozenReplayEvalIdentity } : {}),
         _suppressServeLog: true
     };
     const compileResult = compileRuntimeContext(compileInput);
@@ -4130,6 +4273,7 @@ function ensureRecordedSessionTrace(trace) {
     if (trace.turns.length === 0) {
         throw new Error("recorded session trace requires at least one turn");
     }
+    resolveRecordedSessionReplayEvalTurnCount(trace.turns.length, trace.evalTurnCount, "evalTurnCount");
     for (const [index, cue] of trace.seedCues.entries()) {
         normalizeNonEmptyString(cue.cueId, `seedCues[${index}].cueId`);
         normalizeIsoTimestamp(cue.createdAt, `seedCues[${index}].createdAt`);
@@ -4181,6 +4325,52 @@ function uniqueStringsInOrder(values) {
     }
     return unique;
 }
+function resolveRecordedSessionReplayEvalTurnCount(turnCount, value, fieldName) {
+    if (turnCount === 0) {
+        return 0;
+    }
+    if (value === undefined) {
+        return 1;
+    }
+    const normalized = normalizeNonNegativeInteger(value, fieldName, value);
+    if (normalized < 1) {
+        throw new Error(`${fieldName} must be at least 1 when turns are present`);
+    }
+    if (normalized > turnCount) {
+        throw new Error(`${fieldName} cannot exceed turns.length (${turnCount})`);
+    }
+    return normalized;
+}
+function buildRecordedSessionReplayTurnPlan(fixture) {
+    const evalTurnCount = resolveRecordedSessionReplayEvalTurnCount(fixture.turns.length, fixture.evalTurnCount, "evalTurnCount");
+    const trainTurnCount = Math.max(0, fixture.turns.length - evalTurnCount);
+    return {
+        trainTurns: fixture.turns.slice(0, trainTurnCount),
+        evalTurns: fixture.turns.slice(trainTurnCount),
+        trainTurnCount,
+        evalTurnCount
+    };
+}
+function cloneRecordedSessionReplayFrozenEvalIdentity(value) {
+    if (value === null) {
+        return null;
+    }
+    return {
+        packId: value.packId,
+        routerIdentity: value.routerIdentity
+    };
+}
+function readRecordedSessionReplayFrozenEvalIdentity(activationRoot) {
+    const inspection = inspectActivationState(activationRoot);
+    const activePointer = inspection.pointers.active;
+    if (inspection.active === null || activePointer === null) {
+        return null;
+    }
+    return {
+        packId: activePointer.packId,
+        routerIdentity: inspection.active.routerIdentity ?? null
+    };
+}
 function buildRecordedSessionSeedExport(trace) {
     const agentId = normalizeOptionalString(trace.agentId) ?? DEFAULT_AGENT_ID;
     const seedSessionId = `${trace.sessionId}-seed`;
@@ -4292,6 +4482,9 @@ function recordedSessionFixtureBase(trace) {
             revision: trace.workspace.revision,
             ...(trace.workspace.labels !== undefined ? { labels: [...trace.workspace.labels] } : {})
         },
+        ...(trace.evalTurnCount !== undefined
+            ? { evalTurnCount: resolveRecordedSessionReplayEvalTurnCount(trace.turns.length, trace.evalTurnCount, "evalTurnCount") }
+            : {}),
         seedBuiltAt: trace.seedBuiltAt,
         seedActivatedAt: trace.seedActivatedAt,
         seedExport: buildRecordedSessionSeedExport(trace),
@@ -4327,6 +4520,9 @@ function recordedSessionReplayFixtureBase(fixture) {
             revision: fixture.workspace.revision,
             ...(fixture.workspace.labels !== undefined ? { labels: [...fixture.workspace.labels] } : {})
         },
+        ...(fixture.evalTurnCount !== undefined
+            ? { evalTurnCount: resolveRecordedSessionReplayEvalTurnCount(fixture.turns.length, fixture.evalTurnCount, "evalTurnCount") }
+            : {}),
         seedBuiltAt: fixture.seedBuiltAt,
         seedActivatedAt: fixture.seedActivatedAt,
         seedExport: fixture.seedExport,
@@ -4377,7 +4573,49 @@ function buildRecordedSessionTurnObservability(result) {
         freshestCreatedAt: observability.teacherFreshness.freshestCreatedAt ?? freshestSource?.freshestCreatedAt ?? null
     };
 }
-function buildRecordedSessionTurnReport(turnFixture, result, options) {
+const RECORDED_SESSION_REPLAY_MODE_PLAN = {
+    no_brain: {
+        activationStrategy: "no_brain",
+        runtimeMode: null,
+        routeModeRequested: null,
+        selectionEngine: null,
+        learnedRouting: false
+    },
+    vector_only: {
+        activationStrategy: "seed_pack",
+        runtimeMode: "vector_only",
+        routeModeRequested: "heuristic",
+        selectionEngine: "flat_rank_v1",
+        learnedRouting: false
+    },
+    graph_prior_only: {
+        activationStrategy: "seed_pack",
+        runtimeMode: "graph_prior_only",
+        routeModeRequested: "heuristic",
+        selectionEngine: "graph_walk_v1",
+        learnedRouting: false
+    },
+    learned_route: {
+        activationStrategy: "continuous_learned_loop",
+        runtimeMode: "learned_route",
+        routeModeRequested: "learned",
+        selectionEngine: "graph_walk_v1",
+        learnedRouting: true
+    }
+};
+function recordedSessionReplayModePlan(mode) {
+    return RECORDED_SESSION_REPLAY_MODE_PLAN[mode];
+}
+function buildRecordedSessionReplayTurnInput(turnFixture, modeRoot, replayMode) {
+    const plan = recordedSessionReplayModePlan(replayMode);
+    return {
+        ...turnFixture.turn,
+        ...(plan.runtimeMode === null ? {} : { mode: plan.runtimeMode }),
+        export: buildRecordedSessionTurnExportRoot(modeRoot, turnFixture.turnId)
+    };
+}
+function buildRecordedSessionTurnReport(replayMode, turnFixture, result, options) {
+    const plan = recordedSessionReplayModePlan(replayMode);
     const compileOk = result.ok;
     const selectedContextTexts = compileOk ? result.compileResponse.selectedContext.map((block) => block.text) : [];
     const selectedContextIds = compileOk ? result.compileResponse.selectedContext.map((block) => block.id) : [];
@@ -4390,10 +4628,15 @@ function buildRecordedSessionTurnReport(turnFixture, result, options) {
     const eventExportDigest = result.eventExport.ok === true ? result.eventExport.normalizedEventExport.provenance.exportDigest : null;
     return {
         turnId: turnFixture.turnId,
+        replayMode,
+        phase: options.phase,
         compileOk,
         fallbackToStaticContext: result.fallbackToStaticContext,
         hardRequirementViolated: result.hardRequirementViolated,
         activePackId: result.ok ? result.activePackId : null,
+        modeRequested: plan.routeModeRequested,
+        modeEffective: result.ok ? result.compileResponse.diagnostics.modeEffective : null,
+        selectionEngine: plan.selectionEngine,
         usedLearnedRouteFn: result.ok ? result.compileResponse.diagnostics.usedLearnedRouteFn : false,
         routerIdentity: result.ok ? result.compileResponse.diagnostics.routerIdentity : null,
         selectionDigest: result.ok ? result.compileResponse.diagnostics.selectionDigest : null,
@@ -4447,7 +4690,7 @@ function buildRecordedSessionReplayScannerWarnings(mode, turns, activePackChange
     if (turns.some((turn) => turn.compileOk) && selectionDigestTurnCount === 0) {
         warnings.push("selection_digest_missing");
     }
-    if (mode === "learned_replay" && activePackChangeCount === 0) {
+    if (mode === "learned_route" && activePackChangeCount === 0) {
         warnings.push("active_pack_never_moved");
     }
     return warnings;
@@ -4479,17 +4722,33 @@ function buildRecordedSessionReplayScannerEvidence(mode, turns) {
         warnings: buildRecordedSessionReplayScannerWarnings(mode, turns, activePackChangeCount)
     };
 }
-function buildRecordedSessionReplayModeSummary(mode, turns) {
+function buildRecordedSessionReplayModeQualityScore(turns, compileOkCount, phraseHitCount, phraseCount) {
+    if (turns.length === 0) {
+        return 0;
+    }
+    // Score mode quality from aggregate replay coverage so multi-phrase turns
+    // keep their full weight instead of being flattened into a per-turn average.
+    const compileScore = (compileOkCount / turns.length) * 40;
+    const phraseScore = phraseCount === 0 ? 60 : (phraseHitCount / phraseCount) * 60;
+    return Math.min(100, Math.round(compileScore + phraseScore));
+}
+function buildRecordedSessionReplayModeSummary(mode, turns, options = {}) {
+    const plan = recordedSessionReplayModePlan(mode);
     const compileOkCount = turns.filter((turn) => turn.compileOk).length;
     const phraseHitCount = turns.reduce((sum, turn) => sum + turn.phraseHits.length, 0);
     const phraseCount = turns.reduce((sum, turn) => sum + turn.expectedContextPhrases.length, 0);
     const usedLearnedRouteTurnCount = turns.filter((turn) => turn.usedLearnedRouteFn).length;
     const promotionCount = turns.filter((turn) => turn.promoted).length;
-    const qualityScore = turns.length === 0 ? 0 : Math.round(turns.reduce((sum, turn) => sum + turn.qualityScore, 0) / turns.length);
+    const qualityScore = buildRecordedSessionReplayModeQualityScore(turns, compileOkCount, phraseHitCount, phraseCount);
     const packIds = uniqueStringsInOrder(turns.map((turn) => turn.activePackId).filter(isPresent));
+    const trainTurnCount = turns.filter((turn) => turn.phase === "train").length;
+    const evalTurnCount = turns.filter((turn) => turn.phase === "eval").length;
     const scannerEvidence = buildRecordedSessionReplayScannerEvidence(mode, turns);
     const base = {
         mode,
+        activationStrategy: plan.activationStrategy,
+        modeRequested: plan.routeModeRequested,
+        selectionEngine: plan.selectionEngine,
         qualityScore,
         compileOkCount,
         phraseHitCount,
@@ -4497,6 +4756,10 @@ function buildRecordedSessionReplayModeSummary(mode, turns) {
         usedLearnedRouteTurnCount,
         promotionCount,
         packIds,
+        trainTurnCount,
+        evalTurnCount,
+        frozenEvalPackId: options.frozenEvalIdentity?.packId ?? null,
+        frozenEvalRouterIdentity: options.frozenEvalIdentity?.routerIdentity ?? null,
         scannerEvidence
     };
     return {
@@ -4505,10 +4768,15 @@ function buildRecordedSessionReplayModeSummary(mode, turns) {
             summary: base,
             turns: turns.map((turn) => ({
                 turnId: turn.turnId,
+                phase: turn.phase,
                 qualityScore: turn.qualityScore,
                 phraseHits: turn.phraseHits,
                 missedPhrases: turn.missedPhrases,
                 compileOk: turn.compileOk,
+                replayMode: turn.replayMode,
+                modeRequested: turn.modeRequested,
+                modeEffective: turn.modeEffective,
+                selectionEngine: turn.selectionEngine,
                 usedLearnedRouteFn: turn.usedLearnedRouteFn,
                 activePackId: turn.activePackId,
                 selectionDigest: turn.selectionDigest,
@@ -4518,16 +4786,19 @@ function buildRecordedSessionReplayModeSummary(mode, turns) {
         })
     };
 }
-function buildRecordedSessionReplayModeReport(mode, turns) {
+function buildRecordedSessionReplayModeReport(mode, turns, options = {}) {
     return {
         mode,
-        summary: buildRecordedSessionReplayModeSummary(mode, turns),
+        summary: buildRecordedSessionReplayModeSummary(mode, turns, options),
         turns: [...turns]
     };
 }
 function buildRecordedSessionReplayScoreHash(modes) {
     return checksumJsonPayload(modes.map((mode) => ({
         mode: mode.mode,
+        activationStrategy: mode.summary.activationStrategy,
+        modeRequested: mode.summary.modeRequested,
+        selectionEngine: mode.summary.selectionEngine,
         qualityScore: mode.summary.qualityScore,
         compileOkCount: mode.summary.compileOkCount,
         phraseHitCount: mode.summary.phraseHitCount,
@@ -4535,6 +4806,10 @@ function buildRecordedSessionReplayScoreHash(modes) {
         usedLearnedRouteTurnCount: mode.summary.usedLearnedRouteTurnCount,
         promotionCount: mode.summary.promotionCount,
         packIds: mode.summary.packIds,
+        trainTurnCount: mode.summary.trainTurnCount,
+        evalTurnCount: mode.summary.evalTurnCount,
+        frozenEvalPackId: mode.summary.frozenEvalPackId,
+        frozenEvalRouterIdentity: mode.summary.frozenEvalRouterIdentity,
         scannerEvidence: mode.summary.scannerEvidence,
         scoreHash: mode.summary.scoreHash
     })));
@@ -4625,45 +4900,42 @@ function runRecordedSessionNoBrainMode(rootDir, fixture) {
     const modeRoot = prepareReplayModeRoot(rootDir, "no_brain");
     const activationRoot = path.join(modeRoot, "activation");
     const turns = fixture.turns.map((turnFixture) => {
-        const result = runRuntimeTurn({
-            ...turnFixture.turn,
-            export: buildRecordedSessionTurnExportRoot(modeRoot, turnFixture.turnId)
-        }, {
+        const result = runRuntimeTurn(buildRecordedSessionReplayTurnInput(turnFixture, modeRoot, "no_brain"), {
             activationRoot,
             failOpen: true
         });
-        return buildRecordedSessionTurnReport(turnFixture, result, {
+        return buildRecordedSessionTurnReport("no_brain", turnFixture, result, {
+            phase: "eval",
             compileActiveVersion: null,
             promoted: false
         });
     });
     return buildRecordedSessionReplayModeReport("no_brain", turns);
 }
-function runRecordedSessionSeedPackMode(rootDir, fixture) {
-    const modeRoot = prepareReplayModeRoot(rootDir, "seed_pack");
+function runRecordedSessionSeededComparativeMode(rootDir, fixture, replayMode) {
+    const modeRoot = prepareReplayModeRoot(rootDir, replayMode);
     const { activationRoot } = prepareSeedActivation(modeRoot, fixture);
     const turns = fixture.turns.map((turnFixture) => {
-        const result = runRuntimeTurn({
-            ...turnFixture.turn,
-            export: buildRecordedSessionTurnExportRoot(modeRoot, turnFixture.turnId)
-        }, {
+        const result = runRuntimeTurn(buildRecordedSessionReplayTurnInput(turnFixture, modeRoot, replayMode), {
             activationRoot,
             failOpen: false
         });
-        return buildRecordedSessionTurnReport(turnFixture, result, {
+        return buildRecordedSessionTurnReport(replayMode, turnFixture, result, {
+            phase: "eval",
             compileActiveVersion: 1,
             promoted: false
         });
     });
-    return buildRecordedSessionReplayModeReport("seed_pack", turns);
+    return buildRecordedSessionReplayModeReport(replayMode, turns);
 }
-function runRecordedSessionLearnedReplayMode(rootDir, fixture) {
-    const modeRoot = prepareReplayModeRoot(rootDir, "learned_replay");
+function runRecordedSessionLearnedRouteMode(rootDir, fixture) {
+    const modeRoot = prepareReplayModeRoot(rootDir, "learned_route");
     const { activationRoot } = prepareSeedActivation(modeRoot, fixture);
     const loopRoot = path.join(modeRoot, "loop");
+    const turnPlan = buildRecordedSessionReplayTurnPlan(fixture);
     let state;
     const turns = [];
-    for (const turnFixture of fixture.turns) {
+    for (const turnFixture of turnPlan.trainTurns) {
         const compileCreatedAt = normalizeIsoTimestamp(turnFixture.turn.compile?.createdAt, "turn.compile.createdAt", turnFixture.turn.createdAt);
         const result = runContinuousProductLoopTurn({
             activationRoot,
@@ -4682,12 +4954,40 @@ function runRecordedSessionLearnedReplayMode(rootDir, fixture) {
             promoteUpdatedAt: addMinutes(compileCreatedAt, 4)
         });
         state = result.state;
-        turns.push(buildRecordedSessionTurnReport(turnFixture, result.turn, {
+        turns.push(buildRecordedSessionTurnReport("learned_route", turnFixture, result.turn, {
+            phase: "train",
             compileActiveVersion: result.compileActiveVersion,
             promoted: result.learning.promoted
         }));
     }
-    return buildRecordedSessionReplayModeReport("learned_replay", turns);
+    const frozenEvalIdentity = readRecordedSessionReplayFrozenEvalIdentity(activationRoot);
+    for (const turnFixture of turnPlan.evalTurns) {
+        const currentState = cloneContinuousProductLoopState(state ??
+            createContinuousProductLoopState({
+                activationRoot,
+                loopRoot
+            }));
+        currentState.activationRoot = activationRoot;
+        currentState.loopRoot = loopRoot;
+        const activeBeforeTurn = syncContinuousActivePack(currentState);
+        state = cloneContinuousProductLoopState(currentState);
+        const result = runRuntimeTurn({
+            ...turnFixture.turn,
+            export: buildRecordedSessionTurnExportRoot(modeRoot, turnFixture.turnId)
+        }, {
+            activationRoot,
+            failOpen: false,
+            ...(frozenEvalIdentity === null ? {} : { _frozenReplayEvalIdentity: frozenEvalIdentity })
+        });
+        turns.push(buildRecordedSessionTurnReport("learned_route", turnFixture, result, {
+            phase: "eval",
+            compileActiveVersion: activeBeforeTurn?.version ?? 0,
+            promoted: false
+        }));
+    }
+    return buildRecordedSessionReplayModeReport("learned_route", turns, {
+        frozenEvalIdentity: cloneRecordedSessionReplayFrozenEvalIdentity(frozenEvalIdentity)
+    });
 }
 export function runRecordedSessionReplay(rootDir, fixture) {
     const resolvedRoot = path.resolve(normalizeNonEmptyString(rootDir, "rootDir"));
@@ -4701,8 +5001,9 @@ export function runRecordedSessionReplay(rootDir, fixture) {
     }
     const modes = [
         runRecordedSessionNoBrainMode(resolvedRoot, fixture),
-        runRecordedSessionSeedPackMode(resolvedRoot, fixture),
-        runRecordedSessionLearnedReplayMode(resolvedRoot, fixture)
+        runRecordedSessionSeededComparativeMode(resolvedRoot, fixture, "vector_only"),
+        runRecordedSessionSeededComparativeMode(resolvedRoot, fixture, "graph_prior_only"),
+        runRecordedSessionLearnedRouteMode(resolvedRoot, fixture)
     ];
     const ranking = modes
         .map((mode) => ({
@@ -4754,7 +5055,14 @@ function rescoreRecordedSessionReplayTurn(turn) {
 }
 function rescoreRecordedSessionReplayMode(mode) {
     const turns = mode.turns.map((turn) => rescoreRecordedSessionReplayTurn(turn));
-    return buildRecordedSessionReplayModeReport(mode.mode, turns);
+    return buildRecordedSessionReplayModeReport(mode.mode, turns, {
+        frozenEvalIdentity: mode.summary.frozenEvalPackId === null
+            ? null
+            : {
+                packId: mode.summary.frozenEvalPackId,
+                routerIdentity: mode.summary.frozenEvalRouterIdentity ?? null
+            }
+    });
 }
 export function rescoreRecordedSessionReplayBundle(bundle) {
     const modes = bundle.modes.map((mode) => rescoreRecordedSessionReplayMode(mode));
@@ -4775,6 +5083,558 @@ export function verifyRecordedSessionReplayBundleHashes(bundle) {
         scoreHashMatches: rescored.scoreHash === bundle.scoreHash
     };
 }
+function buildRecordedSessionReplayProofEnvironment() {
+    return {
+        contract: RECORDED_SESSION_REPLAY_PROOF_ENVIRONMENT_CONTRACT,
+        runtimeOwner: "openclaw",
+        generator: {
+            packageName: "@openclawbrain/cli",
+            entrypoint: "writeRecordedSessionReplayProofBundle",
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch
+        },
+        determinism: {
+            hashAlgorithm: "sha256",
+            canonicalJson: true,
+            modeOrder: [...RECORDED_SESSION_REPLAY_MODE_ORDER],
+            scratchReplayRoot: "temporary_directory"
+        }
+    };
+}
+function toRecordedSessionReplayProofRate(numerator, denominator) {
+    return denominator > 0 ? Number((numerator / denominator).toFixed(6)) : null;
+}
+function buildRecordedSessionReplayProofSummaryTables(bundle) {
+    const orderedModes = orderedRecordedSessionReplayModes(bundle.modes);
+    return {
+        contract: RECORDED_SESSION_REPLAY_PROOF_SUMMARY_TABLES_CONTRACT,
+        traceId: bundle.traceId,
+        winnerMode: bundle.summary.winnerMode,
+        ranking: bundle.summary.ranking.map((entry) => ({ ...entry })),
+        modes: orderedModes.map((mode) => ({
+            mode: mode.mode,
+            turnCount: mode.turns.length,
+            qualityScore: mode.summary.qualityScore,
+            compileOkCount: mode.summary.compileOkCount,
+            phraseHitCount: mode.summary.phraseHitCount,
+            phraseCount: mode.summary.phraseCount,
+            usedLearnedRouteTurnCount: mode.summary.usedLearnedRouteTurnCount,
+            promotionCount: mode.summary.promotionCount,
+            exportTurnCount: mode.summary.scannerEvidence.exportTurnCount,
+            humanLabelCount: mode.summary.scannerEvidence.humanLabelCount,
+            attributedTurnCount: mode.summary.scannerEvidence.attributedTurnCount,
+            activePackChangeCount: mode.summary.scannerEvidence.activePackChangeCount,
+            warningCount: mode.summary.scannerEvidence.warnings.length,
+            scoreHash: mode.summary.scoreHash
+        })),
+        turns: orderedModes.flatMap((mode) => mode.turns.map((turn) => ({
+            mode: mode.mode,
+            turnId: turn.turnId,
+            qualityScore: turn.qualityScore,
+            compileOk: turn.compileOk,
+            phraseHitCount: turn.phraseHits.length,
+            phraseCount: turn.expectedContextPhrases.length,
+            usedLearnedRouteFn: turn.usedLearnedRouteFn,
+            promoted: turn.promoted,
+            activePackId: turn.activePackId,
+            selectionDigest: turn.selectionDigest,
+            eventExportDigest: turn.eventExportDigest,
+            warningCount: turn.warnings.length
+        })))
+    };
+}
+function buildRecordedSessionReplayProofCoverageSnapshot(bundle) {
+    const orderedModes = orderedRecordedSessionReplayModes(bundle.modes);
+    const totalTurns = orderedModes.reduce((sum, mode) => sum + mode.turns.length, 0);
+    const compileOkTurnCount = orderedModes.reduce((sum, mode) => sum + mode.summary.compileOkCount, 0);
+    const phraseHitCount = orderedModes.reduce((sum, mode) => sum + mode.summary.phraseHitCount, 0);
+    const phraseCount = orderedModes.reduce((sum, mode) => sum + mode.summary.phraseCount, 0);
+    return {
+        contract: RECORDED_SESSION_REPLAY_PROOF_COVERAGE_SNAPSHOT_CONTRACT,
+        traceId: bundle.traceId,
+        winnerMode: bundle.summary.winnerMode,
+        totalTurns,
+        compileOkTurnCount,
+        compileOkRate: toRecordedSessionReplayProofRate(compileOkTurnCount, totalTurns),
+        phraseHitCount,
+        phraseCount,
+        phraseHitRate: toRecordedSessionReplayProofRate(phraseHitCount, phraseCount),
+        modes: orderedModes.map((mode) => ({
+            mode: mode.mode,
+            turnCount: mode.turns.length,
+            compileOkRate: toRecordedSessionReplayProofRate(mode.summary.compileOkCount, mode.turns.length),
+            phraseHitRate: toRecordedSessionReplayProofRate(mode.summary.phraseHitCount, mode.summary.phraseCount),
+            learnedRouteTurnRate: toRecordedSessionReplayProofRate(mode.summary.usedLearnedRouteTurnCount, mode.turns.length),
+            attributedTurnRate: toRecordedSessionReplayProofRate(mode.summary.scannerEvidence.attributedTurnCount, mode.turns.length)
+        }))
+    };
+}
+function buildRecordedSessionReplayProofHardeningSnapshot(bundle) {
+    const orderedModes = orderedRecordedSessionReplayModes(bundle.modes);
+    const totalTurns = orderedModes.reduce((sum, mode) => sum + mode.turns.length, 0);
+    const compileFailureCount = orderedModes.reduce((sum, mode) => sum + (mode.turns.length - mode.summary.compileOkCount), 0);
+    const warningCount = orderedModes.reduce((sum, mode) => sum + mode.summary.scannerEvidence.warnings.length, 0);
+    const promotionCount = orderedModes.reduce((sum, mode) => sum + mode.summary.promotionCount, 0);
+    const exportTurnCount = orderedModes.reduce((sum, mode) => sum + mode.summary.scannerEvidence.exportTurnCount, 0);
+    const attributedTurnCount = orderedModes.reduce((sum, mode) => sum + mode.summary.scannerEvidence.attributedTurnCount, 0);
+    return {
+        contract: RECORDED_SESSION_REPLAY_PROOF_HARDENING_SNAPSHOT_CONTRACT,
+        traceId: bundle.traceId,
+        totalTurns,
+        compileFailureCount,
+        compileFailureRate: toRecordedSessionReplayProofRate(compileFailureCount, totalTurns),
+        warningCount,
+        promotionCount,
+        exportTurnCount,
+        attributedTurnCount,
+        modes: orderedModes.map((mode) => ({
+            mode: mode.mode,
+            warningCount: mode.summary.scannerEvidence.warnings.length,
+            compileFailureCount: mode.turns.length - mode.summary.compileOkCount,
+            promotionCount: mode.summary.promotionCount,
+            exportTurnCount: mode.summary.scannerEvidence.exportTurnCount,
+            attributedTurnCount: mode.summary.scannerEvidence.attributedTurnCount
+        }))
+    };
+}
+function buildRecordedSessionReplayProofSummary(input) {
+    const rankingRows = input.summaryTables.ranking.map((entry, index) => `| ${index + 1} | ${entry.mode} | ${entry.qualityScore} |`);
+    const modeRows = input.summaryTables.modes.map((mode) => `| ${mode.mode} | ${mode.turnCount} | ${mode.compileOkCount} | ${mode.phraseHitCount}/${mode.phraseCount} | ${mode.usedLearnedRouteTurnCount} | ${mode.promotionCount} | ${mode.exportTurnCount} | ${mode.humanLabelCount} | ${mode.warningCount} | ${mode.scoreHash} |`);
+    const turnRows = input.summaryTables.turns.map((turn) => `| ${turn.mode} | ${turn.turnId} | ${turn.qualityScore} | ${turn.compileOk ? "yes" : "no"} | ${turn.phraseHitCount}/${turn.phraseCount} | ${turn.usedLearnedRouteFn ? "yes" : "no"} | ${turn.promoted ? "yes" : "no"} | ${turn.activePackId ?? "none"} | ${turn.selectionDigest ?? "none"} |`);
+    const coverageRows = input.coverageSnapshot.modes.map((mode) => `| ${mode.mode} | ${mode.turnCount} | ${mode.compileOkRate ?? "none"} | ${mode.phraseHitRate ?? "none"} | ${mode.learnedRouteTurnRate ?? "none"} | ${mode.attributedTurnRate ?? "none"} |`);
+    const hardeningRows = input.hardeningSnapshot.modes.map((mode) => `| ${mode.mode} | ${mode.warningCount} | ${mode.compileFailureCount} | ${mode.promotionCount} | ${mode.exportTurnCount} | ${mode.attributedTurnCount} |`);
+    return [
+        "# Recorded Session Replay Proof Bundle",
+        "",
+        `- trace id: \`${input.bundle.traceId}\``,
+        `- winner mode: \`${input.bundle.summary.winnerMode ?? "none"}\``,
+        `- trace hash: \`${input.semanticHashes.traceHash}\``,
+        `- fixture hash: \`${input.semanticHashes.fixtureHash}\``,
+        `- score hash: \`${input.semanticHashes.scoreHash}\``,
+        `- bundle hash: \`${input.semanticHashes.bundleHash}\``,
+        "",
+        "## Ranking",
+        "| rank | mode | quality score |",
+        "| --- | --- | ---: |",
+        ...(rankingRows.length === 0 ? ["| - | none | 0 |"] : rankingRows),
+        "",
+        "## Coverage Snapshot",
+        `- compile ok turns: ${input.coverageSnapshot.compileOkTurnCount}/${input.coverageSnapshot.totalTurns}`,
+        `- compile ok rate: ${input.coverageSnapshot.compileOkRate ?? "none"}`,
+        `- phrase hits: ${input.coverageSnapshot.phraseHitCount}/${input.coverageSnapshot.phraseCount}`,
+        `- phrase hit rate: ${input.coverageSnapshot.phraseHitRate ?? "none"}`,
+        "",
+        "| mode | turns | compile ok rate | phrase hit rate | learned route turn rate | attributed turn rate |",
+        "| --- | ---: | ---: | ---: | ---: | ---: |",
+        ...(coverageRows.length === 0 ? ["| - | 0 | none | none | none | none |"] : coverageRows),
+        "",
+        "## Hardening Snapshot",
+        `- compile failures: ${input.hardeningSnapshot.compileFailureCount}/${input.hardeningSnapshot.totalTurns}`,
+        `- compile failure rate: ${input.hardeningSnapshot.compileFailureRate ?? "none"}`,
+        `- warnings: ${input.hardeningSnapshot.warningCount}`,
+        `- promotions: ${input.hardeningSnapshot.promotionCount}`,
+        "",
+        "| mode | warnings | compile failures | promotions | export turns | attributed turns |",
+        "| --- | ---: | ---: | ---: | ---: | ---: |",
+        ...(hardeningRows.length === 0 ? ["| - | 0 | 0 | 0 | 0 | 0 |"] : hardeningRows),
+        "",
+        "## Mode Table",
+        "| mode | turns | compile ok | phrase hits | learned route turns | promotions | export turns | human labels | warnings | score hash |",
+        "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |",
+        ...(modeRows.length === 0 ? ["| - | 0 | 0 | 0/0 | 0 | 0 | 0 | 0 | 0 | none |"] : modeRows),
+        "",
+        "## Turn Table",
+        "| mode | turn | quality | compile ok | phrase hits | learned route | promoted | active pack | selection digest |",
+        "| --- | --- | ---: | --- | ---: | --- | --- | --- | --- |",
+        ...(turnRows.length === 0 ? ["| - | none | 0 | no | 0/0 | no | no | none | none |"] : turnRows),
+        ""
+    ].join("\n");
+}
+function buildRecordedSessionReplayProofManifest(bundle) {
+    return {
+        contract: RECORDED_SESSION_REPLAY_PROOF_MANIFEST_CONTRACT,
+        traceId: bundle.traceId,
+        source: bundle.source,
+        recordedAt: bundle.recordedAt,
+        generatedAt: bundle.generatedAt,
+        hashAlgorithm: "sha256",
+        modeOrder: [...RECORDED_SESSION_REPLAY_MODE_ORDER],
+        contracts: {
+            trace: RECORDED_SESSION_TRACE_CONTRACT,
+            fixture: RECORDED_SESSION_FIXTURE_CONTRACT,
+            bundle: RECORDED_SESSION_BUNDLE_CONTRACT,
+            environment: RECORDED_SESSION_REPLAY_PROOF_ENVIRONMENT_CONTRACT,
+            summaryTables: RECORDED_SESSION_REPLAY_PROOF_SUMMARY_TABLES_CONTRACT,
+            coverageSnapshot: RECORDED_SESSION_REPLAY_PROOF_COVERAGE_SNAPSHOT_CONTRACT,
+            hardeningSnapshot: RECORDED_SESSION_REPLAY_PROOF_HARDENING_SNAPSHOT_CONTRACT,
+            hashes: RECORDED_SESSION_REPLAY_PROOF_HASHES_CONTRACT
+        },
+        hashes: {
+            traceHash: bundle.traceHash,
+            fixtureHash: bundle.fixtureHash,
+            scoreHash: bundle.scoreHash,
+            bundleHash: bundle.bundleHash
+        },
+        files: {
+            trace: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.trace,
+            fixture: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.fixture,
+            bundle: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.bundle,
+            environment: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.environment,
+            summary: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.summary,
+            summaryTables: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.summaryTables,
+            coverageSnapshot: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.coverageSnapshot,
+            hardeningSnapshot: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.hardeningSnapshot,
+            hashes: RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.hashes,
+            modes: RECORDED_SESSION_REPLAY_MODE_ORDER.map((mode) => ({
+                mode,
+                path: recordedSessionReplayModeOutputPath(mode)
+            }))
+        }
+    };
+}
+function validateRecordedSessionReplayProofManifest(manifest) {
+    const errors = [];
+    if (manifest.contract !== RECORDED_SESSION_REPLAY_PROOF_MANIFEST_CONTRACT) {
+        errors.push("manifest contract is invalid");
+    }
+    if (canonicalJson(manifest.modeOrder ?? []) !== canonicalJson(RECORDED_SESSION_REPLAY_MODE_ORDER)) {
+        errors.push("manifest modeOrder must stay fixed at no_brain, vector_only, graph_prior_only, learned_route");
+    }
+    if (manifest.hashAlgorithm !== "sha256") {
+        errors.push("manifest hashAlgorithm must be sha256");
+    }
+    if (manifest.contracts?.trace !== RECORDED_SESSION_TRACE_CONTRACT ||
+        manifest.contracts?.fixture !== RECORDED_SESSION_FIXTURE_CONTRACT ||
+        manifest.contracts?.bundle !== RECORDED_SESSION_BUNDLE_CONTRACT ||
+        manifest.contracts?.environment !== RECORDED_SESSION_REPLAY_PROOF_ENVIRONMENT_CONTRACT ||
+        manifest.contracts?.summaryTables !== RECORDED_SESSION_REPLAY_PROOF_SUMMARY_TABLES_CONTRACT ||
+        manifest.contracts?.coverageSnapshot !== RECORDED_SESSION_REPLAY_PROOF_COVERAGE_SNAPSHOT_CONTRACT ||
+        manifest.contracts?.hardeningSnapshot !== RECORDED_SESSION_REPLAY_PROOF_HARDENING_SNAPSHOT_CONTRACT ||
+        manifest.contracts?.hashes !== RECORDED_SESSION_REPLAY_PROOF_HASHES_CONTRACT) {
+        errors.push("manifest contracts block is invalid");
+    }
+    if (manifest.files?.trace !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.trace ||
+        manifest.files?.fixture !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.fixture ||
+        manifest.files?.bundle !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.bundle ||
+        manifest.files?.environment !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.environment ||
+        manifest.files?.summary !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.summary ||
+        manifest.files?.summaryTables !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.summaryTables ||
+        manifest.files?.coverageSnapshot !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.coverageSnapshot ||
+        manifest.files?.hardeningSnapshot !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.hardeningSnapshot ||
+        manifest.files?.hashes !== RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.hashes) {
+        errors.push("manifest top-level file layout is invalid");
+    }
+    const expectedModeFiles = RECORDED_SESSION_REPLAY_MODE_ORDER.map((mode) => ({
+        mode,
+        path: recordedSessionReplayModeOutputPath(mode)
+    }));
+    if (canonicalJson(manifest.files?.modes ?? []) !== canonicalJson(expectedModeFiles)) {
+        errors.push("manifest mode outputs must stay under modes/<mode>.json in canonical order");
+    }
+    return errors;
+}
+function validateRecordedSessionReplayProofEnvironment(environment) {
+    const errors = [];
+    if (environment.contract !== RECORDED_SESSION_REPLAY_PROOF_ENVIRONMENT_CONTRACT) {
+        errors.push("environment contract is invalid");
+    }
+    if (environment.runtimeOwner !== "openclaw") {
+        errors.push("environment runtimeOwner must be openclaw");
+    }
+    if (environment.generator?.packageName !== "@openclawbrain/cli" ||
+        environment.generator?.entrypoint !== "writeRecordedSessionReplayProofBundle") {
+        errors.push("environment generator metadata is invalid");
+    }
+    if (normalizeOptionalString(environment.generator?.nodeVersion) === undefined ||
+        normalizeOptionalString(environment.generator?.platform) === undefined ||
+        normalizeOptionalString(environment.generator?.arch) === undefined) {
+        errors.push("environment generator runtime fields are required");
+    }
+    if (environment.determinism?.hashAlgorithm !== "sha256" ||
+        environment.determinism?.canonicalJson !== true ||
+        canonicalJson(environment.determinism?.modeOrder ?? []) !== canonicalJson(RECORDED_SESSION_REPLAY_MODE_ORDER) ||
+        environment.determinism?.scratchReplayRoot !== "temporary_directory") {
+        errors.push("environment determinism block is invalid");
+    }
+    return errors;
+}
+function buildRecordedSessionReplayProofFileDigestEntries(rootDir, manifest) {
+    const relativePaths = [
+        manifest.files.trace,
+        manifest.files.fixture,
+        manifest.files.bundle,
+        manifest.files.environment,
+        manifest.files.summary,
+        manifest.files.summaryTables,
+        manifest.files.coverageSnapshot,
+        manifest.files.hardeningSnapshot,
+        manifest.files.modes.map((entry) => entry.path),
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.manifest
+    ].flat();
+    return relativePaths.map((relativePath, index) => ({
+        path: relativePath,
+        digest: checksumTextPayload(readRecordedSessionReplayProofText(rootDir, relativePath, `files[${index}]`))
+    }));
+}
+function buildRecordedSessionReplayProofHashes(rootDir, manifest) {
+    return {
+        contract: RECORDED_SESSION_REPLAY_PROOF_HASHES_CONTRACT,
+        algorithm: "sha256",
+        semantic: {
+            traceHash: manifest.hashes.traceHash,
+            fixtureHash: manifest.hashes.fixtureHash,
+            scoreHash: manifest.hashes.scoreHash,
+            bundleHash: manifest.hashes.bundleHash
+        },
+        files: buildRecordedSessionReplayProofFileDigestEntries(rootDir, manifest)
+    };
+}
+export function loadRecordedSessionReplayProofBundle(rootDir) {
+    const resolvedRoot = path.resolve(rootDir);
+    const manifestPath = path.join(resolvedRoot, RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.manifest);
+    const manifest = readJsonFile(manifestPath);
+    const tracePath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.trace, "manifest.files.trace");
+    const fixturePath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.fixture, "manifest.files.fixture");
+    const bundlePath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.bundle, "manifest.files.bundle");
+    const environmentPath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.environment, "manifest.files.environment");
+    const summaryPath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.summary, "manifest.files.summary");
+    const summaryTablesPath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.summaryTables, "manifest.files.summaryTables");
+    const coverageSnapshotPath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.coverageSnapshot, "manifest.files.coverageSnapshot");
+    const hardeningSnapshotPath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.hardeningSnapshot, "manifest.files.hardeningSnapshot");
+    const hashesPath = resolveRecordedSessionReplayProofPath(resolvedRoot, manifest.files.hashes, "manifest.files.hashes");
+    const modeOutputs = (manifest.files.modes ?? []).map((entry, index) => {
+        const outputPath = resolveRecordedSessionReplayProofPath(resolvedRoot, entry.path, `manifest.files.modes[${index}].path`);
+        return {
+            mode: entry.mode,
+            path: outputPath,
+            report: readJsonFile(outputPath)
+        };
+    });
+    return {
+        rootDir: resolvedRoot,
+        manifestPath,
+        tracePath,
+        fixturePath,
+        bundlePath,
+        environmentPath,
+        summaryPath,
+        summaryTablesPath,
+        coverageSnapshotPath,
+        hardeningSnapshotPath,
+        hashesPath,
+        manifest,
+        trace: readJsonFile(tracePath),
+        fixture: readJsonFile(fixturePath),
+        bundle: readJsonFile(bundlePath),
+        environment: readJsonFile(environmentPath),
+        summaryText: readFileSync(summaryPath, "utf8"),
+        summaryTables: readJsonFile(summaryTablesPath),
+        coverageSnapshot: readJsonFile(coverageSnapshotPath),
+        hardeningSnapshot: readJsonFile(hardeningSnapshotPath),
+        hashes: readJsonFile(hashesPath),
+        modeOutputs
+    };
+}
+export function validateRecordedSessionReplayProofBundle(rootDir) {
+    const resolvedRoot = path.resolve(rootDir);
+    try {
+        const descriptor = loadRecordedSessionReplayProofBundle(resolvedRoot);
+        const errors = [];
+        errors.push(...validateRecordedSessionReplayProofManifest(descriptor.manifest));
+        errors.push(...validateRecordedSessionReplayProofEnvironment(descriptor.environment));
+        if (descriptor.trace.contract !== RECORDED_SESSION_TRACE_CONTRACT) {
+            errors.push("trace.json contract is invalid");
+        }
+        if (descriptor.fixture.contract !== RECORDED_SESSION_FIXTURE_CONTRACT) {
+            errors.push("fixture.json contract is invalid");
+        }
+        if (descriptor.bundle.contract !== RECORDED_SESSION_BUNDLE_CONTRACT) {
+            errors.push("bundle.json contract is invalid");
+        }
+        if (descriptor.summaryTables.contract !== RECORDED_SESSION_REPLAY_PROOF_SUMMARY_TABLES_CONTRACT) {
+            errors.push("summary-tables.json contract is invalid");
+        }
+        if (descriptor.coverageSnapshot.contract !== RECORDED_SESSION_REPLAY_PROOF_COVERAGE_SNAPSHOT_CONTRACT) {
+            errors.push("coverage-snapshot.json contract is invalid");
+        }
+        if (descriptor.hardeningSnapshot.contract !== RECORDED_SESSION_REPLAY_PROOF_HARDENING_SNAPSHOT_CONTRACT) {
+            errors.push("hardening-snapshot.json contract is invalid");
+        }
+        if (descriptor.hashes.contract !== RECORDED_SESSION_REPLAY_PROOF_HASHES_CONTRACT) {
+            errors.push("hashes.json contract is invalid");
+        }
+        if (descriptor.hashes.algorithm !== "sha256") {
+            errors.push("hashes.json algorithm must be sha256");
+        }
+        const rebuiltFixture = buildRecordedSessionReplayFixture(structuredClone(descriptor.trace));
+        if (canonicalJson(rebuiltFixture) !== canonicalJson(descriptor.fixture)) {
+            errors.push("fixture.json does not match the canonical fixture rebuilt from trace.json");
+        }
+        if (descriptor.bundle.traceHash !== descriptor.fixture.traceHash) {
+            errors.push("bundle traceHash does not match fixture traceHash");
+        }
+        if (descriptor.bundle.fixtureHash !== descriptor.fixture.fixtureHash) {
+            errors.push("bundle fixtureHash does not match fixture fixtureHash");
+        }
+        if (descriptor.manifest.hashes.traceHash !== descriptor.fixture.traceHash ||
+            descriptor.manifest.hashes.fixtureHash !== descriptor.fixture.fixtureHash ||
+            descriptor.manifest.hashes.scoreHash !== descriptor.bundle.scoreHash ||
+            descriptor.manifest.hashes.bundleHash !== descriptor.bundle.bundleHash) {
+            errors.push("manifest hashes do not match the replay artifacts");
+        }
+        const summaryTables = buildRecordedSessionReplayProofSummaryTables(descriptor.bundle);
+        if (canonicalJson(summaryTables) !== canonicalJson(descriptor.summaryTables)) {
+            errors.push("summary-tables.json does not match bundle.json");
+        }
+        const coverageSnapshot = buildRecordedSessionReplayProofCoverageSnapshot(descriptor.bundle);
+        if (canonicalJson(coverageSnapshot) !== canonicalJson(descriptor.coverageSnapshot)) {
+            errors.push("coverage-snapshot.json does not match bundle.json");
+        }
+        const hardeningSnapshot = buildRecordedSessionReplayProofHardeningSnapshot(descriptor.bundle);
+        if (canonicalJson(hardeningSnapshot) !== canonicalJson(descriptor.hardeningSnapshot)) {
+            errors.push("hardening-snapshot.json does not match bundle.json");
+        }
+        const expectedSummaryText = buildRecordedSessionReplayProofSummary({
+            bundle: descriptor.bundle,
+            summaryTables: descriptor.summaryTables,
+            coverageSnapshot: descriptor.coverageSnapshot,
+            hardeningSnapshot: descriptor.hardeningSnapshot,
+            semanticHashes: descriptor.hashes.semantic
+        });
+        if (descriptor.summaryText !== expectedSummaryText) {
+            errors.push("summary.md does not match the canonical replay proof summary");
+        }
+        const expectedModeCount = descriptor.bundle.modes.length;
+        if (descriptor.modeOutputs.length !== expectedModeCount) {
+            errors.push("mode output count does not match bundle modes");
+        }
+        const bundleModes = new Map(descriptor.bundle.modes.map((mode) => [mode.mode, mode]));
+        for (const modeOutput of descriptor.modeOutputs) {
+            const expectedMode = bundleModes.get(modeOutput.mode);
+            if (expectedMode === undefined) {
+                errors.push(`unexpected mode output: ${modeOutput.mode}`);
+                continue;
+            }
+            if (canonicalJson(expectedMode) !== canonicalJson(modeOutput.report)) {
+                errors.push(`mode output drift detected for ${modeOutput.mode}`);
+            }
+        }
+        const semanticHashVerification = verifyRecordedSessionReplayBundleHashes(descriptor.bundle);
+        if (!semanticHashVerification.bundleHashMatches) {
+            errors.push("bundleHash verification failed");
+        }
+        if (!semanticHashVerification.scoreHashMatches) {
+            errors.push("scoreHash verification failed");
+        }
+        const expectedHashes = buildRecordedSessionReplayProofHashes(resolvedRoot, descriptor.manifest);
+        const expectedFileDigests = new Map(expectedHashes.files.map((entry) => [entry.path, entry.digest]));
+        let verifiedFileCount = 0;
+        for (const fileEntry of descriptor.hashes.files ?? []) {
+            if (expectedFileDigests.get(fileEntry.path) === fileEntry.digest) {
+                verifiedFileCount += 1;
+            }
+        }
+        const fileHashesMatch = canonicalJson(expectedHashes.files) === canonicalJson(descriptor.hashes.files ?? []);
+        if (!fileHashesMatch) {
+            errors.push("hashes.json file digests do not match the written artifacts");
+        }
+        if (canonicalJson(expectedHashes.semantic) !== canonicalJson(descriptor.hashes.semantic ?? {})) {
+            errors.push("hashes.json semantic hashes do not match the manifest");
+        }
+        return {
+            contract: RECORDED_SESSION_REPLAY_PROOF_VALIDATION_CONTRACT,
+            ok: errors.length === 0,
+            rootDir: resolvedRoot,
+            expectedFileCount: expectedHashes.files.length,
+            verifiedFileCount,
+            fileHashesMatch,
+            bundleHashMatches: semanticHashVerification.bundleHashMatches,
+            scoreHashMatches: semanticHashVerification.scoreHashMatches,
+            errors
+        };
+    }
+    catch (error) {
+        return {
+            contract: RECORDED_SESSION_REPLAY_PROOF_VALIDATION_CONTRACT,
+            ok: false,
+            rootDir: resolvedRoot,
+            expectedFileCount: 0,
+            verifiedFileCount: 0,
+            fileHashesMatch: false,
+            bundleHashMatches: false,
+            scoreHashMatches: false,
+            errors: [toErrorMessage(error)]
+        };
+    }
+}
+export function writeRecordedSessionReplayProofBundle(input) {
+    const resolvedRoot = path.resolve(normalizeNonEmptyString(input.rootDir, "rootDir"));
+    const scratchRootParent = path.resolve(normalizeOptionalString(input.scratchRootDir) ?? tmpdir());
+    mkdirSync(resolvedRoot, { recursive: true });
+    mkdirSync(scratchRootParent, { recursive: true });
+    rmSync(path.join(resolvedRoot, RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.modeDir), {
+        recursive: true,
+        force: true
+    });
+    for (const relativePath of [
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.trace,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.fixture,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.bundle,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.environment,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.summary,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.summaryTables,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.coverageSnapshot,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.hardeningSnapshot,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.manifest,
+        RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.hashes
+    ]) {
+        rmSync(path.join(resolvedRoot, relativePath), { force: true });
+    }
+    const trace = structuredClone(input.trace);
+    const fixture = buildRecordedSessionReplayFixture(trace);
+    const scratchRoot = mkdtempSync(path.join(scratchRootParent, "openclawbrain-recorded-session-replay-"));
+    let bundle;
+    try {
+        bundle = runRecordedSessionReplay(scratchRoot, fixture);
+    }
+    finally {
+        rmSync(scratchRoot, { recursive: true, force: true });
+    }
+    const environment = buildRecordedSessionReplayProofEnvironment();
+    const summaryTables = buildRecordedSessionReplayProofSummaryTables(bundle);
+    const coverageSnapshot = buildRecordedSessionReplayProofCoverageSnapshot(bundle);
+    const hardeningSnapshot = buildRecordedSessionReplayProofHardeningSnapshot(bundle);
+    const manifest = buildRecordedSessionReplayProofManifest(bundle);
+    const summaryText = buildRecordedSessionReplayProofSummary({
+        bundle,
+        summaryTables,
+        coverageSnapshot,
+        hardeningSnapshot,
+        semanticHashes: manifest.hashes
+    });
+    const modeRoot = path.join(resolvedRoot, RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.modeDir);
+    mkdirSync(modeRoot, { recursive: true });
+    writeFileSync(path.join(resolvedRoot, manifest.files.trace), canonicalJson(trace), "utf8");
+    writeFileSync(path.join(resolvedRoot, manifest.files.fixture), canonicalJson(fixture), "utf8");
+    writeFileSync(path.join(resolvedRoot, manifest.files.bundle), canonicalJson(bundle), "utf8");
+    writeFileSync(path.join(resolvedRoot, manifest.files.environment), canonicalJson(environment), "utf8");
+    writeFileSync(path.join(resolvedRoot, manifest.files.summaryTables), canonicalJson(summaryTables), "utf8");
+    writeFileSync(path.join(resolvedRoot, manifest.files.coverageSnapshot), canonicalJson(coverageSnapshot), "utf8");
+    writeFileSync(path.join(resolvedRoot, manifest.files.hardeningSnapshot), canonicalJson(hardeningSnapshot), "utf8");
+    for (const mode of orderedRecordedSessionReplayModes(bundle.modes)) {
+        writeFileSync(path.join(resolvedRoot, recordedSessionReplayModeOutputPath(mode.mode)), canonicalJson(mode), "utf8");
+    }
+    writeFileSync(path.join(resolvedRoot, manifest.files.summary), summaryText, "utf8");
+    writeFileSync(path.join(resolvedRoot, RECORDED_SESSION_REPLAY_PROOF_BUNDLE_LAYOUT.manifest), canonicalJson(manifest), "utf8");
+    const hashes = buildRecordedSessionReplayProofHashes(resolvedRoot, manifest);
+    writeFileSync(path.join(resolvedRoot, manifest.files.hashes), canonicalJson(hashes), "utf8");
+    const validation = validateRecordedSessionReplayProofBundle(resolvedRoot);
+    if (!validation.ok) {
+        throw new Error(`recorded session replay proof bundle is invalid: ${validation.errors.join("; ")}`);
+    }
+    return loadRecordedSessionReplayProofBundle(resolvedRoot);
+}
 export const OPERATOR_API_CONTRACT_ID = "openclaw_operator_api.v1";
 export const SUPPORTED_OPERATOR_API_FAMILIES = [
     "bootstrap_attach",
@@ -5737,7 +6597,128 @@ function summarizeTeacherLoopWatchState(input) {
         snapshotUpdatedAt: input.watchSnapshot.updatedAt,
         lastWatchHeartbeatAt,
         pollIntervalSeconds,
-        watchState: Number.isFinite(lagMs) && lagMs >= 0 && lagMs <= staleAfterMs ? "watching" : "stale_snapshot"
+            watchState: Number.isFinite(lagMs) && lagMs >= 0 && lagMs <= staleAfterMs ? "watching" : "stale_snapshot"
+    };
+}
+function emptyOperatorLearningAttribution(source, snapshotKind, detail) {
+    return {
+        available: false,
+        source,
+        snapshotKind,
+        quality: "unavailable",
+        nonZeroObservationCount: 0,
+        skippedZeroRewardCount: 0,
+        exactMatchCount: 0,
+        heuristicMatchCount: 0,
+        unmatchedCount: 0,
+        ambiguousCount: 0,
+        matchedByMode: {
+            exactDecisionId: 0,
+            exactSelectionDigest: 0,
+            turnCompileEventId: 0,
+            legacyHeuristic: 0
+        },
+        unmatchedByMode: {
+            exactDecisionId: 0,
+            exactSelectionDigest: 0,
+            turnCompileEventId: 0,
+            legacyHeuristic: 0
+        },
+        ambiguousByMode: {
+            exactDecisionId: 0,
+            exactSelectionDigest: 0,
+            turnCompileEventId: 0,
+            legacyHeuristic: 0
+        },
+        detail
+    };
+}
+function sumObservationBindingModes(counts) {
+    return (counts.exactDecisionId ?? 0)
+        + (counts.exactSelectionDigest ?? 0)
+        + (counts.turnCompileEventId ?? 0)
+        + (counts.legacyHeuristic ?? 0);
+}
+function deriveObservationBindingQuality(summary) {
+    if (summary.nonZeroObservationCount === 0) {
+        return "no_nonzero_observations";
+    }
+    if (summary.ambiguousCount > 0) {
+        if (summary.exactMatchCount > 0) {
+            return "exact_with_ambiguous";
+        }
+        if (summary.heuristicMatchCount > 0) {
+            return "heuristic_with_ambiguous";
+        }
+        return "ambiguous_present";
+    }
+    if (summary.unmatchedCount > 0) {
+        if (summary.exactMatchCount > 0) {
+            return "exact_with_unmatched";
+        }
+        if (summary.heuristicMatchCount > 0) {
+            return "heuristic_with_unmatched";
+        }
+        return "unmatched_present";
+    }
+    if (summary.exactMatchCount > 0 && summary.heuristicMatchCount > 0) {
+        return "exact_plus_heuristic";
+    }
+    if (summary.exactMatchCount > 0) {
+        return "exact_only";
+    }
+    if (summary.heuristicMatchCount > 0) {
+        return "heuristic_only";
+    }
+    return "no_matches";
+}
+function summarizeTeacherLoopObservationBinding(snapshot, sourceKind) {
+    const stats = snapshot.learner.lastMaterialization?.candidate.routingBuild?.observationBindingStats ?? null;
+    if (stats === null) {
+        return emptyOperatorLearningAttribution("latest_materialization", sourceKind, snapshot.learner.lastMaterialization === null
+            ? "no materialized candidate pack is visible in the teacher snapshot"
+            : "latest materialization did not expose observation binding stats");
+    }
+    const exactMatchCount = (stats.matched.exactDecisionId ?? 0)
+        + (stats.matched.exactSelectionDigest ?? 0)
+        + (stats.matched.turnCompileEventId ?? 0);
+    const heuristicMatchCount = stats.matched.legacyHeuristic ?? 0;
+    const unmatchedCount = sumObservationBindingModes(stats.unmatched);
+    const ambiguousCount = sumObservationBindingModes(stats.ambiguous);
+    const summary = {
+        available: true,
+        source: "latest_materialization",
+        snapshotKind: sourceKind,
+        quality: "unavailable",
+        nonZeroObservationCount: stats.nonZeroObservationCount ?? 0,
+        skippedZeroRewardCount: stats.skippedZeroRewardCount ?? 0,
+        exactMatchCount,
+        heuristicMatchCount,
+        unmatchedCount,
+        ambiguousCount,
+        matchedByMode: {
+            exactDecisionId: stats.matched.exactDecisionId ?? 0,
+            exactSelectionDigest: stats.matched.exactSelectionDigest ?? 0,
+            turnCompileEventId: stats.matched.turnCompileEventId ?? 0,
+            legacyHeuristic: stats.matched.legacyHeuristic ?? 0
+        },
+        unmatchedByMode: {
+            exactDecisionId: stats.unmatched.exactDecisionId ?? 0,
+            exactSelectionDigest: stats.unmatched.exactSelectionDigest ?? 0,
+            turnCompileEventId: stats.unmatched.turnCompileEventId ?? 0,
+            legacyHeuristic: stats.unmatched.legacyHeuristic ?? 0
+        },
+        ambiguousByMode: {
+            exactDecisionId: stats.ambiguous.exactDecisionId ?? 0,
+            exactSelectionDigest: stats.ambiguous.exactSelectionDigest ?? 0,
+            turnCompileEventId: stats.ambiguous.turnCompileEventId ?? 0,
+            legacyHeuristic: stats.ambiguous.legacyHeuristic ?? 0
+        },
+        detail: "teacher observation binding stats came from the latest materialized candidate"
+    };
+    return {
+        ...summary,
+        quality: deriveObservationBindingQuality(summary)
     };
 }
 function summarizeTeacherLoop(input) {
@@ -5779,6 +6760,7 @@ function summarizeTeacherLoop(input) {
             failureDetail: null,
             lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
+            observationBinding: emptyOperatorLearningAttribution("unavailable", "missing", "no teacher snapshot path supplied"),
             lastObservedDelta: unavailableFromMissing,
             notes: [],
             detail: "no teacher snapshot path supplied"
@@ -5818,6 +6800,7 @@ function summarizeTeacherLoop(input) {
             failureDetail: null,
             lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
+            observationBinding: emptyOperatorLearningAttribution("unavailable", "missing", "teacher snapshot could not be loaded"),
             lastObservedDelta: unavailableFromMissing,
             notes: [],
             detail: "teacher snapshot could not be loaded"
@@ -5866,6 +6849,7 @@ function summarizeTeacherLoop(input) {
             snapshot.learner.lastMaterialization?.jobId ??
             null,
         lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null,
+        observationBinding: summarizeTeacherLoopObservationBinding(snapshot, loaded.sourceKind),
         lastObservedDelta: loaded.sourceKind === "watch_snapshot" && watchSnapshot !== null
             ? cloneLastObservedDelta(watchSnapshot.lastObservedDelta)
             : unavailableFromAsync,
@@ -5994,7 +6978,7 @@ function summarizeLearningWarningStates(input) {
         input.teacherSnapshot.queue.depth >= input.teacherSnapshot.queue.capacity) {
         warnings.add("teacher_queue_full");
     }
-    if (input.teacherSnapshot.diagnostics.latestFreshness === "stale") {
+    if (input.teacherSnapshot.diagnostics.latestFreshness === "stale" && input.teacherSnapshot.diagnostics.lastNoOpReason !== "no_teacher_artifacts") {
         warnings.add("teacher_labels_stale");
     }
     if (input.teacherSnapshot.diagnostics.lastNoOpReason === "no_teacher_artifacts") {
@@ -6619,6 +7603,10 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
             installState: report.hook.installState,
             loadability: report.hook.loadability,
             loadProof: report.hook.loadProof,
+            guardSeverity: report.hook.guardSeverity,
+            guardActionability: report.hook.guardActionability,
+            guardSummary: report.hook.guardSummary,
+            guardAction: report.hook.guardAction,
             desynced: report.hook.desynced,
             detail: report.hook.detail
         },
@@ -6665,7 +7653,10 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
                                             ? "current profile would fail open to static context because no serving pack is available"
                                             : report.servePath.state === "hard_fail"
                                                 ? "current profile cannot serve because the learned-route or activation requirement hard-failed"
-                                                : "current profile serve state has not been compile-probed yet"
+                                            : "current profile serve state has not been compile-probed yet"
+        },
+        learningAttribution: {
+            ...report.teacherLoop.observationBinding
         },
         passiveLearning,
         currentTurnAttribution: buildCurrentProfileTurnAttributionFromReport(report, policyMode, profileId)