@openclawbrain/openclaw 0.2.3 → 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}`
     ];
 }
@@ -233,10 +237,13 @@ 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(value.interactionEvents)],
-        feedbackEvents: [...structuredClone(value.feedbackEvents)],
-        seenExportDigests: [...value.seenExportDigests]
+        interactionEvents: [...structuredClone(interactionEvents)],
+        feedbackEvents: [...structuredClone(feedbackEvents)],
+        seenExportDigests: [...seenExportDigests]
     };
 }
 function cloneAsyncTeacherSnapshotRuntime(value) {
@@ -521,6 +528,7 @@ export class AsyncTeacherLiveLoop {
     input;
     queueCapacity;
     staleAfterMs;
+    teacherLabeler;
     queuedExportDigests = new Set();
     seenExportDigests = new Set();
     queue = [];
@@ -530,6 +538,7 @@ export class AsyncTeacherLiveLoop {
     teacherArtifacts = [];
     learnerState = createAlwaysOnLearningRuntimeState();
     lastMaterialization = null;
+    lastTeacherLabelerResult = null;
     diagnostics = {
         acceptedExportCount: 0,
         processedExportCount: 0,
@@ -548,13 +557,15 @@ 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");
         }
@@ -621,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,
@@ -800,57 +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 learnedRoutingState = this.input.resolveLearnedRoutingState?.() ?? {};
-            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));
+            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;
             }
-            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();
         }
     }
     refreshNotes() {
@@ -862,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
         });
     }
 }
@@ -968,7 +1031,8 @@ export function scanLiveEventExport(input) {
                 dedupedArtifactCount: 0,
                 sparseFeedback: learnerResult.state.sparseFeedback,
                 noOpReason: lastNoOpReason,
-                materialization: learnerResult.materialization
+                materialization: learnerResult.materialization,
+                teacherLabeler: null
             })
         }
     };
@@ -991,8 +1055,270 @@ function readJsonFile(filePath) {
 export function resolveAsyncTeacherLiveLoopSnapshotPath(activationRoot) {
     return path.join(path.resolve(normalizeNonEmptyString(activationRoot, "activationRoot")), "async-teacher-live-loop.snapshot.json");
 }
-export function loadAsyncTeacherLiveLoopSnapshot(snapshotPath) {
-    const snapshot = readJsonFile(path.resolve(snapshotPath));
+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");
     }
@@ -1019,6 +1345,17 @@ export function loadAsyncTeacherLiveLoopSnapshot(snapshotPath) {
     }
     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);
@@ -1653,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);
@@ -2102,6 +2451,31 @@ function normalizeServeRouteChannel(value) {
 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;
@@ -2132,7 +2506,8 @@ function appendCompileServeRouteDecisionLog(input) {
             activationRoot: input.activationRoot,
             turn: syntheticTurn,
             compileResult: input.compileResult,
-            recordedAt
+            recordedAt,
+            breadcrumbs: buildCompileServeRouteBreadcrumbs(input.compileInput)
         });
     }
     catch (error) {
@@ -3274,6 +3649,7 @@ export function writeScannedEventExportBundle(input) {
 }
 export function runRuntimeTurn(turn, options = {}) {
     const warnings = [];
+    const serveRouteBreadcrumbs = buildRunRuntimeTurnServeRouteBreadcrumbs();
     const agentId = normalizeOptionalString(turn.agentId);
     const compileInput = {
         activationRoot: (options.activationRoot ?? turn.activationRoot),
@@ -3294,7 +3670,8 @@ export function runRuntimeTurn(turn, options = {}) {
                 activationRoot: compileResult.activationRoot,
                 turn,
                 compileResult,
-                recordedAt: serveLoggedAt
+                recordedAt: serveLoggedAt,
+                breadcrumbs: serveRouteBreadcrumbs
             });
         }
         catch (error) {
@@ -3312,7 +3689,8 @@ export function runRuntimeTurn(turn, options = {}) {
                 turn,
                 compileResult,
                 normalizedEventExport,
-                recordedAt: compileEvent?.createdAt ?? serveLoggedAt
+                recordedAt: compileEvent?.createdAt ?? serveLoggedAt,
+                breadcrumbs: serveRouteBreadcrumbs
             });
         }
         catch (error) {
@@ -4536,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 {
@@ -4692,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) {
@@ -4880,70 +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;
     }
-    return loadAsyncTeacherLiveLoopSnapshot(teacherSnapshotPath);
+    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,
-        lastAppliedMaterializationJobId: snapshot.runtime?.lastAppliedMaterializationJobId ?? null,
+        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) {
@@ -5000,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,
@@ -5033,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",
@@ -5066,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;
@@ -5091,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,
@@ -5140,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) {
@@ -5281,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.";
     }
@@ -5322,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
@@ -5360,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
             ? {
@@ -5398,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
     };
@@ -5421,62 +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 = summarizeActivePackObservability(activationRoot, active);
+    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),
+        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: {
-            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),
+        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),
@@ -5564,6 +6193,7 @@ export { describeActivationObservability, inspectActivationState, rollbackActive
 export { createOpenClawLocalSessionTail, OpenClawLocalSessionTail } from "./session-tail.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