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

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_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.815",
+      "changes": [
+        "Protect Sanctuary's resident control socket from transient Telegram app disposal, and safely retry interrupted startup and cleanup without stealing another listener.",
+        "Preserve the order of overlapping startup and shutdown requests, and check socket modification time without mistaking permission changes for replacement."
+      ]
+    },
     {
       "version": "0.1.0-alpha.814",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.814",
+  "runtimeVersion": "0.1.0-alpha.815",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.814</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.815</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

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/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.814",
+  "version": "0.1.0-alpha.815",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.814",
+      "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.814",
+  "version": "0.1.0-alpha.815",
   "engines": {
     "node": ">=22"
   },