@fitchmultz/pi-subagents 0.49.1 → 0.51.0

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

@@ -1,17 +1,15 @@
 import { spawn } from "child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { mkdir } from "fs/promises";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import net from "net";
 import { getPiAgentDir } from "../agent-dir.js";
-import { getBrokerSocketPath, getLegacyBrokerSocketPath, isOwnedBrokerSocket } from "./paths.js";
+import { getBrokerRuntimeDir, getBrokerSocketPath, getPreviousBrokerSocketPaths, isOwnedBrokerSocket, prepareBrokerSocketPath, } from "./paths.js";
 import { isBrokerPidReused } from "./pid.js";
 import { errorMessage, hasErrorCode } from "../../shared/unknown.js";
-const INTERCOM_DIR = join(getPiAgentDir(), "intercom");
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-const BROKER_PID = join(INTERCOM_DIR, "broker.pid");
-const BROKER_SPAWN_LOCK = join(INTERCOM_DIR, "broker.spawn.lock");
+const BROKER_PID = join(getBrokerRuntimeDir(), "broker.pid");
+const BROKER_SPAWN_LOCK = join(getBrokerRuntimeDir(), "broker.spawn.lock");
 function sleep(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
@@ -47,7 +45,8 @@ function toError(error) {
     return error instanceof Error ? error : new Error(errorMessage(error));
 }
 export async function spawnBrokerIfNeeded(brokerCommand, brokerArgs) {
-    await mkdir(INTERCOM_DIR, { recursive: true });
+    prepareBrokerSocketPath();
+    await warnPreviousBroker();
     if (await isBrokerRunning()) {
         return;
     }
@@ -102,13 +101,19 @@ export async function spawnBrokerIfNeeded(brokerCommand, brokerArgs) {
 export async function isBrokerRunning() {
     return checkSocketConnectable();
 }
-function readLivePid() {
-    if (!existsSync(BROKER_PID)) {
+export async function assertBrokerCanStart() {
+    if (await isBrokerRunning()) {
+        throw new Error("Intercom broker is already running; refusing to replace its socket.");
+    }
+    await stopUnhealthyBrokerBeforeSpawn();
+}
+function readLivePid(pidPath) {
+    if (!existsSync(pidPath)) {
         return null;
     }
     let raw;
     try {
-        raw = readFileSync(BROKER_PID, "utf-8");
+        raw = readFileSync(pidPath, "utf-8");
     }
     catch {
         return null;
@@ -125,23 +130,34 @@ function readLivePid() {
     }
     return isBrokerPidReused(pid, raw) ? null : pid;
 }
+async function warnPreviousBroker() {
+    const previousSockets = getPreviousBrokerSocketPaths();
+    for (const socketPath of previousSockets) {
+        // Migration probes are sequential and never register or send to old peers.
+        // oxlint-disable-next-line no-await-in-loop
+        if (isOwnedBrokerSocket(socketPath) && (await checkOneSocket(socketPath))) {
+            console.warn("An older agent-directory Intercom broker is still running. Its peers are not part of shared same-user discovery until they reload with the updated extension. Existing sessions and accepted work are untouched; no legacy fallback is used.");
+            return;
+        }
+    }
+    const previousPid = readLivePid(join(getPiAgentDir(), "intercom", "broker.pid"));
+    if (previousPid !== null) {
+        console.warn(`Older Intercom broker PID ${previousPid} may still own accepted work. Its peers need to reload with the updated extension to join shared same-user discovery. Nothing was stopped or replaced; no legacy fallback is used.`);
+    }
+}
 export async function stopUnhealthyBrokerBeforeSpawn() {
     if (await checkSocketConnectable()) {
         return;
     }
-    const pid = readLivePid();
+    const pid = readLivePid(BROKER_PID);
     if (pid === null) {
         return;
     }
     throw new Error(`Intercom broker PID ${pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`);
 }
 async function checkSocketConnectable() {
-    const preferred = getBrokerSocketPath();
-    if (isOwnedBrokerSocket(preferred) && (await checkOneSocket(preferred))) {
-        return true;
-    }
-    const legacy = getLegacyBrokerSocketPath();
-    return legacy !== preferred && isOwnedBrokerSocket(legacy) && (await checkOneSocket(legacy));
+    const socketPath = getBrokerSocketPath();
+    return isOwnedBrokerSocket(socketPath) && (await checkOneSocket(socketPath));
 }
 function checkOneSocket(brokerSocket) {
     return new Promise((resolve) => {

package/dist/pi-intercom/broker/targets.d.ts

@@ -0,0 +1,9 @@
+import type { SessionInfo } from "../types.ts";
+export declare function canSeeSession(from: SessionInfo, target: SessionInfo): boolean;
+export declare function assertMainParent(session: Omit<SessionInfo, "id">, sessions: ReadonlyMap<string, {
+    readonly info: SessionInfo;
+}>): void;
+/** Preserve exact-ID precedence and case-insensitive duplicate-name ambiguity. */
+export declare function findSessions<T extends {
+    readonly info: SessionInfo;
+}>(sessions: ReadonlyMap<string, T>, nameOrId: string, fromId: string): T[];

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

@@ -0,0 +1,24 @@
+import { nativePeerId } from "../session-targets.js";
+export function canSeeSession(from, target) {
+    return ((from.rootSessionId ?? from.id) === (target.rootSessionId ?? target.id) ||
+        (from.parentSessionId === undefined && target.parentSessionId === undefined));
+}
+export function assertMainParent(session, sessions) {
+    if (session.parentSessionId !== undefined &&
+        sessions.get(nativePeerId(session.parentSessionId))?.info.parentSessionId !== undefined) {
+        throw new Error("Nested child sessions are not supported.");
+    }
+}
+/** Preserve exact-ID precedence and case-insensitive duplicate-name ambiguity. */
+export function findSessions(sessions, nameOrId, fromId) {
+    const from = sessions.get(fromId);
+    if (!from) {
+        return [];
+    }
+    const byId = sessions.get(nameOrId);
+    if (byId && canSeeSession(from.info, byId.info)) {
+        return [byId];
+    }
+    const lowerName = nameOrId.toLowerCase();
+    return [...sessions.values()].filter((session) => canSeeSession(from.info, session.info) && session.info.name?.toLowerCase() === lowerName);
+}

package/dist/pi-intercom/config.js

@@ -1,10 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { Key } from "@earendil-works/pi-tui";
 import { getPiAgentDir } from "./agent-dir.js";
 import { isRecord, isUnknownArray } from "./validation.js";
 const defaults = {
-    shortcut: Key.altShift("m"),
     brokerCommand: process.execPath,
     brokerArgs: [],
     confirmSend: false,
@@ -13,13 +11,6 @@ const defaults = {
     sendTimeoutMs: 8000,
     listTimeoutMs: 5000,
 };
-const namedKeys = new Set(Object.values(Key).filter((key) => typeof key === "string"));
-function isShortcut(value) {
-    const prefix = value.match(/^(?:(?:ctrl|shift|alt|super)\+)+/)?.[0] ?? "";
-    const modifiers = prefix.split("+").filter(Boolean);
-    const key = value.slice(prefix.length);
-    return (new Set(modifiers).size === modifiers.length && (namedKeys.has(key) || /^[a-z0-9]$/.test(key)));
-}
 function configuredString(parsed, key) {
     if (!Object.hasOwn(parsed, key)) {
         return defaults[key];
@@ -39,19 +30,6 @@ function configuredString(parsed, key) {
 function brokerCommand(parsed) {
     return configuredString(parsed, "brokerCommand") ?? defaults.brokerCommand;
 }
-function configuredShortcut(parsed) {
-    if (!Object.hasOwn(parsed, "shortcut")) {
-        return defaults.shortcut;
-    }
-    if (typeof parsed.shortcut !== "string") {
-        throw new Error('"shortcut" must be a native key identifier');
-    }
-    const shortcut = parsed.shortcut.trim();
-    if (!isShortcut(shortcut)) {
-        throw new Error('"shortcut" must be a native key identifier, for example alt+shift+m');
-    }
-    return shortcut;
-}
 function configuredArgs(parsed) {
     if (!Object.hasOwn(parsed, "brokerArgs")) {
         return defaults.brokerArgs;
@@ -98,7 +76,6 @@ export function loadConfig() {
             throw new Error("Config must be a JSON object");
         }
         return {
-            shortcut: configuredShortcut(parsed),
             brokerCommand: brokerCommand(parsed),
             brokerArgs: configuredArgs(parsed),
             confirmSend: configuredBoolean(parsed, "confirmSend"),

package/dist/pi-intercom/connection.js

@@ -1,6 +1,8 @@
 import { IntercomClient } from "./broker/client.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
-import { asError, errorMessage } from "./validation.js";
+import { readLastMessage } from "./last-message.js";
+import { asError } from "./validation.js";
+import { RecoveryError } from "./tool-results.js";
 import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./session-targets.js";
 /** Owns socket registration, coalesced connects and the reconnect/startup timers. */
 export class IntercomConnection {
@@ -10,32 +12,19 @@ export class IntercomConnection {
     connecting = null;
     connectingGeneration = null;
     attempt = 0;
-    syncError;
     lifecycle;
     config;
-    topics;
     hooks;
-    constructor(lifecycle, config, topics, hooks) {
+    constructor(lifecycle, config, hooks) {
         this.lifecycle = lifecycle;
         this.config = config;
-        this.topics = topics;
         this.hooks = hooks;
     }
     get active() {
         return this.client;
     }
-    get topicSyncError() {
-        return this.syncError;
-    }
-    get isConnecting() {
-        return this.startupTimer !== null || this.connecting !== null;
-    }
-    clearTopicSyncError() {
-        this.syncError = undefined;
-    }
     start(ctx, generation) {
         this.attempt = 0;
-        this.syncError = undefined;
         this.clearTimers();
         this.scheduleStartup(ctx, generation);
     }
@@ -62,7 +51,7 @@ export class IntercomConnection {
             if (!this.lifecycle.live(ctx, generation)) {
                 return;
             }
-            this.ensure("startup").catch(() => {
+            this.ensure().catch(() => {
                 if (!this.lifecycle.live(ctx, generation)) {
                     return;
                 }
@@ -85,7 +74,7 @@ export class IntercomConnection {
                 return;
             }
             this.attempt += 1;
-            this.ensure("background").catch(() => {
+            this.ensure().catch(() => {
                 /* ensure owns the next retry after settlement. */
             });
         }, delay);
@@ -105,6 +94,7 @@ export class IntercomConnection {
             this.client.updatePresence({
                 status: this.lifecycle.status(),
                 ...this.lifecycle.health(this.hooks.pendingAsks()),
+                applicationGuard: this.lifecycle.snapshot().applicationGuard ?? null,
             });
         }
     }
@@ -114,6 +104,30 @@ export class IntercomConnection {
             listTimeoutMs: this.config.listTimeoutMs,
         });
         this.client = next;
+        next.on("last_request", (request) => {
+            const ctx = this.lifecycle.live();
+            const id = next.sessionId;
+            if (this.client !== next || !ctx || id === null) {
+                next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
+                return;
+            }
+            try {
+                if ("messageId" in request.query) {
+                    next.respondLast(request.requestId, this.hooks.receipt(request.query));
+                    return;
+                }
+                next.respondLast(request.requestId, readLastMessage(ctx.sessionManager, {
+                    id,
+                    ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
+                    cwd: ctx.cwd,
+                    model: ctx.model?.id ?? "unknown",
+                    status: this.lifecycle.status(),
+                }, request.query));
+            }
+            catch (error) {
+                next.respondLast(request.requestId, { error: asError(error).message });
+            }
+        });
         next.on("message", (from, message) => {
             const ctx = this.lifecycle.live();
             if (this.client !== next || !ctx) {
@@ -127,7 +141,6 @@ export class IntercomConnection {
             if (this.client !== next) {
                 return;
             }
-            this.topics.disconnected(id);
             this.hooks.peerLeft(id);
         });
         next.on("disconnected", (error) => {
@@ -136,7 +149,7 @@ export class IntercomConnection {
             }
             this.hooks.disconnected(error);
             this.client = null;
-            this.topics.disconnected();
+            this.lifecycle.transport(null);
             this.clearReconnect();
             this.scheduleReconnect();
         });
@@ -145,78 +158,33 @@ export class IntercomConnection {
         });
         return next;
     }
-    async restoreTopics(active) {
-        const changes = [
-            ...[...this.topics.presence().topics].map((topic) => ({
-                action: "restore",
-                topic,
-            })),
-            ...[...this.topics.presence().subscriptions].map((subscription) => ({
-                action: "restore",
-                subscription,
-            })),
-        ];
-        let failure;
-        for (const change of changes) {
-            try {
-                // Restore order preserves publication/subscription admission and bounded transport pressure.
-                // oxlint-disable-next-line no-await-in-loop
-                await active.updateTopics(change);
-            }
-            catch (error) {
-                if (!active.isConnected()) {
-                    throw error;
-                }
-                failure ??= errorMessage(error);
-            }
-        }
-        return failure;
-    }
-    async synchronizeTopics(next, ctx, generation) {
-        if (!next.supportsTopics) {
-            this.topics.disconnected();
-            return;
-        }
-        const failure = await this.restoreTopics(next);
-        const sessions = await next.listSessions();
-        if (!this.lifecycle.live(ctx, generation)) {
-            return;
-        }
-        this.syncError = failure;
-        this.topics.refresh(sessions);
-        if (failure !== undefined && failure !== "" && next.sessionId !== null) {
-            this.topics.disconnected(next.sessionId);
-        }
-    }
-    async connect(reason, ctx, generation, sessionId) {
+    async connect(ctx, generation, sessionId) {
         const next = this.createClient();
         try {
-            if (reason !== "peer-awareness") {
-                await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
-            }
+            await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
             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");
             }
             this.client = next;
+            this.lifecycle.transport(next.sessionId, next.supportsGuardedDelivery);
             this.syncIdentity(ctx.sessionManager.getSessionId());
             this.attempt = 0;
-            await this.synchronizeTopics(next, ctx, generation);
             return next;
         }
         catch (error) {
             if (this.client === next) {
                 this.client = null;
             }
-            // A failed topic snapshot can leave a registered socket alive; the attempt still owns it.
+            // A failed registration still owns its socket.
             await next.disconnect().catch((cleanupError) => {
                 console.error("Intercom failed connection cleanup:", cleanupError);
             });
             throw asError(error);
         }
     }
-    async ensure(reason) {
+    async ensure() {
         const generation = this.lifecycle.generation;
         const restoring = this.hooks.restoring();
         if (restoring) {
@@ -238,7 +206,7 @@ export class IntercomConnection {
         }
         this.clearReconnect();
         // Publish ownership before registration, which can synchronously invoke subscribers.
-        const attempt = Promise.resolve().then(() => this.connect(reason, ctx, generation, sessionId));
+        const attempt = Promise.resolve().then(() => this.connect(ctx, generation, sessionId));
         this.connecting = attempt;
         this.connectingGeneration = generation;
         return await this.finishAttempt(attempt, ctx, generation);
@@ -279,10 +247,10 @@ export async function resolveConnectedTarget(active, name) {
         return resolution.target.id;
     }
     if (resolution.status === "ambiguous") {
-        throw new Error(`Target "${name}" matches multiple sessions. Use one of these targets: ${formatTargetOptions(resolution.matches, sessions)}.`);
+        throw new RecoveryError("ambiguous_target", `Target "${name}" matches multiple sessions. Use one of these targets: ${formatTargetOptions(resolution.matches, sessions)}.`);
     }
     if (resolution.status === "prefix_too_short") {
-        throw new Error(`Target "${name}" is too short. Use the displayed target from intercom list, such as ${formatTargetOptions(resolution.matches, sessions)}.`);
+        throw new RecoveryError("ambiguous_target", `Target "${name}" is too short. Use the displayed target from intercom list, such as ${formatTargetOptions(resolution.matches, sessions)}.`);
     }
     return null;
 }

package/dist/pi-intercom/identity.js

@@ -1,42 +1,18 @@
-function environmentText(name) {
-    return process.env[name]?.trim() ?? "";
-}
-export function readChildOrchestratorMetadata() {
-    const orchestratorTarget = environmentText("PI_SUBAGENT_ORCHESTRATOR_TARGET");
-    const runId = environmentText("PI_SUBAGENT_RUN_ID");
-    const agent = environmentText("PI_SUBAGENT_CHILD_AGENT");
-    const index = environmentText("PI_SUBAGENT_CHILD_INDEX");
-    if ([orchestratorTarget, runId, agent, index].includes("")) {
-        return null;
+// Launches set both variables to the parent's exact native session ID. Absence means a main;
+// anything else is refused, never normalized into a different identity.
+export function readIntercomLineage() {
+    const rootSessionId = process.env.PI_INTERCOM_ROOT_SESSION_ID;
+    const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID;
+    if (rootSessionId === undefined && parentSessionId === undefined) {
+        return;
     }
-    const sessionName = environmentText("PI_SUBAGENT_INTERCOM_SESSION_NAME");
-    return {
-        orchestratorTarget,
-        runId,
-        agent,
-        index,
-        ...(sessionName !== "" ? { sessionName } : {}),
-    };
-}
-export function formatChildOrchestratorMessage(kind, metadata, message) {
-    const headings = {
-        ask: "Subagent needs a supervisor decision.",
-        interview: "Subagent requests a structured supervisor interview.",
-        update: "Subagent progress update.",
-    };
-    return [
-        headings[kind],
-        `Run: ${metadata.runId}`,
-        `Agent: ${metadata.agent}`,
-        `Child index: ${metadata.index}`,
-        metadata.sessionName !== undefined && metadata.sessionName !== ""
-            ? `Child intercom target: ${metadata.sessionName}`
-            : undefined,
-        "",
-        message,
-    ]
-        .filter((line) => line !== undefined)
-        .join("\n");
+    if (rootSessionId === undefined ||
+        rootSessionId === "" ||
+        rootSessionId !== rootSessionId.trim() ||
+        rootSessionId !== parentSessionId) {
+        throw new Error("Child launch requires identical, unpadded root and parent native session IDs.");
+    }
+    return { rootSessionId, parentSessionId };
 }
 export function resolveIntercomPresenceName(sessionName, sessionId) {
     const name = sessionName?.trim();
@@ -49,10 +25,5 @@ export function resolveIntercomPresenceName(sessionName, sessionId) {
     return `subagent-chat-${normalized.slice(0, 8)}`;
 }
 export function buildPresenceIdentity(pi, sessionId) {
-    const name = process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME?.trim();
-    return {
-        name: name !== undefined && name !== ""
-            ? name
-            : resolveIntercomPresenceName(pi.getSessionName(), sessionId),
-    };
+    return { name: resolveIntercomPresenceName(pi.getSessionName(), sessionId) };
 }