@openclawbrain/openclaw 0.2.2 → 0.3.0

package/dist/src/index.js

@@ -8,6 +8,8 @@ import { classifyFeedbackSignalContent, describeNormalizedEventExportObservabili
 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 { appendLearningUpdateLogs, appendServeTimeRouteDecisionLog } from "./learning-spine.js";
+import { createTeacherLabeler } from "./teacher-labeler.js";
+export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler } from "./teacher-labeler.js";
 const DEFAULT_AGENT_ID = "openclaw-runtime";
 const FEEDBACK_KINDS = new Set(["correction", "teaching", "approval", "suppression"]);
 export const DEFAULT_ASYNC_TEACHER_QUEUE_CAPACITY = 8;
@@ -220,6 +222,8 @@ function buildAsyncTeacherLoopNotes(input) {
         `teacher_feedback_budgeted_out=${input.sparseFeedback.budgetedOutFeedbackCount}`,
         `teacher_background_amplified=${input.sparseFeedback.amplifiedBackgroundLabelCount}`,
         `teacher_noop=${input.noOpReason}`,
+        `teacher_labeler=${input.teacherLabeler?.status ?? "disabled"}`,
+        `teacher_labeler_detail=${input.teacherLabeler?.detail ?? "disabled"}`,
         input.materialization === null ? "teacher_materialization=noop" : `teacher_materialized_pack=${input.materialization.candidate.summary.packId}`
     ];
 }
@@ -229,6 +233,22 @@ function cloneAlwaysOnLearningMaterializationJobOrNull(value) {
 function cloneTeacherSupervisionArtifacts(value) {
     return [...structuredClone(value)];
 }
+function cloneAsyncTeacherSnapshotState(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const interactionEvents = Array.isArray(value.interactionEvents) ? value.interactionEvents : [];
+    const feedbackEvents = Array.isArray(value.feedbackEvents) ? value.feedbackEvents : [];
+    const seenExportDigests = Array.isArray(value.seenExportDigests) ? value.seenExportDigests : [];
+    return {
+        interactionEvents: [...structuredClone(interactionEvents)],
+        feedbackEvents: [...structuredClone(feedbackEvents)],
+        seenExportDigests: [...seenExportDigests]
+    };
+}
+function cloneAsyncTeacherSnapshotRuntime(value) {
+    return value === undefined ? undefined : { ...value };
+}
 function cloneCanonicalSupervision(value) {
     return structuredClone(value);
 }
@@ -508,6 +528,7 @@ export class AsyncTeacherLiveLoop {
     input;
     queueCapacity;
     staleAfterMs;
+    teacherLabeler;
     queuedExportDigests = new Set();
     seenExportDigests = new Set();
     queue = [];
@@ -517,6 +538,7 @@ export class AsyncTeacherLiveLoop {
     teacherArtifacts = [];
     learnerState = createAlwaysOnLearningRuntimeState();
     lastMaterialization = null;
+    lastTeacherLabelerResult = null;
     diagnostics = {
         acceptedExportCount: 0,
         processedExportCount: 0,
@@ -535,19 +557,40 @@ export class AsyncTeacherLiveLoop {
             dedupedArtifactCount: 0,
             sparseFeedback: this.learnerState.sparseFeedback,
             noOpReason: "none",
-            materialization: null
+            materialization: null,
+            teacherLabeler: null
         })
     };
     constructor(input) {
         this.input = input;
         this.queueCapacity = input.maxQueuedExports ?? DEFAULT_ASYNC_TEACHER_QUEUE_CAPACITY;
         this.staleAfterMs = input.staleAfterMs ?? DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS;
+        this.teacherLabeler = createTeacherLabeler(input.teacherLabeler);
         if (!Number.isInteger(this.queueCapacity) || this.queueCapacity <= 0) {
             throw new Error("maxQueuedExports must be a positive integer");
         }
         if (!Number.isInteger(this.staleAfterMs) || this.staleAfterMs <= 0) {
             throw new Error("staleAfterMs must be a positive integer");
         }
+        const resumedSnapshot = input.resumeFromSnapshot;
+        if (resumedSnapshot !== undefined && resumedSnapshot !== null) {
+            if (resumedSnapshot.runtimeOwner !== "openclaw") {
+                throw new Error("async teacher resume snapshot runtimeOwner must be openclaw");
+            }
+            this.interactionEvents = [...structuredClone(resumedSnapshot.state?.interactionEvents ?? [])];
+            this.feedbackEvents = [...structuredClone(resumedSnapshot.state?.feedbackEvents ?? [])];
+            this.teacherArtifacts = cloneTeacherSupervisionArtifacts(resumedSnapshot.teacher.artifacts);
+            this.learnerState = structuredClone(resumedSnapshot.learner.state);
+            this.lastMaterialization = cloneAlwaysOnLearningMaterializationJobOrNull(resumedSnapshot.learner.lastMaterialization);
+            this.diagnostics = {
+                ...structuredClone(resumedSnapshot.diagnostics),
+                notes: [...resumedSnapshot.diagnostics.notes]
+            };
+            for (const exportDigest of resumedSnapshot.state?.seenExportDigests ?? []) {
+                this.seenExportDigests.add(exportDigest);
+            }
+            this.refreshNotes();
+        }
     }
     enqueueNormalizedEventExport(normalizedEventExport, options = {}) {
         const validationErrors = validateNormalizedEventExport(normalizedEventExport);
@@ -589,7 +632,9 @@ export class AsyncTeacherLiveLoop {
         this.queuedExportDigests.add(exportDigest);
         this.diagnostics.acceptedExportCount += 1;
         this.refreshNotes();
-        void this.ensureDrain();
+        void this.ensureDrain().catch(() => {
+            // Explicit flush()/ingest callers observe the failure; the background kickoff must not leak an unhandled rejection.
+        });
         return {
             accepted: true,
             exportDigest,
@@ -745,6 +790,11 @@ export class AsyncTeacherLiveLoop {
             diagnostics: {
                 ...this.diagnostics,
                 notes: [...this.diagnostics.notes]
+            },
+            state: {
+                interactionEvents: [...structuredClone(this.interactionEvents)],
+                feedbackEvents: [...structuredClone(this.feedbackEvents)],
+                seenExportDigests: [...this.seenExportDigests].sort()
             }
         };
     }
@@ -763,49 +813,106 @@ export class AsyncTeacherLiveLoop {
         while (this.queue.length > 0) {
             const job = this.queue.shift();
             this.queuedExportDigests.delete(job.exportDigest);
-            this.seenExportDigests.add(job.exportDigest);
-            this.interactionEvents = mergeUniqueEvents(this.interactionEvents, job.normalizedEventExport.interactionEvents);
-            this.feedbackEvents = mergeUniqueEvents(this.feedbackEvents, job.normalizedEventExport.feedbackEvents);
-            const mergedNormalizedEventExport = buildNormalizedEventExport({
-                interactionEvents: this.interactionEvents,
-                feedbackEvents: this.feedbackEvents
-            });
-            const builtArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
-                normalizedEventExport: mergedNormalizedEventExport,
-                observedAt: job.observedAt,
-                staleAfterMs: this.staleAfterMs,
-                ...(this.input.sparseFeedback !== undefined ? { sparseFeedback: this.input.sparseFeedback } : {})
-            });
-            const currentDedupIds = new Set(this.teacherArtifacts.map((artifact) => artifact.dedupId));
-            const nextTeacherArtifacts = mergeTeacherArtifacts(this.teacherArtifacts, builtArtifacts);
-            const emittedArtifactCount = builtArtifacts.filter((artifact) => !currentDedupIds.has(artifact.dedupId)).length;
-            const dedupedArtifactCount = builtArtifacts.length - emittedArtifactCount;
-            this.teacherArtifacts = nextTeacherArtifacts;
-            const learnerResult = advanceAlwaysOnLearningRuntime({
-                packLabel: this.input.packLabel,
-                workspace: this.input.workspace,
-                interactionEvents: this.interactionEvents,
-                feedbackEvents: this.feedbackEvents,
-                teacherSupervisionArtifacts: this.teacherArtifacts,
-                learnedRouting: this.input.learnedRouting,
-                state: this.learnerState,
-                builtAt: this.input.builtAt ?? job.observedAt,
-                ...(this.input.offlineArtifacts !== undefined ? { offlineArtifacts: this.input.offlineArtifacts } : {}),
-                ...(this.input.structuralOps !== undefined ? { structuralOps: this.input.structuralOps } : {}),
-                ...(this.input.sparseFeedback !== undefined ? { sparseFeedback: this.input.sparseFeedback } : {}),
-                ...(this.input.liveSliceSize !== undefined ? { liveSliceSize: this.input.liveSliceSize } : {}),
-                ...(this.input.backfillSliceSize !== undefined ? { backfillSliceSize: this.input.backfillSliceSize } : {}),
-                ...(this.input.cadence !== undefined ? { cadence: this.input.cadence } : {})
-            });
-            this.learnerState = structuredClone(learnerResult.state);
-            this.lastMaterialization = cloneAlwaysOnLearningMaterializationJobOrNull(learnerResult.materialization);
-            this.diagnostics.processedExportCount += 1;
-            this.diagnostics.emittedArtifactCount += emittedArtifactCount;
-            this.diagnostics.dedupedArtifactCount += dedupedArtifactCount;
-            this.diagnostics.lastProcessedAt = job.observedAt;
-            this.diagnostics.latestFreshness = latestTeacherFreshness(this.teacherArtifacts);
-            this.diagnostics.lastNoOpReason = emittedArtifactCount === 0 ? "no_teacher_artifacts" : "none";
-            this.refreshNotes();
+            const previousInteractionEvents = [...structuredClone(this.interactionEvents)];
+            const previousFeedbackEvents = [...structuredClone(this.feedbackEvents)];
+            const previousTeacherArtifacts = cloneTeacherSupervisionArtifacts(this.teacherArtifacts);
+            const previousLearnerState = structuredClone(this.learnerState);
+            const previousLastMaterialization = cloneAlwaysOnLearningMaterializationJobOrNull(this.lastMaterialization);
+            const previousDiagnostics = {
+                ...structuredClone(this.diagnostics),
+                notes: [...this.diagnostics.notes]
+            };
+            const previousSeenExportDigests = [...this.seenExportDigests];
+            try {
+                this.seenExportDigests.add(job.exportDigest);
+                this.interactionEvents = mergeUniqueEvents(this.interactionEvents, job.normalizedEventExport.interactionEvents);
+                this.feedbackEvents = mergeUniqueEvents(this.feedbackEvents, job.normalizedEventExport.feedbackEvents);
+                const mergedNormalizedEventExport = buildNormalizedEventExport({
+                    interactionEvents: this.interactionEvents,
+                    feedbackEvents: this.feedbackEvents
+                });
+                const learnedRoutingState = this.input.resolveLearnedRoutingState?.() ?? {};
+                const builtArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
+                    normalizedEventExport: mergedNormalizedEventExport,
+                    observedAt: job.observedAt,
+                    staleAfterMs: this.staleAfterMs,
+                    ...(this.input.sparseFeedback !== undefined ? { sparseFeedback: this.input.sparseFeedback } : {})
+                });
+                let generatedTeacherArtifacts = [];
+                if (this.teacherLabeler !== null) {
+                    try {
+                        this.lastTeacherLabelerResult = await this.teacherLabeler.label({
+                            normalizedEventExport: mergedNormalizedEventExport,
+                            observedAt: job.observedAt,
+                            staleAfterMs: this.staleAfterMs,
+                            existingArtifacts: [...this.teacherArtifacts, ...builtArtifacts],
+                            ...(learnedRoutingState.serveTimeDecisions !== undefined
+                                ? { serveTimeDecisions: learnedRoutingState.serveTimeDecisions }
+                                : {})
+                        });
+                        generatedTeacherArtifacts = this.lastTeacherLabelerResult.artifacts;
+                    }
+                    catch (error) {
+                        this.lastTeacherLabelerResult = {
+                            artifacts: [],
+                            status: "fail_open",
+                            detail: toErrorMessage(error)
+                        };
+                    }
+                }
+                const nextBuiltArtifacts = mergeTeacherArtifacts([], [...builtArtifacts, ...generatedTeacherArtifacts]);
+                const currentDedupIds = new Set(this.teacherArtifacts.map((artifact) => artifact.dedupId));
+                const nextTeacherArtifacts = mergeTeacherArtifacts(this.teacherArtifacts, nextBuiltArtifacts);
+                const emittedArtifactCount = nextBuiltArtifacts.filter((artifact) => !currentDedupIds.has(artifact.dedupId)).length;
+                const dedupedArtifactCount = nextBuiltArtifacts.length - emittedArtifactCount;
+                this.teacherArtifacts = nextTeacherArtifacts;
+                const learnerResult = advanceAlwaysOnLearningRuntime({
+                    packLabel: this.input.packLabel,
+                    workspace: this.input.workspace,
+                    interactionEvents: this.interactionEvents,
+                    feedbackEvents: this.feedbackEvents,
+                    teacherSupervisionArtifacts: this.teacherArtifacts,
+                    learnedRouting: this.input.learnedRouting,
+                    state: this.learnerState,
+                    builtAt: this.input.builtAt ?? job.observedAt,
+                    ...(this.input.offlineArtifacts !== undefined ? { offlineArtifacts: this.input.offlineArtifacts } : {}),
+                    ...(this.input.structuralOps !== undefined ? { structuralOps: this.input.structuralOps } : {}),
+                    ...(this.input.sparseFeedback !== undefined ? { sparseFeedback: this.input.sparseFeedback } : {}),
+                    ...(this.input.liveSliceSize !== undefined ? { liveSliceSize: this.input.liveSliceSize } : {}),
+                    ...(this.input.backfillSliceSize !== undefined ? { backfillSliceSize: this.input.backfillSliceSize } : {}),
+                    ...(this.input.cadence !== undefined ? { cadence: this.input.cadence } : {}),
+                    ...(learnedRoutingState.pgVersion !== undefined ? { pgVersion: learnedRoutingState.pgVersion } : {}),
+                    ...(learnedRoutingState.serveTimeDecisions !== undefined ? { serveTimeDecisions: learnedRoutingState.serveTimeDecisions } : {}),
+                    ...(learnedRoutingState.baselineState !== undefined ? { baselineState: learnedRoutingState.baselineState } : {})
+                });
+                this.learnerState = structuredClone(learnerResult.state);
+                this.lastMaterialization = cloneAlwaysOnLearningMaterializationJobOrNull(learnerResult.materialization);
+                const updatedBaseline = learnerResult.materialization?.candidate.routingBuild.updatedBaseline ?? null;
+                if (updatedBaseline !== null) {
+                    this.input.persistUpdatedBaseline?.(structuredClone(updatedBaseline));
+                }
+                this.diagnostics.processedExportCount += 1;
+                this.diagnostics.emittedArtifactCount += emittedArtifactCount;
+                this.diagnostics.dedupedArtifactCount += dedupedArtifactCount;
+                this.diagnostics.lastProcessedAt = job.observedAt;
+                this.diagnostics.latestFreshness = latestTeacherFreshness(this.teacherArtifacts);
+                this.diagnostics.lastNoOpReason = emittedArtifactCount === 0 ? "no_teacher_artifacts" : "none";
+                this.refreshNotes();
+            }
+            catch (error) {
+                this.interactionEvents = previousInteractionEvents;
+                this.feedbackEvents = previousFeedbackEvents;
+                this.teacherArtifacts = previousTeacherArtifacts;
+                this.learnerState = previousLearnerState;
+                this.lastMaterialization = previousLastMaterialization;
+                this.diagnostics = previousDiagnostics;
+                this.seenExportDigests.clear();
+                for (const exportDigest of previousSeenExportDigests) {
+                    this.seenExportDigests.add(exportDigest);
+                }
+                this.refreshNotes();
+                throw error;
+            }
         }
     }
     refreshNotes() {
@@ -817,7 +924,8 @@ export class AsyncTeacherLiveLoop {
             dedupedArtifactCount: this.diagnostics.dedupedArtifactCount,
             sparseFeedback: this.learnerState.sparseFeedback,
             noOpReason: this.diagnostics.lastNoOpReason,
-            materialization: this.lastMaterialization
+            materialization: this.lastMaterialization,
+            teacherLabeler: this.lastTeacherLabelerResult
         });
     }
 }
