@ouro.bot/cli 0.1.0-alpha.357 → 0.1.0-alpha.359

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.359",
+      "changes": [
+        "Fixed session storage explosion caused by `findCommonPrefixLength` returning 0 every turn (system prompt changes invalidated the prefix). Skips system messages in prefix comparison, prunes non-projected events from the envelope, archives evicted events to NDJSON, and adds `loadFullEventHistory()` for consumers that need full history. Eliminates unbounded duplicate event accumulation that caused 512MB session files and 15s freezes."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.358",
+      "changes": [
+        "Removed `/new` slash command from CLI (kept on Teams). Made `dispatch()` channel-aware so commands only fire on their registered channels."
+      ]
+    },
     {
       "version": "0.1.0-alpha.357",
       "changes": [

package/dist/heart/outlook/readers/sessions.js

@@ -213,7 +213,8 @@ function readSessionTranscript(agentName, friendId, channel, key, options = {})
     const envelope = (0, shared_1.readSessionEnvelope)(sessionPath);
     if (!envelope)
         return null;
-    const rawMessages = envelope.events;
+    // Use full event history (envelope + archive) for complete transcript
+    const rawMessages = (0, session_events_1.loadFullEventHistory)(sessionPath);
     const friendsDir = path.join(agentRoot, "friends");
     const friendName = (0, shared_1.resolveFriendName)(friendsDir, friendId);
     const messages = rawMessages;

package/dist/heart/session-events.js

@@ -51,6 +51,8 @@ exports.migrateLegacySessionEnvelope = migrateLegacySessionEnvelope;
 exports.parseSessionEnvelope = parseSessionEnvelope;
 exports.loadSessionEnvelopeFile = loadSessionEnvelopeFile;
 exports.buildCanonicalSessionEnvelope = buildCanonicalSessionEnvelope;
+exports.loadFullEventHistory = loadFullEventHistory;
+exports.appendEvictedToArchive = appendEvictedToArchive;
 exports.appendSyntheticAssistantEvent = appendSyntheticAssistantEvent;
 const fs = __importStar(require("fs"));
 const runtime_1 = require("../nerves/runtime");
@@ -652,10 +654,24 @@ function loadSessionEnvelopeFile(filePath) {
         return null;
     }
 }
+function messageRole(msg) {
+    return normalizeRole(msg.role);
+}
+function filterNonSystem(messages) {
+    return messages.filter((msg) => messageRole(msg) !== "system");
+}
+/**
+ * Compare two message arrays by their non-system messages only.
+ * Returns the number of matching non-system messages from the start.
+ * System messages (whose content changes every turn due to live world-state)
+ * are excluded so that prefix matching is not defeated by system prompt updates.
+ */
 function findCommonPrefixLength(a, b) {
-    const max = Math.min(a.length, b.length);
+    const aNonSys = filterNonSystem(a);
+    const bNonSys = filterNonSystem(b);
+    const max = Math.min(aNonSys.length, bNonSys.length);
     for (let i = 0; i < max; i++) {
-        if (messageFingerprint(a[i]) !== messageFingerprint(b[i]))
+        if (messageFingerprint(aNonSys[i]) !== messageFingerprint(bNonSys[i]))
             return i;
     }
     return max;
@@ -684,33 +700,145 @@ function buildCanonicalSessionEnvelope(options) {
     const previousProjectionIds = existing?.projection.eventIds.length
         ? [...existing.projection.eventIds]
         : existing?.events.map((event) => event.id) ?? [];
-    const commonPrefix = findCommonPrefixLength(previousMessages, currentMessages);
-    const appendFrom = previousMessages.length === commonPrefix ? previousMessages.length : commonPrefix;
-    const newMessages = currentMessages.slice(appendFrom);
-    const newIngressTimes = currentIngressTimes.slice(appendFrom);
-    const baseSequence = existing?.events.length ?? 0;
-    const newEvents = newMessages.map((message, index) => buildEventFromMessage(message, baseSequence + index + 1, options.recordedAt, "live", null, null, newIngressTimes[index]));
-    const events = [...(existing?.events ?? []), ...newEvents];
-    const currentEventIds = [
-        ...previousProjectionIds.slice(0, appendFrom),
-        ...newEvents.map((event) => event.id),
-    ];
+    // Compare only non-system messages to find the common prefix.
+    // System messages change every turn (live world-state in system prompt)
+    // and must not defeat prefix matching of the actual conversation.
+    const nonSystemPrefix = findCommonPrefixLength(previousMessages, currentMessages);
+    // Build a lookup of non-system previous projection IDs.
+    const prevNonSystemIds = [];
+    for (let i = 0; i < previousMessages.length; i++) {
+        if (messageRole(previousMessages[i]) !== "system") {
+            prevNonSystemIds.push(previousProjectionIds[i]);
+        }
+    }
+    // Walk currentMessages and build currentEventIds + new events.
+    // Non-system messages within the prefix reuse old event IDs.
+    // System messages and post-prefix messages get new events.
+    const events = [...(existing?.events ?? [])];
+    const currentEventIds = [];
+    let nonSystemSeen = 0;
+    for (let i = 0; i < currentMessages.length; i++) {
+        const role = messageRole(currentMessages[i]);
+        const isSystem = role === "system";
+        const inPrefix = !isSystem && nonSystemSeen < nonSystemPrefix;
+        if (inPrefix) {
+            // Reuse existing event ID for this matched non-system message
+            currentEventIds.push(prevNonSystemIds[nonSystemSeen]);
+            nonSystemSeen++;
+        }
+        else if (isSystem && i < previousMessages.length
+            && messageRole(previousMessages[i]) === "system"
+            && messageFingerprint(currentMessages[i]) === messageFingerprint(previousMessages[i])) {
+            // System message at same position with identical content -- reuse event ID
+            currentEventIds.push(previousProjectionIds[i]);
+        }
+        else {
+            if (!isSystem)
+                nonSystemSeen++;
+            // Create a new event
+            const event = buildEventFromMessage(currentMessages[i], events.length + 1, options.recordedAt, "live", null, null, currentIngressTimes[i]);
+            events.push(event);
+            currentEventIds.push(event.id);
+        }
+    }
     const projectionEventIds = selectProjectedEventIds(currentMessages, currentEventIds, trimmedMessages);
+    // Prune events: only keep events whose IDs are in the projection.
+    // Events not in projection are returned as evicted for archiving.
+    const projectionIdSet = new Set(projectionEventIds);
+    const prunedEvents = events.filter((event) => projectionIdSet.has(event.id));
+    const evictedEvents = events.filter((event) => !projectionIdSet.has(event.id));
     return {
-        version: 2,
-        events,
-        projection: {
-            eventIds: projectionEventIds,
-            trimmed: projectionEventIds.length < currentEventIds.length,
-            maxTokens: options.projectionBasis.maxTokens,
-            contextMargin: options.projectionBasis.contextMargin,
-            inputTokens: options.projectionBasis.inputTokens,
-            projectedAt: options.recordedAt,
+        envelope: {
+            version: 2,
+            events: prunedEvents,
+            projection: {
+                eventIds: projectionEventIds,
+                trimmed: projectionEventIds.length < currentEventIds.length,
+                maxTokens: options.projectionBasis.maxTokens,
+                contextMargin: options.projectionBasis.contextMargin,
+                inputTokens: options.projectionBasis.inputTokens,
+                projectedAt: options.recordedAt,
+            },
+            lastUsage: normalizeUsage(options.lastUsage),
+            state: normalizeContinuityState(options.state),
         },
-        lastUsage: normalizeUsage(options.lastUsage),
-        state: normalizeContinuityState(options.state),
+        evictedEvents,
     };
 }
+/**
+ * Load full event history from both the pruned envelope and the NDJSON archive.
+ * Returns all events deduplicated by id and sorted by sequence.
+ * Corrupted archive lines are silently skipped.
+ */
+function loadFullEventHistory(sessPath) {
+    const envelope = loadSessionEnvelopeFile(sessPath);
+    if (!envelope)
+        return [];
+    const envelopeEvents = envelope.events;
+    const archivePath = sessPath.replace(/\.json$/, ".archive.ndjson");
+    let archiveEvents = [];
+    try {
+        const raw = fs.readFileSync(archivePath, "utf-8");
+        const lines = raw.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0)
+                continue;
+            try {
+                const event = JSON.parse(trimmed);
+                if (event && typeof event.id === "string" && typeof event.sequence === "number") {
+                    archiveEvents.push(event);
+                }
+            }
+            catch {
+                // Skip corrupted lines
+            }
+        }
+    }
+    catch {
+        // Archive file doesn't exist or can't be read -- that's fine
+    }
+    // Merge, deduplicate by id, sort by sequence
+    const seen = new Set();
+    const merged = [];
+    for (const event of [...archiveEvents, ...envelopeEvents]) {
+        if (seen.has(event.id))
+            continue;
+        seen.add(event.id);
+        merged.push(event);
+    }
+    merged.sort((a, b) => a.sequence - b.sequence);
+    return merged;
+}
+/**
+ * Append evicted events to an NDJSON archive file.
+ * The archive path is derived from the session path by replacing .json with .archive.ndjson.
+ * Each event is written as a single JSON line. The file is appended to, not overwritten.
+ * Failures are logged and swallowed -- archive write must never crash the persist path.
+ */
+function appendEvictedToArchive(sessPath, evictedEvents) {
+    if (evictedEvents.length === 0)
+        return;
+    const archivePath = sessPath.replace(/\.json$/, ".archive.ndjson");
+    try {
+        const ndjson = evictedEvents.map((event) => JSON.stringify(event)).join("\n") + "\n";
+        fs.appendFileSync(archivePath, ndjson);
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "heart",
+            event: "heart.archive_write_error",
+            message: "failed to write evicted events to archive",
+            meta: {
+                archivePath,
+                eventCount: evictedEvents.length,
+                /* v8 ignore next -- defensive: Node fs always throws Error instances @preserve */
+                error: err instanceof Error ? err.message : String(err),
+            },
+        });
+    }
+}
 function appendSyntheticAssistantEvent(envelope, content, recordedAt) {
     const sequence = envelope.events.length + 1;
     const event = buildEventFromMessage({ role: "assistant", content }, sequence, recordedAt, "synthetic", null, null);

package/dist/heart/session-transcript.js

@@ -137,10 +137,15 @@ async function searchSessionTranscript(options) {
             maxMatches: options.maxMatches ?? 5,
         },
     });
