@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/pi-intercom/reply-wait.js

@@ -0,0 +1,201 @@
+import { RECIPIENT_TURN_FAILED_ATTACHMENT } from "./runtime-types.js";
+import { asError } from "./validation.js";
+import { AskDeliveryError } from "./tool-results.js";
+import { cancelSupervisorQuestion, readQuestionState, saveQuestionAnswer, } from "../runs/shared/supervisor-questions.js";
+/** Owns the single blocking wait, abort listener, timeout and durable polling. */
+export class ReplyWait {
+    waiter = null;
+    pi;
+    lifecycle;
+    timeoutMs;
+    constructor(pi, lifecycle, timeoutMs) {
+        this.pi = pi;
+        this.lifecycle = lifecycle;
+        this.timeoutMs = timeoutMs;
+    }
+    get waiting() {
+        return this.waiter !== null;
+    }
+    get durable() {
+        return this.waiter?.question !== undefined;
+    }
+    isWaitingFor(id) {
+        return this.waiter?.replyTo === id;
+    }
+    retarget(id, from) {
+        if (this.waiter?.replyTo === id) {
+            this.waiter = { ...this.waiter, from };
+        }
+    }
+    clearRetry(id) {
+        if (this.waiter?.replyTo === id) {
+            this.waiter = { ...this.waiter, retryNotification: undefined };
+        }
+    }
+    retry(id, retryNotification) {
+        if (this.waiter?.replyTo === id) {
+            this.waiter = { ...this.waiter, retryNotification };
+        }
+    }
+    reject(error) {
+        this.waiter?.reject(error);
+    }
+    peerDisconnected(id) {
+        if (this.waiter?.from === id && !this.waiter.question) {
+            this.reject(new Error(`Reply peer disconnected before answering: ${id}`));
+        }
+    }
+    receive(sender, message, onMatch) {
+        const { id: from, name } = sender;
+        const waiter = this.waiter;
+        if (!waiter) {
+            return false;
+        }
+        const senderTarget = name !== undefined && name !== "" ? name : from;
+        if ((senderTarget.toLowerCase() !== waiter.from.toLowerCase() && from !== waiter.from) ||
+            message.replyTo !== waiter.replyTo) {
+            return false;
+        }
+        onMatch();
+        waiter.resolve(message);
+        return true;
+    }
+    poll(question, replyTo) {
+        try {
+            const saved = readQuestionState(question);
+            if (saved.state === "cancelled") {
+                this.lifecycle.live()?.abort();
+                this.reject(new Error("Cancelled"));
+                return;
+            }
+            if (saved.answer) {
+                this.waiter?.resolve({
+                    id: replyTo,
+                    replyTo,
+                    timestamp: saved.answer.answeredAt,
+                    content: { text: saved.answer.message },
+                });
+            }
+            else {
+                this.waiter?.retryNotification?.();
+            }
+        }
+        catch (error) {
+            this.reject(asError(error));
+        }
+    }
+    saveAnswer(question, message) {
+        if (!question) {
+            return true;
+        }
+        if (message.content.attachments?.some((attachment) => attachment.name === RECIPIENT_TURN_FAILED_ATTACHMENT) === true) {
+            this.pi.appendEntry("intercom_question_notification_error", {
+                questionId: question.questionId,
+                error: message.content.text,
+            });
+            return false;
+        }
+        saveQuestionAnswer(question, message.content.text);
+        return true;
+    }
+    wait(options) {
+        if (this.waiter) {
+            throw new Error("Already waiting for a reply");
+        }
+        if (options.signal?.aborted === true) {
+            throw new Error("Cancelled");
+        }
+        return new Promise((resolve, reject) => {
+            const { from, replyTo, signal, question } = options;
+            const timeout = question
+                ? undefined
+                : setTimeout(() => {
+                    this.reject(new Error(`No reply from "${from}" within ${Math.max(1, Math.round(this.timeoutMs / 60000))} minute(s)`));
+                }, this.timeoutMs);
+            timeout?.unref();
+            const poll = question
+                ? setInterval(() => {
+                    this.poll(question, replyTo);
+                }, 250)
+                : undefined;
+            const cleanup = () => {
+                clearTimeout(timeout);
+                clearInterval(poll);
+                signal?.removeEventListener("abort", onAbort);
+                if (this.waiter?.replyTo === replyTo) {
+                    this.waiter = null;
+                }
+            };
+            const onAbort = () => {
+                try {
+                    if (question) {
+                        cancelSupervisorQuestion(question);
+                    }
+                }
+                finally {
+                    cleanup();
+                    reject(new Error("Cancelled"));
+                }
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            this.waiter = {
+                from,
+                replyTo,
+                question,
+                resolve: (message) => {
+                    try {
+                        if (!this.saveAnswer(question, message)) {
+                            return;
+                        }
+                        cleanup();
+                        resolve(message);
+                    }
+                    catch (error) {
+                        cleanup();
+                        reject(asError(error));
+                    }
+                },
+                reject: (error) => {
+                    cleanup();
+                    reject(error);
+                },
+            };
+        });
+    }
+    async transact(activeClient, transaction) {
+        const { to, questionId, options, signal, onSent } = transaction;
+        const reply = this.wait({ from: to, replyTo: questionId, signal });
+        // Delivery may reject before the reply is joined; the transaction owns both branches.
+        reply.catch(() => {
+            /* The original error is propagated below after cleanup. */
+        });
+        try {
+            if (signal?.aborted === true) {
+                throw new Error("Cancelled");
+            }
+            const result = await activeClient.send(to, {
+                ...options,
+                messageId: questionId,
+                expectsReply: true,
+            });
+            if (!result.accepted) {
+                throw new AskDeliveryError(result);
+            }
+            this.lifecycle.markActivity();
+            onSent(result);
+            return await reply;
+        }
+        catch (error) {
+            if (this.isWaitingFor(questionId)) {
+                this.reject(asError(error));
+            }
+            try {
+                await reply;
+            }
+            catch {
+                /* Preserve the delivery failure rather than its cleanup rejection. */
+            }
+            throw error;
+        }
+    }
+}

package/dist/pi-intercom/runtime-types.js

@@ -0,0 +1,3 @@
+export const RECIPIENT_TURN_FAILED_ATTACHMENT = "pi-intercom-recipient-turn-failure";
+export const INBOUND_CHECKPOINT_TYPE = "intercom_delivery";
+export const TOPICS_UNAVAILABLE = "Intercom topics are unavailable while an older broker is still running. Direct messaging and active sessions are unchanged. Let its sessions close normally; after it exits, reconnect with the updated package and retry. Nothing was stopped or restarted.";

package/dist/pi-intercom/session-events.js

@@ -0,0 +1,180 @@
+import { isDurableSupervisorQuestion } from "./reply-tracker.js";
+import { RECIPIENT_TURN_FAILED_ATTACHMENT } from "./runtime-types.js";
+import { getAssistantErrorMessage, inboundIdFromCustomMessage } from "./message-format.js";
+import { restoreLazyTools } from "../shared/lazy-tools.js";
+/** Native phase ordering is centralized here; each resource is cleaned by its owner. */
+export class IntercomSessionEvents {
+    pi;
+    owners;
+    constructor(pi, owners) {
+        this.pi = pi;
+        this.owners = owners;
+    }
+    async start(reason, ctx) {
+        const { lifecycle, bridges, awareness, connection, topics, delivery } = this.owners;
+        bridges.start();
+        const generation = lifecycle.start(ctx);
+        awareness?.reset();
+        connection.clearTimers();
+        topics.start(ctx);
+        if (reason !== "reload") {
+            restoreLazyTools(this.pi, ctx, "load_intercom", ["intercom"]);
+        }
+        await delivery.start(ctx, reason, generation);
+        if (lifecycle.live(ctx, generation)) {
+            connection.start(ctx, generation);
+        }
+    }
+    async shutdown() {
+        const { bridges, connection, delivery, wait, lifecycle, replies, journal, supervisor } = this.owners;
+        bridges.stop();
+        connection.clearTimers();
+        delivery.clearTimer();
+        wait.reject(new Error("Session shutting down"));
+        // Reload keeps the outgoing runner valid until native handoff completes.
+        await delivery.drain();
+        lifecycle.invalidate();
+        await Promise.allSettled([connection.shutdown(), bridges.drain(), supervisor?.drain()]);
+        delivery.reset();
+        replies.reset();
+        journal.reset();
+        lifecycle.clear();
+    }
+    consumeMessage(message) {
+        const id = inboundIdFromCustomMessage(message);
+        if (id !== undefined && id !== "") {
+            this.owners.journal.consume(id);
+        }
+    }
+    async messageEnd(message) {
+        const { journal, connection, replies } = this.owners;
+        this.consumeMessage(message);
+        const client = connection.active;
+        const context = replies.currentTurn();
+        const error = getAssistantErrorMessage(message);
+        if (client?.isConnected() !== true ||
+            !context ||
+            context.message.expectsReply !== true ||
+            error === null ||
+            error === "") {
+            return;
+        }
+        try {
+            const result = await client.send(context.from.id, {
+                text: `Recipient turn failed: ${error}`,
+                replyTo: context.message.id,
+                attachments: [{ type: "context", name: RECIPIENT_TURN_FAILED_ATTACHMENT, content: error }],
+            });
+            if (result.delivered && !isDurableSupervisorQuestion(context.message)) {
+                journal.retire(context.message.id);
+            }
+        }
+        catch {
+            /* Best-effort propagation; the recipient's local error remains visible. */
+        }
+    }
+    registerSessionBoundaries() {
+        const { lifecycle, connection, journal, awareness } = this.owners;
+        this.pi.on("session_start", async (event, ctx) => {
+            await this.start(event.reason, ctx);
+        });
+        this.pi.on("session_shutdown", async () => {
+            await this.shutdown();
+        });
+        this.pi.on("session_info_changed", (_event, ctx) => {
+            const id = lifecycle.currentSessionId;
+            if (lifecycle.live(ctx) && id !== null) {
+                connection.syncIdentity(id);
+            }
+        });
+        this.pi.on("session_tree", (_event, ctx) => {
+            if (lifecycle.live(ctx)) {
+                journal.reconcileConsumed(ctx, true);
+            }
+            journal.reconcileTools();
+        });
+        this.pi.on("session_compact", () => {
+            journal.reconcileTools();
+        });
+        this.pi.on("before_agent_start", async (event, ctx) => {
+            await awareness?.beforeStart(event, ctx);
+        });
+        this.pi.on("model_select", (event, ctx) => {
+            if (!lifecycle.live(ctx)) {
+                return;
+            }
+            lifecycle.selectModel(event.model.id);
+            connection.active?.updatePresence({
+                ...lifecycle.identity(ctx.sessionManager.getSessionId()),
+                model: event.model.id,
+                status: lifecycle.status(),
+            });
+        });
+    }
+    registerTurns() {
+        const { lifecycle, connection, replies, journal, delivery } = this.owners;
+        this.pi.on("turn_start", (_event, ctx) => {
+            if (!lifecycle.live(ctx)) {
+                return;
+            }
+            connection.syncIdentity(ctx.sessionManager.getSessionId());
+            replies.beginTurn();
+        });
+        this.pi.on("turn_end", (event) => {
+            if (!lifecycle.live()) {
+                return;
+            }
+            // Pi exposes the next batch, not every custom queued item. Empty proves all cleared.
+            // ponytail: selective queue removal is unobservable; upgrade to a complete native snapshot if added.
+            if (event.context.pendingMessages.length === 0) {
+                journal.clearNative();
+            }
+            replies.endTurn();
+            delivery.schedule(0);
+        });
+        this.pi.on("message_end", async (event) => {
+            await this.messageEnd(event.message);
+        });
+        this.pi.on("agent_start", () => {
+            if (!lifecycle.live()) {
+                return;
+            }
+            lifecycle.agentStart();
+            connection.syncStatus();
+            return delivery.flush();
+        });
+        this.pi.on("agent_settled", async (_event, ctx) => {
+            if (!lifecycle.live(ctx) || ctx.signal) {
+                return;
+            }
+            const generation = lifecycle.generation;
+            lifecycle.agentSettled();
+            replies.endAgent();
+            connection.syncStatus();
+            await delivery.redeliver(ctx, generation);
+            if (lifecycle.live(ctx, generation)) {
+                delivery.schedule(0);
+            }
+        });
+    }
+    register() {
+        this.registerSessionBoundaries();
+        this.registerTurns();
+        const { lifecycle, connection, delivery } = this.owners;
+        this.pi.on("tool_execution_start", (event) => {
+            if (!lifecycle.live()) {
+                return;
+            }
+            lifecycle.toolStart(event.toolCallId, event.toolName);
+            connection.syncStatus();
+        });
+        this.pi.on("tool_execution_end", (event) => {
+            if (!lifecycle.live()) {
+                return;
+            }
+            lifecycle.toolEnd(event.toolCallId);
+            connection.syncStatus();
+            return delivery.flush();
+        });
+    }
+}

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

@@ -22,7 +22,7 @@ function resolveGitCommonDirectory(cwd) {
             timeout: 500,
         }, (error, stdout) => {
             const gitDirectory = error ? "" : stdout.trim();
-            resolve(gitDirectory && !/[\0\r\n]/.test(gitDirectory)
+            resolve(gitDirectory !== "" && !/[\0\r\n]/.test(gitDirectory)
                 ? normalizedPath(path.resolve(cwd, gitDirectory))
                 : undefined);
         });
@@ -30,7 +30,9 @@ function resolveGitCommonDirectory(cwd) {
 }
 export async function resolveSessionProjectId(cwd) {
     const gitDirectory = await resolveGitCommonDirectory(cwd);
-    const identity = gitDirectory ? `git:${gitDirectory}` : `cwd:${normalizedPath(cwd)}`;
+    const identity = gitDirectory !== undefined && gitDirectory !== ""
+        ? `git:${gitDirectory}`
+        : `cwd:${normalizedPath(cwd)}`;
     return createHash("sha256").update(identity).digest("hex");
 }
 function normalizedNames(sessions) {
@@ -53,11 +55,11 @@ export function formatSessionTarget(session, allSessions = [session]) {
 }
 export function formatTargetOptions(sessions, allSessions = sessions) {
     return sessions
-        .map((session) => `${session.name || shortSessionId(session.id)} → ${formatSessionTarget(session, allSessions)}`)
+        .map((session) => `${session.name === undefined || session.name === "" ? shortSessionId(session.id) : session.name} → ${formatSessionTarget(session, allSessions)}`)
         .join(", ");
 }
 export function targetDisplayName(session, allSessions = [session]) {
-    if (!session.name?.trim()) {
+    if (session.name === undefined || session.name.trim() === "") {
         return session.id;
     }
     const lowerName = session.name.trim().toLowerCase();
@@ -75,54 +77,60 @@ export function targetDisplayName(session, allSessions = [session]) {
 export const PEER_AWARENESS_HINT = `Other Pi sessions may be connected to this project. Use load_intercom({}) if needed, then intercom({ action: "list" }) before changing shared state or coordinating known overlapping work. Routine standalone read-only tasks do not need a peer check. Coordinate only when work overlaps; use subagent controls for managed child runs.`;
 export function filterProjectSessions(sessions, currentSessionId) {
     const current = sessions.find((session) => session.id === currentSessionId);
-    if (!current)
+    if (!current) {
         return [];
-    return sessions.filter((session) => session.id === currentSessionId
-        || session.cwd === current.cwd
-        || Boolean(current.projectId && session.projectId && session.projectId === current.projectId));
+    }
+    return sessions.filter((session) => session.id === currentSessionId ||
+        session.cwd === current.cwd ||
+        (current.projectId !== undefined &&
+            current.projectId !== "" &&
+            session.projectId !== undefined &&
+            session.projectId !== "" &&
+            session.projectId === current.projectId));
 }
 export function formatPeerAwarenessHint(sessions, currentSessionId) {
     return filterProjectSessions(sessions, currentSessionId).some((session) => session.id !== currentSessionId)
         ? PEER_AWARENESS_HINT
         : undefined;
 }
+function matchedTargets(matches) {
+    if (matches.length === 1) {
+        return { status: "found", target: matches[0], matches };
+    }
+    return matches.length > 1 ? { status: "ambiguous", matches } : { status: "none", matches: [] };
+}
+function shortTargetResolution(names, prefixes) {
+    if (names.length === 0) {
+        return {
+            status: "prefix_too_short",
+            matches: prefixes,
+            minLength: MIN_SESSION_TARGET_PREFIX_LENGTH,
+        };
+    }
+    const byId = new Map();
+    for (const session of [...names, ...prefixes]) {
+        byId.set(session.id, session);
+    }
+    return matchedTargets([...byId.values()]);
+}
 export function resolveSessionTarget(sessions, rawTarget) {
     const target = rawTarget.trim();
     const lowerTarget = target.toLowerCase();
     const exactIdMatches = sessions.filter((session) => session.id.toLowerCase() === lowerTarget);
-    if (exactIdMatches.length === 1) {
-        return { status: "found", target: exactIdMatches[0], matches: exactIdMatches };
-    }
-    if (exactIdMatches.length > 1) {
-        return { status: "ambiguous", matches: exactIdMatches };
+    if (exactIdMatches.length > 0) {
+        return matchedTargets(exactIdMatches);
     }
     const nameMatches = sessions.filter((session) => session.name?.trim().toLowerCase() === lowerTarget);
     const allPrefixMatches = sessions.filter((session) => session.id.toLowerCase().startsWith(lowerTarget));
     const prefixMatches = target.length >= MIN_SESSION_TARGET_PREFIX_LENGTH ? allPrefixMatches : [];
-    if (target.length > 0 && target.length < MIN_SESSION_TARGET_PREFIX_LENGTH && allPrefixMatches.length > 0) {
-        if (nameMatches.length > 0) {
-            const matchesById = new Map();
-            for (const session of [...nameMatches, ...allPrefixMatches]) {
-                matchesById.set(session.id, session);
-            }
-            const matches = Array.from(matchesById.values());
-            if (matches.length === 1) {
-                return { status: "found", target: matches[0], matches };
-            }
-            return { status: "ambiguous", matches };
-        }
-        return { status: "prefix_too_short", matches: allPrefixMatches, minLength: MIN_SESSION_TARGET_PREFIX_LENGTH };
+    if (target.length > 0 &&
+        target.length < MIN_SESSION_TARGET_PREFIX_LENGTH &&
+        allPrefixMatches.length > 0) {
+        return shortTargetResolution(nameMatches, allPrefixMatches);
     }
     const matchesById = new Map();
     for (const session of [...nameMatches, ...prefixMatches]) {
         matchesById.set(session.id, session);
     }
-    const matches = Array.from(matchesById.values());
-    if (matches.length === 1) {
-        return { status: "found", target: matches[0], matches };
-    }
-    if (matches.length > 1) {
-        return { status: "ambiguous", matches };
-    }
-    return { status: "none", matches: [] };
+    return matchedTargets(Array.from(matchesById.values()));
 }