@@ -923,22 +1031,331 @@ export function scanLiveEventExport(input) {
                 dedupedArtifactCount: 0,
                 sparseFeedback: learnerResult.state.sparseFeedback,
                 noOpReason: lastNoOpReason,
-                materialization: learnerResult.materialization
+                materialization: learnerResult.materialization,
+                teacherLabeler: null
             })
         }
     };
+    const labelFlow = summarizeNormalizedEventExportLabelFlow(normalizedEventExport, teacherArtifacts.length);
+    const learningPath = summarizeLearningPathFromMaterialization(learnerResult.materialization);
     return {
         runtimeOwner: "openclaw",
         scanMode: "live",
         observedAt,
         packLabel,
         supervision: buildCanonicalSupervision(normalizedEventExport),
-        snapshot
+        snapshot,
+        labelFlow,
+        learningPath
     };
 }
 function readJsonFile(filePath) {
     return JSON.parse(readFileSync(filePath, "utf8"));
 }
+export function resolveAsyncTeacherLiveLoopSnapshotPath(activationRoot) {
+    return path.join(path.resolve(normalizeNonEmptyString(activationRoot, "activationRoot")), "async-teacher-live-loop.snapshot.json");
+}
+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";
+function isAsyncTeacherLiveLoopSnapshot(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.runtimeOwner === "openclaw" &&
+        candidate.queue !== undefined &&
+        candidate.teacher !== undefined &&
+        candidate.learner !== undefined &&
+        candidate.diagnostics !== undefined);
+}
+function isWatchTeacherSnapshot(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.contract === "openclaw_watch_teacher_snapshot.v1" &&
+        candidate.runtimeOwner === "openclaw" &&
+        isAsyncTeacherLiveLoopSnapshot(candidate.snapshot));
+}
+function cloneWatchTeacherSnapshotFailure(value) {
+    if (value === null ||
+        value === undefined ||
+        !["materialization_failed", "teacher_fail_open"].includes(value.mode) ||
+        typeof value.detail !== "string" ||
+        typeof value.at !== "string") {
+        return null;
+    }
+    return {
+        mode: value.mode,
+        detail: value.detail,
+        at: value.at
+    };
+}
+function cloneRuntimeEventExportScannerCheckpoint(value) {
+    return structuredClone(value);
+}
+function buildWatchTeacherSnapshotTeacherSummary(snapshot) {
+    return {
+        artifactCount: snapshot.teacher.artifactCount,
+        latestFreshness: snapshot.teacher.latestFreshness,
+        acceptedExportCount: snapshot.diagnostics.acceptedExportCount,
+        processedExportCount: snapshot.diagnostics.processedExportCount,
+        duplicateExportCount: snapshot.diagnostics.duplicateExportCount,
+        droppedExportCount: snapshot.diagnostics.droppedExportCount,
+        emittedArtifactCount: snapshot.diagnostics.emittedArtifactCount,
+        dedupedArtifactCount: snapshot.diagnostics.dedupedArtifactCount,
+        lastProcessedAt: snapshot.diagnostics.lastProcessedAt,
+        lastNoOpReason: snapshot.diagnostics.lastNoOpReason,
+        queueDepth: snapshot.queue.depth,
+        queueCapacity: snapshot.queue.capacity,
+        running: snapshot.queue.running,
+        lastAppliedMaterializationJobId: snapshot.runtime?.lastAppliedMaterializationJobId ?? snapshot.learner.lastMaterialization?.jobId ?? null,
+        lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null
+    };
+}
+function buildWatchTeacherSnapshotLearningSummary(snapshot, lastHandledMaterializationPackId) {
+    const plan = describeAlwaysOnLearningRuntimeState(snapshot.learner.state, snapshot.learner.lastMaterialization);
+    return {
+        bootstrapped: plan.bootstrapped,
+        mode: plan.mode,
+        nextPriorityLane: plan.nextPriorityLane,
+        nextPriorityBucket: plan.nextPriorityBucket,
+        pendingLive: plan.pending.live,
+        pendingBackfill: plan.pending.backfill,
+        pendingTotal: plan.pending.total,
+        pendingByBucket: { ...plan.pending.byBucket },
+        materializationCount: plan.materialization.count,
+        lastMaterializedAt: plan.materialization.lastMaterializedAt,
+        lastMaterializationReason: plan.materialization.lastReason,
+        lastMaterializationLane: plan.materialization.lastLane,
+        lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null,
+        lastHandledMaterializationPackId
+    };
+}
+function buildWatchTeacherSnapshotLabelingSummary(snapshot) {
+    const learningSurface = snapshot.learner.lastMaterialization?.candidate.summary.learningSurface ??
+        snapshot.learner.state.learnedEventExport?.provenance.learningSurface ??
+        null;
+    return {
+        learningCadence: learningSurface?.learningCadence ?? "passive_background",
+        scanPolicy: learningSurface?.scanPolicy ?? "always_on",
+        liveSlicesPerCycle: 1,
+        backfillSlicesPerCycle: 1,
+        teacherBudget: snapshot.learner.state.sparseFeedback.teacherBudget,
+        teacherDelayMs: snapshot.learner.state.sparseFeedback.teacherDelayMs,
+        backgroundLabelAmplification: snapshot.learner.state.sparseFeedback.backgroundLabelAmplification
+    };
+}
+function normalizeWatchTeacherSnapshotFromValue(value, snapshot, sourcePath) {
+    const activationRoot = path.dirname(path.dirname(sourcePath));
+    const defaultScanRoot = path.join(activationRoot, "event-exports");
+    return {
+        contract: "openclaw_watch_teacher_snapshot.v1",
+        runtimeOwner: "openclaw",
+        updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : new Date(0).toISOString(),
+        lastRunAt: typeof value.lastRunAt === "string"
+            ? value.lastRunAt
+            : typeof value.updatedAt === "string"
+                ? value.updatedAt
+                : snapshot.diagnostics.lastProcessedAt ?? new Date(0).toISOString(),
+        scanRoot: typeof value.scanRoot === "string" ? value.scanRoot : defaultScanRoot,
+        sessionTailCursorPath: typeof value.sessionTailCursorPath === "string"
+            ? value.sessionTailCursorPath
+            : resolveWatchSessionTailCursorPath(activationRoot),
+        sessionTailCursorUpdatedAt: typeof value.sessionTailCursorUpdatedAt === "string"
+            ? value.sessionTailCursorUpdatedAt
+            : typeof value.updatedAt === "string"
+                ? value.updatedAt
+                : new Date(0).toISOString(),
+        sessionTailSessionsTracked: typeof value.sessionTailSessionsTracked === "number" ? value.sessionTailSessionsTracked : 0,
+        sessionTailBridgedEventCount: typeof value.sessionTailBridgedEventCount === "number" ? value.sessionTailBridgedEventCount : 0,
+        scannerCheckpointPath: typeof value.scannerCheckpointPath === "string"
+            ? value.scannerCheckpointPath
+            : path.join(typeof value.scanRoot === "string" ? value.scanRoot : defaultScanRoot, ".openclawbrain-scanner-checkpoint.json"),
+        scannerCheckpoint: value.scannerCheckpoint !== undefined
+            ? cloneRuntimeEventExportScannerCheckpoint(value.scannerCheckpoint)
+            : createRuntimeEventExportScannerCheckpoint({
+                scanRoot: typeof value.scanRoot === "string" ? value.scanRoot : defaultScanRoot
+            }),
+        replayedBundleCount: typeof value.replayedBundleCount === "number" ? value.replayedBundleCount : 0,
+        replayedEventCount: typeof value.replayedEventCount === "number" ? value.replayedEventCount : 0,
+        exportedBundleCount: typeof value.exportedBundleCount === "number" ? value.exportedBundleCount : 0,
+        exportedEventCount: typeof value.exportedEventCount === "number" ? value.exportedEventCount : 0,
+        startupWarnings: Array.isArray(value.startupWarnings)
+            ? value.startupWarnings.filter((warning) => typeof warning === "string")
+            : [],
+        lastTeacherError: typeof value.lastTeacherError === "string"
+            ? value.lastTeacherError
+            : null,
+        localSessionTailNoopReason: typeof value.localSessionTailNoopReason === "string" ? value.localSessionTailNoopReason : null,
+        lastHandledMaterializationPackId: typeof value.lastHandledMaterializationPackId === "string" ? value.lastHandledMaterializationPackId : null,
+        teacher: value.teacher ?? buildWatchTeacherSnapshotTeacherSummary(snapshot),
+        learning: value.learning ?? buildWatchTeacherSnapshotLearningSummary(snapshot, typeof value.lastHandledMaterializationPackId === "string" ? value.lastHandledMaterializationPackId : null),
+        labeling: value.labeling ?? buildWatchTeacherSnapshotLabelingSummary(snapshot),
+        failure: cloneWatchTeacherSnapshotFailure(value.failure),
+        snapshot
+    };
+}
+export function resolveWatchStateRoot(activationRoot) {
+    return path.resolve(normalizeNonEmptyString(activationRoot, "activationRoot"), WATCH_STATE_DIRNAME);
+}
+export function resolveWatchSessionTailCursorPath(activationRoot) {
+    return path.join(resolveWatchStateRoot(activationRoot), WATCH_SESSION_TAIL_CURSOR_BASENAME);
+}
+export function resolveWatchTeacherSnapshotPath(activationRoot) {
+    return path.join(resolveWatchStateRoot(activationRoot), WATCH_TEACHER_SNAPSHOT_BASENAME);
+}
+export function resolveOperatorTeacherSnapshotPath(activationRoot, explicitPath) {
+    if (explicitPath !== null && explicitPath !== undefined) {
+        return explicitPath;
+    }
+    const canonicalWatchSnapshotPath = resolveWatchTeacherSnapshotPath(activationRoot);
+    if (existsSync(canonicalWatchSnapshotPath)) {
+        return canonicalWatchSnapshotPath;
+    }
+    const asyncSnapshotPath = resolveAsyncTeacherLiveLoopSnapshotPath(activationRoot);
+    return existsSync(asyncSnapshotPath) ? asyncSnapshotPath : null;
+}
+export function loadTeacherSurface(snapshotPath) {
+    const resolvedPath = path.resolve(snapshotPath);
+    let parsed;
+    try {
+        parsed = readJsonFile(resolvedPath);
+    }
+    catch {
+        return null;
+    }
+    if (isWatchTeacherSnapshot(parsed)) {
+        const snapshot = loadAsyncTeacherLiveLoopSnapshotFromValue(parsed.snapshot);
+        return {
+            sourcePath: resolvedPath,
+            sourceKind: "watch_snapshot",
+            snapshot,
+            watchSnapshot: normalizeWatchTeacherSnapshotFromValue(parsed, snapshot, resolvedPath)
+        };
+    }
+    if (isAsyncTeacherLiveLoopSnapshot(parsed)) {
+        return {
+            sourcePath: resolvedPath,
+            sourceKind: "async_snapshot",
+            snapshot: loadAsyncTeacherLiveLoopSnapshotFromValue(parsed),
+            watchSnapshot: null
+        };
+    }
+    return null;
+}
+export function loadWatchTeacherSnapshotState(snapshotPath) {
+    const resolvedPath = path.resolve(snapshotPath);
+    if (!existsSync(resolvedPath)) {
+        return {
+            lastHandledMaterializationPackId: null,
+            snapshot: null,
+            error: null
+        };
+    }
+    let parsed;
+    try {
+        parsed = readJsonFile(resolvedPath);
+    }
+    catch (error) {
+        return {
+            lastHandledMaterializationPackId: null,
+            snapshot: null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+    if (isWatchTeacherSnapshot(parsed)) {
+        return {
+            lastHandledMaterializationPackId: parsed.lastHandledMaterializationPackId,
+            snapshot: loadAsyncTeacherLiveLoopSnapshotFromValue(parsed.snapshot),
+            error: null
+        };
+    }
+    if (isAsyncTeacherLiveLoopSnapshot(parsed)) {
+        return {
+            lastHandledMaterializationPackId: null,
+            snapshot: loadAsyncTeacherLiveLoopSnapshotFromValue(parsed),
+            error: null
+        };
+    }
+    return {
+        lastHandledMaterializationPackId: null,
+        snapshot: null,
+        error: `watch teacher snapshot is invalid: ${resolvedPath}`
+    };
+}
+export function persistWatchTeacherSnapshot(snapshotPath, input) {
+    const persistedAt = new Date().toISOString();
+    const canonicalSnapshot = loadAsyncTeacherLiveLoopSnapshotFromValue(input.snapshot);
+    const payload = {
+        contract: "openclaw_watch_teacher_snapshot.v1",
+        runtimeOwner: "openclaw",
+        updatedAt: persistedAt,
+        lastRunAt: input.lastRunAt,
+        scanRoot: path.resolve(input.scanRoot),
+        sessionTailCursorPath: path.resolve(input.sessionTailCursorPath),
+        sessionTailCursorUpdatedAt: input.sessionTailCursorUpdatedAt,
+        sessionTailSessionsTracked: input.sessionTailSessionsTracked,
+        sessionTailBridgedEventCount: input.sessionTailBridgedEventCount,
+        scannerCheckpointPath: path.resolve(input.scannerCheckpointPath),
+        scannerCheckpoint: cloneRuntimeEventExportScannerCheckpoint(input.scannerCheckpoint),
+        replayedBundleCount: input.replayedBundleCount,
+        replayedEventCount: input.replayedEventCount,
+        exportedBundleCount: input.exportedBundleCount,
+        exportedEventCount: input.exportedEventCount,
+        startupWarnings: [...input.startupWarnings],
+        lastTeacherError: input.lastTeacherError,
+        localSessionTailNoopReason: input.localSessionTailNoopReason,
+        lastHandledMaterializationPackId: input.lastHandledMaterializationPackId,
+        teacher: buildWatchTeacherSnapshotTeacherSummary(canonicalSnapshot),
+        learning: buildWatchTeacherSnapshotLearningSummary(canonicalSnapshot, input.lastHandledMaterializationPackId),
+        labeling: buildWatchTeacherSnapshotLabelingSummary(canonicalSnapshot),
+        failure: cloneWatchTeacherSnapshotFailure(input.failure),
+        snapshot: canonicalSnapshot
+    };
+    mkdirSync(path.dirname(snapshotPath), { recursive: true });
+    writeFileSync(snapshotPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    return payload;
+}
+function loadAsyncTeacherLiveLoopSnapshotFromValue(snapshot) {
+    if (snapshot.runtimeOwner !== "openclaw") {
+        throw new Error("async teacher snapshot runtimeOwner must be openclaw");
+    }
+    const cloned = {
+        ...snapshot,
+        diagnostics: {
+            ...snapshot.diagnostics,
+            notes: [...snapshot.diagnostics.notes]
+        },
+        teacher: {
+            ...snapshot.teacher,
+            artifacts: cloneTeacherSupervisionArtifacts(snapshot.teacher.artifacts)
+        },
+        learner: {
+            state: structuredClone(snapshot.learner.state),
+            lastMaterialization: cloneAlwaysOnLearningMaterializationJobOrNull(snapshot.learner.lastMaterialization)
+        }
+    };
+    if (snapshot.state !== undefined) {
+        cloned.state = cloneAsyncTeacherSnapshotState(snapshot.state);
+    }
+    if (snapshot.runtime !== undefined) {
+        cloned.runtime = cloneAsyncTeacherSnapshotRuntime(snapshot.runtime);
+    }
+    return cloned;
+}
+export function loadAsyncTeacherLiveLoopSnapshot(snapshotPath) {
+    const resolvedPath = path.resolve(snapshotPath);
+    const parsed = readJsonFile(resolvedPath);
+    if (isWatchTeacherSnapshot(parsed)) {
+        return loadAsyncTeacherLiveLoopSnapshotFromValue(parsed.snapshot);
+    }
+    if (isAsyncTeacherLiveLoopSnapshot(parsed)) {
+        return loadAsyncTeacherLiveLoopSnapshotFromValue(parsed);
+    }
+    throw new Error(`async teacher snapshot is invalid: ${resolvedPath}`);
+}
 function resolveBundlePayloadPath(rootDir, payloadPath) {
     const resolved = path.resolve(rootDir, payloadPath);
     const relative = path.relative(rootDir, resolved);
@@ -1573,6 +1990,18 @@ export class RuntimeEventExportScanner {
     snapshot() {
         return structuredClone(this.checkpoint);
     }
+    restoreCheckpoint(checkpoint) {
+        const restored = structuredClone(checkpoint);
+        const errors = validateRuntimeEventExportScannerCheckpoint(restored);
+        if (errors.length > 0) {
+            throw new Error(`runtime event export scanner checkpoint is invalid: ${errors.join("; ")}`);
+        }
+        if (restored.scanRoot !== this.scanRoot) {
+            throw new Error(`runtime event export scanner checkpoint scanRoot mismatch: checkpoint=${restored.scanRoot} scanner=${this.scanRoot}`);
+        }
+        this.checkpoint = restored;
+        writeRuntimeEventExportScannerCheckpoint(this.checkpointPath, this.checkpoint);
+    }
     scanOnce(options = {}) {
         const scannedAt = normalizeIsoTimestamp(options.scannedAt, "scannedAt", new Date().toISOString());
         const discovered = discoverRuntimeEventExportBundles(this.scanRoot);
@@ -1770,6 +2199,15 @@ function normalizeIsoTimestamp(value, fieldName, fallbackValue) {
 function normalizeMode(value) {
     return value ?? "heuristic";
 }
+function normalizeCompileSelectionMode(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "flat_rank_v1" || value === "graph_walk_v1") {
+        return value;
+    }
+    throw new Error(`selectionMode must be flat_rank_v1 or graph_walk_v1, received ${String(value)}`);
+}
 function normalizeRuntimeHints(value) {
     if (value === undefined) {
         return [];
@@ -1955,6 +2393,9 @@ export function formatPromptContext(compileResponse) {
     lines.push("[/BRAIN_CONTEXT]");
     return `${lines.join("\n")}\n`;
 }
+function resolveActivationRootForFailure(value) {
+    return path.resolve(normalizeOptionalString(value) ?? ".");
+}
 function failOpenCompileResult(error, activationRoot) {
     return {
         ok: false,
@@ -1990,6 +2431,96 @@ function classifyCompileFailure(error, activationRoot) {
 function uniqueNotes(notes) {
     return [...new Set(notes.filter((note) => note.length > 0))];
 }
+function buildServeRouteLogFailOpenWarning(scope, error) {
+    return `learning spine serve route log failed open (${scope}): ${toErrorMessage(error)}`;
+}
+function buildServeRouteLogFailOpenNotes(scope, error) {
+    return [
+        "serve_route_log_status=fail_open",
+        `serve_route_log_scope=${scope}`,
+        `serve_route_log_error=${toErrorMessage(error)}`
+    ];
+}
+function normalizeServeRouteChannel(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeServeRouteMessage(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function normalizeServeRouteInstalledEntryPath(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? null : path.resolve(trimmed);
+}
+function buildCompileServeRouteBreadcrumbs(input) {
+    return {
+        entrypoint: "compileRuntimeContext",
+        invocationSurface: input._serveRouteBreadcrumbs?.invocationSurface ?? "direct_compile_call",
+        hostEvent: input._serveRouteBreadcrumbs?.hostEvent ?? null,
+        installedEntryPath: normalizeServeRouteInstalledEntryPath(input._serveRouteBreadcrumbs?.installedEntryPath),
+        syntheticTurn: true
+    };
+}
+function buildRunRuntimeTurnServeRouteBreadcrumbs() {
+    return {
+        entrypoint: "runRuntimeTurn",
+        invocationSurface: "runtime_turn_helper",
+        hostEvent: null,
+        installedEntryPath: null,
+        syntheticTurn: false
+    };
+}
+function appendCompileServeRouteDecisionLog(input) {
+    if (input.compileInput._suppressServeLog) {
+        return;
+    }
+    const recordedAt = new Date().toISOString();
+    const sessionId = normalizeServeRouteChannel(input.compileInput.sessionId) ?? `ext-compile-${Date.now()}`;
+    const channel = normalizeServeRouteChannel(input.compileInput.channel) ?? "extension";
+    const syntheticTurn = {
+        sessionId,
+        channel,
+        userMessage: input.userMessage,
+        createdAt: recordedAt
+    };
+    if (input.compileInput.maxContextBlocks !== undefined) {
+        syntheticTurn.maxContextBlocks = input.compileInput.maxContextBlocks;
+    }
+    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;
+    }
+    if (input.compileInput.runtimeHints !== undefined) {
+        syntheticTurn.runtimeHints = input.compileInput.runtimeHints;
+    }
+    try {
+        appendServeTimeRouteDecisionLog({
+            activationRoot: input.activationRoot,
+            turn: syntheticTurn,
+            compileResult: input.compileResult,
+            recordedAt,
+            breadcrumbs: buildCompileServeRouteBreadcrumbs(input.compileInput)
+        });
+    }
+    catch (error) {
+        if (input.compileResult.ok) {
+            input.compileResult.compileResponse.diagnostics.notes = uniqueNotes([
+                ...input.compileResult.compileResponse.diagnostics.notes,
+                ...buildServeRouteLogFailOpenNotes("compileRuntimeContext", error)
+            ]);
+        }
+        console.warn(`[openclawbrain] ${buildServeRouteLogFailOpenWarning("compileRuntimeContext", error)} ` +
+            `(activationRoot=${input.activationRoot}, sessionId=${sessionId}, channel=${channel})`);
+    }
+}
 function roundMetric(value) {
     return Math.round(value * 100) / 100;
 }
@@ -2220,24 +2751,52 @@ export function resolveActivePackForCompile(activationRoot) {
     };
 }
 export function compileRuntimeContext(input) {
-    const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
-    const agentId = normalizeOptionalString(input.agentId) ?? process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
-    const runtimeHints = normalizeRuntimeHints(input.runtimeHints);
+    const fallbackActivationRoot = resolveActivationRootForFailure(input.activationRoot);
+    let activationRoot = fallbackActivationRoot;
+    let agentId = process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
+    let runtimeHints = [];
+    let selectionMode;
+    let userMessage = "";
+    let maxContextChars;
+    let mode = "heuristic";
+    let result;
+    try {
+        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);
+    }
+    catch (error) {
+        result = failOpenCompileResult(error, fallbackActivationRoot);
+        appendCompileServeRouteDecisionLog({
+            compileInput: input,
+            activationRoot: result.activationRoot,
+            compileResult: result,
+            userMessage: normalizeServeRouteMessage(input.message)
+        });
+        return result;
+    }
     try {
         const target = resolveActivePackForCompile(activationRoot);
         const resolvedBudget = resolveCompileBudget(target, input);
         const compile = compileRuntimeFromActivation(activationRoot, {
             contract: CONTRACT_IDS.runtimeCompile,
             agentId,
-            userMessage: normalizeNonEmptyString(input.message, "message"),
+            userMessage,
             maxContextBlocks: resolvedBudget.maxContextBlocks,
-            ...(input.maxContextChars !== undefined
-                ? { maxContextChars: normalizeNonNegativeInteger(input.maxContextChars, "maxContextChars", input.maxContextChars) }
-                : {}),
-            modeRequested: normalizeMode(input.mode),
+            ...(maxContextChars !== undefined ? { maxContextChars } : {}),
+            modeRequested: mode,
             activePackId: target.activePointer.packId,
             ...(input.compactionMode !== undefined ? { compactionMode: input.compactionMode } : {}),
             ...(runtimeHints.length > 0 ? { runtimeHints } : {})
+        }, {
+            ...(selectionMode !== undefined ? { selectionMode } : {})
         });
         const compileResponse = {
             ...compile.response,
@@ -2246,7 +2805,7 @@ export function compileRuntimeContext(input) {
                 notes: uniqueNotes([...compile.response.diagnostics.notes, ...resolvedBudget.notes, "OpenClaw remains the runtime owner"])
             }
         };
-        return {
+        result = {
             ok: true,
             fallbackToStaticContext: false,
             hardRequirementViolated: false,
@@ -2258,8 +2817,15 @@ export function compileRuntimeContext(input) {
         };
     }
     catch (error) {
-        return classifyCompileFailure(error, activationRoot);
+        result = classifyCompileFailure(error, activationRoot);
     }
+    appendCompileServeRouteDecisionLog({
+        compileInput: input,
+        activationRoot: result.activationRoot,
+        compileResult: result,
+        userMessage
+    });
+    return result;
 }
 function readDiagnosticNoteValue(notes, prefix) {
     const note = notes.find((entry) => entry.startsWith(prefix));
@@ -3082,29 +3648,35 @@ export function writeScannedEventExportBundle(input) {
     });
 }
 export function runRuntimeTurn(turn, options = {}) {
+    const warnings = [];
+    const serveRouteBreadcrumbs = buildRunRuntimeTurnServeRouteBreadcrumbs();
     const agentId = normalizeOptionalString(turn.agentId);
     const compileInput = {
-        activationRoot: options.activationRoot ?? normalizeNonEmptyString(turn.activationRoot ?? undefined, "activationRoot"),
-        message: normalizeNonEmptyString(turn.userMessage, "userMessage"),
+        activationRoot: (options.activationRoot ?? turn.activationRoot),
+        message: turn.userMessage,
         ...(agentId !== undefined ? { agentId } : {}),
         ...(turn.maxContextBlocks !== undefined ? { maxContextBlocks: turn.maxContextBlocks } : {}),
         ...(turn.budgetStrategy !== undefined ? { budgetStrategy: turn.budgetStrategy } : {}),
         ...(turn.mode !== undefined ? { mode: turn.mode } : {}),
-        ...(turn.runtimeHints !== undefined ? { runtimeHints: turn.runtimeHints } : {})
+        ...(turn.selectionMode !== undefined ? { selectionMode: turn.selectionMode } : {}),
+        ...(turn.runtimeHints !== undefined ? { runtimeHints: turn.runtimeHints } : {}),
+        _suppressServeLog: true
     };
     const compileResult = compileRuntimeContext(compileInput);
-    const warnings = [];
     const serveLoggedAt = turn.compile?.createdAt ?? turn.createdAt ?? new Date().toISOString();
     if (!compileResult.ok && compileResult.hardRequirementViolated) {
         try {
             appendServeTimeRouteDecisionLog({
-                activationRoot: compileInput.activationRoot,
+                activationRoot: compileResult.activationRoot,
                 turn,
                 compileResult,
-                recordedAt: serveLoggedAt
+                recordedAt: serveLoggedAt,
+                breadcrumbs: serveRouteBreadcrumbs
             });
         }
-        catch {
+        catch (error) {
+            console.warn(`[openclawbrain] serve-time route decision log failed before hard-fail throw: ${toErrorMessage(error)} ` +
+                `(activationRoot=${compileResult.activationRoot}, sessionId=${turn.sessionId}, channel=${turn.channel})`);
         }
         throw new Error(compileResult.error);
     }
@@ -3113,27 +3685,48 @@ export function runRuntimeTurn(turn, options = {}) {
         try {
             const compileEvent = normalizedEventExport.interactionEvents.find((event) => event.kind === "memory_compiled");
             appendServeTimeRouteDecisionLog({
-                activationRoot: compileInput.activationRoot,
+                activationRoot: compileResult.activationRoot,
                 turn,
                 compileResult,
                 normalizedEventExport,
-                recordedAt: compileEvent?.createdAt ?? serveLoggedAt
+                recordedAt: compileEvent?.createdAt ?? serveLoggedAt,
+                breadcrumbs: serveRouteBreadcrumbs
             });
         }
         catch (error) {
-            warnings.push(`learning spine serve log failed: ${toErrorMessage(error)}`);
+            warnings.push(buildServeRouteLogFailOpenWarning("runRuntimeTurn", error));
+            if (compileResult.ok) {
+                compileResult.compileResponse.diagnostics.notes = uniqueNotes([
+                    ...compileResult.compileResponse.diagnostics.notes,
+                    ...buildServeRouteLogFailOpenNotes("runRuntimeTurn", error)
+                ]);
+            }
+        }
+        try {
+            const eventExport = writeRuntimeEventExportBundle(turn, normalizedEventExport);
+            return {
+                ...compileResult,
+                eventExport,
+                warnings
+            };
+        }
+        catch (error) {
+            if (options.failOpen === false) {
+                throw error;
+            }
+            warnings.push(toErrorMessage(error));
+            return {
+                ...compileResult,
+                eventExport: {
+                    ok: false,
+                    wroteBundle: false,
+                    error: toErrorMessage(error)
+                },
+                warnings
+            };
         }
-        const eventExport = writeRuntimeEventExportBundle(turn, normalizedEventExport);
-        return {
-            ...compileResult,
-            eventExport,
-            warnings
-        };
     }
     catch (error) {
-        if (options.failOpen === false) {
-            throw error;
-        }
         warnings.push(toErrorMessage(error));
         return {
             ...compileResult,
@@ -4117,6 +4710,144 @@ function summarizeOperatorSlot(slot, updatedAt) {
         findings: [...slot.findings]
     };
 }
+function buildMissingLabelFlowSummary(detail) {
+    return {
+        source: "missing",
+        humanLabelCount: null,
+        selfLabelCount: null,
+        asyncTeacherArtifactCount: null,
+        implicitPositiveCount: null,
+        detail
+    };
+}
+function buildMissingLearningPathSummary(detail) {
+    return {
+        available: false,
+        source: "missing",
+        policyGradientVersion: "unavailable",
+        policyGradientMethod: null,
+        objective: null,
+        targetConstruction: null,
+        connectOpsFired: null,
+        reconstructedTrajectoryCount: null,
+        detail
+    };
+}
+function countTeacherArtifactBlocks(blocks) {
+    return blocks.filter((block) => block.learning.role === "teacher_supervision" && !block.id.endsWith(":teacher-supervision-summary")).length;
+}
+function summarizePolicyGradientVersion(targetConstruction) {
+    if (targetConstruction === "trajectory_reconstruction") {
+        return "v2";
+    }
+    if (targetConstruction === "event_block_plus_related_interaction") {
+        return "v1";
+    }
+    return "unavailable";
+}
+function summarizePackLabelFlow(source, pack) {
+    const labelHarvest = pack.manifest.provenance.learningSurface.labelHarvest;
+    return {
+        source,
+        humanLabelCount: labelHarvest.humanLabels,
+        selfLabelCount: labelHarvest.selfLabels,
+        asyncTeacherArtifactCount: countTeacherArtifactBlocks(pack.graph.blocks),
+        implicitPositiveCount: labelHarvest.approvals,
+        detail: source === "active_pack"
+            ? "active pack label harvest and teacher artifacts are visible"
+            : source === "materialized_candidate"
+                ? "materialized candidate label harvest and teacher artifacts are visible"
+                : "event export label harvest is visible"
+    };
+}
+function summarizePackLearningPath(source, pack) {
+    const targetConstruction = pack.router?.training.objective.profile.targetConstruction ?? null;
+    const policyGradientVersion = summarizePolicyGradientVersion(targetConstruction);
+    const reconstructedTrajectoryCount = policyGradientVersion === "v2"
+        ? pack.router?.training.routeTraceCount ?? 0
+        : pack.router === null
+            ? null
+            : 0;
+    return {
+        available: pack.router !== null,
+        source,
+        policyGradientVersion,
+        policyGradientMethod: pack.router?.training.method ?? null,
+        objective: pack.router?.training.objective.objective ?? null,
+        targetConstruction,
+        connectOpsFired: pack.manifest.graphDynamics.structuralOps.connect,
+        reconstructedTrajectoryCount,
+        detail: pack.router === null
+            ? "pack has no learned router artifact"
+            : policyGradientVersion === "v2"
+                ? "learned routing uses trajectory-reconstruction PG"
+                : policyGradientVersion === "v1"
+                    ? "learned routing uses event-reconstruction PG"
+                    : "learned routing is present but the PG profile is not recognizable"
+    };
+}
+function summarizePackObservability(source, pack) {
+    return {
+        labelFlow: summarizePackLabelFlow(source, pack),
+        learningPath: summarizePackLearningPath(source, pack)
+    };
+}
+export function summarizeNormalizedEventExportLabelFlow(normalizedEventExport, asyncTeacherArtifactCount = 0) {
+    const labelHarvest = normalizedEventExport.provenance.learningSurface.labelHarvest;
+    return {
+        source: "event_export",
+        humanLabelCount: labelHarvest.humanLabels,
+        selfLabelCount: labelHarvest.selfLabels,
+        asyncTeacherArtifactCount,
+        implicitPositiveCount: labelHarvest.approvals,
+        detail: "event export label harvest is visible"
+    };
+}
+export function summarizeLearningPathFromMaterialization(materialization) {
+    if (materialization === null) {
+        return buildMissingLearningPathSummary("no candidate pack materialized during this learning pass");
+    }
+    return summarizePackLearningPath("materialized_candidate", {
+        manifest: materialization.candidate.manifest,
+        graph: materialization.candidate.payloads.graph,
+        router: materialization.candidate.payloads.router
+    });
+}
+function summarizeActivePackObservability(activationRoot, active) {
+    if (active === null) {
+        return {
+            labelFlow: buildMissingLabelFlowSummary("no active pack is attached"),
+            learningPath: buildMissingLearningPathSummary("no active pack is attached")
+        };
+    }
+    if (!active.activationReady) {
+        return {
+            labelFlow: buildMissingLabelFlowSummary(`active pack ${active.packId} is not activation-ready`),
+            learningPath: buildMissingLearningPathSummary(`active pack ${active.packId} is not activation-ready`)
+        };
+    }
+    try {
+        const pack = loadPackFromActivation(activationRoot, "active", { requireActivationReady: true });
+        if (pack === null) {
+            return {
+                labelFlow: buildMissingLabelFlowSummary("active pack payloads are unavailable"),
+                learningPath: buildMissingLearningPathSummary("active pack payloads are unavailable")
+            };
+        }
+        return summarizePackObservability("active_pack", {
+            manifest: pack.manifest,
+            graph: pack.graph,
+            router: pack.router
+        });
+    }
+    catch (error) {
+        const detail = `active pack observability could not be loaded: ${toErrorMessage(error)}`;
+        return {
+            labelFlow: buildMissingLabelFlowSummary(detail),
+            learningPath: buildMissingLearningPathSummary(detail)
+        };
+    }
+}
 function summarizeLastPromotion(inspection) {
     if (inspection.active === null) {
         return {
@@ -4183,9 +4914,137 @@ function summarizeManyProfileSupport(policyMode) {
         detail: "The Host has not declared shared-vs-dedicated attachment policy. Keep the operator read current-profile-only, do not infer profile exclusivity from activation state alone, and do not claim same-gateway many-profile proof."
     };
 }
+function summarizeRetainedActivationSlots(input) {
+    const retained = [];
+    if (input.candidate !== null) {
+        retained.push(`candidate=${input.candidate.packId}`);
+    }
+    if (input.previous !== null) {
+        retained.push(`previous=${input.previous.packId}`);
+    }
+    return retained.length === 0 ? "none" : retained.join(", ");
+}
 function isAwaitingFirstExportSlot(slot) {
     return slot !== null && slot.eventRange.count === 0;
 }
+function summarizeOperatorActivationState(input) {
+    if (input.inspectionError !== null) {
+        return {
+            state: "broken_install",
+            detail: `activation root could not be inspected because activation pointers or pinned pack metadata are unreadable: ${input.inspectionError}`,
+            inspectionError: input.inspectionError
+        };
+    }
+    if (input.active !== null && !input.active.activationReady) {
+        return {
+            state: "broken_install",
+            detail: input.active.findings.length > 0
+                ? `active pack ${input.active.packId} is pinned but not activation-ready: ${input.active.findings.join("; ")}`
+                : `active pack ${input.active.packId} is pinned but not activation-ready`,
+            inspectionError: null
+        };
+    }
+    if (input.active === null) {
+        if (input.candidate !== null || input.previous !== null) {
+            return {
+                state: "stale_incomplete",
+                detail: `activation root has retained non-serving state but no active pack (${summarizeRetainedActivationSlots(input)})`,
+                inspectionError: null
+            };
+        }
+        return {
+            state: "detached",
+            detail: "activation root has no active, candidate, or previous pack pinned",
+            inspectionError: null
+        };
+    }
+    if (input.observability === null) {
+        return {
+            state: "broken_install",
+            detail: `active pack ${input.active.packId} is pinned, but activation observability could not be derived`,
+            inspectionError: null
+        };
+    }
+    if (input.observability.initHandoff.handoffState === "pg_promoted_pack_authoritative") {
+        return {
+            state: "active_promoted",
+            detail: `active pack ${input.active.packId} is authoritative through promotion, not the seed handoff`,
+            inspectionError: null
+        };
+    }
+    if (isAwaitingFirstExportSlot(input.active)) {
+        return {
+            state: "awaiting_first_export",
+            detail: `active seed-state pack ${input.active.packId} is healthy but still waiting for the first live export`,
+            inspectionError: null
+        };
+    }
+    if (input.observability.initHandoff.handoffState === "seed_state_authoritative") {
+        return {
+            state: "healthy_seed",
+            detail: `active seed-state pack ${input.active.packId} is serving beyond the first export`,
+            inspectionError: null
+        };
+    }
+    return {
+        state: "stale_incomplete",
+        detail: `active pack ${input.active.packId} is pinned, but init handoff truth is incomplete (${input.observability.initHandoff.handoffState})`,
+        inspectionError: null
+    };
+}
+function summarizeBrainStateWithoutObservability(active, activation) {
+    return {
+        state: active === null ? "no_active_pack" : "missing",
+        initMode: null,
+        runtimePlasticitySource: null,
+        seedStateVisible: false,
+        seedBlockCount: 0,
+        activePackId: active?.packId ?? null,
+        activeWorkspaceSnapshot: active?.workspaceSnapshot ?? null,
+        activeEventExportDigest: active?.eventExportDigest ?? null,
+        detail: activation.detail
+    };
+}
+function summarizeGraphWithoutObservability(active, activation) {
+    return {
+        available: false,
+        runtimePlasticitySource: null,
+        structuralOps: null,
+        changed: null,
+        operationsApplied: [],
+        liveBlockCount: null,
+        prunedBlockCount: null,
+        prePruneBlockCount: null,
+        strongestBlockId: null,
+        operatorSummary: null,
+        detail: active === null
+            ? activation.detail
+            : `active pack ${active.packId} is pinned, but graph observability is unavailable`
+    };
+}
+function summarizeLearnedRoutingWithoutObservability(active) {
+    return {
+        required: active?.routePolicy === "requires_learned_routing",
+        available: false,
+        routerIdentity: active?.routerIdentity ?? null,
+        routeFnVersion: null,
+        trainingMethod: null,
+        routerTrainedAt: null,
+        objective: null,
+        pgProfile: null,
+        routerChecksum: null,
+        objectiveChecksum: null,
+        updateMechanism: null,
+        updateVersion: null,
+        updateCount: null,
+        supervisionCount: null,
+        collectedLabelsTotal: null,
+        freshnessChecksum: null,
+        handoffState: "missing",
+        initMode: null,
+        seedStateVisible: false
+    };
+}
 function summarizeBrainState(active, observability) {
     if (active === null) {
         return {
@@ -4339,6 +5198,11 @@ function summarizeServePath(compile) {
         error: compile.error
     };
 }
+function probeOperatorServePath(activationRoot, observability, activePackId) {
+    const compileInput = buildAttachStatusCompileInput(activationRoot, undefined);
+    const compile = compileInput === null ? null : buildAttachCompileStatus(compileRuntimeContext(compileInput), observability, activePackId);
+    return summarizeServePath(compile);
+}
 function loadOperatorEventExport(input) {
     const eventExportPath = normalizeOptionalString(input.eventExportPath);
     if (eventExportPath === undefined) {
@@ -4527,62 +5391,125 @@ function summarizeSupervision(input) {
             : "the supplied export does not yet show human supervision"
     };
 }
-function loadTeacherSnapshot(input) {
+function loadTeacherSurfaceFromInput(input) {
     const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
     if (teacherSnapshotPath === undefined) {
         return null;
     }
-    const snapshot = readJsonFile(path.resolve(teacherSnapshotPath));
-    if (snapshot.runtimeOwner !== "openclaw") {
-        throw new Error("teacher snapshot runtimeOwner must be openclaw");
-    }
-    return snapshot;
+    return loadTeacherSurface(teacherSnapshotPath);
 }
 function summarizeTeacherLoop(input) {
-    const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
-    if (teacherSnapshotPath === undefined) {
+    const loaded = loadTeacherSurfaceFromInput(input);
+    if (loaded === null && normalizeOptionalString(input.teacherSnapshotPath) === undefined) {
         return {
             available: false,
             sourcePath: null,
+            sourceKind: "missing",
+            lastRunAt: null,
             lastNoOpReason: "unavailable",
             latestFreshness: "unavailable",
+            startedAt: null,
+            lastHeartbeatAt: null,
+            lastScanAt: null,
             lastProcessedAt: null,
+            artifactCount: null,
             queueDepth: null,
             queueCapacity: null,
             running: null,
+            replayedBundleCount: null,
+            replayedEventCount: null,
+            exportedBundleCount: null,
+            exportedEventCount: null,
+            sessionTailSessionsTracked: null,
+            sessionTailBridgedEventCount: null,
+            localSessionTailNoopReason: null,
+            learningCadence: "unavailable",
+            scanPolicy: "unavailable",
+            liveSlicesPerCycle: null,
+            backfillSlicesPerCycle: null,
+            failureMode: "unavailable",
+            failureDetail: null,
+            lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
             notes: [],
             detail: "no teacher snapshot path supplied"
         };
     }
-    const snapshot = loadTeacherSnapshot(input);
-    if (snapshot === null) {
+    if (loaded === null) {
+        const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
         return {
             available: false,
-            sourcePath: path.resolve(teacherSnapshotPath),
+            sourcePath: teacherSnapshotPath === undefined ? null : path.resolve(teacherSnapshotPath),
+            sourceKind: "missing",
+            lastRunAt: null,
             lastNoOpReason: "unavailable",
             latestFreshness: "unavailable",
+            startedAt: null,
+            lastHeartbeatAt: null,
+            lastScanAt: null,
             lastProcessedAt: null,
+            artifactCount: null,
             queueDepth: null,
             queueCapacity: null,
             running: null,
+            replayedBundleCount: null,
+            replayedEventCount: null,
+            exportedBundleCount: null,
+            exportedEventCount: null,
+            sessionTailSessionsTracked: null,
+            sessionTailBridgedEventCount: null,
+            localSessionTailNoopReason: null,
+            learningCadence: "unavailable",
+            scanPolicy: "unavailable",
+            liveSlicesPerCycle: null,
+            backfillSlicesPerCycle: null,
+            failureMode: "unavailable",
+            failureDetail: null,
+            lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
             notes: [],
             detail: "teacher snapshot could not be loaded"
         };
     }
+    const snapshot = loaded.snapshot;
+    const watchSnapshot = loaded.watchSnapshot;
     return {
         available: true,
-        sourcePath: path.resolve(teacherSnapshotPath),
+        sourcePath: loaded.sourcePath,
+        sourceKind: loaded.sourceKind,
+        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,
+        lastScanAt: snapshot.runtime?.lastScanAt ?? null,
         lastProcessedAt: snapshot.diagnostics.lastProcessedAt,
+        artifactCount: watchSnapshot?.teacher.artifactCount ?? snapshot.teacher.artifactCount,
         queueDepth: snapshot.queue.depth,
         queueCapacity: snapshot.queue.capacity,
         running: snapshot.queue.running,
+        replayedBundleCount: watchSnapshot?.replayedBundleCount ?? null,
+        replayedEventCount: watchSnapshot?.replayedEventCount ?? null,
+        exportedBundleCount: watchSnapshot?.exportedBundleCount ?? null,
+        exportedEventCount: watchSnapshot?.exportedEventCount ?? null,
+        sessionTailSessionsTracked: watchSnapshot?.sessionTailSessionsTracked ?? null,
+        sessionTailBridgedEventCount: watchSnapshot?.sessionTailBridgedEventCount ?? null,
+        localSessionTailNoopReason: watchSnapshot?.localSessionTailNoopReason ?? null,
+        learningCadence: watchSnapshot?.labeling.learningCadence ?? "unavailable",
+        scanPolicy: watchSnapshot?.labeling.scanPolicy ?? "unavailable",
+        liveSlicesPerCycle: watchSnapshot?.labeling.liveSlicesPerCycle ?? null,
+        backfillSlicesPerCycle: watchSnapshot?.labeling.backfillSlicesPerCycle ?? null,
+        failureMode: watchSnapshot?.failure?.mode ?? "none",
+        failureDetail: watchSnapshot?.failure?.detail ?? null,
+        lastAppliedMaterializationJobId: watchSnapshot?.teacher.lastAppliedMaterializationJobId ??
+            snapshot.runtime?.lastAppliedMaterializationJobId ??
+            snapshot.learner.lastMaterialization?.jobId ??
+            null,
         lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null,
         notes: [...snapshot.diagnostics.notes],
-        detail: "async teacher diagnostics loaded"
+        detail: loaded.sourceKind === "watch_snapshot"
+            ? "canonical watch teacher snapshot loaded"
+            : "raw async teacher snapshot loaded"
     };
 }
 function summarizeLearningBacklogState(plan, principalLagStatus) {
@@ -4639,8 +5566,8 @@ function summarizeAlwaysOnLearning(input, active) {
         sequenceLag: null,
         status: "unavailable"
     };
-    const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
-    if (teacherSnapshotPath === undefined) {
+    const loadedTeacherSurface = loadTeacherSurfaceFromInput(input);
+    if (loadedTeacherSurface === null && normalizeOptionalString(input.teacherSnapshotPath) === undefined) {
         return {
             available: false,
             sourcePath: null,
@@ -4672,11 +5599,11 @@ function summarizeAlwaysOnLearning(input, active) {
             detail: "no teacher snapshot path supplied"
         };
     }
-    const snapshot = loadTeacherSnapshot(input);
-    if (snapshot === null) {
+    if (loadedTeacherSurface === null) {
+        const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
         return {
             available: false,
-            sourcePath: path.resolve(teacherSnapshotPath),
+            sourcePath: teacherSnapshotPath === undefined ? null : path.resolve(teacherSnapshotPath),
             bootstrapped: null,
             mode: "unavailable",
             nextPriorityLane: "unavailable",
@@ -4705,6 +5632,7 @@ function summarizeAlwaysOnLearning(input, active) {
             detail: "teacher snapshot could not be loaded"
         };
     }
+    const snapshot = loadedTeacherSurface.snapshot;
     const plan = describeAlwaysOnLearningRuntimeState(snapshot.learner.state, snapshot.learner.lastMaterialization);
     const latestPrincipalSequence = plan.principalBacklog.checkpoints.reduce((latest, checkpoint) => {
         const candidate = checkpoint.newestPendingSequence ?? checkpoint.learnedThroughSequence;
@@ -4730,7 +5658,7 @@ function summarizeAlwaysOnLearning(input, active) {
     });
     return {
         available: true,
-        sourcePath: path.resolve(teacherSnapshotPath),
+        sourcePath: loadedTeacherSurface.sourcePath,
         bootstrapped: plan.bootstrapped,
         mode: plan.mode,
         nextPriorityLane: plan.nextPriorityLane,
@@ -4779,7 +5707,13 @@ function buildOperatorFindings(report) {
     const push = (severity, code, summary, detail) => {
         findings.push({ severity, code, summary, detail });
     };
-    if (report.active === null) {
+    if (report.activation.state === "broken_install") {
+        push("fail", "activation_broken_install", "activation root is broken", report.activation.detail);
+    }
+    else if (report.activation.state === "stale_incomplete") {
+        push("fail", "activation_stale_incomplete", "activation root is stale or incomplete", report.activation.detail);
+    }
+    else if (report.active === null) {
         push("fail", "active_missing", "active slot is empty", "no active pack found; this is the pre-bootstrap state — call `bootstrapRuntimeAttach()` to activate an initial pack before compiling or serving");
     }
     else if (!report.active.activationReady) {
@@ -4920,12 +5854,18 @@ function summarizeCurrentProfileLogRoot(activationRoot) {
     const logRoot = path.join(path.resolve(activationRoot), LEARNING_SPINE_LOG_LAYOUT.dir);
     return existsSync(logRoot) ? logRoot : null;
 }
-function summarizeCurrentProfileLastLearningUpdateAt(activationRoot, learning) {
+function summarizeCurrentProfileLastLearningUpdateAt(activationRoot, learning, teacherLoop) {
     const updates = readLearningSpineLogEntries(activationRoot, "pgRouteUpdates");
-    return updates.at(-1)?.recordedAt ?? learning.lastMaterializedAt ?? null;
+    return updates.at(-1)?.recordedAt ?? teacherLoop.lastRunAt ?? learning.lastMaterializedAt ?? null;
 }
 function summarizeCurrentProfileBrainSummary(input) {
     const packId = input.activePackId ?? "unknown";
+    if (input.activationState === "broken_install") {
+        return "Brain activation is broken and needs repair before serve-path truth can be trusted.";
+    }
+    if (input.activationState === "stale_incomplete") {
+        return "Brain activation has retained stale/incomplete state and no serving active pack.";
+    }
     if (!input.attached) {
         return "Brain is not attached to the current Profile.";
     }
@@ -4961,6 +5901,7 @@ function summarizeCurrentProfileBrainStatusLevel(input) {
 function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId) {
     const attached = report.active !== null;
     const awaitingFirstExport = isAwaitingFirstExportSlot(report.active);
+    const activationState = report.activation.state;
     const routerIdentity = report.servePath.routerIdentity ?? report.learnedRouting.routerIdentity ?? report.active?.routerIdentity ?? null;
     const routeFreshness = report.servePath.refreshStatus === "updated" || report.servePath.refreshStatus === "no_supervision"
         ? report.servePath.refreshStatus
@@ -4999,16 +5940,20 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
             routerIdentity,
             routerChecksum: report.learnedRouting.routerChecksum,
             lastExportAt: report.supervision.exportedAt,
-            lastLearningUpdateAt: summarizeCurrentProfileLastLearningUpdateAt(report.activationRoot, report.learning),
+            lastLearningUpdateAt: summarizeCurrentProfileLastLearningUpdateAt(report.activationRoot, report.learning, report.teacherLoop),
             lastPromotionAt: report.promotion.lastPromotion.at,
             summary: summarizeCurrentProfileBrainSummary({
+                activationState,
                 attached,
                 serveState: report.servePath.state,
                 brainState: report.brain.state,
                 awaitingFirstExport,
-                activePackId
+                activePackId,
+                activationDetail: report.activation.detail
             }),
-            detail: report.brain.detail
+            detail: activationState === "broken_install" || activationState === "stale_incomplete" || activationState === "detached"
+                ? report.activation.detail
+                : report.brain.detail
         },
         attachment: attached
             ? {
@@ -5037,21 +5982,28 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
             status,
             brainState: report.brain.state,
             serveState: report.servePath.state,
+            activationState,
             usedLearnedRouteFn: report.servePath.usedLearnedRouteFn,
             failOpen: report.servePath.fallbackToStaticContext,
             awaitingFirstExport,
             structuralDecision: report.servePath.structuralDecision,
-            detail: 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"
+            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"
         },
         currentTurnAttribution: null
     };
@@ -5060,59 +6012,100 @@ export function buildOperatorSurfaceReport(input) {
     const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
     const updatedAt = normalizeIsoTimestamp(input.updatedAt, "updatedAt", new Date().toISOString());
     const brainAttachmentPolicy = normalizeBrainAttachmentPolicy(input.brainAttachmentPolicy);
-    const inspection = inspectActivationState(activationRoot, updatedAt);
-    const observability = describeActivationObservability(activationRoot, "active", {
-        updatedAt
+    let inspection = null;
+    let observability = null;
+    let inspectionError = null;
+    try {
+        inspection = inspectActivationState(activationRoot, updatedAt);
+    }
+    catch (error) {
+        inspectionError = toErrorMessage(error);
+    }
+    const active = inspection === null ? null : summarizeOperatorSlot(inspection.active, inspection.pointers.active?.updatedAt ?? null);
+    const candidate = inspection === null ? null : summarizeOperatorSlot(inspection.candidate, inspection.pointers.candidate?.updatedAt ?? null);
+    const previous = inspection === null ? null : summarizeOperatorSlot(inspection.previous, inspection.pointers.previous?.updatedAt ?? null);
+    if (inspection !== null && inspection.active !== null) {
+        try {
+            observability = describeActivationObservability(activationRoot, "active", {
+                updatedAt
+            });
+        }
+        catch (error) {
+            inspectionError ??= `activation observability failed: ${toErrorMessage(error)}`;
+        }
+    }
+    const activation = summarizeOperatorActivationState({
+        inspection,
+        observability,
+        active,
+        candidate,
+        previous,
+        inspectionError
     });
-    const attachStatus = describeAttachStatus({ activationRoot });
-    const active = summarizeOperatorSlot(inspection.active, inspection.pointers.active?.updatedAt ?? null);
+    const activeObservability = inspectionError === null
+        ? summarizeActivePackObservability(activationRoot, active)
+        : {
+            labelFlow: buildMissingLabelFlowSummary(`activation observability is unavailable: ${inspectionError}`),
+            learningPath: buildMissingLearningPathSummary(`activation observability is unavailable: ${inspectionError}`)
+        };
+    const servePath = probeOperatorServePath(activationRoot, observability, active?.packId ?? null);
     const reportBase = {
         generatedAt: updatedAt,
         activationRoot,
+        activation,
         active,
-        candidate: summarizeOperatorSlot(inspection.candidate, inspection.pointers.candidate?.updatedAt ?? null),
-        previous: summarizeOperatorSlot(inspection.previous, inspection.pointers.previous?.updatedAt ?? null),
+        candidate,
+        previous,
         freshness: {
-            activeBehindPromotionReadyCandidate: observability.promotionFreshness.activeBehindPromotionReadyCandidate,
-            candidateAheadBy: summarizeCandidateAheadBy(observability.promotionFreshness.candidateAheadBy)
+            activeBehindPromotionReadyCandidate: observability?.promotionFreshness.activeBehindPromotionReadyCandidate ?? false,
+            candidateAheadBy: summarizeCandidateAheadBy(observability?.promotionFreshness.candidateAheadBy ?? null)
         },
-        brain: summarizeBrainState(active, observability),
-        graph: summarizeGraphObservability(active, observability),
-        learnedRouting: {
-            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
-        },
-        servePath: summarizeServePath(attachStatus.compile),
+        brain: observability === null ? summarizeBrainStateWithoutObservability(active, activation) : summarizeBrainState(active, observability),
+        graph: observability === null ? summarizeGraphWithoutObservability(active, activation) : summarizeGraphObservability(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
+            },
+        servePath,
         promotion: {
-            allowed: inspection.promotion.allowed,
-            findings: [...inspection.promotion.findings],
-            lastPromotion: summarizeLastPromotion(inspection),
-            activeUpdatedAt: inspection.pointers.active?.updatedAt ?? null,
-            candidateUpdatedAt: inspection.pointers.candidate?.updatedAt ?? null,
-            previousUpdatedAt: inspection.pointers.previous?.updatedAt ?? null
+            allowed: inspection?.promotion.allowed ?? false,
+            findings: [...(inspection?.promotion.findings ?? [])],
+            lastPromotion: inspection === null ? {
+                known: false,
+                at: null,
+                confidence: "unknown_from_local_pointers",
+                note: activation.detail
+            } : summarizeLastPromotion(inspection),
+            activeUpdatedAt: inspection?.pointers.active?.updatedAt ?? null,
+            candidateUpdatedAt: inspection?.pointers.candidate?.updatedAt ?? null,
+            previousUpdatedAt: inspection?.pointers.previous?.updatedAt ?? null
         },
         rollback: {
-            allowed: inspection.rollback.allowed,
-            findings: [...inspection.rollback.findings],
-            previousPackId: inspection.previous?.packId ?? inspection.pointers.previous?.packId ?? null,
-            state: inspection.rollback.allowed ? "ready" : inspection.active === null ? "unknown" : "blocked"
+            allowed: inspection?.rollback.allowed ?? false,
+            findings: [...(inspection?.rollback.findings ?? [])],
+            previousPackId: inspection?.previous?.packId ?? inspection?.pointers.previous?.packId ?? null,
+            state: inspection === null ? "unknown" : inspection.rollback.allowed ? "ready" : inspection.active === null ? "unknown" : "blocked"
         },
         supervision: summarizeSupervision(input),
         learning: summarizeAlwaysOnLearning(input, active),
@@ -5198,8 +6191,9 @@ export { describeNormalizedEventExportObservability } from "@openclawbrain/event
 export { describeCompileFallbackUsage } from "@openclawbrain/compiler";
 export { describeActivationObservability, inspectActivationState, rollbackActivePack } from "@openclawbrain/pack-format";
 export { createOpenClawLocalSessionTail, OpenClawLocalSessionTail } from "./session-tail.js";
-export { discoverOpenClawMainSessionStores, loadOpenClawSessionIndex, readOpenClawAcpStreamFile, readOpenClawSessionFile } from "./session-store.js";
+export { discoverOpenClawMainSessionStores, discoverOpenClawSessionStores, loadOpenClawSessionIndex, readOpenClawAcpStreamFile, readOpenClawSessionFile } from "./session-store.js";
 export { buildPassiveLearningSessionExportFromOpenClawSessionStore, buildPassiveLearningStoreExportFromOpenClawSessionIndex } from "./local-session-passive-learning.js";
+export { DEFAULT_OLLAMA_BASE_URL, DEFAULT_OLLAMA_TIMEOUT_MS, OllamaClient, OllamaClientError, createOllamaClient } from "./ollama-client.js";
 export { resolveActivationRoot } from "./resolve-activation-root.js";
 export { runDaemonCommand, parseDaemonArgs } from "./daemon.js";
 //# sourceMappingURL=index.js.map