@openclawbrain/openclaw 0.2.2 → 0.2.3

package/dist/src/index.js

@@ -229,6 +229,19 @@ function cloneAlwaysOnLearningMaterializationJobOrNull(value) {
 function cloneTeacherSupervisionArtifacts(value) {
     return [...structuredClone(value)];
 }
+function cloneAsyncTeacherSnapshotState(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return {
+        interactionEvents: [...structuredClone(value.interactionEvents)],
+        feedbackEvents: [...structuredClone(value.feedbackEvents)],
+        seenExportDigests: [...value.seenExportDigests]
+    };
+}
+function cloneAsyncTeacherSnapshotRuntime(value) {
+    return value === undefined ? undefined : { ...value };
+}
 function cloneCanonicalSupervision(value) {
     return structuredClone(value);
 }
@@ -548,6 +561,25 @@ export class AsyncTeacherLiveLoop {
         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);
@@ -745,6 +777,11 @@ export class AsyncTeacherLiveLoop {
             diagnostics: {
                 ...this.diagnostics,
                 notes: [...this.diagnostics.notes]
+            },
+            state: {
+                interactionEvents: [...structuredClone(this.interactionEvents)],
+                feedbackEvents: [...structuredClone(this.feedbackEvents)],
+                seenExportDigests: [...this.seenExportDigests].sort()
             }
         };
     }
@@ -781,6 +818,7 @@ export class AsyncTeacherLiveLoop {
             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,
@@ -795,10 +833,17 @@ export class AsyncTeacherLiveLoop {
                 ...(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.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;
@@ -927,18 +972,53 @@ export function scanLiveEventExport(input) {
             })
         }
     };
+    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 function loadAsyncTeacherLiveLoopSnapshot(snapshotPath) {
+    const snapshot = readJsonFile(path.resolve(snapshotPath));
+    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;
+}
 function resolveBundlePayloadPath(rootDir, payloadPath) {
     const resolved = path.resolve(rootDir, payloadPath);
     const relative = path.relative(rootDir, resolved);
@@ -1770,6 +1850,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 +2044,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 +2082,70 @@ 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 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
+        });
+    }
+    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 +2376,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 +2430,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 +2442,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 +3273,33 @@ export function writeScannedEventExportBundle(input) {
     });
 }
 export function runRuntimeTurn(turn, options = {}) {
+    const warnings = [];
     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
             });
         }
-        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,7 +3308,7 @@ 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,
@@ -3121,19 +3316,39 @@ export function runRuntimeTurn(turn, options = {}) {
             });
         }
         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 +4332,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 {
@@ -4532,11 +4885,7 @@ function loadTeacherSnapshot(input) {
     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 loadAsyncTeacherLiveLoopSnapshot(teacherSnapshotPath);
 }
 function summarizeTeacherLoop(input) {
     const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
@@ -4546,10 +4895,14 @@ function summarizeTeacherLoop(input) {
             sourcePath: null,
             lastNoOpReason: "unavailable",
             latestFreshness: "unavailable",
+            startedAt: null,
+            lastHeartbeatAt: null,
+            lastScanAt: null,
             lastProcessedAt: null,
             queueDepth: null,
             queueCapacity: null,
             running: null,
+            lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
             notes: [],
             detail: "no teacher snapshot path supplied"
@@ -4562,10 +4915,14 @@ function summarizeTeacherLoop(input) {
             sourcePath: path.resolve(teacherSnapshotPath),
             lastNoOpReason: "unavailable",
             latestFreshness: "unavailable",
+            startedAt: null,
+            lastHeartbeatAt: null,
+            lastScanAt: null,
             lastProcessedAt: null,
             queueDepth: null,
             queueCapacity: null,
             running: null,
+            lastAppliedMaterializationJobId: null,
             lastMaterializedPackId: null,
             notes: [],
             detail: "teacher snapshot could not be loaded"
@@ -4576,10 +4933,14 @@ function summarizeTeacherLoop(input) {
         sourcePath: path.resolve(teacherSnapshotPath),
         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,
         queueDepth: snapshot.queue.depth,
         queueCapacity: snapshot.queue.capacity,
         running: snapshot.queue.running,
+        lastAppliedMaterializationJobId: snapshot.runtime?.lastAppliedMaterializationJobId ?? null,
         lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null,
         notes: [...snapshot.diagnostics.notes],
         detail: "async teacher diagnostics loaded"
@@ -5066,6 +5427,7 @@ export function buildOperatorSurfaceReport(input) {
     });
     const attachStatus = describeAttachStatus({ activationRoot });
     const active = summarizeOperatorSlot(inspection.active, inspection.pointers.active?.updatedAt ?? null);
+    const activeObservability = summarizeActivePackObservability(activationRoot, active);
     const reportBase = {
         generatedAt: updatedAt,
         activationRoot,
@@ -5078,6 +5440,8 @@ export function buildOperatorSurfaceReport(input) {
         },
         brain: summarizeBrainState(active, observability),
         graph: summarizeGraphObservability(active, observability),
+        labelFlow: activeObservability.labelFlow,
+        learningPath: activeObservability.learningPath,
         learnedRouting: {
             required: observability.learnedRouteFn.required,
             available: observability.learnedRouteFn.available,
@@ -5198,7 +5562,7 @@ 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 { resolveActivationRoot } from "./resolve-activation-root.js";
 export { runDaemonCommand, parseDaemonArgs } from "./daemon.js";