@openclawbrain/cli 0.4.16 → 0.4.18

package/dist/src/bounded-jsonl-reader.js

@@ -0,0 +1,65 @@
+import { existsSync, openSync, readSync, closeSync, statSync, readFileSync } from "node:fs";
+
+const DEFAULT_TAIL_BYTES = 4 * 1024 * 1024;
+const DEFAULT_MAX_ENTRIES = 512;
+const DEFAULT_MAX_LINE_BYTES = 128 * 1024;
+
+export function readBoundedJsonlTail(filePath, options = {}) {
+    const tailBytes = options.tailBytes ?? DEFAULT_TAIL_BYTES;
+    const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const maxLineBytes = options.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES;
+    if (!existsSync(filePath)) {
+        return { entries: [], fallbackReason: null };
+    }
+    let fallbackReason = null;
+    let raw;
+    try {
+        const fileSize = statSync(filePath).size;
+        if (fileSize <= tailBytes) {
+            raw = readFileSync(filePath, "utf8");
+        }
+        else {
+            fallbackReason = "tail_truncated";
+            const offset = fileSize - tailBytes;
+            const buf = Buffer.alloc(tailBytes);
+            const fd = openSync(filePath, "r");
+            try {
+                readSync(fd, buf, 0, tailBytes, offset);
+            }
+            finally {
+                closeSync(fd);
+            }
+            raw = buf.toString("utf8");
+            const firstNewline = raw.indexOf("\n");
+            if (firstNewline >= 0) {
+                raw = raw.slice(firstNewline + 1);
+            }
+        }
+    }
+    catch {
+        return { entries: [], fallbackReason: "read_error" };
+    }
+    const lines = raw.split(/\r?\n/u).map((l) => l.trim()).filter((l) => l.length > 0);
+    const entries = [];
+    let skippedOversized = 0;
+    for (const line of lines) {
+        if (Buffer.byteLength(line, "utf8") > maxLineBytes) {
+            skippedOversized++;
+            continue;
+        }
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    if (skippedOversized > 0) {
+        fallbackReason = fallbackReason ? `${fallbackReason}+oversized_lines_skipped` : "oversized_lines_skipped";
+    }
+    const trimmed = entries.length > maxEntries ? entries.slice(-maxEntries) : entries;
+    if (entries.length > maxEntries) {
+        fallbackReason = fallbackReason ? `${fallbackReason}+entry_count_capped` : "entry_count_capped";
+    }
+    return { entries: trimmed, fallbackReason };
+}

package/dist/src/cli.js

@@ -10,7 +10,7 @@ import { ensureManagedLearnerServiceForActivationRoot, inspectManagedLearnerServ
 import { exportBrain, importBrain } from "./import-export.js";
 import { buildNormalizedEventExport } from "@openclawbrain/contracts";
 import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, drainAlwaysOnLearningRuntime, loadOrInitBaseline, materializeAlwaysOnLearningCandidatePack, persistBaseline } from "./local-learner.js";
-import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, stageCandidatePack } from "@openclawbrain/pack-format";
+import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, resolveLearningSpineLogPath, stageCandidatePack } from "@openclawbrain/pack-format";
 import { resolveActivationRoot } from "./resolve-activation-root.js";
 import { describeOpenClawHomeInspection, discoverOpenClawHomes, formatOpenClawHomeLayout, formatOpenClawHomeProfileSource, inspectOpenClawHome } from "./openclaw-home-layout.js";
 import { inspectOpenClawBrainHookStatus, inspectOpenClawBrainPluginAllowlist } from "./openclaw-hook-truth.js";
@@ -37,6 +37,68 @@ const INSTALL_COMPATIBLE_LOCAL_TEACHER_MODEL_PREFIXES = [
     "qwen3:8b",
     "qwen2.5:7b"
 ];
