@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/pi-intercom/inbound.js

@@ -1,7 +1,5 @@
-import { requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.js";
+import { requestedDelivery } 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;
@@ -12,29 +10,6 @@ export class IntercomInbound {
         this.config = config;
         this.owners = owners;
     }
-    ownedHuman(from, message) {
-        const origin = message.human;
-        const child = this.owners.child;
-        if (!origin || !child || origin.runId !== child.runId || origin.index !== Number(child.index)) {
-            return false;
-        }
-        const owner = readQuestionOwner(origin.runId);
-        return (owner?.sessionId === origin.ownerSessionId && from.id === nativePeerId(origin.ownerSessionId));
-    }
-    normalize(from, input) {
-        const message = input.topic
-            ? {
-                ...input,
-                content: {
-                    ...input.content,
-                    text: `Topic ${input.topic.topic} · ${input.topic.event}\n${input.content.text}`,
-                },
-            }
-            : input;
-        return message.human && !this.ownedHuman(from, message)
-            ? { ...message, human: undefined }
-            : message;
-    }
     entry(from, message) {
         const attachments = message.content.attachments;
         return {
@@ -70,83 +45,30 @@ export class IntercomInbound {
         }
         return true;
     }
-    async busyNonInteractive(entry, ctx, generation) {
-        if (entry.message.expectsReply !== true) {
-            this.owners.delivery.send(entry, "steer", generation);
-            return;
-        }
-        const active = this.owners.connection.active;
-        if (entry.message.replyTo !== undefined || active?.isConnected() !== true) {
-            return;
-        }
-        try {
-            const result = await active.send(entry.from.id, {
-                text: "This agent is running in non-interactive mode and cannot respond to intercom messages while it is working. It will continue its current task and exit when done.",
-                replyTo: entry.message.id,
-            });
-            if (result.delivered && this.lifecycle.live(ctx, generation)) {
-                this.owners.replies.markReplied(entry.message.id);
-                this.lifecycle.markActivity();
-                this.owners.connection.syncStatus();
-            }
-        }
-        catch {
-            /* Best-effort busy reply; the non-interactive task must continue either way. */
-        }
-    }
-    async prepareBusy(entry, ctx, generation) {
-        if (!isBlockingSupervisorMessage(entry)) {
-            return true;
-        }
-        const willDeliver = ctx.hasUI || requestedDelivery(entry.message) !== "auto";
-        if (willDeliver) {
-            this.owners.journal.remember(entry, "queued", "auto");
-        }
-        await this.owners.delivery.detach(entry);
-        return (this.lifecycle.live(ctx, generation) !== null &&
-            (!willDeliver || this.owners.journal.get(entry.message.id)?.stage === "queued"));
-    }
-    async steerBusy(entry, generation) {
-        this.owners.delivery.send(entry, "steer", generation);
-        if (!isBlockingSupervisorMessage(entry)) {
-            await this.owners.delivery.detach(entry, true);
-        }
-    }
     async admit(entry, live, generation) {
         const active = this.lifecycle.live(live, generation);
         if (!active || this.queueAdmission(entry, active)) {
             return;
         }
         if (!this.lifecycle.isIdle(active)) {
-            await this.busy(entry, active, generation);
+            this.busy(entry, generation);
             return;
         }
         if (this.lifecycle.live(live, generation)) {
             this.owners.delivery.send(entry, requestedDelivery(entry.message) === "passive" ? "passive" : "trigger", generation);
         }
     }
-    async busy(entry, ctx, generation) {
+    busy(entry, generation) {
         const delivery = requestedDelivery(entry.message);
-        if (!(await this.prepareBusy(entry, ctx, generation))) {
-            return;
-        }
         if (delivery === "steer") {
-            await this.steerBusy(entry, generation);
+            this.owners.delivery.send(entry, "steer", generation);
             return;
         }
-        if (delivery === "queue" && entry.message.queueMode !== "replace") {
+        if (delivery === "queue") {
             this.owners.delivery.send(entry, "followUp", generation);
             return;
         }
-        if (delivery === "passive") {
-            this.owners.delivery.queue(entry, "passive");
-            return;
-        }
-        if (!ctx.hasUI) {
-            await this.busyNonInteractive(entry, ctx, generation);
-            return;
-        }
-        this.owners.delivery.queue(entry, "auto");
+        this.owners.delivery.queue(entry, "passive");
     }
     async receive(ctx, from, input) {
         const generation = this.lifecycle.generation;
@@ -155,11 +77,20 @@ export class IntercomInbound {
             await restore;
         }
         const live = this.lifecycle.live(ctx, generation);
-        if (!live || this.owners.topics.receive(from, input)) {
+        if (!live) {
+            return;
+        }
+        if (input.guard && !this.lifecycle.accepts(input.guard)) {
+            return;
+        }
+        // Peer metadata never grants user authority.
+        const message = input.human ? { ...input, human: undefined } : input;
+        const entry = this.entry(from, message);
+        if (!this.owners.journal.owns(entry)) {
             return;
         }
-        const message = this.normalize(from, input);
         if (this.owners.wait.receive(from, message, () => {
+            this.owners.journal.consume(message.id);
             this.lifecycle.markActivity();
             this.owners.connection.syncStatus();
         })) {
@@ -168,10 +99,6 @@ export class IntercomInbound {
         this.owners.replies.recordIncomingMessage(from, message);
         this.lifecycle.markActivity();
         this.owners.connection.syncStatus();
-        const entry = this.entry(from, message);
-        if (this.owners.journal.discardObsolete(entry)) {
-            return;
-        }
         await this.admit(entry, live, generation);
     }
 }

package/dist/pi-intercom/index.js

@@ -1,81 +1,51 @@
 import { loadConfig } from "./config.js";
-import { readChildOrchestratorMetadata } from "./identity.js";
+import { readIntercomLineage } from "./identity.js";
 import { ReplyTracker } from "./reply-tracker.js";
-import { IntercomTopics } from "./topics.js";
 import { IntercomLifecycle } from "./lifecycle.js";
 import { InboundJournal } from "./inbound-journal.js";
 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";
-import { IntercomSupervisor } from "./supervisor.js";
 import { IntercomTools } from "./tools.js";
-import { IntercomOverlay } from "./ui/overlay.js";
-import { SubagentEventBridges } from "./subagent-events.js";
 import { IntercomSessionEvents } from "./session-events.js";
-import { PeerAwareness } from "./peer-awareness.js";
-import { registerMessageRenderers } from "./ui/message-renderers.js";
 import { registerIntercomTools } from "./tool-registration.js";
 export default function piIntercomExtension(pi) {
     const config = loadConfig();
-    const child = readChildOrchestratorMetadata();
-    const lifecycle = new IntercomLifecycle(pi, config);
+    const lifecycle = new IntercomLifecycle(pi, config, readIntercomLineage());
     const replies = new ReplyTracker(config.askTimeoutMs);
-    const topics = new IntercomTopics(pi, () => lifecycle.live());
     const journal = new InboundJournal(pi, lifecycle, replies);
-    const wait = new ReplyWait(pi, lifecycle, config.askTimeoutMs);
-    // Hooks are invoked only after construction, at a native session or event boundary.
-    const connection = new IntercomConnection(lifecycle, config, topics, {
+    const wait = new ReplyWait(lifecycle, config.askTimeoutMs);
+    const connection = new IntercomConnection(lifecycle, config, {
         restoring: () => delivery.restoring,
         pendingAsks: () => replies.listPending().length,
-        incoming: async (ctx, from, message) => {
-            if (!(await controls.receive(ctx, from, message))) {
-                await inbound.receive(ctx, from, message);
-            }
-        },
+        receipt: (query) => journal.receipt(query),
+        incoming: (ctx, from, message) => inbound.receive(ctx, from, message),
         peerLeft: (id) => {
             wait.peerDisconnected(id);
             journal.peerLeft(id);
         },
         disconnected: (error) => {
-            if (!wait.durable) {
-                wait.reject(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
-            }
+            wait.reject(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
         },
     });
-    const controls = new NativeControls(lifecycle, connection);
     const delivery = new InboundDeliveryOwner(pi, lifecycle, journal, {
         replies,
         syncStatus: () => connection.syncStatus(),
     });
+    lifecycle.registerContextEvents(() => connection.syncStatus());
     const inbound = new IntercomInbound(lifecycle, config, {
-        journal,
         delivery,
+        journal,
         replies,
         wait,
         connection,
-        topics,
-        child,
     });
     const outbound = new IntercomOutbound({ pi, lifecycle, connection, replies, wait }, config);
     const inspection = new IntercomInspection(journal, replies);
-    const topicActions = new IntercomTopicActions({ pi, lifecycle, connection, topics });
-    const tools = new IntercomTools({ connection, outbound, topicActions, topics, inspection });
-    const supervisor = child
-        ? new IntercomSupervisor({ pi, lifecycle, connection, wait }, child)
-        : null;
-    const overlay = new IntercomOverlay({ pi, lifecycle, connection, topics });
-    const bridges = new SubagentEventBridges(lifecycle, connection, delivery, {
-        pi,
-        journal,
-        open: (ctx, scope) => overlay.open(ctx, scope),
-    });
-    const awareness = child ? null : new PeerAwareness(connection, lifecycle);
-    bridges.start();
+    const tools = new IntercomTools({ connection, outbound, inspection });
     new IntercomSessionEvents(pi, {
         lifecycle,
         connection,
@@ -83,12 +53,6 @@ export default function piIntercomExtension(pi) {
         journal,
         replies,
         wait,
-        topics,
-        bridges,
-        supervisor,
-        awareness,
     }).register();
-    registerMessageRenderers(pi);
-    registerIntercomTools(pi, tools, supervisor);
-    overlay.register(config.shortcut);
+    registerIntercomTools(pi, tools);
 }

package/dist/pi-intercom/last-message.js

@@ -0,0 +1,46 @@
+import { isLastMessageQuery, LAST_MESSAGE_PAGE_LIMIT, } from "./types.js";
+function completedResponse(manager, entryId) {
+    for (const entry of manager.getBranch().reverse()) {
+        if (entry.type === "message" &&
+            entry.message.role === "assistant" &&
+            (entry.message.stopReason === "stop" || entry.message.stopReason === "length") &&
+            (entryId === undefined || entry.id === entryId)) {
+            return {
+                id: entry.id,
+                text: entry.message.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n"),
+            };
+        }
+    }
+    return;
+}
+/** Reads finalized native history only; no model invocation or synthesized response. */
+export function readLastMessage(manager, session, query) {
+    const offset = query.offset ?? 0;
+    const limit = query.limit ?? LAST_MESSAGE_PAGE_LIMIT;
+    if (!isLastMessageQuery({ offset, limit })) {
+        return {
+            error: "Invalid last response page: offset must be non-negative and limit must be 1–16384.",
+        };
+    }
+    const response = completedResponse(manager, query.entryId);
+    if (!response) {
+        return query.entryId !== undefined
+            ? { error: "Requested completed assistant response is not on the active session branch." }
+            : { session, entryId: null, text: "", offset: 0, totalLength: 0 };
+    }
+    if (offset > response.text.length) {
+        return { error: "Last response offset exceeds its length." };
+    }
+    const end = Math.min(response.text.length, offset + limit);
+    return {
+        session,
+        entryId: response.id,
+        text: response.text.slice(offset, end),
+        offset,
+        totalLength: response.text.length,
+        ...(end < response.text.length ? { nextOffset: end } : {}),
+    };
+}

package/dist/pi-intercom/lifecycle.js

@@ -1,21 +1,32 @@
+import { randomUUID } from "node:crypto";
 import { buildPresenceIdentity } from "./identity.js";
 import { resolveSessionProjectId } from "./session-targets.js";
+import { isContextTarget, } from "./types.js";
+import { isRecord, safeLabel } from "./validation.js";
+export function isContextRequest(value) {
+    return isRecord(value) && typeof value.respond === "function";
+}
 /** Owns native context validity and occupancy, never journal or socket state. */
 export class IntercomLifecycle {
     context = null;
     sessionId = null;
     model = "unknown";
     disposed = true;
-    started = false;
     epoch = 0;
+    incarnation = null;
+    peerId = null;
+    guardedDelivery = false;
+    applicationGuard;
     running = false;
     activity = 0;
     tools = new Map();
     pi;
     config;
-    constructor(pi, config) {
+    lineage;
+    constructor(pi, config, lineage) {
         this.pi = pi;
         this.config = config;
+        this.lineage = lineage;
     }
     get generation() {
         return this.epoch;
@@ -23,22 +34,90 @@ export class IntercomLifecycle {
     get currentSessionId() {
         return this.sessionId;
     }
-    get runtimeStarted() {
-        return this.started;
-    }
     get toolCount() {
         return this.tools.size;
     }
+    registerContextEvents(sync) {
+        this.pi.events.on("pi-intercom:context-query", (request) => this.contextRequest(request));
+        this.pi.events.on("pi-intercom:application-guard", (request) => this.contextRequest(request, sync));
+    }
+    contextRequest(request, sync) {
+        if (!isContextRequest(request)) {
+            return;
+        }
+        if (request.version !== 1) {
+            request.respond({ error: "unsupported_version" });
+            return;
+        }
+        if (sync) {
+            if (!isContextTarget(request.target) ||
+                !this.matches(request.target) ||
+                !(request.revision === null ||
+                    (typeof request.revision === "string" && safeLabel(request.revision)))) {
+                request.respond({ error: "context_changed" });
+                return;
+            }
+            this.applicationGuard = request.revision === null ? undefined : request.revision;
+            sync();
+            this.publishContext();
+        }
+        request.respond(this.snapshot());
+    }
+    snapshot() {
+        if (!this.live()) {
+            return {
+                version: 1,
+                rootSessionId: null,
+                peerId: null,
+                incarnation: null,
+                connected: false,
+                guardedDelivery: null,
+            };
+        }
+        return {
+            version: 1,
+            rootSessionId: this.lineage?.rootSessionId ?? this.sessionId,
+            parentSessionId: this.lineage?.parentSessionId,
+            peerId: this.peerId,
+            incarnation: this.incarnation,
+            connected: this.peerId !== null,
+            guardedDelivery: this.guardedDelivery ? 1 : null,
+            applicationGuard: this.applicationGuard,
+        };
+    }
+    publishContext() {
+        this.pi.events.emit("pi-intercom:context-state", this.snapshot());
+    }
+    transport(peerId, guardedDelivery = false) {
+        this.peerId = peerId;
+        this.guardedDelivery = guardedDelivery;
+        this.publishContext();
+    }
+    matches(target) {
+        const current = this.snapshot();
+        return (current.connected &&
+            current.rootSessionId === target.rootSessionId &&
+            current.peerId === target.peerId &&
+            current.incarnation === target.incarnation);
+    }
+    accepts(guard) {
+        return (this.guardedDelivery &&
+            this.lineage?.parentSessionId === undefined &&
+            this.matches(guard) &&
+            this.applicationGuard === guard.applicationGuard);
+    }
     start(ctx) {
         this.disposed = false;
-        this.started = true;
         this.epoch += 1;
         this.context = ctx;
         this.sessionId = ctx.sessionManager.getSessionId();
+        this.incarnation = randomUUID();
+        this.applicationGuard = undefined;
         this.model = ctx.model?.id ?? "unknown";
         this.running = false;
         this.activity = 0;
         this.tools.clear();
+        this.transport(null);
         return this.epoch;
     }
     invalidate() {
@@ -46,6 +125,7 @@ export class IntercomLifecycle {
         this.epoch += 1;
         this.running = false;
         this.tools.clear();
+        this.publishContext();
     }
     clear() {
         this.context = null;
@@ -70,18 +150,6 @@ export class IntercomLifecycle {
             return null;
         }
     }
-    notify(ctx, message, level, generation = this.epoch) {
-        const live = this.live(ctx, generation);
-        if (live?.hasUI !== true) {
-            return;
-        }
-        try {
-            live.ui.notify(message, level);
-        }
-        catch {
-            // The UI may disappear while an asynchronous overlay settles during shutdown.
-        }
-    }
     isIdle(ctx) {
         // ponytail: Pi 1.0 has no busy signal during foreign prompt preparation.
         if (this.running || this.tools.size > 0) {
@@ -115,7 +183,11 @@ export class IntercomLifecycle {
         this.activity = Date.now();
     }
     identity(sessionId) {
-        return buildPresenceIdentity(this.pi, sessionId);
+        return {
+            ...buildPresenceIdentity(this.pi, sessionId),
+            rootSessionId: this.lineage?.rootSessionId ?? sessionId,
+            parentSessionId: this.lineage?.parentSessionId,
+        };
     }
     status() {
         const tool = this.tools.values().next().value;
@@ -140,29 +212,17 @@ export class IntercomLifecycle {
         if (!live || this.sessionId === null) {
             throw new Error("Intercom runtime not initialized");
         }
-        const cwd = live.cwd;
         return {
             ...this.identity(this.sessionId),
-            cwd,
+            incarnation: this.incarnation ?? undefined,
+            guardedDelivery: 1,
+            applicationGuard: this.applicationGuard,
+            cwd: live.cwd,
             model: this.model,
-            projectId: await resolveSessionProjectId(cwd),
+            projectId: await resolveSessionProjectId(live.cwd),
             lastSeen: Date.now(),
             status: this.status(),
             ...this.health(pendingAsks),
         };
     }
-    targetMatches(to, resolvedTo, brokerId) {
-        const targets = [
-            this.sessionId,
-            brokerId,
-            this.pi.getSessionName(),
-            this.sessionId === null ? undefined : this.identity(this.sessionId).name,
-        ];
-        return ((resolvedTo !== undefined &&
-            resolvedTo !== null &&
-            brokerId !== undefined &&
-            brokerId !== null &&
-            resolvedTo === brokerId) ||
-            targets.some((target) => target?.trim().toLowerCase() === to.trim().toLowerCase()));
-    }
 }

package/dist/pi-intercom/message-format.js

@@ -33,37 +33,6 @@ export function previewText(value, maxLength = 72) {
     }
     return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
 }
-function metadataField(text, pattern) {
-    return text.match(pattern)?.[1]?.trim();
-}
-function namedPreview(label, value) {
-    return value === undefined || value === "" ? undefined : `${label}=${value}`;
-}
 export function pendingAskPreview(message) {
-    const text = message.content.text;
-    const normalized = text.replace(/\s+/g, " ").trim();
-    if (!text.startsWith("Subagent needs a supervisor decision.") &&
-        !text.startsWith("Subagent requests a structured supervisor interview.")) {
-        return previewText(normalized, 180) ?? normalized;
-    }
-    const run = metadataField(text, /^Run:\s*(.+)$/m);
-    const agent = metadataField(text, /^Agent:\s*(.+)$/m);
-    const target = metadataField(text, /^Child intercom target:\s*(.+)$/m);
-    const body = text
-        .split(/\n\s*\n/)
-        .slice(1)
-        .join(" ")
-        .replace(/\s+/g, " ")
-        .trim();
-    return [
-        text.startsWith("Subagent requests")
-            ? "structured supervisor interview"
-            : "supervisor decision",
-        namedPreview("run", run),
-        namedPreview("agent", agent),
-        namedPreview("target", target),
-        namedPreview("question", previewText(body, 180)),
-    ]
-        .filter((part) => part !== undefined)
-        .join(" · ");
+    return previewText(message.content.text, 180) ?? message.content.text;
 }

package/dist/pi-intercom/outbound.js

@@ -3,7 +3,7 @@ import { resolveConnectedTarget, resolvePeerHealth, } from "./connection.js";
 import { RECIPIENT_TURN_FAILED_ATTACHMENT, } from "./runtime-types.js";
 import { errorMessage } from "./validation.js";
 import { formatAttachments } from "./message-format.js";
-import { AskDeliveryError, failureDetails, replyFailureReason, } from "./tool-results.js";
+import { AskDeliveryError, failureDetails, RecoveryError, } from "./tool-results.js";
 import { sendOptions, toolError, toolText } from "./tool-arguments.js";
 export class IntercomOutbound {
     owners;
@@ -101,8 +101,7 @@ export class IntercomOutbound {
             return this.sent(to, params, result);
         }
         catch (error) {
-            const text = errorMessage(error);
-            return toolError(`Failed to send: ${text}`, failureDetails(text.startsWith("Target ") ? "ambiguous_target" : "send_failed", [
+            return toolError(`Failed to send: ${errorMessage(error)}`, failureDetails(error instanceof RecoveryError ? error.code : "send_failed", [
                 { action: "list" },
                 { action: "send", guidance: "Retry with an exact active recipient target." },
             ], { error: true }));
@@ -147,15 +146,7 @@ export class IntercomOutbound {
             const result = this.deliveryFailure(to, error.result);
             return { ...result, details: { ...result.details, error: true } };
         }
-        const text = errorMessage(error);
-        let reason = "ask_failed";
-        if (text.startsWith("No reply from")) {
-            reason = "reply_timeout";
-        }
-        else if (text.startsWith("Target ")) {
-            reason = "ambiguous_target";
-        }
-        return toolError(`Failed: ${text}`, failureDetails(reason, [
+        return toolError(`Failed: ${errorMessage(error)}`, failureDetails(error instanceof RecoveryError ? error.code : "ask_failed", [
             { action: "status" },
             { action: "list" },
             {
@@ -184,10 +175,18 @@ export class IntercomOutbound {
         return this.busyAsk(request.to, result);
     }
     async prepareAsk(active, to, signal) {
-        const target = (await resolveConnectedTarget(active, to)) ?? to;
+        const target = await resolveConnectedTarget(active, to);
         if (this.isCancelled(signal)) {
             return { error: toolError("Cancelled") };
         }
+        if (target === null) {
+            return {
+                error: toolError(`Ask to "${to}" was not sent: connected session not found.`, failureDetails("delivery_failed", [
+                    { action: "list" },
+                    { action: "send", guidance: "Retry with an exact active recipient target." },
+                ], { accepted: false, delivered: false })),
+            };
+        }
         if (target === active.sessionId) {
             return { error: toolError("Cannot message the current session") };
         }
@@ -285,8 +284,7 @@ export class IntercomOutbound {
         }
     }
     replyFailure(error, replyTo) {
-        const text = errorMessage(error);
-        const reason = replyFailureReason(text);
+        const reason = error instanceof RecoveryError ? error.code : "reply_failed";
         const actions = reason === "no_pending_reply"
             ? [
                 { action: "pending" },
@@ -296,7 +294,7 @@ export class IntercomOutbound {
                 },
             ]
             : [{ action: "pending" }, { action: "list" }];
-        return toolError(`Failed to reply: ${text}`, failureDetails(reason, actions, {
+        return toolError(`Failed to reply: ${errorMessage(error)}`, failureDetails(reason, actions, {
             error: true,
             ...((replyTo ?? "") !== "" ? { replyTo } : {}),
         }));