-    const envelope = (0, session_events_1.loadSessionEnvelopeFile)(options.sessionPath);
-    if (!envelope)
-        return { kind: "missing" };
-    const messages = normalizeSessionMessages(envelope.events);
+    // Use full event history (envelope + archive) for search to find older messages
+    const allEvents = (0, session_events_1.loadFullEventHistory)(options.sessionPath);
+    if (allEvents.length === 0) {
+        const envelope = (0, session_events_1.loadSessionEnvelopeFile)(options.sessionPath);
+        if (!envelope)
+            return { kind: "missing" };
+        return { kind: "empty" };
+    }
+    const messages = normalizeSessionMessages(allEvents);
     if (messages.length === 0) {
         return { kind: "empty" };
     }

package/dist/mind/context.js

@@ -198,7 +198,7 @@ function saveSession(filePath, messages, lastUsage, state) {
     const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
     const currentIngressTimes = messages.map(session_events_1.getIngressTime);
     const sanitized = (0, session_events_1.sanitizeProviderMessages)(messages);
-    const envelope = (0, session_events_1.buildCanonicalSessionEnvelope)({
+    const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
         existing,
         previousMessages,
         currentMessages: sanitized,
@@ -295,7 +295,7 @@ function postTurnTrim(messages, usage, hooks) {
 function postTurnPersist(sessPath, prepared, usage, state) {
     const existing = (0, session_events_1.loadSessionEnvelopeFile)(sessPath);
     const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
-    const envelope = (0, session_events_1.buildCanonicalSessionEnvelope)({
+    const { envelope, evictedEvents } = (0, session_events_1.buildCanonicalSessionEnvelope)({
         existing,
         previousMessages,
         currentMessages: prepared.currentMessages,
@@ -310,6 +310,7 @@ function postTurnPersist(sessPath, prepared, usage, state) {
             inputTokens: usage?.input_tokens ?? null,
         },
     });
+    (0, session_events_1.appendEvictedToArchive)(sessPath, evictedEvents);
     writeSessionEnvelope(sessPath, envelope);
     return envelope.events;
 }

package/dist/senses/cli.js

@@ -799,14 +799,6 @@ async function runCliSession(options) {
                         if (dispatchResult.result.action === "exit") {
                             break;
                         }
-                        else if (dispatchResult.result.action === "new") {
-                            messages.length = 0;
-                            messages.push({ role: "system", content: await (0, prompt_1.buildSystem)("cli") });
-                            await options.onNewSession?.();
-                            // eslint-disable-next-line no-console -- terminal UX: session cleared
-                            console.log("session cleared");
-                            continue;
-                        }
                         else if (dispatchResult.result.action === "response") {
                             display.text(dispatchResult.result.message || "");
                             continue;
@@ -839,14 +831,6 @@ async function runCliSession(options) {
                         if (result.commandAction === "exit") {
                             break;
                         }
-                        else if (result.commandAction === "new") {
-                            messages.length = 0;
-                            messages.push({ role: "system", content: await (0, prompt_1.buildSystem)("cli") });
-                            await options.onNewSession?.();
-                            // eslint-disable-next-line no-console -- terminal UX: session cleared
-                            console.log("session cleared");
-                            continue;
-                        }
                         // For "response" commands: the pipeline already emitted the response via onTextChunk
                         cliCallbacks.flushMarkdown();
                         continue;
@@ -1109,9 +1093,6 @@ async function main(agentName, options) {
                 }
                 return { usage: result.usage, turnOutcome: result.turnOutcome, commandAction: result.commandAction };
             },
-            onNewSession: () => {
-                (0, context_1.deleteSession)(sessPath);
-            },
         });
     }
     finally {

package/dist/senses/commands.js

@@ -25,7 +25,7 @@ function createCommandRegistry() {
         },
         dispatch(name, ctx) {
             const cmd = commands.get(name);
-            if (!cmd)
+            if (!cmd || !cmd.channels.includes(ctx.channel))
                 return { handled: false };
             return { handled: true, result: cmd.handler(ctx) };
         },
@@ -63,7 +63,7 @@ function registerDefaultCommands(registry) {
     registry.register({
         name: "new",
         description: "start a new conversation",
-        channels: ["cli", "teams"],
+        channels: ["teams"],
         handler: () => ({ action: "new" }),
     });
     registry.register({
@@ -97,7 +97,6 @@ function registerDefaultCommands(registry) {
                 "Commands:",
                 "  /help         this help",
                 "  /commands     list all commands",
-                "  /new          start a new conversation",
                 "  /exit         quit",
             ].join("\n"),
         }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.357",
+  "version": "0.1.0-alpha.359",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",