@openclawbrain/openclaw 0.3.1 → 0.3.3

package/dist/src/index.js

@@ -3,11 +3,14 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, wri
 import path from "node:path";
 import process from "node:process";
 import { compileRuntimeFromActivation } from "@openclawbrain/compiler";
-import { CONTRACT_IDS, buildNormalizedEventExport, canonicalJson, checksumJsonPayload, createFeedbackEvent, createInteractionEvent, sortNormalizedEvents, validateKernelSurface, validateNormalizedEventExport } from "@openclawbrain/contracts";
+import { CONTRACT_IDS, buildEventSemanticSurface, buildNormalizedEventExport, canonicalJson, checksumJsonPayload, createFeedbackEvent, createInteractionEvent, sortNormalizedEvents, validateKernelSurface, validateNormalizedEventExport } from "@openclawbrain/contracts";
 import { classifyFeedbackSignalContent, describeNormalizedEventExportObservability } from "@openclawbrain/event-export";
 import { DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS, advanceAlwaysOnLearningRuntime, buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, materializeAlwaysOnLearningCandidatePack, materializeCandidatePackFromNormalizedEventExport } from "@openclawbrain/learner";
 import { LEARNING_SPINE_LOG_LAYOUT, activatePack, describeActivationObservability, describeActivationTarget, describePackCompileTarget, inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, rollbackActivePack, stageCandidatePack } from "@openclawbrain/pack-format";
+import { inspectOpenClawBrainHookStatus, summarizeOpenClawBrainHookLoad } from "./openclaw-hook-truth.js";
 import { appendLearningUpdateLogs, appendServeTimeRouteDecisionLog } from "./learning-spine.js";
+import { buildFeedbackSemanticMetadata, buildInteractionSemanticMetadata } from "./semantic-metadata.js";
+export { clearOpenClawProfileRuntimeLoadProof, listOpenClawProfileRuntimeLoadProofs, recordOpenClawProfileRuntimeLoadProof, resolveAttachmentRuntimeLoadProofsPath } from "./attachment-truth.js";
 import { createTeacherLabeler } from "./teacher-labeler.js";
 export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler } from "./teacher-labeler.js";
 const DEFAULT_AGENT_ID = "openclaw-runtime";
@@ -19,6 +22,7 @@ const RECORDED_SESSION_BUNDLE_CONTRACT = "recorded_session_replay_bundle.v1";
 const RUNTIME_EVENT_EXPORT_BUNDLE_CONTRACT = "normalized_event_export_bundle.v1";
 const DEFAULT_ATTACH_STATUS_MESSAGE = "openclaw attach status probe";
 const DEFAULT_ATTACH_STATUS_RUNTIME_HINTS = ["attach", "status", "probe"];
+const BRAIN_SERVE_HOT_PATH_TIMING_DETAIL = "Measured inside compileRuntimeContext before serve-route logging; includes serve-path normalization, active-pack lookup, structural-budget resolution, route/candidate selection, and prompt assembly when run; excludes background scanner/embedder/teacher work, promotion, and runtime event-export writes.";
 export const RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT = {
     manifest: "manifest.json",
     payload: "normalized-event-export.json"
@@ -1058,6 +1062,7 @@ export function resolveAsyncTeacherLiveLoopSnapshotPath(activationRoot) {
 export const WATCH_STATE_DIRNAME = "watch";
 export const WATCH_SESSION_TAIL_CURSOR_BASENAME = "session-tail-cursor.json";
 export const WATCH_TEACHER_SNAPSHOT_BASENAME = "teacher-snapshot.json";
+export const DEFAULT_WATCH_POLL_INTERVAL_SECONDS = 30;
 function isAsyncTeacherLiveLoopSnapshot(value) {
     if (value === null || typeof value !== "object") {
         return false;
@@ -1092,6 +1097,94 @@ function cloneWatchTeacherSnapshotFailure(value) {
         at: value.at
     };
 }
+function buildUnavailableLastObservedDelta(explanation) {
+    return {
+        available: false,
+        observedAt: null,
+        exported: null,
+        labeled: null,
+        promoted: null,
+        served: null,
+        latestPackTransition: null,
+        explanation
+    };
+}
+function cloneLastObservedDelta(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return buildUnavailableLastObservedDelta("last observed delta is unavailable");
+    }
+    const transition = value.latestPackTransition;
+    const latestPackTransition = transition !== null &&
+        transition !== undefined &&
+        (transition.kind === "staged_candidate" || transition.kind === "promoted_active") &&
+        typeof transition.toPackId === "string" &&
+        transition.toPackId.length > 0 &&
+        (transition.fromPackId === null || (typeof transition.fromPackId === "string" && transition.fromPackId.length > 0))
+        ? {
+            kind: transition.kind,
+            fromPackId: transition.fromPackId,
+            toPackId: transition.toPackId
+        }
+        : null;
+    const available = value.available === true;
+    return {
+        available,
+        observedAt: typeof value.observedAt === "string" ? value.observedAt : null,
+        exported: available && typeof value.exported === "boolean" ? value.exported : null,
+        labeled: available && typeof value.labeled === "boolean" ? value.labeled : null,
+        promoted: available && typeof value.promoted === "boolean" ? value.promoted : null,
+        served: available && typeof value.served === "boolean" ? value.served : null,
+        latestPackTransition,
+        explanation: typeof value.explanation === "string" && value.explanation.trim().length > 0
+            ? value.explanation
+            : "last observed delta is unavailable"
+    };
+}
+function cloneWatchEmbedInstrumentationPoint(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return null;
+    }
+    const candidate = value;
+    if (candidate.slot !== null &&
+        candidate.slot !== "candidate" &&
+        candidate.slot !== "active") {
+        return null;
+    }
+    return {
+        slot: candidate.slot ?? null,
+        packId: typeof candidate.packId === "string" ? candidate.packId : null,
+        runtimeEmbedderPresent: candidate.runtimeEmbedderPresent === true,
+        runtimeEmbedderModel: typeof candidate.runtimeEmbedderModel === "string" ? candidate.runtimeEmbedderModel : null,
+        vectorEntryCount: typeof candidate.vectorEntryCount === "number" ? candidate.vectorEntryCount : null,
+        numericEmbeddingEntryCount: typeof candidate.numericEmbeddingEntryCount === "number" ? candidate.numericEmbeddingEntryCount : null,
+        embeddingModels: Array.isArray(candidate.embeddingModels)
+            ? candidate.embeddingModels.filter((model) => typeof model === "string")
+            : [],
+        error: typeof candidate.error === "string" ? candidate.error : null
+    };
+}
+function cloneWatchEmbedInstrumentationTrace(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return null;
+    }
+    const candidate = value;
+    const beforeCandidateMaterialization = cloneWatchEmbedInstrumentationPoint(candidate.beforeCandidateMaterialization);
+    if (beforeCandidateMaterialization === null || typeof candidate.observedAt !== "string") {
+        return null;
+    }
+    return {
+        observedAt: candidate.observedAt,
+        candidatePackId: typeof candidate.candidatePackId === "string" ? candidate.candidatePackId : null,
+        promotionAllowed: typeof candidate.promotionAllowed === "boolean" ? candidate.promotionAllowed : null,
+        promotionFindings: Array.isArray(candidate.promotionFindings)
+            ? candidate.promotionFindings.filter((finding) => typeof finding === "string")
+            : [],
+        beforeCandidateMaterialization,
+        afterCandidateMaterialization: cloneWatchEmbedInstrumentationPoint(candidate.afterCandidateMaterialization),
+        afterStage: cloneWatchEmbedInstrumentationPoint(candidate.afterStage),
+        afterPromote: cloneWatchEmbedInstrumentationPoint(candidate.afterPromote)
+    };
+}
 function cloneRuntimeEventExportScannerCheckpoint(value) {
     return structuredClone(value);
 }
