@ouro.bot/cli 0.1.0-alpha.85 → 0.1.0-alpha.851

package/dist/mind/context.js

@@ -33,18 +33,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSessionMessages = exports.repairSessionMessages = exports.migrateToolNames = exports.detectDuplicateToolCallIds = void 0;
 exports.trimMessages = trimMessages;
-exports.validateSessionMessages = validateSessionMessages;
-exports.repairSessionMessages = repairSessionMessages;
 exports.saveSession = saveSession;
+exports.appendSyntheticAssistantMessage = appendSyntheticAssistantMessage;
 exports.loadSession = loadSession;
 exports.postTurn = postTurn;
+exports.postTurnTrim = postTurnTrim;
+exports.postTurnPersist = postTurnPersist;
+exports.deferPostTurnPersist = deferPostTurnPersist;
 exports.deleteSession = deleteSession;
 const config_1 = require("../heart/config");
+const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
+const session_transaction_1 = require("./session-transaction");
 const token_estimate_1 = require("./token-estimate");
+var session_events_2 = require("../heart/session-events");
+Object.defineProperty(exports, "detectDuplicateToolCallIds", { enumerable: true, get: function () { return session_events_2.detectDuplicateToolCallIds; } });
+Object.defineProperty(exports, "migrateToolNames", { enumerable: true, get: function () { return session_events_2.migrateToolNames; } });
+Object.defineProperty(exports, "repairSessionMessages", { enumerable: true, get: function () { return session_events_2.repairSessionMessages; } });
+Object.defineProperty(exports, "validateSessionMessages", { enumerable: true, get: function () { return session_events_2.validateSessionMessages; } });
+const IDLE_REST_ONLY_KEEP_TURNS = 20;
 function buildTrimmableBlocks(messages) {
     const blocks = [];
     let i = 0;
@@ -86,6 +96,89 @@ function getSystemMessageIndices(messages) {
 function buildTrimmedMessages(messages, kept) {
     return messages.filter((m, idx) => m.role === "system" || kept.has(idx));
 }
+function messageContentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+}
+function toolCallName(toolCall) {
+    return toolCall.function.name;
+}
+function toolCallId(toolCall) {
+    return toolCall.id;
+}
+function isIdleHeartbeatRestUserMessage(message) {
+    if (message.role !== "user")
+        return false;
+    const text = messageContentToText(message.content);
+    return text.includes("...time passing. anything stirring?")
+        && !text.includes("[pending from ")
+        && !text.includes("## task:");
+}
+function isEmptyRestOnlyAssistantMessage(message) {
+    if (message.role !== "assistant")
+        return null;
+    if (messageContentToText(message.content).trim())
+        return null;
+    if (!Array.isArray(message.tool_calls) || message.tool_calls.length !== 1)
+        return null;
+    const onlyToolCall = message.tool_calls[0];
+    if (toolCallName(onlyToolCall) !== "rest")
+        return null;
+    return toolCallId(onlyToolCall);
+}
+function isMatchingToolResult(message, toolId) {
+    return message.tool_call_id === toolId;
+}
+function compactIdleRestOnlyTurns(messages, keepTurns = IDLE_REST_ONLY_KEEP_TURNS) {
+    const blocks = [];
+    let i = 0;
+    while (i < messages.length - 2) {
+        const userMessage = messages[i];
+        const assistantMessage = messages[i + 1];
+        const toolMessage = messages[i + 2];
+        const restToolId = isIdleHeartbeatRestUserMessage(userMessage)
+            ? isEmptyRestOnlyAssistantMessage(assistantMessage)
+            : null;
+        if (restToolId && isMatchingToolResult(toolMessage, restToolId)) {
+            blocks.push({ start: i, end: i + 2 });
+            i += 3;
+            continue;
+        }
+        i++;
+    }
+    if (blocks.length <= keepTurns)
+        return messages;
+    const drop = new Set();
+    for (const block of blocks.slice(0, blocks.length - keepTurns)) {
+        for (let index = block.start; index <= block.end; index++) {
+            drop.add(index);
+        }
+    }
+    const compacted = messages.filter((_message, index) => !drop.has(index));
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.session_idle_rest_compaction",
+        message: "compacted old idle rest-only private-runtime turns",
+        meta: {
+            removedTurns: blocks.length - keepTurns,
+            keptTurns: keepTurns,
+            removedMessages: drop.size,
+            originalCount: messages.length,
+            finalCount: compacted.length,
+        },
+    });
+    return compacted;
+}
 function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     const targetTokens = Math.floor(maxTokens * (1 - contextMargin / 100));
     const estimatedBefore = (0, token_estimate_1.estimateTokensForMessages)(messages);
@@ -173,122 +266,116 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
  * user → assistant (with optional tool calls/results) → user → assistant...
  * Never assistant → assistant without a user in between.
  */
