@openclawbrain/cli 0.4.21 → 0.4.23

package/dist/src/cli.js

@@ -33,6 +33,11 @@ const OPENCLAWBRAIN_EMBEDDER_MODEL_ENV = "OPENCLAWBRAIN_EMBEDDER_MODEL";
 const OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV = "OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION";
 const LEGACY_COMPAT_PACKAGE_NAME = "@jonathangu/openclawbrain";
 const INSTALL_COMPATIBLE_LOCAL_TEACHER_MODEL_PREFIXES = [
+    "unsloth-qwen3.5-27b:q4_k_m",
+    "unsloth-qwen3.5-27b",
+    "qwen3.5:32b",
+    "qwen3.5:27b",
+    "qwen3.5:14b",
     "qwen3.5:9b",
     "qwen3.5:8b",
     "qwen3:8b",
@@ -813,10 +818,14 @@ function summarizeStatusHookFilesState(installHook) {
     return "unverified";
 }
 function summarizeStatusAttachmentWatcher(status) {
-    if (status.passiveLearning.watchState === "watching") {
+    const watchState = status.passiveLearning.watch?.state ?? status.passiveLearning.watchState;
+    if (watchState === "watching") {
         return "alive";
     }
-    if (status.passiveLearning.watchState === "stale_snapshot") {
+    if (watchState === "lagging") {
+        return "lagging";
+    }
+    if (watchState === "stale_snapshot") {
         return "stale";
     }
     return "not_visible";
@@ -1145,13 +1154,14 @@ function summarizeStatusTeacher(report, providerConfig, localLlm) {
             detail: `${providerConfig.teacher.model} is enabled on Ollama, but no watch teacher snapshot is visible yet`
         };
     }
-    const stale = report.teacherLoop.watchState === "stale_snapshot" || (report.teacherLoop.latestFreshness === "stale" && report.teacherLoop.lastNoOpReason !== "no_teacher_artifacts");
+    const watchState = report.teacherLoop.watch?.state ?? report.teacherLoop.watchState ?? "not_visible";
+    const stale = watchState === "stale_snapshot" || (report.teacherLoop.latestFreshness === "stale" && report.teacherLoop.lastNoOpReason !== "no_teacher_artifacts");
     const idle = report.teacherLoop.running === false &&
         (report.teacherLoop.queueDepth ?? 0) === 0 &&
         report.teacherLoop.failureMode === "none";
     const healthy = report.teacherLoop.failureMode === "none" &&
         stale === false &&
-        report.teacherLoop.watchState !== "not_visible";
+        watchState === "watching";
     const cycleDetail = report.teacherLoop.lastNoOpReason === "no_teacher_artifacts"
         ? summarizeTeacherNoArtifactCycle(report.teacherLoop.notes).detail
         : TEACHER_NO_OP_MESSAGES[report.teacherLoop.lastNoOpReason] ?? "the latest teacher cycle detail is unavailable";
@@ -1175,7 +1185,9 @@ function summarizeStatusTeacher(report, providerConfig, localLlm) {
         stale,
         idle,
         latestCycle,
-        detail: `${providerConfig.teacher.model} is enabled on Ollama; ${cycleDetail}`
+        detail: watchState === "lagging"
+            ? `${providerConfig.teacher.model} is enabled on Ollama, but the watch heartbeat is lagging; ${cycleDetail}`
+            : `${providerConfig.teacher.model} is enabled on Ollama; ${cycleDetail}`
     };
 }
 function summarizeStatusEmbedder(embeddings) {
@@ -1329,7 +1341,7 @@ function summarizeStatusAlerts(report, providerConfig, embeddings, localLlm) {
     return buckets;
 }
 function summarizeStatusWatchState(status) {
-    return status.passiveLearning.watchState;
+    return status.passiveLearning.watch?.state ?? status.passiveLearning.watchState;
 }
 function summarizeStatusServeReality(status) {
     if (status.brainStatus.serveState === "serving_active_pack") {
@@ -1478,7 +1490,7 @@ function formatCurrentProfileStatusSummary(status, report, targetInspection, opt
         `budget      requested=${report.servePath.requestedBudgetStrategy ?? "none"} resolved=${report.servePath.resolvedBudgetStrategy ?? "none"} maxBlocks=${report.servePath.resolvedMaxContextBlocks ?? "none"} source=${report.servePath.structuralBudgetSource ?? "none"} origin=${status.brainStatus.structuralDecision.origin} basis=${status.brainStatus.structuralDecision.basis}`,
         `decision    ${status.brainStatus.structuralDecision.detail}`,
         `principal   latest=${formatPrincipalLatest(report)} pending=${report.principal.pendingCount ?? report.learning.pendingPrincipalCount ?? "none"} checkpoint=${formatPrincipalCheckpointFrontier(report)} downstream=${yesNo(report.principal.servingDownstreamOfLatestCorrection)} lag=${report.learning.principalLagToPromotion.sequenceLag ?? "none"}`,
-        `passive     learner=${yesNo(status.passiveLearning.learnerRunning)} firstExport=${yesNo(status.passiveLearning.firstExportOccurred)} watch=${status.passiveLearning.watchState} export=${status.passiveLearning.exportState} backlog=${status.passiveLearning.backlogState} pending=${formatStatusNullableNumber(status.passiveLearning.pendingLive)}/${formatStatusNullableNumber(status.passiveLearning.pendingBackfill)} detail=${status.passiveLearning.detail}`,
+        `passive     learner=${yesNo(status.passiveLearning.learnerRunning)} firstExport=${yesNo(status.passiveLearning.firstExportOccurred)} watch=${summarizeStatusWatchState(status)} export=${status.passiveLearning.exportState} backlog=${status.passiveLearning.backlogState} pending=${formatStatusNullableNumber(status.passiveLearning.pendingLive)}/${formatStatusNullableNumber(status.passiveLearning.pendingBackfill)} detail=${status.passiveLearning.detail}`,
         `delta       observed=${status.passiveLearning.lastObservedDelta.observedAt ?? "none"} exported=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.exported)} labeled=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.labeled)} promoted=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.promoted)} served=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.served)} transition=${formatStatusObservedDeltaTransition(status.passiveLearning.lastObservedDelta)} detail=${status.passiveLearning.lastObservedDelta.explanation}`,
         `scanner     flowing=${yesNo(report.supervision.flowing)} scan=${report.supervision.scanPolicy ?? "none"} surfaces=${formatScannerSurfaces(report)} labels=${report.supervision.humanLabelCount ?? "none"}/${report.supervision.selfLabelCount ?? "none"} attributable=${report.supervision.attributedEventCount ?? "none"}/${report.supervision.totalEventCount ?? "none"} digests=${report.supervision.selectionDigestCount ?? "none"}`,
         `labels      ${formatLabelFlowSummary(report.labelFlow)}`,
@@ -5111,7 +5123,13 @@ function listWatchRuntimeEventExportBundleRoots(scanRoot) {
         .map((entry) => path.join(scanRoot, entry.name))
         .sort((left, right) => left.localeCompare(right));
 }
-async function replayWatchScanRootIntoTeacherLoop(teacherLoop, scanRoot) {
+async function replayWatchScanRootIntoTeacherLoop(teacherLoop, scanRoot, options = {}) {
+    if (options.skip === true) {
+        return {
+            replayedBundleCount: 0,
+            replayedEventCount: 0
+        };
+    }
     const seenExportDigests = new Set();
     const bundles = listWatchRuntimeEventExportBundleRoots(scanRoot)
         .map((rootDir) => {
@@ -5733,6 +5751,7 @@ export async function createWatchCommandRuntime(input) {
         const restoredSeenExportCount = restoredTeacherState.snapshot.state?.seenExportDigests.length ?? 0;
         log(`Restored teacher snapshot: seen=${restoredSeenExportCount} artifacts=${restoredTeacherState.snapshot.teacher.artifactCount}`);
     }
+    const restoredSeenExportCount = restoredTeacherState.snapshot?.state?.seenExportDigests.length ?? 0;
     const resolvedWatchProfileScope = input.profileRoots === undefined
         ? resolveWatchProfileRootsForActivationRoot(activationRoot)
         : {
@@ -5774,7 +5793,13 @@ export async function createWatchCommandRuntime(input) {
         replayedEventCount: 0
     };
     try {
-        replayState = await replayWatchScanRootIntoTeacherLoop(teacherLoop, scanRoot);
+        const skipStoredReplay = restoredSeenExportCount > 0 && startupWarnings.length === 0;
+        if (skipStoredReplay) {
+            log(`Stored replay skipped: restored teacher snapshot already tracks ${restoredSeenExportCount} export digest${restoredSeenExportCount === 1 ? "" : "s"}.`);
+        }
+        replayState = await replayWatchScanRootIntoTeacherLoop(teacherLoop, scanRoot, {
+            skip: skipStoredReplay
+        });
     }
     catch (error) {
         const message = formatWatchError(error);

package/dist/src/index.d.ts

@@ -6,6 +6,16 @@ import { type ActivationInspection, type ActivationObservabilityReport, type Gra
 export { clearOpenClawProfileRuntimeLoadProof, listOpenClawProfileRuntimeLoadProofs, recordOpenClawProfileRuntimeLoadProof, resolveAttachmentRuntimeLoadProofsPath, type OpenClawProfileRuntimeLoadProofRecordV1, type OpenClawProfileRuntimeLoadProofSetV1, type OpenClawProfileRuntimeLoadProofsV1 } from "./attachment-truth.js";
 import { type AsyncTeacherLabelerConfigV1 } from "./teacher-labeler.js";
 export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler, summarizeTeacherLabelerOpportunity, type AsyncTeacherLabelerConfigV1, type AsyncTeacherNoopLabelerConfigV1, type AsyncTeacherOllamaLabelerConfigV1, type OllamaTeacherLabelerClient, type TeacherLabeler, type TeacherLabelerOpportunityInputV1, type TeacherLabelerOpportunityV1, type TeacherLabelerResultV1, type TeacherLabelerRunInputV1 } from "./teacher-labeler.js";
+export type OperatorPassiveLearningWatchState = CurrentProfilePassiveLearningWatchStateV1 | "lagging";
+export interface OperatorPassiveLearningWatchSummary {
+    state: OperatorPassiveLearningWatchState;
+    detail: string;
+    lastHeartbeatAt: string | null;
+    lagSeconds: number | null;
+    intervalSeconds: number | null;
+    healthyWithinSeconds: number | null;
+    staleAfterSeconds: number | null;
+}
 export declare const DEFAULT_ASYNC_TEACHER_QUEUE_CAPACITY = 8;
 declare const RECORDED_SESSION_TRACE_CONTRACT: "recorded_session_trace.v1";
 declare const RECORDED_SESSION_FIXTURE_CONTRACT: "recorded_session_replay_fixture.v1";
@@ -1687,7 +1697,8 @@ export interface OperatorTeacherLoopSummary {
     lastHeartbeatAt: string | null;
     lastScanAt: string | null;
     pollIntervalSeconds: number | null;
-    watchState: CurrentProfilePassiveLearningWatchStateV1;
+    watchState: OperatorPassiveLearningWatchState;
+    watch: OperatorPassiveLearningWatchSummary;
     lastProcessedAt: string | null;
     artifactCount: number | null;
     queueDepth: number | null;

package/dist/src/index.js

@@ -6646,11 +6646,18 @@ function loadTeacherSurfaceFromInput(input) {
 }
 function summarizeTeacherLoopWatchState(input) {
     if (input.sourceKind !== "watch_snapshot" || input.watchSnapshot === null) {
+        const watchState = input.sourceKind === "async_snapshot" ? "snapshot_only" : "not_visible";
         return {
             snapshotUpdatedAt: null,
             lastWatchHeartbeatAt: null,
             pollIntervalSeconds: null,
-            watchState: input.sourceKind === "async_snapshot" ? "snapshot_only" : "not_visible"
+            watchState,
+            watch: buildTeacherLoopWatchSummary({
+                state: watchState,
+                detail: watchState === "snapshot_only"
+                    ? "only a saved watcher snapshot is visible; no live heartbeat is available"
+                    : "no watcher snapshot is visible from the current activation root"
+            })
         };
     }
     const lastWatchHeartbeatAt = input.watchSnapshot.snapshot.runtime?.lastHeartbeatAt ?? input.watchSnapshot.lastRunAt;
@@ -6660,16 +6667,55 @@ function summarizeTeacherLoopWatchState(input) {
             snapshotUpdatedAt: input.watchSnapshot.updatedAt,
             lastWatchHeartbeatAt: null,
             pollIntervalSeconds,
-            watchState: "snapshot_only"
+            watchState: "snapshot_only",
+            watch: buildTeacherLoopWatchSummary({
+                state: "snapshot_only",
+                detail: "only a saved watcher snapshot is visible; no live heartbeat is available",
+                intervalSeconds: pollIntervalSeconds
+            })
         };
     }
-    const lagMs = Date.parse(input.observedAt) - Date.parse(lastWatchHeartbeatAt);
-    const staleAfterMs = pollIntervalSeconds * 2000 + 15_000;
+    const rawLagMs = Date.parse(input.observedAt) - Date.parse(lastWatchHeartbeatAt);
+    const lagMs = Number.isFinite(rawLagMs) ? Math.max(0, rawLagMs) : null;
+    const healthyWithinMs = pollIntervalSeconds * 2000 + 15_000;
+    const staleAfterMs = healthyWithinMs + Math.max(15_000, pollIntervalSeconds * 1000);
+    const watchState = lagMs !== null && lagMs <= healthyWithinMs
+        ? "watching"
+        : lagMs !== null && lagMs <= staleAfterMs
+            ? "lagging"
+            : "stale_snapshot";
     return {
         snapshotUpdatedAt: input.watchSnapshot.updatedAt,
         lastWatchHeartbeatAt,
         pollIntervalSeconds,
-            watchState: Number.isFinite(lagMs) && lagMs >= 0 && lagMs <= staleAfterMs ? "watching" : "stale_snapshot"
+        watchState,
+        watch: buildTeacherLoopWatchSummary({
+            state: watchState,
+            detail: watchState === "watching"
+                ? "watch heartbeat is inside the healthy window"
+                : watchState === "lagging"
+                    ? "watch heartbeat missed the healthy window but has not crossed the stale snapshot threshold"
+                    : "watch heartbeat is older than the stale snapshot threshold",
+            lastHeartbeatAt: lastWatchHeartbeatAt,
+            lagMs,
+            intervalSeconds: pollIntervalSeconds,
+            healthyWithinMs,
+            staleAfterMs
+        })
+    };
+}
+function buildTeacherLoopWatchSummary(input) {
+    const lagSeconds = Number.isFinite(input.lagMs) ? Math.round((input.lagMs / 1000) * 100) / 100 : null;
+    const healthyWithinSeconds = Number.isFinite(input.healthyWithinMs) ? Math.round((input.healthyWithinMs / 1000) * 100) / 100 : null;
+    const staleAfterSeconds = Number.isFinite(input.staleAfterMs) ? Math.round((input.staleAfterMs / 1000) * 100) / 100 : null;
+    return {
+        state: input.state,
+        detail: input.detail,
+        lastHeartbeatAt: input.lastHeartbeatAt ?? null,
+        lagSeconds,
+        intervalSeconds: input.intervalSeconds ?? null,
+        healthyWithinSeconds,
+        staleAfterSeconds
     };
 }
 function emptyOperatorLearningAttribution(source, snapshotKind, detail) {
@@ -6798,6 +6844,10 @@ function summarizeTeacherLoop(input) {
     const teacherSnapshotPath = resolveOperatorTeacherSnapshotPath(input.activationRoot, normalizeOptionalString(input.teacherSnapshotPath) ?? null);
     const unavailableFromMissing = buildUnavailableLastObservedDelta("no watch teacher snapshot is visible for the latest observed cycle");
     const unavailableFromAsync = buildUnavailableLastObservedDelta("raw async teacher snapshots do not record the last observed export/label/promotion delta");
+    const notVisibleWatch = buildTeacherLoopWatchSummary({
+        state: "not_visible",
+        detail: "no watcher snapshot is visible from the current activation root"
+    });
     if (loaded === null && teacherSnapshotPath === null) {
         return {
             available: false,
@@ -6812,6 +6862,7 @@ function summarizeTeacherLoop(input) {
             lastScanAt: null,
             pollIntervalSeconds: null,
             watchState: "not_visible",
+            watch: notVisibleWatch,
             lastProcessedAt: null,
             artifactCount: null,
             queueDepth: null,
@@ -6852,6 +6903,7 @@ function summarizeTeacherLoop(input) {
             lastScanAt: null,
             pollIntervalSeconds: null,
             watchState: "not_visible",
+            watch: notVisibleWatch,
             lastProcessedAt: null,
             artifactCount: null,
             queueDepth: null,
@@ -6898,6 +6950,7 @@ function summarizeTeacherLoop(input) {
         lastScanAt: snapshot.runtime?.lastScanAt ?? null,
         pollIntervalSeconds: watchState.pollIntervalSeconds,
         watchState: watchState.watchState,
+        watch: watchState.watch,
         lastProcessedAt: snapshot.diagnostics.lastProcessedAt,
         artifactCount: watchSnapshot?.teacher.artifactCount ?? snapshot.teacher.artifactCount,
         queueDepth: snapshot.queue.depth,
@@ -7486,6 +7539,13 @@ function didCurrentProfileFirstExportOccur(report) {
 }
 function summarizeCurrentProfilePassiveLearning(report, activePackId) {
     const firstExportOccurred = didCurrentProfileFirstExportOccur(report);
+    const watch = report.teacherLoop.watch ?? buildTeacherLoopWatchSummary({
+        state: report.teacherLoop.watchState,
+        detail: "watch state came from the legacy passive-learning surface",
+        lastHeartbeatAt: report.teacherLoop.lastHeartbeatAt,
+        intervalSeconds: report.teacherLoop.pollIntervalSeconds
+    });
+    const watchState = watch.state ?? report.teacherLoop.watchState;
     const exportState = !firstExportOccurred
         ? "awaiting_first_export"
         : report.supervision.exportedAt !== null
@@ -7495,28 +7555,33 @@ function summarizeCurrentProfilePassiveLearning(report, activePackId) {
         ? report.learning.backlogState
         : "unknown";
     const detail = !firstExportOccurred
-        ? report.teacherLoop.watchState === "watching"
+        ? watchState === "watching"
             ? "watch heartbeat is fresh, but this activation root has not observed its first export yet"
+            : watchState === "lagging"
+                ? "watch heartbeat is lagging, and this activation root is still waiting for the first export before passive learning can advance"
             : "this activation root is still waiting for the first export before passive learning can advance"
         : backlogState === "unknown"
             ? "first export is proven, but passive backlog state is not visible from the current local artifacts"
-            : report.teacherLoop.watchState === "watching"
+            : watchState === "watching"
                 ? `watch heartbeat is fresh; passive backlog is ${backlogState} with live=${report.learning.pendingLive ?? 0} and backfill=${report.learning.pendingBackfill ?? 0}`
-                : report.teacherLoop.watchState === "stale_snapshot"
+                : watchState === "lagging"
+                    ? `watch heartbeat is lagging; latest known passive backlog is ${backlogState} with live=${report.learning.pendingLive ?? 0} and backfill=${report.learning.pendingBackfill ?? 0}`
+                    : watchState === "stale_snapshot"
                     ? `last saved watch snapshot is stale; latest known passive backlog is ${backlogState}`
-                    : report.teacherLoop.watchState === "snapshot_only"
+                    : watchState === "snapshot_only"
                         ? `passive backlog is visible from the last saved snapshot: ${backlogState}`
                         : `passive backlog is visible from the last known learner state: ${backlogState}`;
     return {
-        learnerRunning: report.teacherLoop.watchState === "watching",
+        learnerRunning: watchState === "watching",
         firstExportOccurred,
-        watchState: report.teacherLoop.watchState,
+        watchState,
+        watch,
         exportState,
         backlogState,
         pendingLive: report.learning.available ? report.learning.pendingLive : null,
         pendingBackfill: report.learning.available ? report.learning.pendingBackfill : null,
-        lastWatchHeartbeatAt: report.teacherLoop.lastHeartbeatAt,
-        watchIntervalSeconds: report.teacherLoop.pollIntervalSeconds,
+        lastWatchHeartbeatAt: watch.lastHeartbeatAt ?? report.teacherLoop.lastHeartbeatAt,
+        watchIntervalSeconds: watch.intervalSeconds ?? report.teacherLoop.pollIntervalSeconds,
         lastExportAt: report.supervision.exportedAt,
         lastPromotionAt: report.promotion.lastPromotion.at,
         currentServingPackId: activePackId,

package/dist/src/local-learner.js

@@ -928,13 +928,15 @@ export function advanceAlwaysOnLearningRuntime(input) {
     const schedule = selectScheduledSlices(pending, current.learnedEventExport, cadence);
     const selectedSlices = schedule.selected;
     const learnedEventExport = mergeNormalizedEventExports(current.learnedEventExport, selectedSlices);
-    const runtimeGraphSnapshot = buildRuntimeGraphSnapshot({
-        ...input,
-        state: {
-            ...current,
-            structuralController
-        }
-    });
+    const runtimeGraphSnapshot = selectedSlices.length === 0
+        ? null
+        : buildRuntimeGraphSnapshot({
+            ...input,
+            state: {
+                ...current,
+                structuralController
+            }
+        });
     const runtimeGraph = runtimeGraphSnapshot?.graph ?? current.runtimeGraph;
     const runtimePlasticity = runtimeGraphSnapshot?.plasticity ?? current.runtimePlasticity;
     const sparseFeedbackObservedAt = input.builtAt ?? learnedEventExport?.range.lastCreatedAt ?? learnedEventExport?.range.firstCreatedAt ?? current.lastMaterializedAt ?? "1970-01-01T00:00:00.000Z";

package/dist/src/session-store.js

@@ -171,6 +171,35 @@ function parseOpenClawSessionRecord(value, lineNumber) {
                 timestamp: expectString(record.timestamp, `${lineNumber}.timestamp`)
             };
         }
+        case "compaction": {
+            const data = {};
+            if (record.summary !== undefined) {
+                data.summary = expectString(record.summary, `${lineNumber}.summary`);
+            }
+            if (record.firstKeptEntryId !== undefined) {
+                data.firstKeptEntryId = expectString(record.firstKeptEntryId, `${lineNumber}.firstKeptEntryId`);
+            }
+            if (record.tokensBefore !== undefined) {
+                data.tokensBefore = expectNumber(record.tokensBefore, `${lineNumber}.tokensBefore`);
+            }
+            if (record.details !== undefined) {
+                data.details = expectRecord(record.details, `${lineNumber}.details`);
+            }
+            if (record.fromHook !== undefined) {
+                if (typeof record.fromHook !== "boolean") {
+                    throw new Error(`${lineNumber}.fromHook must be a boolean`);
+                }
+                data.fromHook = record.fromHook;
+            }
+            return {
+                type: "custom",
+                customType: "openclaw.compaction",
+                data,
+                id: expectString(record.id, `${lineNumber}.id`),
+                parentId: expectNullableString(record.parentId, `${lineNumber}.parentId`),
+                timestamp: expectString(record.timestamp, `${lineNumber}.timestamp`)
+            };
+        }
         case "message":
             return {
                 type,
@@ -185,7 +214,9 @@ function parseOpenClawSessionRecord(value, lineNumber) {
 }
 function parseMessagePayload(value, path) {
     const payload = expectRecord(value, path);
-    const content = expectArray(payload.content, `${path}.content`).map((entry, index) => parseContentPart(entry, `${path}.content[${index}]`));
+    const content = typeof payload.content === "string"
+        ? [{ type: "text", text: payload.content }]
+        : expectArray(payload.content, `${path}.content`).map((entry, index) => parseContentPart(entry, `${path}.content[${index}]`));
     return {
         ...payload,
         role: expectString(payload.role, `${path}.role`),
@@ -267,4 +298,4 @@ function expectNumber(value, path) {
     }
     return value;
 }
-//# sourceMappingURL=session-store.js.map
+//# sourceMappingURL=session-store.js.map

package/dist/src/session-tail.js

@@ -383,6 +383,7 @@ export class OpenClawLocalSessionTail {
         const firstPoll = this.initialized === false;
         const warnings = [];
         const changes = [];
+        const observedKeys = new Set();
         const sources = discoverOpenClawSessionStores({
             ...(this.homeDir === undefined ? {} : { homeDir: this.homeDir }),
             ...(this.profileRoots === undefined ? {} : { profileRoots: this.profileRoots })
@@ -409,9 +410,21 @@ export class OpenClawLocalSessionTail {
                     continue;
                 }
                 const key = cursorKey(source.indexPath, sessionKey);
+                observedKeys.add(key);
                 const existing = this.cursorBySession.get(key) ?? null;
                 const sessionFile = typeof entry.sessionFile === "string" && entry.sessionFile.trim().length > 0 ? path.resolve(entry.sessionFile) : null;
                 if (sessionFile === null) {
+                    const nextCursor = createCursor(source.indexPath, sessionKey, entry.sessionId, null, entry.updatedAt, 0, 0);
+                    this.cursorBySession.set(key, nextCursor);
+                    const changed = existing === null ||
+                        existing.sessionId !== entry.sessionId ||
+                        existing.sessionFile !== null ||
+                        existing.updatedAt !== entry.updatedAt ||
+                        existing.rawRecordCount !== 0 ||
+                        existing.bridgedEventCount !== 0;
+                    if (!changed) {
+                        continue;
+                    }
                     changes.push(createChange({
                         source,
                         sessionKey,
@@ -425,6 +438,17 @@ export class OpenClawLocalSessionTail {
                     continue;
                 }
                 if (!existsSync(sessionFile)) {
+                    const nextCursor = createCursor(source.indexPath, sessionKey, entry.sessionId, sessionFile, entry.updatedAt, 0, 0);
+                    this.cursorBySession.set(key, nextCursor);
+                    const changed = existing === null ||
+                        existing.sessionId !== entry.sessionId ||
+                        existing.sessionFile !== sessionFile ||
+                        existing.updatedAt !== entry.updatedAt ||
+                        existing.rawRecordCount !== 0 ||
+                        existing.bridgedEventCount !== 0;
+                    if (!changed) {
+                        continue;
+                    }
                     changes.push(createChange({
                         source,
                         sessionKey,
@@ -535,6 +559,17 @@ export class OpenClawLocalSessionTail {
                 }));
             }
         }
+        let prunedCursorCount = 0;
+        for (const key of [...this.cursorBySession.keys()]) {
+            if (observedKeys.has(key)) {
+                continue;
+            }
+            this.cursorBySession.delete(key);
+            prunedCursorCount += 1;
+        }
+        if (prunedCursorCount > 0) {
+            warnings.push(`session tail pruned ${prunedCursorCount} stale cursor entr${prunedCursorCount === 1 ? "y" : "ies"}`);
+        }
         this.initialized = true;
         const noopReason = firstPoll && !changes.some((change) => change.scannedEventExport !== null)
             ? "seeded_existing_sessions"
@@ -599,4 +634,4 @@ export class OpenClawLocalSessionTail {
 export function createOpenClawLocalSessionTail(input = {}) {
     return new OpenClawLocalSessionTail(input);
 }
-//# sourceMappingURL=session-tail.js.map
+//# sourceMappingURL=session-tail.js.map

package/package.json

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