+const DEFAULT_BOUNDED_JSONL_TAIL_BYTES = 4 * 1024 * 1024;
+const DEFAULT_BOUNDED_JSONL_MAX_ENTRIES = 512;
+const DEFAULT_BOUNDED_JSONL_MAX_LINE_BYTES = 128 * 1024;
+function readBoundedJsonlTail(filePath, options = {}) {
+    const tailBytes = options.tailBytes ?? DEFAULT_BOUNDED_JSONL_TAIL_BYTES;
+    const maxEntries = options.maxEntries ?? DEFAULT_BOUNDED_JSONL_MAX_ENTRIES;
+    const maxLineBytes = options.maxLineBytes ?? DEFAULT_BOUNDED_JSONL_MAX_LINE_BYTES;
+    if (!existsSync(filePath)) {
+        return { entries: [], fallbackReason: null };
+    }
+    let fallbackReason = null;
+    let raw;
+    try {
+        const fileSize = statSync(filePath).size;
+        if (fileSize <= tailBytes) {
+            raw = readFileSync(filePath, "utf8");
+        }
+        else {
+            fallbackReason = "tail_truncated";
+            const offset = fileSize - tailBytes;
+            const buffer = Buffer.alloc(tailBytes);
+            const fileDescriptor = openSync(filePath, "r");
+            try {
+                readSync(fileDescriptor, buffer, 0, tailBytes, offset);
+            }
+            finally {
+                closeSync(fileDescriptor);
+            }
+            raw = buffer.toString("utf8");
+            const firstNewline = raw.indexOf("\n");
+            if (firstNewline >= 0) {
+                raw = raw.slice(firstNewline + 1);
+            }
+        }
+    }
+    catch {
+        return { entries: [], fallbackReason: "read_error" };
+    }
+    const lines = raw.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
+    const entries = [];
+    let skippedOversized = 0;
+    for (const line of lines) {
+        if (Buffer.byteLength(line, "utf8") > maxLineBytes) {
+            skippedOversized++;
+            continue;
+        }
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    if (skippedOversized > 0) {
+        fallbackReason = fallbackReason === null ? "oversized_lines_skipped" : `${fallbackReason}+oversized_lines_skipped`;
+    }
+    const trimmedEntries = entries.length > maxEntries ? entries.slice(-maxEntries) : entries;
+    if (entries.length > maxEntries) {
+        fallbackReason = fallbackReason === null ? "entry_count_capped" : `${fallbackReason}+entry_count_capped`;
+    }
+    return { entries: trimmedEntries, fallbackReason };
+}
 function quoteShellArg(value) {
     return `'${value.replace(/'/g, `"'"'`)}'`;
 }
@@ -1171,6 +1233,7 @@ function summarizeStatusEmbedder(embeddings) {
 }
 function summarizeStatusRouteFn(status, report) {
     const freshness = report.servePath.refreshStatus ?? status.brain.routeFreshness;
+    const fallbackReason = report.routeFn.fallbackReason ?? null;
     if (!report.routeFn.available) {
         return {
             available: false,
@@ -1178,6 +1241,7 @@ function summarizeStatusRouteFn(status, report) {
             trainedAt: report.routeFn.trainedAt,
             updatedAt: report.routeFn.updatedAt,
             usedAt: report.routeFn.usedAt,
+            fallbackReason,
             detail: report.routeFn.detail
         };
     }
@@ -1191,12 +1255,16 @@ function summarizeStatusRouteFn(status, report) {
     else if (report.routeFn.updatedAt !== null) {
         detail = `active route_fn was last updated at ${report.routeFn.updatedAt}, but no learned serve use is visible yet for the current pack`;
     }
+    if (fallbackReason !== null && !detail.includes(fallbackReason)) {
+        detail = `${detail}; bounded_log_read=${fallbackReason}`;
+    }
     return {
         available: true,
         freshness,
         trainedAt: report.routeFn.trainedAt,
         updatedAt: report.routeFn.updatedAt,
         usedAt: report.routeFn.usedAt,
+        fallbackReason,
         detail
     };
 }
@@ -4453,14 +4521,8 @@ function runUninstallCommand(parsed) {
     return 0;
 }
 function resolveServeTimeLearningRuntimeInput(activationRoot) {
-    let serveTimeDecisions = [];
-    let fallbackReason = null;
-    try {
-        serveTimeDecisions = readLearningSpineLogEntries(activationRoot, "serveTimeRouteDecisions");
-    }
-    catch {
-        fallbackReason = "serve_time_decision_log_read_failed";
-    }
+    const logPath = resolveLearningSpineLogPath(activationRoot, "serveTimeRouteDecisions");
+    const { entries: serveTimeDecisions, fallbackReason } = readBoundedJsonlTail(logPath);
     const decisionLogCount = serveTimeDecisions.length;
     const pgVersion = decisionLogCount > 0 ? "v2" : "v1";
     return {
@@ -4468,7 +4530,7 @@ function resolveServeTimeLearningRuntimeInput(activationRoot) {
         serveTimeDecisions,
         decisionLogCount,
         baselineState: pgVersion === "v2" ? loadOrInitBaseline(activationRoot) : undefined,
-        fallbackReason
+        fallbackReason: fallbackReason === null ? null : `serve_time_decision_log_${fallbackReason}`
     };
 }
 function resolveActivationInspectionPackId(inspection, slot) {

package/dist/src/index.js

@@ -7,9 +7,10 @@ import { compileRuntimeFromActivation } from "@openclawbrain/compiler";
 import { CONTRACT_IDS, buildEventSemanticSurface, buildNormalizedEventExport, canonicalJson, checksumJsonPayload, createFeedbackEvent, createInteractionEvent, sortNormalizedEvents, validateKernelSurface, validateNormalizedEventExport } from "@openclawbrain/contracts";
 import { classifyFeedbackSignalContent, describeNormalizedEventExportObservability } from "@openclawbrain/event-export";
 import { DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS, advanceAlwaysOnLearningRuntime, buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, materializeAlwaysOnLearningCandidatePack, materializeCandidatePackFromNormalizedEventExport } from "./local-learner.js";
-import { LEARNING_SPINE_LOG_LAYOUT, activatePack, describeActivationObservability, describeActivationTarget, describePackCompileTarget, inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, rollbackActivePack, stageCandidatePack } from "@openclawbrain/pack-format";
+import { LEARNING_SPINE_LOG_LAYOUT, activatePack, describeActivationObservability, describeActivationTarget, describePackCompileTarget, inspectActivationState, loadPackFromActivation, promoteCandidatePack, resolveLearningSpineLogPath, rollbackActivePack, stageCandidatePack } from "@openclawbrain/pack-format";
 import { inspectOpenClawBrainHookStatus, summarizeOpenClawBrainHookLoad } from "./openclaw-hook-truth.js";
 import { appendLearningUpdateLogs, appendServeTimeRouteDecisionLog } from "./learning-spine.js";
+import { readBoundedJsonlTail } from "./bounded-jsonl-reader.js";
 import { buildFeedbackSemanticMetadata, buildInteractionSemanticMetadata } from "./semantic-metadata.js";
 export { clearOpenClawProfileRuntimeLoadProof, listOpenClawProfileRuntimeLoadProofs, recordOpenClawProfileRuntimeLoadProof, resolveAttachmentRuntimeLoadProofsPath } from "./attachment-truth.js";
 import { createTeacherLabeler, summarizeTeacherLabelerOpportunity } from "./teacher-labeler.js";
@@ -6930,6 +6931,10 @@ function summarizeTeacherLoop(input) {
             : "raw async teacher snapshot loaded"
     };
 }
+function readBoundedLearningSpineLogEntries(activationRoot, stream) {
+    const logPath = resolveLearningSpineLogPath(activationRoot, stream);
+    return readBoundedJsonlTail(logPath).entries;
+}
 function matchesActiveRouteFnLog(input) {
     if (input.activePackId !== null && input.entryPackId === input.activePackId) {
         return true;
@@ -6970,8 +6975,8 @@ function summarizeRouteFnFreshness(input) {
                 : `active pack ${input.activePackId} does not require a learned route_fn`
         };
     }
-    const updates = readLearningSpineLogEntries(input.activationRoot, "pgRouteUpdates");
-    const decisions = readLearningSpineLogEntries(input.activationRoot, "serveTimeRouteDecisions");
+    const updates = readBoundedLearningSpineLogEntries(input.activationRoot, "pgRouteUpdates");
+    const decisions = readBoundedLearningSpineLogEntries(input.activationRoot, "serveTimeRouteDecisions");
     const updated = [...updates].reverse().find((entry) => matchesActiveRouteFnLog({
         activePackId: input.activePackId,
         routerChecksum: input.learnedRouting.routerChecksum,
@@ -7458,7 +7463,7 @@ function summarizeCurrentProfileLogRoot(activationRoot) {
     return existsSync(logRoot) ? logRoot : null;
 }
 function summarizeCurrentProfileLastLearningUpdateAt(activationRoot, learning, teacherLoop) {
-    const updates = readLearningSpineLogEntries(activationRoot, "pgRouteUpdates");
+    const updates = readBoundedLearningSpineLogEntries(activationRoot, "pgRouteUpdates");
     return updates.at(-1)?.recordedAt ?? teacherLoop.lastRunAt ?? learning.lastMaterializedAt ?? null;
 }
 function didCurrentProfileFirstExportOccur(report) {

package/dist/src/traced-learning-bridge.js

@@ -15,9 +15,66 @@ function normalizeCount(value) {
 function normalizeOptionalString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function normalizeUnitInterval(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.min(1, Number(value))) : 0;
+}
 function normalizeSource(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function normalizeLastInterruptionSummary(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const normalized = {
+        reason: normalizeOptionalString(value.reason),
+        stage: normalizeOptionalString(value.stage),
+        servedPartial: value.servedPartial === true,
+        droppedFrontierCount: normalizeCount(value.droppedFrontierCount),
+        droppedProposalCount: normalizeCount(value.droppedProposalCount),
+        budgetUtilization: normalizeUnitInterval(value.budgetUtilization)
+    };
+    return normalized.reason !== null ||
+        normalized.stage !== null ||
+        normalized.servedPartial ||
+        normalized.droppedFrontierCount > 0 ||
+        normalized.droppedProposalCount > 0 ||
+        normalized.budgetUtilization > 0
+        ? normalized
+        : null;
+}
+function formatLastInterruptionDetail(value) {
+    const summary = normalizeLastInterruptionSummary(value);
+    if (summary === null) {
+        return null;
+    }
+    return [
+        `interrupt=${summary.reason ?? summary.stage ?? "unknown"}`,
+        `partial=${summary.servedPartial ? "yes" : "no"}`,
+        `frontier=${summary.droppedFrontierCount}`,
+        `proposals=${summary.droppedProposalCount}`,
+        `budget=${Math.round(summary.budgetUtilization * 100)}%`
+    ].join(" ");
+}
+function buildLastInterruptionSummaryFromAssemblyDecision(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const accounting = value.interruptionAccounting !== null &&
+        typeof value.interruptionAccounting === "object" &&
+        !Array.isArray(value.interruptionAccounting)
+        ? value.interruptionAccounting
+        : null;
+    return normalizeLastInterruptionSummary({
+        reason: normalizeOptionalString(value.brainDropReason) ?? normalizeOptionalString(value.interruptionReason),
+        stage: normalizeOptionalString(value.interruptionStage),
+        servedPartial: value.servedPartial === true,
+        droppedFrontierCount: Array.isArray(accounting?.droppedFrontierNodeIds)
+            ? accounting.droppedFrontierNodeIds.filter((entry) => typeof entry === "string" && entry.trim().length > 0).length
+            : normalizeCount(accounting?.droppedFrontierCount),
+        droppedProposalCount: normalizeCount(accounting?.droppedProposalCount),
+        budgetUtilization: accounting?.budgetUtilization
+    });
+}
 function summarizeBridgeSource(value) {
     const source = normalizeSource(value);
     if (source === null) {
@@ -53,6 +110,7 @@ function normalizeBridgePayload(payload) {
         materializedPackId: normalizeOptionalString(payload.materializedPackId),
         promoted: payload.promoted === true,
         baselinePersisted: payload.baselinePersisted === true,
+        lastInterruptionSummary: normalizeLastInterruptionSummary(payload.lastInterruptionSummary),
         source: normalizeSource(payload.source)
     };
 }
@@ -79,6 +137,7 @@ function normalizePersistedStatusSurface(payload) {
         materializedPackId: normalizeOptionalString(payload.materializedPackId),
         promoted: payload.promoted === true,
         baselinePersisted: payload.baselinePersisted === true,
+        lastInterruptionSummary: normalizeLastInterruptionSummary(payload.lastInterruptionSummary),
         source
     };
 }
@@ -97,6 +156,7 @@ function defaultSurface(pathname, detail, error = null) {
         materializedPackId: null,
         promoted: false,
         baselinePersisted: false,
+        lastInterruptionSummary: null,
         source: null,
         detail,
         error
@@ -145,6 +205,10 @@ function loadTrainingStateJson(db, key) {
         };
     }
 }
+function loadLastAssemblyInterruptionSummary(db) {
+    const loaded = loadTrainingStateJson(db, "last_assembly_decision_json");
+    return loaded.value === null ? null : buildLastInterruptionSummaryFromAssemblyDecision(loaded.value);
+}
 function writeTrainingStateJson(db, key, value) {
     db.prepare(`INSERT OR REPLACE INTO brain_training_state (key, value) VALUES (?, ?)`).run(key, JSON.stringify(value));
 }
@@ -187,6 +251,7 @@ export function buildTracedLearningBridgePayloadFromRuntime(input) {
         materializedPackId: input?.materializedPackId ?? lastMaterialization?.candidate?.summary?.packId ?? null,
         promoted: input?.promoted === true,
         baselinePersisted: input?.baselinePersisted === true,
+        lastInterruptionSummary: input?.lastInterruptionSummary ?? null,
         source: input?.source
     });
 }
@@ -212,6 +277,7 @@ function buildPersistedStatusSurfaceBridge(summary, context) {
         materializedPackId: summary.materializedPackId,
         promoted: summary.promoted,
         baselinePersisted: summary.baselinePersisted,
+        lastInterruptionSummary: summary.lastInterruptionSummary,
         source: {
             command: "brain-store",
             bridge: TRACED_LEARNING_STATUS_SURFACE_BRIDGE,
@@ -246,7 +312,7 @@ function loadPersistedStatusSurface(db, context) {
         };
     }
 }
-function buildDerivedBrainStoreBridge(db, context) {
+function buildDerivedBrainStoreBridge(db, context, lastInterruptionSummary = null) {
     const routeTraceCount = countRows(db, "brain_traces");
     const supervisionCount = countRows(db, "brain_trace_supervision");
     const candidateUpdateRaw = loadTrainingStateValue(db, "last_pg_candidate_update_json");
@@ -269,6 +335,7 @@ function buildDerivedBrainStoreBridge(db, context) {
         materializedPackId: null,
         promoted: false,
         baselinePersisted: false,
+        lastInterruptionSummary,
         source: {
             command: "brain-store",
             bridge: "brain_store_state",
@@ -288,6 +355,7 @@ function hasMeaningfulTracedLearningSignal(bridge) {
         bridge.materializedPackId !== null ||
         bridge.promoted ||
         bridge.baselinePersisted ||
+        bridge.lastInterruptionSummary !== null ||
         bridge.pgVersionRequested !== null ||
         bridge.pgVersionUsed !== null ||
         bridge.fallbackReason !== null ||
@@ -410,21 +478,28 @@ export function loadBrainStoreTracedLearningBridge(options = {}) {
     let db;
     try {
         db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+        const lastInterruptionSummary = loadLastAssemblyInterruptionSummary(db);
         const persisted = loadPersistedStatusSurface(db, {
             brainRoot,
             dbPath
         });
         if (persisted.bridge !== null) {
+            const bridge = lastInterruptionSummary === null
+                ? persisted.bridge
+                : normalizeBridgePayload({
+                    ...persisted.bridge,
+                    lastInterruptionSummary
+                });
             return {
                 path: dbPath,
-                bridge: persisted.bridge,
+                bridge,
                 error: null
             };
         }
         const bridge = buildDerivedBrainStoreBridge(db, {
             brainRoot,
             dbPath
-        });
+        }, lastInterruptionSummary);
         if (!hasMeaningfulTracedLearningSignal(bridge)) {
             return {
                 path: dbPath,
@@ -471,6 +546,10 @@ function buildStatusSurface(pathname, bridge, options = {}) {
     if (bridge.routerNoOpReason !== null) {
         detailParts.push(`noOp=${bridge.routerNoOpReason}`);
     }
+    const interruptionDetail = formatLastInterruptionDetail(bridge.lastInterruptionSummary);
+    if (interruptionDetail !== null) {
+        detailParts.push(interruptionDetail);
+    }
     return {
         path: pathname,
         present: true,
@@ -485,6 +564,7 @@ function buildStatusSurface(pathname, bridge, options = {}) {
         materializedPackId: bridge.materializedPackId,
         promoted: bridge.promoted,
         baselinePersisted: bridge.baselinePersisted,
+        lastInterruptionSummary: bridge.lastInterruptionSummary,
         source: bridge.source,
         detail: detailParts.join(" "),
         error: options.error ?? null
@@ -507,6 +587,7 @@ function buildRuntimeMaterializationMetadata(loaded) {
         materializedPackId: loaded.bridge.materializedPackId,
         promoted: loaded.bridge.promoted,
         baselinePersisted: loaded.bridge.baselinePersisted,
+        lastInterruptionSummary: loaded.bridge.lastInterruptionSummary,
         fallbackReason: loaded.bridge.fallbackReason,
         routerNoOpReason: loaded.bridge.routerNoOpReason,
         source: loaded.bridge.source
@@ -529,6 +610,7 @@ function mergeCanonicalStatusBridge(canonicalBridge, runtimeLoaded) {
             materializedPackId: canonicalBridge.materializedPackId,
             promoted: canonicalBridge.promoted,
             baselinePersisted: canonicalBridge.baselinePersisted,
+            lastInterruptionSummary: canonicalBridge.lastInterruptionSummary ?? runtimeBridge?.lastInterruptionSummary ?? null,
             fallbackReason: canonicalBridge.fallbackReason,
             routerNoOpReason: canonicalBridge.routerNoOpReason,
             source: runtimeMaterialized === null
@@ -551,6 +633,7 @@ function mergeCanonicalStatusBridge(canonicalBridge, runtimeLoaded) {
         materializedPackId: runtimeBridge?.materializedPackId ?? canonicalBridge.materializedPackId ?? null,
         promoted: runtimeBridge?.promoted ?? canonicalBridge.promoted,
         baselinePersisted: runtimeBridge?.baselinePersisted ?? canonicalBridge.baselinePersisted,
+        lastInterruptionSummary: canonicalBridge.lastInterruptionSummary ?? runtimeBridge?.lastInterruptionSummary ?? null,
         fallbackReason: runtimeBridge?.fallbackReason ?? canonicalBridge.fallbackReason ?? null,
         routerNoOpReason: runtimeBridge?.routerNoOpReason ?? canonicalBridge.routerNoOpReason ?? null,
         source: runtimeMaterialized === null
@@ -571,10 +654,12 @@ export function mergeTracedLearningBridgePayload(payload, persisted) {
     const supervisionCount = Math.max(current.supervisionCount, persistedBridge.supervisionCount);
     const routerUpdateCount = Math.max(current.routerUpdateCount, persistedBridge.routerUpdateCount);
     const teacherArtifactCount = Math.max(current.teacherArtifactCount, persistedBridge.teacherArtifactCount);
+    const lastInterruptionSummary = current.lastInterruptionSummary ?? persistedBridge.lastInterruptionSummary ?? null;
     const usedBridge = routeTraceCount !== current.routeTraceCount ||
         supervisionCount !== current.supervisionCount ||
         routerUpdateCount !== current.routerUpdateCount ||
-        teacherArtifactCount !== current.teacherArtifactCount;
+        teacherArtifactCount !== current.teacherArtifactCount ||
+        lastInterruptionSummary !== current.lastInterruptionSummary;
     if (!usedBridge) {
         return current;
     }
@@ -584,6 +669,7 @@ export function mergeTracedLearningBridgePayload(payload, persisted) {
         supervisionCount,
         routerUpdateCount,
         teacherArtifactCount,
+        lastInterruptionSummary,
         routerNoOpReason: supervisionCount > 0 || routerUpdateCount > 0 ? null : current.routerNoOpReason,
         source: {
             ...(current.source ?? {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclawbrain/cli",
-  "version": "0.4.16",
+  "version": "0.4.18",
   "description": "OpenClawBrain operator CLI package with install/status helpers, daemon controls, and import/export tooling.",
   "type": "module",
   "main": "./dist/src/index.js",