-function validateSessionMessages(messages) {
-    const violations = [];
-    let prevNonToolRole = null;
-    let prevAssistantHadToolCalls = false;
-    let sawToolResultSincePrevAssistant = false;
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === "system")
-            continue;
-        if (msg.role === "tool") {
-            sawToolResultSincePrevAssistant = true;
-            continue;
-        }
-        if (msg.role === "assistant" && prevNonToolRole === "assistant") {
-            // assistant → tool(s) → assistant is valid (tool call flow)
-            if (!(prevAssistantHadToolCalls && sawToolResultSincePrevAssistant)) {
-                violations.push(`back-to-back assistant at index ${i}`);
-            }
-        }
-        prevAssistantHadToolCalls = msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
-        sawToolResultSincePrevAssistant = false;
-        prevNonToolRole = msg.role;
-    }
-    return violations;
+function denormalizeContinuityState(state) {
+    if (!state.mustResolveBeforeHandoff && typeof state.lastFriendActivityAt !== "string")
+        return undefined;
+    return {
+        ...(state.mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+        ...(typeof state.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
+    };
 }
-/**
- * Repairs session invariant violations by merging consecutive assistant messages.
- */
-function repairSessionMessages(messages) {
-    const violations = validateSessionMessages(messages);
-    if (violations.length === 0)
-        return messages;
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === "assistant" && result.length > 0) {
-            const prev = result[result.length - 1];
-            if (prev.role === "assistant" && !("tool_calls" in prev)) {
-                const prevContent = typeof prev.content === "string" ? prev.content : "";
-                const curContent = typeof msg.content === "string" ? msg.content : "";
-                prev.content = `${prevContent}\n\n${curContent}`;
-                continue;
-            }
-        }
-        result.push(msg);
+function withMutationLease(filePath, lease, work) {
+    if (lease) {
+        (0, session_transaction_1.assertSessionTurnLease)(filePath, lease);
+        return work(lease);
     }
-    (0, runtime_1.emitNervesEvent)({
-        level: "warn",
-        event: "mind.session_invariant_repair",
-        component: "mind",
-        message: "repaired session invariant violations",
-        meta: { violations },
+    const contextual = (0, session_transaction_1.currentSessionTurnLease)(filePath);
+    if (contextual)
+        return work(contextual);
+    return (0, session_transaction_1.withImmediateSessionTurnLease)(filePath, work);
+}
+function writeSessionEnvelopeUnderLease(filePath, envelope, lease, expectedRevision) {
+    const current = (0, session_transaction_1.readSessionTransaction)(filePath, lease);
+    (0, session_transaction_1.writeSessionTransaction)(filePath, envelope, {
+        lease,
+        expectedRevision: expectedRevision ?? current.revision,
     });
-    return result;
 }
-function saveSession(filePath, messages, lastUsage, state) {
-    const violations = validateSessionMessages(messages);
-    if (violations.length > 0) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            event: "mind.session_invariant_violation",
-            component: "mind",
-            message: "session invariant violated on save",
-            meta: { path: filePath, violations },
+function saveSession(filePath, messages, lastUsage, state, lease) {
+    return withMutationLease(filePath, lease, (owned) => {
+        const existing = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+        const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+        const currentIngressTimes = messages.map(session_events_1.getIngressTime);
+        const currentIngressRelations = messages.map(session_events_1.getIngressRelations);
+        const sanitized = (0, session_events_1.sanitizeProviderMessages)(messages);
+        const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
+            existing,
+            previousMessages,
+            currentMessages: sanitized,
+            trimmedMessages: sanitized,
+            currentIngressTimes,
+            currentIngressRelations,
+            recordedAt: new Date().toISOString(),
+            lastUsage: lastUsage ?? null,
+            state,
+            projectionBasis: {
+                maxTokens: null,
+                contextMargin: null,
+                inputTokens: lastUsage?.input_tokens ?? null,
+            },
+        });
+        writeSessionEnvelopeUnderLease(filePath, envelope, owned);
+        return envelope.events;
+    });
+}
+function appendSyntheticAssistantMessage(filePath, content, lease) {
+    try {
+        return withMutationLease(filePath, lease, (owned) => {
+            if (!fs.existsSync(filePath))
+                return false;
+            const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+            if (!envelope)
+                return false;
+            const updated = (0, session_events_1.appendSyntheticAssistantEvent)(envelope, content, new Date().toISOString());
+            writeSessionEnvelopeUnderLease(filePath, updated, owned);
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.session_synthetic_message_appended",
+                message: "appended synthetic assistant message to session",
+                meta: { path: filePath, contentLength: content.length },
+            });
+            return true;
         });
-        messages = repairSessionMessages(messages);
     }
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const envelope = { version: 1, messages };
-    if (lastUsage)
-        envelope.lastUsage = lastUsage;
-    if (state?.mustResolveBeforeHandoff === true || typeof state?.lastFriendActivityAt === "string") {
-        envelope.state = {
-            ...(state?.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
-            ...(typeof state?.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
-        };
+    catch {
+        return false;
     }
-    fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
 function loadSession(filePath) {
     try {
-        const raw = fs.readFileSync(filePath, "utf-8");
-        const data = JSON.parse(raw);
-        if (data.version !== 1)
+        const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+        if (!envelope)
             return null;
-        let messages = data.messages;
-        const violations = validateSessionMessages(messages);
-        if (violations.length > 0) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                event: "mind.session_invariant_violation",
-                component: "mind",
-                message: "session invariant violated on load",
-                meta: { path: filePath, violations },
-            });
-            messages = repairSessionMessages(messages);
-        }
-        const rawState = data?.state && typeof data.state === "object" && data.state !== null
-            ? data.state
-            : undefined;
-        const state = rawState && (rawState.mustResolveBeforeHandoff === true
-            || typeof rawState.lastFriendActivityAt === "string")
-            ? {
-                ...(rawState.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
-                ...(typeof rawState.lastFriendActivityAt === "string" ? { lastFriendActivityAt: rawState.lastFriendActivityAt } : {}),
-            }
-            : undefined;
-        return { messages, lastUsage: data.lastUsage, state };
+        return {
+            messages: (0, session_events_1.sanitizeProviderMessages)((0, session_events_1.projectProviderMessages)(envelope)),
+            events: envelope.events,
+            projectionEventIds: [...(0, session_events_1.projectedSessionEventIds)(envelope)],
+            structuredOutputs: envelope.structuredOutputs ?? [],
+            lastUsage: envelope.lastUsage ?? undefined,
+            state: denormalizeContinuityState(envelope.state),
+        };
     }
     catch {
         return null;
     }
 }
+/**
+ * Synchronous post-turn: sanitize, trim (mutates messages in place), and persist to disk.
+ * For non-blocking persist, use postTurnTrim() + deferPostTurnPersist() instead.
+ */
 function postTurn(messages, sessPath, usage, hooks, state) {
+    const prepared = postTurnTrim(messages, usage, hooks);
+    postTurnPersist(sessPath, prepared, usage, state);
+}
+/**
+ * Synchronous phase: run hooks, sanitize, trim, and mutate the messages array in place.
+ * Returns the data needed by postTurnPersist / deferPostTurnPersist.
+ */
+function postTurnTrim(messages, usage, hooks) {
+    const preTrimMessages = [...messages];
     if (hooks?.beforeTrim) {
         try {
-            hooks.beforeTrim([...messages]);
+            hooks.beforeTrim(preTrimMessages);
         }
         catch (error) {
             (0, runtime_1.emitNervesEvent)({
@@ -303,16 +390,127 @@ function postTurn(messages, sessPath, usage, hooks, state) {
         }
     }
     const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
-    const trimmed = trimMessages(messages, maxTokens, contextMargin, usage?.input_tokens);
-    messages.splice(0, messages.length, ...trimmed);
-    saveSession(sessPath, messages, usage, state);
-}
-function deleteSession(filePath) {
-    try {
-        fs.unlinkSync(filePath);
-    }
-    catch (e) {
-        if (e instanceof Error && e.code !== "ENOENT")
-            throw e;
+    const currentIngressTimes = preTrimMessages.map(session_events_1.getIngressTime);
+    const currentIngressRelations = preTrimMessages.map(session_events_1.getIngressRelations);
+    const currentMessages = (0, session_events_1.sanitizeProviderMessages)(messages);
+    let tokenTrimmedMessages = trimMessages(currentMessages, maxTokens, contextMargin, usage?.input_tokens);
+    const estimatedTokens = (0, token_estimate_1.estimateTokensForMessages)(tokenTrimmedMessages);
+    if (estimatedTokens > maxTokens) {
+        const targetTokens = Math.floor(maxTokens * (1 - contextMargin / 100));
+        const lastUser = tokenTrimmedMessages.findLastIndex((message) => message.role === "user");
+        const lastAssistant = tokenTrimmedMessages.findLastIndex((message) => message.role === "assistant");
+        const dropped = new Set();
+        let remaining = estimatedTokens;
+        for (const block of buildTrimmableBlocks(tokenTrimmedMessages)) {
+            if (remaining <= targetTokens)
+                break;
+            if (block.indices.includes(lastUser) || lastAssistant > lastUser && block.indices.includes(lastAssistant))
+                continue;
+            for (const index of block.indices)
+                dropped.add(index);
+            remaining -= block.estimatedTokens;
+        }
+        tokenTrimmedMessages = remaining > maxTokens ? [] : tokenTrimmedMessages.filter((_message, index) => !dropped.has(index));
+        (0, runtime_1.emitNervesEvent)({
+            level: tokenTrimmedMessages.length === 0 ? "warn" : "info",
+            event: "mind.step_end",
+            component: "mind",
+            message: "bounded post-turn projection using canonical token estimates",
+            meta: {
+                maxTokens, targetTokens, estimated_before: estimatedTokens,
+                estimated_after: (0, token_estimate_1.estimateTokensForMessages)(tokenTrimmedMessages),
+                reported_input_tokens: usage?.input_tokens ?? null,
+                emptyProjection: tokenTrimmedMessages.length === 0,
+            },
+        });
     }
+    const trimmedMessages = compactIdleRestOnlyTurns(tokenTrimmedMessages);
+    messages.splice(0, messages.length, ...trimmedMessages);
+    return { currentMessages, trimmedMessages, currentIngressTimes, currentIngressRelations, maxTokens, contextMargin };
+}
+/**
+ * Synchronous persist: load existing envelope, build canonical envelope, write to disk.
+ */
+function postTurnPersist(sessPath, prepared, usage, state, lease, expectedRevision) {
+    return withMutationLease(sessPath, lease, (owned) => {
+        const existing = (0, session_events_1.loadSessionEnvelopeFile)(sessPath);
+        const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+        const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
+            existing,
+            previousMessages,
+            currentMessages: prepared.currentMessages,
+            trimmedMessages: prepared.trimmedMessages,
+            currentIngressTimes: prepared.currentIngressTimes,
+            currentIngressRelations: prepared.currentIngressRelations,
+            recordedAt: new Date().toISOString(),
+            lastUsage: usage ?? null,
+            state,
+            projectionBasis: {
+                maxTokens: prepared.maxTokens,
+                contextMargin: prepared.contextMargin,
+                inputTokens: usage?.input_tokens ?? null,
+            },
+        });
+        writeSessionEnvelopeUnderLease(sessPath, envelope, owned, expectedRevision);
+        return envelope.events;
+    });
+}
+/**
+ * Per-sessPath serialization queue. Without this, two concurrent
+ * `deferPostTurnPersist` calls (e.g. two BlueBubbles webhooks for the same
+ * chat firing back-to-back, or a CLI postTurn racing the private-runtime turn
+ * for the same MCP session) would each load the envelope, both compute the
+ * same "next sequence", and write events with colliding ids. The session
+ * file would silently accumulate duplicates and replay would diverge from
+ * what was actually sent on the wire.
+ *
+ * The queue is in-process only — it does not protect against multiple Node
+ * processes writing to the same file. The dedup-on-load behaviour in
+ * parseSessionEnvelope keeps cross-process races from leaving permanent
+ * corruption; this serializer just keeps the common (single-process) case
+ * race-free in the first place.
+ */
+const sessionPersistQueues = new Map();
+function enqueueSessionPersist(sessPath, fn) {
+    const previous = sessionPersistQueues.get(sessPath) ?? Promise.resolve();
+    // Chain on the previous tail. fn runs whether previous resolved or rejected,
+    // so one failed turn cannot block subsequent turns on the same session.
+    const next = previous.then(fn, fn);
+    // Save a swallowed-rejection sentinel as the new tail so the next caller's
+    // `previous.then(fn, fn)` sees a clean resolution; the original `next` still
+    // propagates rejection to its own caller as expected.
+    /* v8 ignore start -- the swallow only matters when fn rejects, which is the failure path covered separately */
+    const sentinel = next.then(() => undefined, () => undefined);
+    /* v8 ignore stop */
+    sessionPersistQueues.set(sessPath, sentinel);
+    return next;
+}
+/**
+ * Deferred persist: same as postTurnPersist but runs on the next event loop
+ * tick AND serializes against any other deferred persist for the same
+ * sessPath, so concurrent turns cannot race and produce duplicate event ids
+ * in the saved session.
+ */
+function deferPostTurnPersist(sessPath, prepared, usage, state, lease, expectedRevision) {
+    return enqueueSessionPersist(sessPath, () => new Promise((resolve) => {
+        setImmediate(() => {
+            try {
+                const events = postTurnPersist(sessPath, prepared, usage, state, lease, expectedRevision);
+                resolve(events);
+            }
+            catch (err) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.deferred_persist_error",
+                    message: "deferred session persist failed",
+                    meta: { error: err instanceof Error ? err.message : String(err) },
+                });
+                resolve([]);
+            }
+        });
+    }));
+}
+function deleteSession(filePath, lease) {
+    withMutationLease(filePath, lease, (owned) => (0, session_transaction_1.deleteSessionTransaction)(filePath, owned));
 }