@fitchmultz/pi-subagents 0.47.0 → 0.49.0

package/dist/pi-intercom/bridge-wake.js

@@ -1,146 +1,232 @@
+import { createHash } from "node:crypto";
 import { log } from "./bridge-protocol.js";
 import { Mailbox } from "./bridge-mailbox.js";
-const POLL_MS = 15000;
-const FALLBACK_AFTER_MS = 120000;
-const MAX_BACKOFF_MS = 300000;
-export class WakeDelivery {
+import { WakeState } from "./bridge-wake-state.js";
+function actionable(entry) {
+    const message = entry.message;
+    if (entry.acknowledged || message.passive === true || message.delivery === "passive") {
+        return false;
+    }
+    return (message.expectsReply === true ||
+        !/^(?:ACK|DUP-ACK|FYI|NOTE|RECEIPT|NOWAKE)(?=$|[\s:])/.test(message.content.text));
+}
+function bucket(identity) {
+    return createHash("sha256")
+        .update(identity.wake?.url ?? "")
+        .digest("hex");
+}
+/** Mailbox commits and durable retry/quota deadlines drive wakes; there is no intake scan timer. */
+export class WakeDeliveries {
+    stateDir;
+    state;
+    allowed;
+    deliveries = new Map();
     controller = new AbortController();
     timer;
     running;
-    backoff = POLL_MS;
-    name;
-    mailbox;
-    policy;
-    authorized;
-    constructor(name, mailbox, policy, authorized) {
-        this.name = name;
-        this.mailbox = mailbox;
-        this.policy = policy;
-        this.authorized = authorized;
+    dirty = false;
+    storageBackoff = 15000;
+    constructor(stateDir, allowed) {
+        this.stateDir = stateDir;
+        this.allowed = allowed;
+        // Initialize before any presence proof/mailbox is created, so genuinely fresh installs start now.
+        this.state = stateDir === undefined ? undefined : new WakeState(stateDir);
+    }
+    session(identity, expires) {
+        if (!identity.wake ||
+            this.stateDir === undefined ||
+            this.deliveries.has(identity.fingerprint256)) {
+            return;
+        }
+        this.deliveries.set(identity.fingerprint256, {
+            identity,
+            expires,
+            mailbox: new Mailbox(this.stateDir, identity.fingerprint256, true),
+            controller: new AbortController(),
+        });
+        // Startup restores every certificate proof synchronously before the scheduled reconciliation.
+        // An empty first fingerprint must not clear another retained fingerprint's durable cold batch.
+        this.changed(false);
+    }
+    changed(reconcile = true) {
+        if (this.controller.signal.aborted) {
+            return;
+        }
+        try {
+            // ACK may be followed by fresh mail before the event timer runs. Clear completed batches now
+            // so a new obligation does not inherit a completed batch's uncertainty/backoff.
+            if (reconcile) {
+                this.reconcile();
+            }
+        }
+        catch {
+            // The scheduled storage recovery fails closed; never let an event bypass durable admission.
+        }
+        if (this.running) {
+            this.dirty = true;
+        }
+        else {
+            this.schedule(Date.now());
+        }
     }
-    start() {
-        if (!this.running && !this.controller.signal.aborted) {
-            this.schedule(0);
+    reconcile() {
+        for (const [key, candidate] of this.groups()) {
+            if (candidate) {
+                this.state?.deadline(key);
+            }
+            else {
+                this.state?.retire(key);
+            }
         }
     }
-    schedule(delay) {
+    schedule(deadline) {
         clearTimeout(this.timer);
         this.timer = setTimeout(() => {
+            this.dirty = false;
+            let next = Infinity;
             this.running = this.deliver()
+                .then((due) => {
+                next = due;
+                this.storageBackoff = 15000;
+                return;
+            })
                 .catch(() => {
-                log("wake_delivery", { name: this.name, result: "storage_unavailable" });
-                this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF_MS);
+                log("wake_delivery", { result: "storage_unavailable" });
+                next = Date.now() + this.storageBackoff;
+                this.storageBackoff = Math.min(this.storageBackoff * 2, 300000);
             })
                 .finally(() => {
                 this.running = undefined;
-                if (!this.controller.signal.aborted) {
-                    this.schedule(this.backoff);
+                if (!this.controller.signal.aborted && (this.dirty || Number.isFinite(next))) {
+                    this.schedule(this.dirty ? Date.now() : next);
                 }
             });
-        }, delay);
+        }, Math.max(0, Math.min(deadline - Date.now(), 0x7fffffff)));
+    }
+    authorized(delivery) {
+        return (!this.controller.signal.aborted &&
+            this.allowed(delivery.identity) &&
+            delivery.expires > Date.now());
+    }
+    pending(delivery) {
+        let after = 0;
+        let next;
+        let page;
+        do {
+            page = delivery.mailbox.pendingNotifications(after);
+            for (const entry of page.messages) {
+                if (!actionable(entry)) {
+                    // Retire only notification intent. Payload/reply obligations require actual ACK/reply.
+                    delivery.mailbox.notificationAccepted(entry.message.id);
+                }
+                else if (!next) {
+                    next = entry;
+                }
+            }
+            after = Number(page.nextCursor);
+        } while (page.hasMore);
+        return next;
+    }
+    groups() {
+        const groups = new Map();
+        for (const delivery of this.deliveries.values()) {
+            if (!this.authorized(delivery)) {
+                continue;
+            }
+            const key = bucket(delivery.identity);
+            const entry = this.pending(delivery);
+            const previous = groups.get(key);
+            if (!groups.has(key) ||
+                (entry && (!previous || entry.receivedAt < previous.entry.receivedAt))) {
+                groups.set(key, entry ? { delivery, entry } : undefined);
+            }
+        }
+        return groups;
     }
     async deliver() {
-        if (!this.authorized()) {
-            return;
+        const state = this.state;
+        let next = Infinity;
+        if (!state) {
+            return next;
         }
-        const entries = this.mailbox.pendingNotifications().messages;
-        for (const entry of entries) {
-            if (entry.acknowledged) {
-                // The box's durable worker owns primary wake/replay after acknowledgement.
-                this.mailbox.notificationAccepted(entry.message.id);
+        // ACK can remove the final candidate while its failed completion write still needs recovery.
+        state.retrySettlement();
+        for (const [key, candidate] of this.groups()) {
+            if (!candidate) {
+                state.retire(key);
+                continue;
             }
+            const due = state.deadline(key);
+            if (due > Date.now()) {
+                next = Math.min(next, due);
+                continue;
+            }
+            const deferred = state.reserve(key);
+            if (deferred !== undefined) {
+                next = Math.min(next, deferred);
+                continue;
+            }
+            // ponytail: two cold Macs can each admit one wake. Literal cross-Mac single admission
+            // requires a neutral quota authority governing every writer, not a URL hash or HTTP 2xx.
+            try {
+                // oxlint-disable-next-line no-await-in-loop
+                await this.post(candidate);
+            }
+            finally {
+                // Expiry starts after response/error/abort, never before COMMIT or connect/TLS.
+                state.settle();
+            }
+            // Re-read ACKs and all groups after transport I/O; a snapshot must not wake already consumed mail.
+            return Date.now();
         }
-        const next = entries.find((entry) => !entry.acknowledged && Date.now() - entry.receivedAt >= FALLBACK_AFTER_MS);
-        if (next) {
-            // One fallback wakes the box to drain the remaining mailbox; never flood a reset VM.
-            await this.post(next);
-            return;
-        }
-        this.backoff = POLL_MS;
+        return next;
     }
-    async post(entry) {
-        if (!this.authorized()) {
+    async post({ delivery, entry }) {
+        const policy = delivery.identity.wake;
+        if (!policy || !this.authorized(delivery)) {
             return;
         }
-        const fields = { name: this.name, messageId: entry.message.id };
+        const fields = { name: delivery.identity.name, messageId: entry.message.id };
         try {
-            const response = await fetch(this.policy.url, {
+            const response = await fetch(policy.url, {
                 method: "POST",
                 redirect: "error",
-                headers: {
-                    Authorization: `Bearer ${this.policy.key}`,
-                    "Content-Type": "application/json",
-                },
+                headers: { Authorization: `Bearer ${policy.key}`, "Content-Type": "application/json" },
                 body: JSON.stringify({
                     from: entry.from.name ?? entry.from.id,
                     from_id: entry.from.id,
-                    to: this.name,
+                    to: delivery.identity.name,
                     message_id: entry.message.id,
                     ask_id: entry.message.expectsReply === true ? entry.message.id : null,
                     text: entry.message.content.text,
                 }),
-                signal: AbortSignal.any([this.controller.signal, AbortSignal.timeout(10000)]),
+                signal: AbortSignal.any([
+                    this.controller.signal,
+                    delivery.controller.signal,
+                    AbortSignal.timeout(10000),
+                ]),
             });
             await response.body?.cancel();
-            if (response.ok && !this.controller.signal.aborted && this.authorized()) {
-                // HTTP acceptance cannot prove durable intake; the same ID remains pending until inbox ACK.
-                this.backoff = MAX_BACKOFF_MS;
-                log("wake_delivery", { ...fields, result: "accepted" });
-            }
-            else {
-                this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF_MS);
-                log("wake_delivery", { ...fields, result: "http_rejected", status: response.status });
-            }
+            // Acceptance does not consume mail or reset uncertainty: only real inbox ACK retires intent.
+            log("wake_delivery", {
+                ...fields,
+                result: response.ok ? "accepted" : "http_rejected",
+                status: response.status,
+            });
         }
         catch {
-            this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF_MS);
             if (!this.controller.signal.aborted) {
                 log("wake_delivery", { ...fields, result: "transport_unconfirmed" });
             }
         }
     }
-    async stop() {
-        this.controller.abort();
-        clearTimeout(this.timer);
-        await this.running;
-    }
-}
-export class WakeDeliveries {
-    stateDir;
-    allowed;
-    deliveries = new Map();
-    cleanup = new Set();
-    constructor(stateDir, allowed) {
-        this.stateDir = stateDir;
-        this.allowed = allowed;
-    }
-    session(identity, expires) {
-        if (!identity.wake ||
-            this.stateDir === undefined ||
-            this.deliveries.has(identity.fingerprint256)) {
-            return;
-        }
-        const mailbox = new Mailbox(this.stateDir, identity.fingerprint256, true);
-        const worker = new WakeDelivery(identity.name, mailbox, identity.wake, () => this.allowed(identity) && expires > Date.now());
-        this.deliveries.set(identity.fingerprint256, { identity, mailbox, worker });
-        worker.start();
-    }
     drop(fp) {
         const delivery = this.deliveries.get(fp);
-        if (!delivery) {
-            return;
-        }
         this.deliveries.delete(fp);
-        const cleanup = delivery.worker
-            .stop()
-            .then(() => delivery.mailbox.close())
-            .catch(() => {
-            log("wake_delivery", { name: delivery.identity.name, result: "cleanup_failed" });
-        })
-            .finally(() => {
-            this.cleanup.delete(cleanup);
-        });
-        this.cleanup.add(cleanup);
+        delivery?.controller.abort();
+        delivery?.mailbox.close();
+        // Membership removal alone is not an ACK. Reload restores proof-backed replacements first.
+        this.changed(false);
     }
     reload() {
         for (const [fp, delivery] of this.deliveries) {
@@ -148,11 +234,16 @@ export class WakeDeliveries {
                 this.drop(fp);
             }
         }
+        this.changed(false);
     }
     async stop() {
-        for (const fp of this.deliveries.keys()) {
-            this.drop(fp);
+        this.controller.abort();
+        clearTimeout(this.timer);
+        await this.running;
+        for (const delivery of this.deliveries.values()) {
+            delivery.mailbox.close();
         }
-        await Promise.all(this.cleanup);
+        this.deliveries.clear();
+        this.state?.close();
     }
 }

package/dist/pi-intercom/bridge.js

@@ -7,12 +7,21 @@ import { loadConfig, sameListener } from "./bridge-config.js";
 import { ASK_TIMEOUT, Fault, fingerprint, log } from "./bridge-protocol.js";
 import { Session } from "./bridge-session.js";
 import { operationFor, routeFor } from "./bridge-routes.js";
-import { reply } from "./bridge-http.js";
-import { Launcher, sameIdentity } from "./bridge-launch.js";
+import { reply, replyFault } from "./bridge-http.js";
+import { sameIdentity } from "./bridge-launch.js";
+import { BridgeOperations } from "./bridge-operations.js";
+import { authenticatedCertificateChain } from "./native-control-auth.js";
 import { PersistentPresence } from "./bridge-presence.js";
 import { WakeDeliveries } from "./bridge-wake.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
 const MAX_CONNECTIONS = 128;
+const LONG_ROUTES = new Set([
+    "POST /v1/start",
+    "POST /v1/spawn",
+    "POST /v1/resume",
+    "GET /v1/transcript",
+    "POST /v1/transcript",
+]);
 function validCertificateDates(starts, expires) {
     return (Number.isFinite(starts) &&
         Number.isFinite(expires) &&
@@ -24,7 +33,7 @@ class Bridge {
     configPath;
     sessions = new Map();
     losses = new Map();
-    launcher = new Launcher();
+    operations;
     sockets = new Set();
     connections = new Map();
     server;
@@ -35,11 +44,13 @@ class Bridge {
     constructor(config, configPath) {
         this.config = config;
         this.configPath = configPath;
+        this.operations = new BridgeOperations(config.stateDir);
         this.deliveries = new WakeDeliveries(config.stateDir, (identity) => this.allowed(identity));
         if (config.stateDir !== undefined) {
             this.presence = new PersistentPresence({
                 stateDir: config.stateDir,
                 clients: () => this.config.clients,
+                restored: (identity, expires) => this.deliveries.session(identity, expires),
                 connect: async (identity, expires) => {
                     await spawnBrokerIfNeeded(process.execPath, []);
                     if (!this.allowed(identity)) {
@@ -122,6 +133,7 @@ class Bridge {
             session = new Session({
                 stateDir: this.config.stateDir,
                 notifications: identity.wake !== undefined,
+                mailboxChanged: () => this.deliveries.changed(),
                 allowed: (candidate) => this.allowed(candidate),
                 lost: (fp, count) => this.lost(fp, count),
                 losses: (fp) => this.losses.get(fp) ?? 0,
@@ -221,13 +233,13 @@ class Bridge {
             }
             this.config = next;
             this.revokeRemoved();
-            this.launcher.revoke(next.clients).catch(() => log("launch_cleanup", { result: "failed" }));
+            this.operations.revoke(next.clients).catch(() => log("launch_cleanup", { result: "failed" }));
             log("allowlist_reloaded", { result: "accepted", clients: next.clients.size });
         }
         catch {
             this.config = { ...this.config, clients: new Map() };
             this.deliveries.reload();
-            this.launcher
+            this.operations
                 .revoke(this.config.clients)
                 .catch(() => log("launch_cleanup", { result: "failed" }));
             for (const session of this.sessions.values()) {
@@ -257,6 +269,9 @@ class Bridge {
                 this.losses.delete(fp);
             }
         }
+        // Retire stale sessions before publishing replacement delivery membership for the same pin.
+        this.presence?.restoreAll();
+        this.deliveries.changed();
     }
     stop() {
         this.shutdown().catch(() => {
@@ -280,7 +295,7 @@ class Bridge {
         await Promise.all([
             ...this.handlers,
             ...sessions.map((session) => session.settled()),
-            this.launcher.shutdown(),
+            this.operations.shutdown(),
             this.presence?.stop(),
             this.deliveries.stop(),
         ]);
@@ -302,7 +317,11 @@ class Bridge {
             this.drop(connection.fingerprint, fault);
             throw fault;
         }
-        return { identity, expires: connection.expires };
+        return {
+            identity,
+            expires: connection.expires,
+            certificate: authenticatedCertificateChain(socket),
+        };
     }
     async handle(req, res) {
         const requestId = randomUUID();
@@ -311,7 +330,9 @@ class Bridge {
         let controller;
         let deadline;
         let peer;
-        const abort = () => session?.close(new Fault(499, "client_aborted", "HTTP client disconnected; delivery may be unknown."));
+        let readOnlyInbox = false;
+        const cancel = (fault) => readOnlyInbox ? controller?.abort(fault) : session?.close(fault);
+        const abort = () => cancel(new Fault(499, "client_aborted", "HTTP client disconnected; delivery may be unknown."));
         const onClose = () => {
             if (!res.writableFinished) {
                 abort();
@@ -319,26 +340,31 @@ class Bridge {
         };
         const setDeadline = (ms) => {
             clearTimeout(deadline);
-            deadline = setTimeout(() => session?.close(new Fault(504, "request_timeout", "HTTP operation deadline exceeded; delivery may be unknown.")), Math.max(1, ms - (Date.now() - started)));
+            deadline = setTimeout(() => cancel(new Fault(504, "request_timeout", "HTTP operation deadline exceeded; delivery may be unknown.")), Math.max(1, ms - (Date.now() - started)));
         };
         try {
-            const { identity, expires } = this.admission(req);
+            const { identity, expires, certificate } = this.admission(req);
             const route = routeFor(req);
+            readOnlyInbox = route === "GET /v1/inbox";
             session = this.session(identity, expires);
             controller = session.begin();
             const signal = controller.signal;
             req.once("aborted", abort);
             res.once("close", onClose);
             const duration = route === "POST /v1/ask" ? ASK_TIMEOUT + 15000 : 15000;
-            setDeadline(route === "POST /v1/start" ? 75000 : duration);
+            setDeadline(LONG_ROUTES.has(route) ? 75000 : duration);
             const operation = await operationFor(req, route, signal);
             if (operation.route === "POST /v1/ask") {
                 setDeadline(operation.timeoutMs + 15000);
             }
-            const data = await this.execute(operation, session, {
+            else if (operation.route === "GET /v1/transcript") {
+                setDeadline(75000);
+            }
+            const data = await this.operations.execute(operation, session, {
                 signal,
                 requestId,
                 expires,
+                certificate,
                 onPeer: (id) => {
                     peer = id;
                 },
@@ -352,10 +378,7 @@ class Bridge {
                 ? error
                 : new Fault(503, "broker_unavailable", "Local broker operation failed.");
             log("request", { ...session?.fields(), requestId, peer, result: fault.code });
-            reply(res, requestId, fault.status, {
-                ok: false,
-                error: { code: fault.code, message: fault.message, ...fault.details },
-            });
+            replyFault(res, requestId, fault);
         }
         finally {
             clearTimeout(deadline);
@@ -366,29 +389,6 @@ class Bridge {
             }
         }
     }
-    async execute(operation, session, context) {
-        switch (operation.route) {
-            case "POST /v1/start":
-                return this.launcher.start(operation.name, {
-                    identity: session.identity,
-                    expires: context.expires,
-                    signal: context.signal,
-                    peers: (signal) => session.connectedPeers(signal),
-                });
-            case "GET /v1/sessions":
-                return this.launcher.list(session.identity);
-            case "POST /v1/stop":
-                return this.launcher.stop(session.identity, operation.sessionId);
-            case "GET /v1/list":
-            case "GET /v1/inbox":
-            case "POST /v1/register":
-            case "POST /v1/ask":
-            case "POST /v1/send":
-            case "POST /v1/reply":
-            case "POST /v1/ack":
-                return session.execute(operation, context);
-        }
-    }
 }
 function main() {
     const args = process.argv.slice(2);

package/dist/pi-intercom/broker/client.js

@@ -320,6 +320,7 @@ export class IntercomClient extends EventEmitter {
             expectsReply: options.expectsReply,
             ...(options.human ? { human: options.human } : {}),
             ...(options.topic ? { topic: options.topic } : {}),
+            ...(options.control ? { control: options.control } : {}),
             delivery: messageDelivery(options),
             queueMode: options.queueMode,
             threadId: options.threadId,

package/dist/pi-intercom/connection.js

@@ -1,8 +1,7 @@
-import { createHash } from "node:crypto";
 import { IntercomClient } from "./broker/client.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
 import { asError, errorMessage } from "./validation.js";
-import { formatTargetOptions, resolveSessionTarget } from "./session-targets.js";
+import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./session-targets.js";
 /** Owns socket registration, coalesced connects and the reconnect/startup timers. */
 export class IntercomConnection {
     client = null;
@@ -195,7 +194,7 @@ export class IntercomConnection {
             if (reason !== "peer-awareness") {
                 await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
             }
-            await next.connect(await this.lifecycle.registration(this.hooks.pendingAsks()), `pi-${createHash("sha256").update(sessionId).digest("hex").slice(0, 32)}`);
+            await next.connect(await this.lifecycle.registration(this.hooks.pendingAsks()), nativePeerId(sessionId));
             if (!this.lifecycle.live(ctx, generation)) {
                 await next.disconnect();
                 throw new Error("Intercom runtime no longer active");

package/dist/pi-intercom/inbound.js

@@ -1,7 +1,7 @@
-import { createHash } from "node:crypto";
 import { requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.js";
 import { formatAttachments } from "./message-format.js";
 import { readQuestionOwner } from "../runs/shared/supervisor-questions.js";
+import { nativePeerId } from "./session-targets.js";
 /** Validates origin and chooses admission; state/resources remain in their owners. */
 export class IntercomInbound {
     lifecycle;
@@ -19,9 +19,7 @@ export class IntercomInbound {
             return false;
         }
         const owner = readQuestionOwner(origin.runId);
-        return (owner?.sessionId === origin.ownerSessionId &&
-            from.id ===
-                `pi-${createHash("sha256").update(origin.ownerSessionId).digest("hex").slice(0, 32)}`);
+        return (owner?.sessionId === origin.ownerSessionId && from.id === nativePeerId(origin.ownerSessionId));
     }
     normalize(from, input) {
         const message = input.topic

package/dist/pi-intercom/index.js

@@ -8,6 +8,7 @@ import { InboundDeliveryOwner } from "./inbound-delivery.js";
 import { ReplyWait } from "./reply-wait.js";
 import { IntercomConnection } from "./connection.js";
 import { IntercomInbound } from "./inbound.js";
+import { NativeControls } from "./native-control.js";
 import { IntercomOutbound } from "./outbound.js";
 import { IntercomInspection } from "./inspection.js";
 import { IntercomTopicActions } from "./topic-actions.js";
@@ -31,7 +32,11 @@ export default function piIntercomExtension(pi) {
     const connection = new IntercomConnection(lifecycle, config, topics, {
         restoring: () => delivery.restoring,
         pendingAsks: () => replies.listPending().length,
-        incoming: (ctx, from, message) => inbound.receive(ctx, from, message),
+        incoming: async (ctx, from, message) => {
+            if (!(await controls.receive(ctx, from, message))) {
+                await inbound.receive(ctx, from, message);
+            }
+        },
         peerLeft: (id) => {
             wait.peerDisconnected(id);
             journal.peerLeft(id);
@@ -42,6 +47,7 @@ export default function piIntercomExtension(pi) {
             }
         },
     });
+    const controls = new NativeControls(lifecycle, connection);
     const delivery = new InboundDeliveryOwner(pi, lifecycle, journal, {
         replies,
         syncStatus: () => connection.syncStatus(),