@@ -1159,6 +1252,11 @@ function normalizeWatchTeacherSnapshotFromValue(value, snapshot, sourcePath) {
             : typeof value.updatedAt === "string"
                 ? value.updatedAt
                 : snapshot.diagnostics.lastProcessedAt ?? new Date(0).toISOString(),
+        pollIntervalSeconds: typeof value.pollIntervalSeconds === "number" &&
+            Number.isInteger(value.pollIntervalSeconds) &&
+            value.pollIntervalSeconds > 0
+            ? value.pollIntervalSeconds
+            : DEFAULT_WATCH_POLL_INTERVAL_SECONDS,
         scanRoot: typeof value.scanRoot === "string" ? value.scanRoot : defaultScanRoot,
         sessionTailCursorPath: typeof value.sessionTailCursorPath === "string"
             ? value.sessionTailCursorPath
@@ -1193,6 +1291,8 @@ function normalizeWatchTeacherSnapshotFromValue(value, snapshot, sourcePath) {
         teacher: value.teacher ?? buildWatchTeacherSnapshotTeacherSummary(snapshot),
         learning: value.learning ?? buildWatchTeacherSnapshotLearningSummary(snapshot, typeof value.lastHandledMaterializationPackId === "string" ? value.lastHandledMaterializationPackId : null),
         labeling: value.labeling ?? buildWatchTeacherSnapshotLabelingSummary(snapshot),
+        lastObservedDelta: cloneLastObservedDelta(value.lastObservedDelta),
+        embedInstrumentation: cloneWatchEmbedInstrumentationTrace(value.embedInstrumentation),
         failure: cloneWatchTeacherSnapshotFailure(value.failure),
         snapshot
     };
@@ -1250,6 +1350,8 @@ export function loadWatchTeacherSnapshotState(snapshotPath) {
     if (!existsSync(resolvedPath)) {
         return {
             lastHandledMaterializationPackId: null,
+            lastObservedDelta: buildUnavailableLastObservedDelta("no watch teacher snapshot is visible for the latest observed cycle"),
+            embedInstrumentation: null,
             snapshot: null,
             error: null
         };
@@ -1261,6 +1363,8 @@ export function loadWatchTeacherSnapshotState(snapshotPath) {
     catch (error) {
         return {
             lastHandledMaterializationPackId: null,
+            lastObservedDelta: buildUnavailableLastObservedDelta("watch teacher snapshot could not be loaded"),
+            embedInstrumentation: null,
             snapshot: null,
             error: error instanceof Error ? error.message : String(error)
         };
@@ -1268,6 +1372,8 @@ export function loadWatchTeacherSnapshotState(snapshotPath) {
     if (isWatchTeacherSnapshot(parsed)) {
         return {
             lastHandledMaterializationPackId: parsed.lastHandledMaterializationPackId,
+            lastObservedDelta: cloneLastObservedDelta(parsed.lastObservedDelta),
+            embedInstrumentation: cloneWatchEmbedInstrumentationTrace(parsed.embedInstrumentation),
             snapshot: loadAsyncTeacherLiveLoopSnapshotFromValue(parsed.snapshot),
             error: null
         };
@@ -1275,12 +1381,16 @@ export function loadWatchTeacherSnapshotState(snapshotPath) {
     if (isAsyncTeacherLiveLoopSnapshot(parsed)) {
         return {
             lastHandledMaterializationPackId: null,
+            lastObservedDelta: buildUnavailableLastObservedDelta("raw async teacher snapshots do not record the last observed export/label/promotion delta"),
+            embedInstrumentation: null,
             snapshot: loadAsyncTeacherLiveLoopSnapshotFromValue(parsed),
             error: null
         };
     }
     return {
         lastHandledMaterializationPackId: null,
+        lastObservedDelta: buildUnavailableLastObservedDelta("watch teacher snapshot is invalid"),
+        embedInstrumentation: null,
         snapshot: null,
         error: `watch teacher snapshot is invalid: ${resolvedPath}`
     };
@@ -1293,6 +1403,7 @@ export function persistWatchTeacherSnapshot(snapshotPath, input) {
         runtimeOwner: "openclaw",
         updatedAt: persistedAt,
         lastRunAt: input.lastRunAt,
+        pollIntervalSeconds: input.pollIntervalSeconds,
         scanRoot: path.resolve(input.scanRoot),
         sessionTailCursorPath: path.resolve(input.sessionTailCursorPath),
         sessionTailCursorUpdatedAt: input.sessionTailCursorUpdatedAt,
@@ -1311,6 +1422,8 @@ export function persistWatchTeacherSnapshot(snapshotPath, input) {
         teacher: buildWatchTeacherSnapshotTeacherSummary(canonicalSnapshot),
         learning: buildWatchTeacherSnapshotLearningSummary(canonicalSnapshot, input.lastHandledMaterializationPackId),
         labeling: buildWatchTeacherSnapshotLabelingSummary(canonicalSnapshot),
+        lastObservedDelta: cloneLastObservedDelta(input.lastObservedDelta),
+        embedInstrumentation: cloneWatchEmbedInstrumentationTrace(input.embedInstrumentation),
         failure: cloneWatchTeacherSnapshotFailure(input.failure),
         snapshot: canonicalSnapshot
     };
@@ -1383,7 +1496,12 @@ export function buildRuntimeEventExportBundleManifest(input) {
             interactionCount: input.normalizedEventExport.provenance.interactionCount,
             feedbackCount: input.normalizedEventExport.provenance.feedbackCount,
             sourceStreams: [...input.normalizedEventExport.provenance.sourceStreams],
-            contracts: [...input.normalizedEventExport.provenance.contracts]
+            contracts: [...input.normalizedEventExport.provenance.contracts],
+            semanticSurface: structuredClone(input.normalizedEventExport.provenance.semanticSurface ??
+                buildEventSemanticSurface([
+                    ...input.normalizedEventExport.interactionEvents,
+                    ...input.normalizedEventExport.feedbackEvents
+                ]))
         },
         ...(input.scanner !== undefined ? { scanner: cloneScannerExportManifestOrNull(input.scanner) } : {})
     };
@@ -1426,7 +1544,8 @@ export function validateRuntimeEventExportBundleManifest(value, normalizedEventE
         if (rebuilt.payloadDigest !== value.payloadDigest) {
             errors.push("event export bundle payloadDigest does not match the supplied normalized event export");
         }
-        if (canonicalJson(rebuilt.summary) !== canonicalJson(value.summary)) {
+        const expectedSummary = value.summary.semanticSurface === undefined ? { ...rebuilt.summary, semanticSurface: undefined } : rebuilt.summary;
+        if (canonicalJson(expectedSummary) !== canonicalJson(value.summary)) {
             errors.push("event export bundle summary does not match the supplied normalized event export");
         }
         if (canonicalJson(rebuilt.scanner ?? null) !== canonicalJson(value.scanner ?? null)) {
@@ -1542,8 +1661,14 @@ export function buildNormalizedEventExportFromScannedEvents(input) {
         };
     }
     const normalizedEventExport = buildNormalizedEventExport({
-        interactionEvents: [...input.interactionEvents],
-        feedbackEvents: [...input.feedbackEvents]
+        interactionEvents: input.interactionEvents.map((event) => ({
+            ...event,
+            semantic: event.semantic ?? buildInteractionSemanticMetadata("scanner_export", event.kind)
+        })),
+        feedbackEvents: input.feedbackEvents.map((event) => ({
+            ...event,
+            semantic: event.semantic ?? buildFeedbackSemanticMetadata("scanner_export", event.kind)
+        }))
     });
     const exportErrors = validateNormalizedEventExport(normalizedEventExport);
     if (exportErrors.length > 0) {
@@ -2396,17 +2521,53 @@ export function formatPromptContext(compileResponse) {
 function resolveActivationRootForFailure(value) {
     return path.resolve(normalizeOptionalString(value) ?? ".");
 }
-function failOpenCompileResult(error, activationRoot) {
+function monotonicClockNs() {
+    return process.hrtime.bigint();
+}
+function elapsedMsFrom(startedAtNs, endedAtNs = monotonicClockNs()) {
+    return Number(endedAtNs - startedAtNs) / 1_000_000;
+}
+function roundHotPathTimingMs(value) {
+    return Math.round(value * 1_000) / 1_000;
+}
+function buildUnavailableBrainServeHotPathTiming(detail) {
+    return {
+        scope: "brain_serve_hot_path_only",
+        totalMs: null,
+        routeSelectionMs: null,
+        promptAssemblyMs: null,
+        otherMs: null,
+        backgroundWorkIncluded: false,
+        detail
+    };
+}
+function buildBrainServeHotPathTiming(input) {
+    const totalMs = roundHotPathTimingMs(input.totalMs);
+    const routeSelectionMs = input.routeSelectionMs === null ? null : roundHotPathTimingMs(input.routeSelectionMs);
+    const promptAssemblyMs = input.promptAssemblyMs === null ? null : roundHotPathTimingMs(input.promptAssemblyMs);
+    const otherMs = roundHotPathTimingMs(Math.max(0, input.totalMs - (input.routeSelectionMs ?? 0) - (input.promptAssemblyMs ?? 0)));
+    return {
+        scope: "brain_serve_hot_path_only",
+        totalMs,
+        routeSelectionMs,
+        promptAssemblyMs,
+        otherMs,
+        backgroundWorkIncluded: false,
+        detail: BRAIN_SERVE_HOT_PATH_TIMING_DETAIL
+    };
+}
+function failOpenCompileResult(error, activationRoot, timing = buildUnavailableBrainServeHotPathTiming("serve-path timing was unavailable")) {
     return {
         ok: false,
         fallbackToStaticContext: true,
         hardRequirementViolated: false,
         activationRoot: path.resolve(activationRoot),
         error: toErrorMessage(error),
-        brainContext: ""
+        brainContext: "",
+        timing
     };
 }
-function classifyCompileFailure(error, activationRoot) {
+function classifyCompileFailure(error, activationRoot, timing = buildUnavailableBrainServeHotPathTiming("serve-path timing was unavailable")) {
     const resolvedActivationRoot = path.resolve(activationRoot);
     try {
         const inspection = inspectActivationState(resolvedActivationRoot);
@@ -2419,14 +2580,15 @@ function classifyCompileFailure(error, activationRoot) {
                 hardRequirementViolated: true,
                 activationRoot: resolvedActivationRoot,
                 error: `Learned-routing hotpath hard requirement violated for active pack ${active.packId} (routerIdentity=${active.routerIdentity ?? "null"}): ${failureReason}`,
-                brainContext: ""
+                brainContext: "",
+                timing
             };
         }
     }
     catch {
-        return failOpenCompileResult(error, resolvedActivationRoot);
+        return failOpenCompileResult(error, resolvedActivationRoot, timing);
     }
-    return failOpenCompileResult(error, resolvedActivationRoot);
+    return failOpenCompileResult(error, resolvedActivationRoot, timing);
 }
 function uniqueNotes(notes) {
     return [...new Set(notes.filter((note) => note.length > 0))];
@@ -2480,6 +2642,11 @@ function appendCompileServeRouteDecisionLog(input) {
     if (input.compileInput._suppressServeLog) {
         return;
     }
+    if (!input.compileResult.ok && input.userMessage.length === 0) {
+        // Invalid/partial invocation envelopes should fail open without paying for
+        // serve-time route log writes on the live compile hot path.
+        return;
+    }
     const recordedAt = new Date().toISOString();
     const sessionId = normalizeServeRouteChannel(input.compileInput.sessionId) ?? `ext-compile-${Date.now()}`;
     const channel = normalizeServeRouteChannel(input.compileInput.channel) ?? "extension";
@@ -2751,6 +2918,7 @@ export function resolveActivePackForCompile(activationRoot) {
     };
 }
 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;
@@ -2759,6 +2927,10 @@ export function compileRuntimeContext(input) {
     let userMessage = "";
     let maxContextChars;
     let mode = "heuristic";
+    let routeSelectionStartedAtNs = null;
+    let routeSelectionMs = null;
+    let promptAssemblyStartedAtNs = null;
+    let promptAssemblyMs = null;
     let result;
     try {
         activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
@@ -2773,7 +2945,11 @@ export function compileRuntimeContext(input) {
         mode = normalizeMode(input.mode);
     }
     catch (error) {
-        result = failOpenCompileResult(error, fallbackActivationRoot);
+        result = failOpenCompileResult(error, fallbackActivationRoot, buildBrainServeHotPathTiming({
+            totalMs: elapsedMsFrom(totalStartedAtNs),
+            routeSelectionMs,
+            promptAssemblyMs
+        }));
         appendCompileServeRouteDecisionLog({
             compileInput: input,
             activationRoot: result.activationRoot,
@@ -2785,6 +2961,7 @@ export function compileRuntimeContext(input) {
     try {
         const target = resolveActivePackForCompile(activationRoot);
         const resolvedBudget = resolveCompileBudget(target, input);
+        routeSelectionStartedAtNs = monotonicClockNs();
         const compile = compileRuntimeFromActivation(activationRoot, {
             contract: CONTRACT_IDS.runtimeCompile,
             agentId,
@@ -2798,6 +2975,7 @@ export function compileRuntimeContext(input) {
         }, {
             ...(selectionMode !== undefined ? { selectionMode } : {})
         });
+        routeSelectionMs = elapsedMsFrom(routeSelectionStartedAtNs);
         const compileResponse = {
             ...compile.response,
             diagnostics: {
@@ -2805,6 +2983,9 @@ export function compileRuntimeContext(input) {
                 notes: uniqueNotes([...compile.response.diagnostics.notes, ...resolvedBudget.notes, "OpenClaw remains the runtime owner"])
             }
         };
+        promptAssemblyStartedAtNs = monotonicClockNs();
+        const brainContext = formatPromptContext(compileResponse);
+        promptAssemblyMs = elapsedMsFrom(promptAssemblyStartedAtNs);
         result = {
             ok: true,
             fallbackToStaticContext: false,
@@ -2813,11 +2994,26 @@ export function compileRuntimeContext(input) {
             activePackId: compile.target.packId,
             packRootDir: path.resolve(target.activePointer.packRootDir),
             compileResponse,
-            brainContext: formatPromptContext(compileResponse)
+            brainContext,
+            timing: buildBrainServeHotPathTiming({
+                totalMs: elapsedMsFrom(totalStartedAtNs),
+                routeSelectionMs,
+                promptAssemblyMs
+            })
         };
     }
     catch (error) {
-        result = classifyCompileFailure(error, activationRoot);
+        if (routeSelectionStartedAtNs !== null && routeSelectionMs === null) {
+            routeSelectionMs = elapsedMsFrom(routeSelectionStartedAtNs);
+        }
+        if (promptAssemblyStartedAtNs !== null && promptAssemblyMs === null) {
+            promptAssemblyMs = elapsedMsFrom(promptAssemblyStartedAtNs);
+        }
+        result = classifyCompileFailure(error, activationRoot, buildBrainServeHotPathTiming({
+            totalMs: elapsedMsFrom(totalStartedAtNs),
+            routeSelectionMs,
+            promptAssemblyMs
+        }));
     }
     appendCompileServeRouteDecisionLog({
         compileInput: input,
@@ -3020,6 +3216,7 @@ function buildAttachCompileStatus(result, observability, activePackId) {
             activePackId,
             usedLearnedRouteFn: null,
             routerIdentity: observability?.learnedRouteFn.routerIdentity ?? null,
+            selectionDigest: null,
             initMode: observability?.initHandoff.initMode ?? null,
             handoffState: observability?.initHandoff.handoffState ?? null,
             seedSources: observability?.initHandoff.seedSources ?? [],
@@ -3028,6 +3225,7 @@ function buildAttachCompileStatus(result, observability, activePackId) {
                 hardRequirementViolated: result.hardRequirementViolated,
                 usedLearnedRouteFn: null
             }),
+            timing: result.timing,
             notes: [],
             error: result.error
         };
@@ -3047,12 +3245,14 @@ function buildAttachCompileStatus(result, observability, activePackId) {
         activePackId: result.activePackId,
         usedLearnedRouteFn: result.compileResponse.diagnostics.usedLearnedRouteFn,
         routerIdentity: result.compileResponse.diagnostics.routerIdentity,
+        selectionDigest: result.compileResponse.diagnostics.selectionDigest,
         initMode: readDiagnosticNoteValue(notes, "init_mode=") ?? observability?.initHandoff.initMode ?? null,
         handoffState: readDiagnosticNoteValue(notes, "handoff_state=") ?? observability?.initHandoff.handoffState ?? null,
         seedSources: readDiagnosticNoteList(notes, "seed_sources=").length > 0
             ? readDiagnosticNoteList(notes, "seed_sources=")
             : observability?.initHandoff.seedSources ?? [],
         contextAttribution,
+        timing: result.timing,
         notes,
         error: null
     };
@@ -3447,6 +3647,7 @@ function buildCompileInteractionEvent(input) {
             runtimeOwner: "openclaw",
             stream: input.sourceStream
         },
+        semantic: buildInteractionSemanticMetadata("runtime_turn", "memory_compiled"),
         packId: input.compileResult.compileResponse.packId,
         principal: buildRuntimeSelfPrincipal(input.turn),
         attribution: input.attribution
@@ -3482,6 +3683,7 @@ function buildDeliveryInteractionEvent(input) {
             runtimeOwner: "openclaw",
             stream: input.sourceStream
         },
+        semantic: buildInteractionSemanticMetadata("runtime_turn", "message_delivered"),
         attribution: input.attribution,
         ...(input.compileResult.ok ? { packId: input.compileResult.compileResponse.packId } : {}),
         ...(messageId !== undefined ? { messageId } : {})
@@ -3531,6 +3733,7 @@ function buildFeedbackEvents(input) {
                 stream: input.sourceStream
             },
             content,
+            semantic: buildFeedbackSemanticMetadata("runtime_turn", kind),
             attribution: input.attribution,
             ...(messageId !== undefined ? { messageId } : {}),
             ...(principal === undefined ? {} : { principal }),
@@ -3980,6 +4183,7 @@ function buildRecordedSessionSeedExport(trace) {
                 runtimeOwner: "openclaw",
                 stream: sourceStream
             },
+            semantic: buildInteractionSemanticMetadata("recorded_session_seed", "operator_override"),
             messageId: `${cue.cueId}-seed-message`
         });
         sequence += 1;
@@ -3996,6 +4200,7 @@ function buildRecordedSessionSeedExport(trace) {
                 stream: sourceStream
             },
             content: cue.content,
+            semantic: buildFeedbackSemanticMetadata("recorded_session_seed", cue.kind ?? "teaching"),
             relatedInteractionId: interaction.eventId
         });
         sequence += 1;
@@ -5005,18 +5210,22 @@ function summarizeBrainStateWithoutObservability(active, activation) {
         detail: activation.detail
     };
 }
-function summarizeGraphWithoutObservability(active, activation) {
+function summarizeGraphWithoutObservability(input, active, activation) {
+    const latestMaterialization = summarizeLatestGraphMaterialization(input, active, null);
     return {
         available: false,
         runtimePlasticitySource: null,
         structuralOps: null,
+        connectDiagnostics: null,
         changed: null,
+        blockCount: null,
         operationsApplied: [],
         liveBlockCount: null,
         prunedBlockCount: null,
         prePruneBlockCount: null,
         strongestBlockId: null,
         operatorSummary: null,
+        latestMaterialization,
         detail: active === null
             ? activation.detail
             : `active pack ${active.packId} is pinned, but graph observability is unavailable`
@@ -5077,19 +5286,59 @@ function summarizeBrainState(active, observability) {
         detail
     };
 }
-function summarizeGraphObservability(active, observability) {
+function summarizeLatestGraphMaterialization(input, active, activeGraphEvolution) {
+    const loadedTeacherSurface = loadTeacherSurfaceFromInput(input);
+    const latestMaterialization = loadedTeacherSurface?.snapshot.learner.lastMaterialization ?? null;
+    const latestGraph = latestMaterialization?.candidate.summary.graphEvolutionLog ?? null;
+    if (latestGraph !== null) {
+        const packId = latestMaterialization?.candidate.summary.packId ?? latestGraph.packId;
+        return {
+            known: true,
+            packId,
+            changed: latestGraph.structuralEvolutionSummary.changed,
+            connectDiagnostics: latestGraph.connectDiagnostics === null ? null : { ...latestGraph.connectDiagnostics },
+            operatorSummary: latestGraph.structuralEvolutionSummary.operatorSummary,
+            detail: `latest known materialization is ${packId} from the teacher snapshot`
+        };
+    }
+    if (active !== null && activeGraphEvolution !== null) {
+        return {
+            known: true,
+            packId: active.packId,
+            changed: activeGraphEvolution.structuralEvolutionSummary.changed,
+            connectDiagnostics: activeGraphEvolution.connectDiagnostics === null ? null : { ...activeGraphEvolution.connectDiagnostics },
+            operatorSummary: activeGraphEvolution.structuralEvolutionSummary.operatorSummary,
+            detail: `latest known materialization is the active pack ${active.packId}`
+        };
+    }
+    return {
+        known: false,
+        packId: null,
+        changed: null,
+        connectDiagnostics: null,
+        operatorSummary: null,
+        detail: active === null
+            ? "no active pack or materialized learner snapshot is visible"
+            : `active pack ${active.packId} is pinned, but no latest materialization snapshot is visible`
+    };
+}
+function summarizeGraphObservability(input, active, observability) {
+    const latestMaterialization = summarizeLatestGraphMaterialization(input, active, observability.graphEvolutionLog);
     if (active === null) {
         return {
             available: false,
             runtimePlasticitySource: null,
             structuralOps: null,
+            connectDiagnostics: null,
             changed: null,
+            blockCount: null,
             operationsApplied: [],
             liveBlockCount: null,
             prunedBlockCount: null,
             prePruneBlockCount: null,
             strongestBlockId: null,
             operatorSummary: null,
+            latestMaterialization,
             detail: "no active pack is pinned, so there is no structural graph surface to inspect"
         };
     }
@@ -5099,13 +5348,16 @@ function summarizeGraphObservability(active, observability) {
             available: false,
             runtimePlasticitySource: observability.graphDynamics.runtimePlasticitySource,
             structuralOps: null,
+            connectDiagnostics: null,
             changed: null,
+            blockCount: null,
             operationsApplied: [],
             liveBlockCount: null,
             prunedBlockCount: null,
             prePruneBlockCount: null,
             strongestBlockId: null,
             operatorSummary: null,
+            latestMaterialization,
             detail: "active pack is present, but the graph evolution log is missing from activation observability"
         };
     }
@@ -5113,13 +5365,16 @@ function summarizeGraphObservability(active, observability) {
         available: true,
         runtimePlasticitySource: observability.graphDynamics.runtimePlasticitySource,
         structuralOps: { ...graphEvolution.structuralOps },
+        connectDiagnostics: graphEvolution.connectDiagnostics === null ? null : { ...graphEvolution.connectDiagnostics },
         changed: graphEvolution.structuralEvolutionSummary.changed,
+        blockCount: graphEvolution.blockCount,
         operationsApplied: [...graphEvolution.structuralEvolutionSummary.operationsApplied],
         liveBlockCount: graphEvolution.structuralEvolutionSummary.liveBlockCount,
         prunedBlockCount: graphEvolution.structuralEvolutionSummary.prunedBlockCount,
         prePruneBlockCount: graphEvolution.structuralEvolutionSummary.prePruneBlockCount,
         strongestBlockId: graphEvolution.strongestBlockId,
         operatorSummary: graphEvolution.structuralEvolutionSummary.operatorSummary,
+        latestMaterialization,
         detail: graphEvolution.structuralEvolutionSummary.changed
             ? graphEvolution.structuralEvolutionSummary.operatorSummary
             : "active pack graph is stable with no structural evolution beyond the current promoted artifact"
@@ -5136,6 +5391,7 @@ function summarizeServePath(compile) {
             usedLearnedRouteFn: null,
             routerIdentity: null,
             selectionMode: null,
+            selectionDigest: null,
             refreshStatus: null,
             freshnessChecksum: null,
             requestedBudgetStrategy: null,
@@ -5151,6 +5407,7 @@ function summarizeServePath(compile) {
                 usedLearnedRouteFn: null,
                 unprobed: true
             }),
+            timing: buildUnavailableBrainServeHotPathTiming("serve-path timing is unavailable because the hot path was not probed"),
             error: null
         };
     }
@@ -5163,6 +5420,7 @@ function summarizeServePath(compile) {
             usedLearnedRouteFn: compile.usedLearnedRouteFn,
             routerIdentity: compile.routerIdentity,
             selectionMode: null,
+            selectionDigest: null,
             refreshStatus: null,
             freshnessChecksum: null,
             requestedBudgetStrategy: null,
@@ -5173,6 +5431,7 @@ function summarizeServePath(compile) {
             structuralBudgetPressures: null,
             structuralDecision,
             contextAttribution: compile.contextAttribution,
+            timing: compile.timing,
             error: compile.error
         };
     }
@@ -5184,6 +5443,7 @@ function summarizeServePath(compile) {
         usedLearnedRouteFn: compile.usedLearnedRouteFn,
         routerIdentity: compile.routerIdentity,
         selectionMode: readDiagnosticNoteValue(compile.notes, "selection_mode="),
+        selectionDigest: compile.selectionDigest,
         refreshStatus: readDiagnosticNoteValue(compile.notes, "router_refresh_status="),
         freshnessChecksum: readDiagnosticNoteValue(compile.notes, "router_freshness_checksum="),
         requestedBudgetStrategy: readDiagnosticNoteValue(compile.notes, "requested_budget_strategy="),
@@ -5195,6 +5455,7 @@ function summarizeServePath(compile) {
         structuralBudgetPressures: readDiagnosticNoteValue(compile.notes, "structural_budget_pressures="),
         structuralDecision,
         contextAttribution: compile.contextAttribution,
+        timing: compile.timing,
         error: compile.error
     };
 }
@@ -5203,12 +5464,7 @@ function probeOperatorServePath(activationRoot, observability, activePackId) {
     const compile = compileInput === null ? null : buildAttachCompileStatus(compileRuntimeContext(compileInput), observability, activePackId);
     return summarizeServePath(compile);
 }
-function loadOperatorEventExport(input) {
-    const eventExportPath = normalizeOptionalString(input.eventExportPath);
-    if (eventExportPath === undefined) {
-        return null;
-    }
-    const resolvedPath = path.resolve(eventExportPath);
+function loadOperatorEventExportFromPath(resolvedPath) {
     const stats = statSync(resolvedPath);
     if (stats.isDirectory()) {
         const bundle = loadRuntimeEventExportBundle(resolvedPath);
@@ -5231,6 +5487,44 @@ function loadOperatorEventExport(input) {
         exportedAt: null
     };
 }
+function resolveOperatorEventExportScanRoots(input) {
+    const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
+    const teacherSurface = loadTeacherSurfaceFromInput(input);
+    const teacherScanRoot = normalizeOptionalString(teacherSurface?.watchSnapshot?.scanRoot);
+    return uniqueStringsInOrder([
+        teacherScanRoot === undefined ? undefined : path.resolve(teacherScanRoot),
+        path.join(activationRoot, "event-exports")
+    ].filter((value) => value !== undefined));
+}
+function loadLatestOperatorEventExportFromScanRoots(scanRoots) {
+    let latest = null;
+    for (const scanRoot of scanRoots) {
+        const discovered = discoverRuntimeEventExportBundles(scanRoot);
+        const candidate = discovered.bundles[discovered.bundles.length - 1] ?? null;
+        if (candidate === null) {
+            continue;
+        }
+        if (latest === null || compareRuntimeEventExportScannerBundleCursor(latest.cursor, candidate.cursor) < 0) {
+            latest = candidate;
+        }
+    }
+    if (latest === null) {
+        return null;
+    }
+    return {
+        sourcePath: latest.descriptor.rootDir,
+        sourceKind: "bundle_root",
+        normalizedEventExport: latest.descriptor.normalizedEventExport,
+        exportedAt: latest.descriptor.manifest.exportedAt
+    };
+}
+function loadOperatorEventExport(input) {
+    const eventExportPath = normalizeOptionalString(input.eventExportPath);
+    if (eventExportPath !== undefined) {
+        return loadOperatorEventExportFromPath(path.resolve(eventExportPath));
+    }
+    return loadLatestOperatorEventExportFromScanRoots(resolveOperatorEventExportScanRoots(input));
+}
 function summarizePrincipalItem(event) {
     if (event.principal === undefined) {
         return null;
@@ -5392,25 +5686,59 @@ function summarizeSupervision(input) {
     };
 }
 function loadTeacherSurfaceFromInput(input) {
-    const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
-    if (teacherSnapshotPath === undefined) {
+    const teacherSnapshotPath = resolveOperatorTeacherSnapshotPath(input.activationRoot, normalizeOptionalString(input.teacherSnapshotPath) ?? null);
+    if (teacherSnapshotPath === null) {
         return null;
     }
     return loadTeacherSurface(teacherSnapshotPath);
 }
+function summarizeTeacherLoopWatchState(input) {
+    if (input.sourceKind !== "watch_snapshot" || input.watchSnapshot === null) {
+        return {
+            snapshotUpdatedAt: null,
+            lastWatchHeartbeatAt: null,
+            pollIntervalSeconds: null,
+            watchState: input.sourceKind === "async_snapshot" ? "snapshot_only" : "not_visible"
+        };
+    }
+    const lastWatchHeartbeatAt = input.watchSnapshot.snapshot.runtime?.lastHeartbeatAt ?? input.watchSnapshot.lastRunAt;
+    const pollIntervalSeconds = input.watchSnapshot.pollIntervalSeconds;
+    if (lastWatchHeartbeatAt === null) {
+        return {
+            snapshotUpdatedAt: input.watchSnapshot.updatedAt,
+            lastWatchHeartbeatAt: null,
+            pollIntervalSeconds,
+            watchState: "snapshot_only"
+        };
+    }
+    const lagMs = Date.parse(input.observedAt) - Date.parse(lastWatchHeartbeatAt);
+    const staleAfterMs = pollIntervalSeconds * 2000 + 15_000;
+    return {
+        snapshotUpdatedAt: input.watchSnapshot.updatedAt,
+        lastWatchHeartbeatAt,
+        pollIntervalSeconds,
+        watchState: Number.isFinite(lagMs) && lagMs >= 0 && lagMs <= staleAfterMs ? "watching" : "stale_snapshot"
+    };
+}
 function summarizeTeacherLoop(input) {
     const loaded = loadTeacherSurfaceFromInput(input);
-    if (loaded === null && normalizeOptionalString(input.teacherSnapshotPath) === undefined) {
+    const teacherSnapshotPath = resolveOperatorTeacherSnapshotPath(input.activationRoot, normalizeOptionalString(input.teacherSnapshotPath) ?? null);
+    const unavailableFromMissing = buildUnavailableLastObservedDelta("no watch teacher snapshot is visible for the latest observed cycle");
+    const unavailableFromAsync = buildUnavailableLastObservedDelta("raw async teacher snapshots do not record the last observed export/label/promotion delta");
+    if (loaded === null && teacherSnapshotPath === null) {
         return {
             available: false,
             sourcePath: null,
             sourceKind: "missing",
+            snapshotUpdatedAt: null,
             lastRunAt: null,
             lastNoOpReason: "unavailable",
             latestFreshness: "unavailable",
             startedAt: null,
             lastHeartbeatAt: null,
             lastScanAt: null,
+            pollIntervalSeconds: null,
+            watchState: "not_visible",
             lastProcessedAt: null,
             artifactCount: null,
             queueDepth: null,
@@ -5431,22 +5759,25 @@ function summarizeTeacherLoop(input) {
             failureDetail: null,
             lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
+            lastObservedDelta: unavailableFromMissing,
             notes: [],
             detail: "no teacher snapshot path supplied"
         };
     }
     if (loaded === null) {
-        const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
         return {
             available: false,
-            sourcePath: teacherSnapshotPath === undefined ? null : path.resolve(teacherSnapshotPath),
+            sourcePath: path.resolve(teacherSnapshotPath),
             sourceKind: "missing",
+            snapshotUpdatedAt: null,
             lastRunAt: null,
             lastNoOpReason: "unavailable",
             latestFreshness: "unavailable",
             startedAt: null,
             lastHeartbeatAt: null,
             lastScanAt: null,
+            pollIntervalSeconds: null,
+            watchState: "not_visible",
             lastProcessedAt: null,
             artifactCount: null,
             queueDepth: null,
@@ -5467,22 +5798,31 @@ function summarizeTeacherLoop(input) {
             failureDetail: null,
             lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
+            lastObservedDelta: unavailableFromMissing,
             notes: [],
             detail: "teacher snapshot could not be loaded"
         };
     }
     const snapshot = loaded.snapshot;
     const watchSnapshot = loaded.watchSnapshot;
+    const watchState = summarizeTeacherLoopWatchState({
+        observedAt: normalizeIsoTimestamp(input.updatedAt, "updatedAt", new Date().toISOString()),
+        sourceKind: loaded.sourceKind,
+        watchSnapshot
+    });
     return {
         available: true,
         sourcePath: loaded.sourcePath,
         sourceKind: loaded.sourceKind,
+        snapshotUpdatedAt: watchState.snapshotUpdatedAt,
         lastRunAt: watchSnapshot?.lastRunAt ?? snapshot.runtime?.lastHeartbeatAt ?? snapshot.diagnostics.lastProcessedAt ?? null,
         lastNoOpReason: snapshot.diagnostics.lastNoOpReason,
         latestFreshness: snapshot.diagnostics.latestFreshness,
         startedAt: snapshot.runtime?.startedAt ?? null,
-        lastHeartbeatAt: snapshot.runtime?.lastHeartbeatAt ?? null,
+        lastHeartbeatAt: watchState.lastWatchHeartbeatAt ?? snapshot.runtime?.lastHeartbeatAt ?? null,
         lastScanAt: snapshot.runtime?.lastScanAt ?? null,
+        pollIntervalSeconds: watchState.pollIntervalSeconds,
+        watchState: watchState.watchState,
         lastProcessedAt: snapshot.diagnostics.lastProcessedAt,
         artifactCount: watchSnapshot?.teacher.artifactCount ?? snapshot.teacher.artifactCount,
         queueDepth: snapshot.queue.depth,
@@ -5506,12 +5846,95 @@ function summarizeTeacherLoop(input) {
             snapshot.learner.lastMaterialization?.jobId ??
             null,
         lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null,
+        lastObservedDelta: loaded.sourceKind === "watch_snapshot" && watchSnapshot !== null
+            ? cloneLastObservedDelta(watchSnapshot.lastObservedDelta)
+            : unavailableFromAsync,
         notes: [...snapshot.diagnostics.notes],
         detail: loaded.sourceKind === "watch_snapshot"
             ? "canonical watch teacher snapshot loaded"
             : "raw async teacher snapshot loaded"
     };
 }
+function matchesActiveRouteFnLog(input) {
+    if (input.activePackId !== null && input.entryPackId === input.activePackId) {
+        return true;
+    }
+    if (input.routerChecksum !== null && input.entryRouterChecksum === input.routerChecksum) {
+        return true;
+    }
+    return false;
+}
+function summarizeRouteFnFreshness(input) {
+    if (input.activePackId === null) {
+        return {
+            available: false,
+            activePackId: null,
+            routerIdentity: input.learnedRouting.routerIdentity,
+            routerChecksum: input.learnedRouting.routerChecksum,
+            trainedAt: null,
+            updatedAt: null,
+            usedAt: null,
+            lastDecisionAt: null,
+            lastDecisionUsedLearnedRouteFn: null,
+            detail: "no active pack is pinned, so there is no current route_fn to time"
+        };
+    }
+    if (!input.learnedRouting.available) {
+        return {
+            available: false,
+            activePackId: input.activePackId,
+            routerIdentity: input.learnedRouting.routerIdentity,
+            routerChecksum: input.learnedRouting.routerChecksum,
+            trainedAt: input.learnedRouting.routerTrainedAt,
+            updatedAt: null,
+            usedAt: null,
+            lastDecisionAt: null,
+            lastDecisionUsedLearnedRouteFn: null,
+            detail: input.learnedRouting.required
+                ? `active pack ${input.activePackId} requires learned routing, but no route_fn artifact is available`
+                : `active pack ${input.activePackId} does not require a learned route_fn`
+        };
+    }
+    const updates = readLearningSpineLogEntries(input.activationRoot, "pgRouteUpdates");
+    const decisions = readLearningSpineLogEntries(input.activationRoot, "serveTimeRouteDecisions");
+    const updated = [...updates].reverse().find((entry) => matchesActiveRouteFnLog({
+        activePackId: input.activePackId,
+        routerChecksum: input.learnedRouting.routerChecksum,
+        entryPackId: entry.nextPackId,
+        entryRouterChecksum: entry.nextRouterChecksum
+    }));
+    const learnedUse = [...decisions].reverse().find((entry) => entry.usedLearnedRouteFn === true &&
+        matchesActiveRouteFnLog({
+            activePackId: input.activePackId,
+            routerChecksum: input.learnedRouting.routerChecksum,
+            entryPackId: entry.activePackId,
+            entryRouterChecksum: entry.activePackRouterChecksum
+        }));
+    const lastDecision = [...decisions].reverse().find((entry) => matchesActiveRouteFnLog({
+        activePackId: input.activePackId,
+        routerChecksum: input.learnedRouting.routerChecksum,
+        entryPackId: entry.activePackId,
+        entryRouterChecksum: entry.activePackRouterChecksum
+    }));
+    return {
+        available: true,
+        activePackId: input.activePackId,
+        routerIdentity: input.learnedRouting.routerIdentity,
+        routerChecksum: input.learnedRouting.routerChecksum,
+        trainedAt: input.learnedRouting.routerTrainedAt,
+        updatedAt: updated?.recordedAt ?? null,
+        usedAt: learnedUse?.recordedAt ?? null,
+        lastDecisionAt: lastDecision?.recordedAt ?? null,
+        lastDecisionUsedLearnedRouteFn: lastDecision?.usedLearnedRouteFn ?? null,
+        detail: learnedUse !== undefined
+            ? `active route_fn last served a learned turn at ${learnedUse.recordedAt}`
+            : updated !== undefined
+                ? `active route_fn was updated at ${updated.recordedAt}, but no learned serve decision for the current pack is visible yet`
+                : input.learnedRouting.routerTrainedAt !== null
+                    ? `active route_fn was trained at ${input.learnedRouting.routerTrainedAt}, but no matching update or serve-use log is visible yet`
+                    : `active pack ${input.activePackId} exposes a route_fn, but the train/update timestamps are not visible`
+    };
+}
 function summarizeLearningBacklogState(plan, principalLagStatus) {
     if (!plan.bootstrapped && plan.pending.total === 0) {
         return "awaiting_first_export";
@@ -5567,7 +5990,8 @@ function summarizeAlwaysOnLearning(input, active) {
         status: "unavailable"
     };
     const loadedTeacherSurface = loadTeacherSurfaceFromInput(input);
-    if (loadedTeacherSurface === null && normalizeOptionalString(input.teacherSnapshotPath) === undefined) {
+    const teacherSnapshotPath = resolveOperatorTeacherSnapshotPath(input.activationRoot, normalizeOptionalString(input.teacherSnapshotPath) ?? null);
+    if (loadedTeacherSurface === null && teacherSnapshotPath === null) {
         return {
             available: false,
             sourcePath: null,
@@ -5600,10 +6024,9 @@ function summarizeAlwaysOnLearning(input, active) {
         };
     }
     if (loadedTeacherSurface === null) {
-        const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
         return {
             available: false,
-            sourcePath: teacherSnapshotPath === undefined ? null : path.resolve(teacherSnapshotPath),
+            sourcePath: path.resolve(teacherSnapshotPath),
             bootstrapped: null,
             mode: "unavailable",
             nextPriorityLane: "unavailable",
@@ -5707,6 +6130,18 @@ function buildOperatorFindings(report) {
     const push = (severity, code, summary, detail) => {
         findings.push({ severity, code, summary, detail });
     };
+    if (report.hook.desynced) {
+        push("fail", "hook_desynced", "profile hook is blocked by OpenClaw config desync", report.hook.detail);
+    }
+    else if (report.attachmentTruth.state === "not_attached") {
+        push("fail", "current_profile_not_attached", "current profile is not attached", report.attachmentTruth.detail);
+    }
+    else if (report.attachmentTruth.state === "unknown") {
+        push("warn", "attachment_scope_partial", "current-profile attachment is not self-proven", report.attachmentTruth.detail);
+    }
+    else {
+        push("pass", "current_profile_attached", "current profile hook is present", report.attachmentTruth.detail);
+    }
     if (report.activation.state === "broken_install") {
         push("fail", "activation_broken_install", "activation root is broken", report.activation.detail);
     }
@@ -5858,6 +6293,105 @@ function summarizeCurrentProfileLastLearningUpdateAt(activationRoot, learning, t
     const updates = readLearningSpineLogEntries(activationRoot, "pgRouteUpdates");
     return updates.at(-1)?.recordedAt ?? teacherLoop.lastRunAt ?? learning.lastMaterializedAt ?? null;
 }
+function didCurrentProfileFirstExportOccur(report) {
+    if ((report.active?.eventRange.count ?? 0) > 0) {
+        return true;
+    }
+    if (report.supervision.exportedAt !== null) {
+        return true;
+    }
+    if (report.learning.available && (report.learning.learnedRange?.count ?? 0) > 0) {
+        return true;
+    }
+    if (!report.teacherLoop.available) {
+        return false;
+    }
+    return ((report.teacherLoop.replayedBundleCount ?? 0) > 0 ||
+        (report.teacherLoop.exportedBundleCount ?? 0) > 0 ||
+        report.teacherLoop.lastProcessedAt !== null ||
+        report.teacherLoop.lastMaterializedPackId !== null);
+}
+function summarizeCurrentProfilePassiveLearning(report, activePackId) {
+    const firstExportOccurred = didCurrentProfileFirstExportOccur(report);
+    const exportState = !firstExportOccurred
+        ? "awaiting_first_export"
+        : report.supervision.exportedAt !== null
+            ? "latest_export_visible"
+            : "history_only";
+    const backlogState = report.learning.available && report.learning.backlogState !== "unavailable"
+        ? report.learning.backlogState
+        : "unknown";
+    const detail = !firstExportOccurred
+        ? report.teacherLoop.watchState === "watching"
+            ? "watch heartbeat is fresh, but this activation root has not observed its first export yet"
+            : "this activation root is still waiting for the first export before passive learning can advance"
+        : backlogState === "unknown"
+            ? "first export is proven, but passive backlog state is not visible from the current local artifacts"
+            : report.teacherLoop.watchState === "watching"
+                ? `watch heartbeat is fresh; passive backlog is ${backlogState} with live=${report.learning.pendingLive ?? 0} and backfill=${report.learning.pendingBackfill ?? 0}`
+                : report.teacherLoop.watchState === "stale_snapshot"
+                    ? `last saved watch snapshot is stale; latest known passive backlog is ${backlogState}`
+                    : report.teacherLoop.watchState === "snapshot_only"
+                        ? `passive backlog is visible from the last saved snapshot: ${backlogState}`
+                        : `passive backlog is visible from the last known learner state: ${backlogState}`;
+    return {
+        learnerRunning: report.teacherLoop.watchState === "watching",
+        firstExportOccurred,
+        watchState: report.teacherLoop.watchState,
+        exportState,
+        backlogState,
+        pendingLive: report.learning.available ? report.learning.pendingLive : null,
+        pendingBackfill: report.learning.available ? report.learning.pendingBackfill : null,
+        lastWatchHeartbeatAt: report.teacherLoop.lastHeartbeatAt,
+        watchIntervalSeconds: report.teacherLoop.pollIntervalSeconds,
+        lastExportAt: report.supervision.exportedAt,
+        lastPromotionAt: report.promotion.lastPromotion.at,
+        currentServingPackId: activePackId,
+        lastMaterializedPackId: report.learning.lastMaterializedPackId ?? report.teacherLoop.lastMaterializedPackId,
+        lastObservedDelta: cloneLastObservedDelta(report.teacherLoop.lastObservedDelta),
+        detail
+    };
+}
+function summarizeOperatorHook(report) {
+    return summarizeOpenClawBrainHookLoad(inspectOpenClawBrainHookStatus(report.openclawHome ?? null), report.servePath.state === "serving_active_pack");
+}
+function summarizeOperatorAttachmentTruth(report) {
+    const watchOnly = report.active !== null || report.teacherLoop.watchState !== "not_visible";
+    if (report.hook.scope === "exact_openclaw_home") {
+        if (report.hook.installState === "not_installed") {
+            return {
+                state: "not_attached",
+                proofState: "self_proving",
+                watchOnly,
+                activationRoot: null,
+                servingSlot: "none",
+                detail: watchOnly
+                    ? "the selected OpenClaw home has no OpenClawBrain hook, even though this activation root still shows serve/watch activity"
+                    : "the selected OpenClaw home has no OpenClawBrain hook"
+            };
+        }
+        return {
+            state: "attached",
+            proofState: "self_proving",
+            watchOnly: false,
+            activationRoot: report.activationRoot,
+            servingSlot: report.active === null ? "none" : "active",
+            detail: report.hook.installState === "blocked_by_allowlist"
+                ? "current profile hook files exist, but OpenClaw will not load them until the plugin allowlist/config desync is repaired"
+                : "current profile hook is present on the selected OpenClaw home"
+        };
+    }
+    return {
+        state: "unknown",
+        proofState: "activation_root_only",
+        watchOnly,
+        activationRoot: watchOnly ? report.activationRoot : null,
+        servingSlot: report.active === null ? "none" : "active",
+        detail: watchOnly
+            ? "activation-root-only status can see this root serving and/or being watched, but it does not prove that the current profile is attached"
+            : "activation-root-only status cannot prove whether the current profile is attached"
+    };
+}
 function summarizeCurrentProfileBrainSummary(input) {
     const packId = input.activePackId ?? "unknown";
     if (input.activationState === "broken_install") {
@@ -5866,9 +6400,17 @@ function summarizeCurrentProfileBrainSummary(input) {
     if (input.activationState === "stale_incomplete") {
         return "Brain activation has retained stale/incomplete state and no serving active pack.";
     }
-    if (!input.attached) {
+    if (input.attachmentState === "not_attached") {
         return "Brain is not attached to the current Profile.";
     }
+    if (input.hookDesynced) {
+        return "Brain hook files exist, but OpenClaw config currently blocks them from loading.";
+    }
+    if (input.attachmentState === "unknown") {
+        return input.watchOnly
+            ? "This activation root is visible, but current-profile attachment is only watch/serve scoped and not self-proven."
+            : "Current-profile attachment is unknown because this read is activation-root-only.";
+    }
     if (input.serveState === "fail_open_static_context") {
         return "Brain is attached but would fail open to static context.";
     }
@@ -5887,19 +6429,98 @@ function summarizeCurrentProfileBrainSummary(input) {
     return "Brain is attached but has not been compile-probed yet.";
 }
 function summarizeCurrentProfileBrainStatusLevel(input) {
-    if (!input.attached) {
+    if (input.hookDesynced || input.attachmentState === "not_attached") {
         return "fail";
     }
     if (input.serveState === "fail_open_static_context" || input.serveState === "hard_fail") {
         return "fail";
     }
-    if (input.awaitingFirstExport || input.serveState === "unprobed") {
+    if (input.attachmentState === "unknown" || input.awaitingFirstExport || input.serveState === "unprobed") {
         return "warn";
     }
     return input.routeFreshness === "updated" ? "ok" : "warn";
 }
+function buildCurrentProfileTurnAttributionFromReport(report, policyMode, profileId) {
+    if (report.servePath.state === "unprobed" || report.attachmentTruth.state !== "attached") {
+        return null;
+    }
+    const brainStatus = report.servePath.state;
+    const sessionId = "current-profile-status-probe";
+    const channel = "operator_status";
+    const createdAt = report.generatedAt;
+    const sourceStream = "openclaw/operator/status";
+    const packId = brainStatus === "serving_active_pack"
+        ? report.servePath.activePackId ?? report.brain.activePackId ?? report.active?.packId ?? null
+        : null;
+    const routerIdentity = brainStatus === "serving_active_pack"
+        ? report.servePath.routerIdentity ?? report.learnedRouting.routerIdentity ?? report.active?.routerIdentity ?? null
+        : null;
+    const usedLearnedRouteFn = brainStatus === "serving_active_pack" ? report.servePath.usedLearnedRouteFn : null;
+    const selectionMode = brainStatus === "serving_active_pack" ? report.servePath.selectionMode : null;
+    const selectionDigest = brainStatus === "serving_active_pack" ? report.servePath.selectionDigest : null;
+    const contextAttribution = report.servePath.contextAttribution;
+    const probeTurn = {
+        sessionId,
+        channel,
+        sourceStream,
+        userMessage: DEFAULT_ATTACH_STATUS_MESSAGE,
+        createdAt,
+        runtimeHints: [...DEFAULT_ATTACH_STATUS_RUNTIME_HINTS],
+        profileSelector: "current_profile",
+        profileId,
+        brainAttachmentPolicy: policyMode
+    };
+    return {
+        contract: CONTRACT_IDS.profileTurnAttribution,
+        hostRuntimeOwner: "openclaw",
+        profileSelector: "current_profile",
+        profileId,
+        brainAttachmentPolicy: policyMode,
+        brainStatus,
+        sessionId,
+        channel,
+        interactionEventId: deterministicEventId({
+            source: sourceStream,
+            activationRoot: report.activationRoot,
+            createdAt,
+            brainStatus,
+            packId,
+            routerIdentity,
+            selectionDigest
+        }),
+        createdAt,
+        packId,
+        routerIdentity,
+        usedLearnedRouteFn,
+        selectionMode,
+        selectionTiers: contextAttribution.selectionTiers,
+        selectionDigest,
+        contextFingerprint: buildRuntimeContextFingerprint({
+            turn: probeTurn,
+            sourceStream,
+            profileSelector: "current_profile",
+            brainAttachmentPolicy: policyMode,
+            brainStatus,
+            activePackId: packId,
+            usedLearnedRouteFn,
+            routerIdentity,
+            selectionDigest
+        }),
+        selectedContextCount: contextAttribution.selectedContextCount,
+        stableKernelBlockCount: contextAttribution.stableKernelBlockCount,
+        brainCompiledBlockCount: contextAttribution.brainCompiledBlockCount,
+        stableKernelSources: [...contextAttribution.stableKernelSources],
+        brainCompiledSources: [...contextAttribution.brainCompiledSources],
+        contextEvidence: contextAttribution.evidence === "unprobed" ? "stable_kernel_only" : contextAttribution.evidence,
+        detail: brainStatus === "serving_active_pack"
+            ? "current profile status probe compiled from the active pack with explicit route-function and block-source attribution"
+            : brainStatus === "hard_fail"
+                ? "current profile status probe hit a learned-route hard fail before serving context could compile"
+                : "current profile status probe fail-opened to static context because no serving pack was available"
+    };
+}
 function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId) {
-    const attached = report.active !== null;
+    const attachmentState = report.attachmentTruth.state;
     const awaitingFirstExport = isAwaitingFirstExportSlot(report.active);
     const activationState = report.activation.state;
     const routerIdentity = report.servePath.routerIdentity ?? report.learnedRouting.routerIdentity ?? report.active?.routerIdentity ?? null;
@@ -5907,8 +6528,10 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
         ? report.servePath.refreshStatus
         : "unknown";
     const activePackId = report.brain.activePackId ?? report.servePath.activePackId ?? report.active?.packId ?? null;
+    const passiveLearning = summarizeCurrentProfilePassiveLearning(report, activePackId);
     const status = summarizeCurrentProfileBrainStatusLevel({
-        attached,
+        attachmentState,
+        hookDesynced: report.hook.desynced,
         serveState: report.servePath.state,
         routeFreshness,
         awaitingFirstExport
@@ -5925,13 +6548,15 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
             noun: "Profile",
             selector: "current_profile",
             profileId,
-            detail: attached
-                ? "The Host resolves the current Profile through the active Attachment boundary only."
-                : "The current Profile has no active Brain attachment visible at the Host boundary."
+            detail: attachmentState === "attached"
+                ? "The Host resolves the current Profile through the selected OpenClaw home and its active Attachment boundary."
+                : attachmentState === "not_attached"
+                    ? "The selected OpenClaw home has no OpenClawBrain hook for the current Profile."
+                    : "This read is activation-root-only, so current-profile attachment is not self-proven."
         },
         brain: {
             noun: "Brain",
-            activationRoot: attached ? report.activationRoot : null,
+            activationRoot: attachmentState === "not_attached" ? null : report.activationRoot,
             logRoot: summarizeCurrentProfileLogRoot(report.activationRoot),
             activePackId,
             initMode: report.learnedRouting.initMode,
@@ -5944,7 +6569,9 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
             lastPromotionAt: report.promotion.lastPromotion.at,
             summary: summarizeCurrentProfileBrainSummary({
                 activationState,
-                attached,
+                attachmentState,
+                watchOnly: report.attachmentTruth.watchOnly,
+                hookDesynced: report.hook.desynced,
                 serveState: report.servePath.state,
                 brainState: report.brain.state,
                 awaitingFirstExport,
@@ -5955,29 +6582,30 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
                 ? report.activation.detail
                 : report.brain.detail
         },
-        attachment: attached
-            ? {
-                noun: "Attachment",
-                state: "attached",
-                activationRoot: report.activationRoot,
-                servingSlot: "active",
-                policyMode,
-                policy: buildCurrentProfileAttachmentPolicy(policyMode),
-                detail: policyMode === "shared"
-                    ? "current profile is attached to a shared OpenClawBrain activation boundary"
-                    : policyMode === "dedicated"
-                        ? "current profile is attached to a dedicated OpenClawBrain activation boundary"
-                        : "current profile is attached to an OpenClawBrain activation boundary, but shared-vs-dedicated policy has not been declared"
-            }
-            : {
-                noun: "Attachment",
-                state: "not_attached",
-                activationRoot: null,
-                servingSlot: "none",
-                policyMode,
-                policy: buildCurrentProfileAttachmentPolicy(policyMode),
-                detail: "current profile is not attached to an OpenClawBrain activation boundary"
-            },
+        hook: {
+            noun: "Hook",
+            scope: report.hook.scope,
+            openclawHome: report.hook.openclawHome,
+            hookPath: report.hook.hookPath,
+            runtimeGuardPath: report.hook.runtimeGuardPath,
+            manifestPath: report.hook.manifestPath,
+            installState: report.hook.installState,
+            loadability: report.hook.loadability,
+            loadProof: report.hook.loadProof,
+            desynced: report.hook.desynced,
+            detail: report.hook.detail
+        },
+        attachment: {
+            noun: "Attachment",
+            state: attachmentState,
+            activationRoot: report.attachmentTruth.activationRoot,
+            servingSlot: report.attachmentTruth.servingSlot,
+            policyMode,
+            policy: buildCurrentProfileAttachmentPolicy(policyMode),
+            proofState: report.attachmentTruth.proofState,
+            watchOnly: report.attachmentTruth.watchOnly,
+            detail: report.attachmentTruth.detail
+        },
         brainStatus: {
             status,
             brainState: report.brain.state,
@@ -5987,25 +6615,33 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
             failOpen: report.servePath.fallbackToStaticContext,
             awaitingFirstExport,
             structuralDecision: report.servePath.structuralDecision,
+            timing: report.servePath.timing,
             detail: activationState === "broken_install"
                 ? `current profile activation is broken: ${report.activation.detail}`
-                : activationState === "stale_incomplete"
-                    ? `current profile activation is stale/incomplete: ${report.activation.detail}`
-                    : activationState === "detached"
-                        ? "current profile has no attached active pack at the activation boundary"
-                        : report.servePath.state === "serving_active_pack"
-                            ? awaitingFirstExport
-                                ? `current profile is serving seed-state pack ${activePackId ?? "unknown"} while awaiting the first exported turn`
-                                : report.brain.state === "pg_promoted_pack_authoritative"
-                                    ? `current profile is serving promoted pack ${activePackId ?? "unknown"}; serve-visible change came from activation promotion, not hot-path mutation`
-                                    : `current profile is serving active pack ${activePackId ?? "unknown"}; learned routing is active, but authority is still seed-state`
-                            : report.servePath.state === "fail_open_static_context"
-                                ? "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"
+                : report.hook.desynced
+                    ? `current profile hook is blocked: ${report.hook.detail}`
+                    : activationState === "stale_incomplete"
+                        ? `current profile activation is stale/incomplete: ${report.activation.detail}`
+                        : attachmentState === "not_attached"
+                            ? "current profile is not attached to this Brain activation root"
+                            : attachmentState === "unknown"
+                                ? "current profile attachment is not self-proven from this activation-root-only read"
+                                : activationState === "detached"
+                                    ? "current profile has no attached active pack at the activation boundary"
+                                    : report.servePath.state === "serving_active_pack"
+                                        ? awaitingFirstExport
+                                            ? `current profile is serving seed-state pack ${activePackId ?? "unknown"} while awaiting the first exported turn`
+                                            : report.brain.state === "pg_promoted_pack_authoritative"
+                                                ? `current profile is serving promoted pack ${activePackId ?? "unknown"}; serve-visible change came from activation promotion, not hot-path mutation`
+                                                : `current profile is serving active pack ${activePackId ?? "unknown"}; learned routing is active, but authority is still seed-state`
+                                        : report.servePath.state === "fail_open_static_context"
+                                            ? "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"
         },
-        currentTurnAttribution: null
+        passiveLearning,
+        currentTurnAttribution: buildCurrentProfileTurnAttributionFromReport(report, policyMode, profileId)
     };
 }
 export function buildOperatorSurfaceReport(input) {
@@ -6049,6 +6685,46 @@ export function buildOperatorSurfaceReport(input) {
             learningPath: buildMissingLearningPathSummary(`activation observability is unavailable: ${inspectionError}`)
         };
     const servePath = probeOperatorServePath(activationRoot, observability, active?.packId ?? null);
+    const learnedRouting = observability === null
+        ? summarizeLearnedRoutingWithoutObservability(active)
+        : {
+            required: observability.learnedRouteFn.required,
+            available: observability.learnedRouteFn.available,
+            routerIdentity: observability.learnedRouteFn.routerIdentity,
+            routeFnVersion: observability.learnedRouteFn.routeFnVersion,
+            trainingMethod: observability.learnedRouteFn.trainingMethod,
+            routerTrainedAt: observability.learnedRouteFn.routerTrainedAt,
+            objective: observability.learnedRouteFn.objective,
+            pgProfile: observability.learnedRouteFn.pgProfile,
+            routerChecksum: observability.learnedRouteFn.routerChecksum,
+            objectiveChecksum: observability.learnedRouteFn.objectiveChecksum,
+            updateMechanism: observability.learnedRouteFn.updateMechanism,
+            updateVersion: observability.learnedRouteFn.updateVersion,
+            updateCount: observability.learnedRouteFn.updateCount,
+            supervisionCount: observability.learnedRouteFn.supervisionCount,
+            collectedLabelsTotal: observability.learnedRouteFn.collectedLabels?.total ?? null,
+            freshnessChecksum: observability.learnedRouteFn.freshnessChecksum,
+            handoffState: observability.initHandoff.handoffState,
+            initMode: observability.initHandoff.initMode,
+            seedStateVisible: observability.initHandoff.seedStateVisible
+        };
+    const routeFn = summarizeRouteFnFreshness({
+        activationRoot,
+        activePackId: active?.packId ?? null,
+        learnedRouting
+    });
+    const teacherLoop = summarizeTeacherLoop(input);
+    const hook = summarizeOperatorHook({
+        activationRoot,
+        openclawHome: normalizeOptionalString(input.openclawHome) ?? null,
+        servePath
+    });
+    const attachmentTruth = summarizeOperatorAttachmentTruth({
+        activationRoot,
+        active,
+        teacherLoop,
+        hook
+    });
     const reportBase = {
         generatedAt: updatedAt,
         activationRoot,
@@ -6061,32 +6737,12 @@ export function buildOperatorSurfaceReport(input) {
             candidateAheadBy: summarizeCandidateAheadBy(observability?.promotionFreshness.candidateAheadBy ?? null)
         },
         brain: observability === null ? summarizeBrainStateWithoutObservability(active, activation) : summarizeBrainState(active, observability),
-        graph: observability === null ? summarizeGraphWithoutObservability(active, activation) : summarizeGraphObservability(active, observability),
+        graph: observability === null
+            ? summarizeGraphWithoutObservability(input, active, activation)
+            : summarizeGraphObservability(input, active, observability),
         labelFlow: activeObservability.labelFlow,
         learningPath: activeObservability.learningPath,
-        learnedRouting: observability === null
-            ? summarizeLearnedRoutingWithoutObservability(active)
-            : {
-                required: observability.learnedRouteFn.required,
-                available: observability.learnedRouteFn.available,
-                routerIdentity: observability.learnedRouteFn.routerIdentity,
-                routeFnVersion: observability.learnedRouteFn.routeFnVersion,
-                trainingMethod: observability.learnedRouteFn.trainingMethod,
-                routerTrainedAt: observability.learnedRouteFn.routerTrainedAt,
-                objective: observability.learnedRouteFn.objective,
-                pgProfile: observability.learnedRouteFn.pgProfile,
-                routerChecksum: observability.learnedRouteFn.routerChecksum,
-                objectiveChecksum: observability.learnedRouteFn.objectiveChecksum,
-                updateMechanism: observability.learnedRouteFn.updateMechanism,
-                updateVersion: observability.learnedRouteFn.updateVersion,
-                updateCount: observability.learnedRouteFn.updateCount,
-                supervisionCount: observability.learnedRouteFn.supervisionCount,
-                collectedLabelsTotal: observability.learnedRouteFn.collectedLabels?.total ?? null,
-                freshnessChecksum: observability.learnedRouteFn.freshnessChecksum,
-                handoffState: observability.initHandoff.handoffState,
-                initMode: observability.initHandoff.initMode,
-                seedStateVisible: observability.initHandoff.seedStateVisible
-            },
+        learnedRouting,
         servePath,
         promotion: {
             allowed: inspection?.promotion.allowed ?? false,
@@ -6109,7 +6765,10 @@ export function buildOperatorSurfaceReport(input) {
         },
         supervision: summarizeSupervision(input),
         learning: summarizeAlwaysOnLearning(input, active),
-        teacherLoop: summarizeTeacherLoop(input),
+        teacherLoop,
+        routeFn,
+        hook,
+        attachmentTruth,
         principal: summarizePrincipalObservability(input, active),
         manyProfile: summarizeManyProfileSupport(brainAttachmentPolicy)
     };