@ouro.bot/cli 0.1.0-alpha.813 → 0.1.0-alpha.815

package/dist/mailbox-ui/index.html

@@ -6,7 +6,7 @@
     <meta name="color-scheme" content="dark" />
     <title>Ouro Mailbox</title>
     <meta name="description" content="The daemon-hosted shared orientation surface for agents alive on this machine." />
-    <script type="module" crossorigin src="/assets/index-J8zDwHmE.js"></script>
+    <script type="module" crossorigin src="/assets/index-Cyv4mw3Y.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-CcN1XpQ9.js">
     <link rel="stylesheet" crossorigin href="/assets/index-Du_9G9WO.css">
   </head>

package/dist/mind/context.js

@@ -393,7 +393,37 @@ function postTurnTrim(messages, usage, hooks) {
     const currentIngressTimes = preTrimMessages.map(session_events_1.getIngressTime);
     const currentIngressRelations = preTrimMessages.map(session_events_1.getIngressRelations);
     const currentMessages = (0, session_events_1.sanitizeProviderMessages)(messages);
-    const tokenTrimmedMessages = trimMessages(currentMessages, maxTokens, contextMargin, usage?.input_tokens);
+    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 };

package/dist/senses/sanctuary-interactive-control.js

@@ -229,70 +229,174 @@ function createSanctuaryInteractiveControl(options) {
     const socketPath = path.join(options.agentRoot, "state", "acceptance", "telegram-control.sock");
     const runRequest = options.runRequest ?? (async (operation) => operation());
     let server;
+    let endpoint;
+    let startPromise;
+    let stopPromise;
     let updateId = 2_100_000_000;
+    const readEndpoint = () => (0, node_fs_1.lstatSync)(socketPath, { bigint: true, throwIfNoEntry: false });
+    // Socket mtime, unlike ctime, survives permission-only changes.
+    const matches = (observed, current) => current !== undefined && current.isSocket() && current.dev === observed.dev && current.ino === observed.ino
+        && current.birthtimeNs === observed.birthtimeNs && current.mtimeNs === observed.mtimeNs;
+    const stopListener = async () => {
+        const active = server;
+        if (!active)
+            return;
+        if (active.listening) {
+            const current = readEndpoint();
+            // Native Server.close() also unlinks its pathname, so ownership must precede it.
+            if (current && (!endpoint || !matches(endpoint, current)))
+                throw new Error("Sanctuary interactive control socket ownership was replaced");
+            await new Promise((resolve, reject) => active.close((error) => error ? reject(error) : resolve()));
+        }
+        server = undefined;
+        endpoint = undefined;
+    };
     return {
         socketPath,
-        async start() {
-            if (server)
-                return;
-            (0, node_fs_1.mkdirSync)(path.dirname(socketPath), { recursive: true, mode: 0o700 });
-            if ((0, node_fs_1.existsSync)(socketPath))
-                (0, node_fs_1.unlinkSync)(socketPath);
-            server = (0, node_net_1.createServer)({ allowHalfOpen: true }, (connection) => {
-                let raw = "";
-                connection.setEncoding("utf8");
-                connection.on("error", () => undefined);
-                connection.on("data", (chunk) => { raw += chunk; if (Buffer.byteLength(raw) > MAX_CONTROL_REQUEST)
-                    connection.destroy(); });
-                connection.on("end", () => {
-                    void runRequest(async () => {
+        start() {
+            if (startPromise)
+                return startPromise;
+            const previousStop = stopPromise;
+            stopPromise = undefined;
+            const starting = (async () => {
+                if (previousStop)
+                    await previousStop;
+                if (server) {
+                    if (endpoint && matches(endpoint, readEndpoint()))
+                        return;
+                    await stopListener();
+                }
+                (0, node_fs_1.mkdirSync)(path.dirname(socketPath), { recursive: true, mode: 0o700 });
+                const previous = readEndpoint();
+                if (previous) {
+                    if (!previous.isSocket())
+                        throw new Error("Sanctuary interactive control endpoint is not a socket");
+                    await new Promise((resolve, reject) => {
+                        const socket = (0, node_net_1.createConnection)(socketPath);
+                        const finish = (error) => { socket.destroy(); if (error)
+                            reject(error);
+                        else
+                            resolve(); };
+                        socket.setTimeout(1_000, () => finish(new Error("Sanctuary interactive control ownership probe timed out")));
+                        socket.once("connect", () => finish(new Error("Sanctuary interactive control endpoint has another live listener")));
+                        socket.once("error", (error) => finish(error.code === "ECONNREFUSED" ? undefined : error));
+                    });
+                    const current = readEndpoint();
+                    if (!matches(previous, current) || current.ctimeNs !== previous.ctimeNs)
+                        throw new Error("Sanctuary interactive control endpoint was replaced during the ownership probe");
+                    (0, node_fs_1.unlinkSync)(socketPath);
+                }
+                server = (0, node_net_1.createServer)({ allowHalfOpen: true }, (connection) => {
+                    let raw = "";
+                    connection.setEncoding("utf8");
+                    connection.on("error", () => undefined);
+                    connection.on("data", (chunk) => { raw += chunk; if (Buffer.byteLength(raw) > MAX_CONTROL_REQUEST)
+                        connection.destroy(); });
+                    connection.on("end", () => {
+                        void runRequest(async () => {
+                            try {
+                                (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_interactive_control_request", message: "Sanctuary interactive control request received", meta: { bytes: Buffer.byteLength(raw) } });
+                                const parsed = object(JSON.parse(raw), "interactive control request");
+                                if (parsed.operation === "interactive_runtime_ready") {
+                                    exactKeys(parsed, ["operation", "label", "scenarioHandleDigest"], "interactive readiness request");
+                                    if (parsed.label !== "unit-16m-restart-continuation" || typeof parsed.scenarioHandleDigest !== "string" || !SHA256.test(parsed.scenarioHandleDigest))
+                                        throw new Error("interactive readiness binding is invalid");
+                                    connection.end(`${JSON.stringify({ ok: true, result: { ready: true } })}\n`);
+                                    return;
+                                }
+                                const result = await executeSanctuaryInteractiveEngine(parsed, {
+                                    agentRoot: options.agentRoot,
+                                    readApprovals: (digest) => (0, approval_store_1.readApprovalsByScenarioHandleDigest)(path.join(options.agentRoot, "state", "approvals", "approvals.sqlite"), digest),
+                                    readPending: () => new telegram_client_1.FileTelegramPendingApprovalStore(path.join(options.agentRoot, "state", "approvals", "telegram-pending.json")).load(),
+                                    createSession: async () => ({
+                                        handle: ({ callbackData, queryId, messageId }) => runRequest(() => options.transport.handleUpdate({
+                                            update_id: updateId++,
+                                            callback_query: {
+                                                id: queryId,
+                                                from: { id: Number(options.authorizedUserId) },
+                                                data: callbackData,
+                                                message: {
+                                                    message_id: Number(messageId),
+                                                    chat: { id: Number(options.authorizedChatId) },
+                                                },
+                                            },
+                                        })),
+                                        pendingApprovalIds: () => options.transport.listPendingDeliveries().map(({ approvalId }) => approvalId),
+                                        close: () => undefined,
+                                    }),
+                                    proveIndeterminateRecovery: (approval, digest) => proveSanctuaryAttemptedRecoveryWithoutRetry(options.agentRoot, digest, approval),
+                                    writeCredentialObserved: () => /credential|api[_-]?key|token|secret/iu.test(raw),
+                                });
+                                connection.end(`${JSON.stringify({ ok: true, result })}\n`);
+                            }
+                            catch {
+                                connection.end(`${JSON.stringify({ ok: false, error: "interactive runtime operation failed" })}\n`);
+                            }
+                        }).catch(() => { if (!connection.destroyed)
+                            connection.end(`${JSON.stringify({ ok: false, error: "interactive runtime operation failed" })}\n`); });
+                    });
+                });
+                const active = server;
+                try {
+                    await new Promise((resolve, reject) => {
+                        const onError = (error) => { active.off("listening", onListening); reject(error); };
+                        const onListening = () => {
+                            active.off("error", onError);
+                            try {
+                                if (!endpoint || !matches(endpoint, readEndpoint()))
+                                    throw new Error("Sanctuary interactive control socket ownership was replaced during startup");
+                                resolve();
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                        };
+                        active.once("error", onError);
+                        active.once("listening", onListening);
                         try {
-                            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_interactive_control_request", message: "Sanctuary interactive control request received", meta: { bytes: Buffer.byteLength(raw) } });
-                            const parsed = object(JSON.parse(raw), "interactive control request");
-                            if (parsed.operation === "interactive_runtime_ready") {
-                                exactKeys(parsed, ["operation", "label", "scenarioHandleDigest"], "interactive readiness request");
-                                if (parsed.label !== "unit-16m-restart-continuation" || typeof parsed.scenarioHandleDigest !== "string" || !SHA256.test(parsed.scenarioHandleDigest))
-                                    throw new Error("interactive readiness binding is invalid");
-                                connection.end(`${JSON.stringify({ ok: true, result: { ready: true } })}\n`);
-                                return;
+                            active.listen(socketPath);
+                            if (active.listening) {
+                                endpoint = readEndpoint();
+                                if (!endpoint?.isSocket())
+                                    throw new Error("Sanctuary interactive control startup ownership is unproven");
+                                (0, node_fs_1.chmodSync)(socketPath, 0o600);
+                                endpoint = readEndpoint();
                             }
-                            const result = await executeSanctuaryInteractiveEngine(parsed, {
-                                agentRoot: options.agentRoot,
-                                readApprovals: (digest) => (0, approval_store_1.readApprovalsByScenarioHandleDigest)(path.join(options.agentRoot, "state", "approvals", "approvals.sqlite"), digest),
-                                readPending: () => new telegram_client_1.FileTelegramPendingApprovalStore(path.join(options.agentRoot, "state", "approvals", "telegram-pending.json")).load(),
-                                createSession: async () => ({
-                                    handle: ({ callbackData, queryId, messageId }) => runRequest(() => options.transport.handleUpdate({
-                                        update_id: updateId++,
-                                        callback_query: {
-                                            id: queryId,
-                                            from: { id: Number(options.authorizedUserId) },
-                                            data: callbackData,
-                                            message: {
-                                                message_id: Number(messageId),
-                                                chat: { id: Number(options.authorizedChatId) },
-                                            },
-                                        },
-                                    })),
-                                    pendingApprovalIds: () => options.transport.listPendingDeliveries().map(({ approvalId }) => approvalId),
-                                    close: () => undefined,
-                                }),
-                                proveIndeterminateRecovery: (approval, digest) => proveSanctuaryAttemptedRecoveryWithoutRetry(options.agentRoot, digest, approval),
-                                writeCredentialObserved: () => /credential|api[_-]?key|token|secret/iu.test(raw),
-                            });
-                            connection.end(`${JSON.stringify({ ok: true, result })}\n`);
                         }
-                        catch {
-                            connection.end(`${JSON.stringify({ ok: false, error: "interactive runtime operation failed" })}\n`);
+                        catch (error) {
+                            active.off("error", onError);
+                            onError(error);
                         }
-                    }).catch(() => { if (!connection.destroyed)
-                        connection.end(`${JSON.stringify({ ok: false, error: "interactive runtime operation failed" })}\n`); });
-                });
-            });
-            await new Promise((resolve, reject) => { server.once("error", reject); server.listen(socketPath, () => { server.off("error", reject); (0, node_fs_1.chmodSync)(socketPath, 0o600); resolve(); }); });
+                    });
+                }
+                catch (error) {
+                    try {
+                        await stopListener();
+                    }
+                    catch (cleanupError) {
+                        throw new AggregateError([error, cleanupError], "Sanctuary interactive control startup and ownership cleanup failed");
+                    }
+                    throw error;
+                }
+            })().finally(() => { if (startPromise === starting)
+                startPromise = undefined; });
+            startPromise = starting;
+            return starting;
+        },
+        stop() {
+            if (stopPromise)
+                return stopPromise;
+            const starting = startPromise;
+            startPromise = undefined;
+            const stopping = (async () => {
+                if (starting)
+                    await starting;
+                await stopListener();
+            })().finally(() => { if (stopPromise === stopping)
+                stopPromise = undefined; });
+            stopPromise = stopping;
+            return stopping;
         },
-        async stop() { const active = server; server = undefined; if (active)
-            await new Promise((resolve) => active.close(() => resolve())); if ((0, node_fs_1.existsSync)(socketPath))
-            (0, node_fs_1.unlinkSync)(socketPath); },
     };
 }
 async function sanctuaryInteractiveControlReady(socketPath, timeoutMs = 1_000) {

package/dist/senses/shared-turn.js

@@ -268,14 +268,26 @@ function rawSessionEvents(value) {
     const record = value;
     return record.version === 2 && Array.isArray(record.events) ? record.events : [];
 }
-function exactProjectedIngressMessage(existing, messages, eventId) {
+function exactProjectedIngressMessage(existing, messages, eventId, nativeValue) {
+    if (!nativeValue || typeof nativeValue !== "object" || Array.isArray(nativeValue))
+        return null;
+    const native = nativeValue;
+    if (native.version !== 2 || !native.projection || typeof native.projection !== "object" || Array.isArray(native.projection))
+        return null;
+    const projection = native.projection;
+    if (!Array.isArray(projection.eventIds))
+        return null;
+    // Authorization must inspect stored IDs before a reader filters unresolved entries.
+    const projectionIds = projection.eventIds.length > 0
+        ? projection.eventIds
+        : projection.trimmed === true ? [] : existing.projectionEventIds;
     const eventsById = new Map(existing.events.map((event) => [event.id, event]));
     if (eventsById.size !== existing.events.length)
         return null;
     const seenProjectionIds = new Set();
     const effectiveIds = new Set((0, session_events_1.selectEffectiveSessionEvents)(existing.events).map((event) => event.id));
     const projectedEvents = [];
-    for (const projectedId of existing.projectionEventIds) {
+    for (const projectedId of projectionIds) {
         if (typeof projectedId !== "string" || !projectedId.trim() || seenProjectionIds.has(projectedId))
             return null;
         const event = eventsById.get(projectedId);
@@ -285,7 +297,7 @@ function exactProjectedIngressMessage(existing, messages, eventId) {
         if (effectiveIds.has(event.id))
             projectedEvents.push(event);
     }
-    if (existing.projectionEventIds.filter((projectedId) => projectedId === eventId).length !== 1)
+    if (projectionIds.filter((projectedId) => projectedId === eventId).length !== 1)
         return null;
     const projectedUsers = projectedEvents.filter((event) => event.role === "user");
     const providerUsers = messages.filter((message) => message.role === "user");
@@ -401,7 +413,8 @@ async function runSenseTurnExclusive(options, owner) {
     const runWithLease = options._withSessionTurnLease ?? session_transaction_1.withSessionTurnLease;
     try {
         return await runWithLease(sessPath, async (sessionTurnLease) => {
-            const baseSessionRevision = (0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).revision;
+            const baseSession = (0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease);
+            const baseSessionRevision = baseSession.revision;
             const existing = options.disablePersistence ? undefined : (0, context_1.loadSession)(sessPath);
             const precommittedIngressEvent = options.precommittedIngress
                 ? existing?.events?.find((candidate) => candidate.id === options.precommittedIngress.eventId)
@@ -424,7 +437,7 @@ async function runSenseTurnExclusive(options, owner) {
                         content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, options.disableTools ? { tools: [], hardDisableTools: true } : {}, undefined)),
                     }];
             if (precommittedIngressEvent) {
-                const projectedIngress = exactProjectedIngressMessage(existing, sessionMessages, precommittedIngressEvent.id);
+                const projectedIngress = exactProjectedIngressMessage(existing, sessionMessages, precommittedIngressEvent.id, baseSession.value);
                 if (!projectedIngress || projectedIngress.role !== "user" || projectedIngress.content !== userMessage)
                     throw new Error("shared turn precommitted ingress is absent from the provider projection");
                 (0, session_events_1.stampIngressRelations)(projectedIngress, {

package/dist/senses/telegram-effect-adapter.js

@@ -724,11 +724,15 @@ function appendTelegramArtifactEvents(envelope, artifact, recordedAt) {
         };
     });
     const eventIds = events.map((event) => event.id);
+    const priorIds = (0, session_events_1.projectedSessionEventIds)(envelope);
     return {
         envelope: {
             ...envelope,
             events: [...envelope.events, ...events],
-            projection: { ...envelope.projection, eventIds: [...envelope.projection.eventIds, ...eventIds], projectedAt: recordedAt, trimmed: false },
+            projection: {
+                ...envelope.projection, eventIds: [...priorIds, ...eventIds], projectedAt: recordedAt,
+                trimmed: new Set(priorIds).size < (0, session_events_1.selectEffectiveSessionEvents)(envelope.events).length,
+            },
         },
         eventIds,
     };
@@ -758,10 +762,14 @@ function appendTelegramInboundEvent(envelope, input) {
         },
         provenance: { captureKind: "live", legacyVersion: null, sourceMessageIndex: null },
     };
+    const priorIds = (0, session_events_1.projectedSessionEventIds)(envelope);
     return {
         ...envelope,
         events: [...envelope.events, event],
-        projection: { ...envelope.projection, eventIds: [...envelope.projection.eventIds, id], projectedAt: input.recordedAt, trimmed: false },
+        projection: {
+            ...envelope.projection, eventIds: [...priorIds, id], projectedAt: input.recordedAt,
+            trimmed: new Set(priorIds).size < (0, session_events_1.selectEffectiveSessionEvents)(envelope.events).length,
+        },
     };
 }
 async function recordTelegramEffectsInSession(input) {

package/dist/senses/telegram.js

@@ -1669,6 +1669,26 @@ function createTelegramSenseApp(options) {
     catch (error) {
         releaseAcceptanceAudit(error);
     }
+    const pendingCleanup = new Set([
+        () => poll.stop(),
+        async () => { await runPromise?.catch(() => undefined); },
+        async () => { await Promise.all([...approvalReconciliationsInFlight]); },
+        async () => { await interactiveControl?.stop(); },
+        () => api.stop(),
+        () => approvalRuntime?.close(),
+        () => effectJournal?.close(),
+        () => admissionStore?.close(),
+        () => (0, tools_awaiting_1.resetAwaitToolDeps)(),
+        () => runWithAcceptanceAuditOwner(() => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.telegram_poll_end",
+                message: "Telegram long poll stopped",
+                meta: { agentName: options.agentName, subject },
+            });
+        }),
+        retireAcceptanceAudit,
+    ]);
     return {
         run(signal) {
             if (runPromise)
@@ -1762,37 +1782,20 @@ function createTelegramSenseApp(options) {
                 return stopPromise;
             stopPromise = (async () => {
                 const errors = [];
-                const attempt = async (operation) => {
+                for (const operation of pendingCleanup) {
                     try {
                         await operation();
+                        pendingCleanup.delete(operation);
                     }
                     catch (error) {
                         errors.push(error);
                     }
-                };
-                await attempt(() => poll.stop());
-                await attempt(async () => { await runPromise?.catch(() => undefined); });
-                await attempt(async () => { await Promise.all([...approvalReconciliationsInFlight]); });
-                await attempt(async () => { await interactiveControl?.stop(); });
-                await attempt(() => api.stop());
-                await attempt(() => approvalRuntime?.close());
-                await attempt(() => effectJournal?.close());
-                await attempt(() => admissionStore?.close());
-                await attempt(() => (0, tools_awaiting_1.resetAwaitToolDeps)());
-                await attempt(() => runWithAcceptanceAuditOwner(() => {
-                    (0, runtime_1.emitNervesEvent)({
-                        component: "senses",
-                        event: "senses.telegram_poll_end",
-                        message: "Telegram long poll stopped",
-                        meta: { agentName: options.agentName, subject },
-                    });
-                }));
-                await attempt(retireAcceptanceAudit);
+                }
                 if (errors.length === 1)
                     throw errors[0];
                 if (errors.length > 1)
                     throw new AggregateError(errors, "Telegram sense cleanup failed");
-            })();
+            })().catch((error) => { stopPromise = undefined; throw error; });
             return stopPromise;
         },
     };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.813",
+  "version": "0.1.0-alpha.815",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.813",
+      "version": "0.1.0-alpha.815",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.813",
+  "version": "0.1.0-alpha.815",
   "engines": {
     "node": ">=22"
   },