@openclawbrain/cli 0.4.17 → 0.4.19

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

@@ -284,7 +284,7 @@ function buildPersistedStatusSurfaceBridge(summary, context) {
             brainRoot: context.brainRoot,
             stateDbPath: context.dbPath,
             persistedKey: TRACED_LEARNING_STATUS_SURFACE_STATE_KEY,
-            surfacedFrom: summary.source
+            surfacedFrom: summarizeBridgeSource(summary.source)
         }
     });
 }
@@ -590,7 +590,7 @@ function buildRuntimeMaterializationMetadata(loaded) {
         lastInterruptionSummary: loaded.bridge.lastInterruptionSummary,
         fallbackReason: loaded.bridge.fallbackReason,
         routerNoOpReason: loaded.bridge.routerNoOpReason,
-        source: loaded.bridge.source
+        source: summarizeBridgeSource(loaded.bridge.source)
     };
 }
 function mergeCanonicalStatusBridge(canonicalBridge, runtimeLoaded) {

package/package.json

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