@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/pi-intercom/lifecycle.js

@@ -6,16 +6,17 @@ export class IntercomLifecycle {
     sessionId = null;
     model = "unknown";
     disposed = true;
-    started = false;
     epoch = 0;
     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,15 +24,11 @@ export class IntercomLifecycle {
     get currentSessionId() {
         return this.sessionId;
     }
-    get runtimeStarted() {
-        return this.started;
-    }
     get toolCount() {
         return this.tools.size;
     }
     start(ctx) {
         this.disposed = false;
-        this.started = true;
         this.epoch += 1;
         this.context = ctx;
         this.sessionId = ctx.sessionManager.getSessionId();
@@ -70,18 +67,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 +100,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;
@@ -151,18 +140,4 @@ export class IntercomLifecycle {
             ...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

@@ -184,10 +184,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") };
         }

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

@@ -23,9 +23,6 @@ function pendingSenderOptions(contexts, allContexts = contexts) {
         .map((context) => `${context.from.name === undefined || context.from.name === "" ? shortSessionId(context.from.id) : context.from.name}: to: ${JSON.stringify(formatSessionTarget(context.from, allSenders))} or replyTo: ${JSON.stringify(context.message.id)}`)
         .join(", ");
 }
-export function isDurableSupervisorQuestion(message) {
-    return message.content.text.includes(`Question ID: ${message.id}`);
-}
 function matchingSender(contexts, to) {
     const tooShort = tooShortSenderTargetMessage(contexts, to);
     if (tooShort !== null && tooShort !== "") {
@@ -104,7 +101,7 @@ export class ReplyTracker {
         this.activeAgentContext = null;
     }
     expireSender(sessionId) {
-        const expires = (context) => context.from.id === sessionId && !isDurableSupervisorQuestion(context.message);
+        const expires = (context) => context.from.id === sessionId;
         let expired = 0;
         for (const [messageId, context] of this.pendingAsks) {
             if (expires(context)) {
@@ -161,12 +158,6 @@ export class ReplyTracker {
     markReplied(replyTo) {
         this.removeContext(replyTo);
     }
-    get hasReplyContext() {
-        return (this.pendingAsks.size > 0 ||
-            this.pendingTurnContexts.length > 0 ||
-            this.currentTurnContext !== null ||
-            this.activeAgentContext !== null);
-    }
     listPending(now = Date.now()) {
         this.pruneExpired(now);
         return Array.from(this.pendingAsks.values()).sort((a, b) => a.receivedAt - b.receivedAt);
@@ -192,8 +183,7 @@ export class ReplyTracker {
     }
     pruneExpired(now) {
         for (const [messageId, context] of this.pendingAsks) {
-            if (!isDurableSupervisorQuestion(context.message) &&
-                now - context.receivedAt > this.askTimeoutMs) {
+            if (now - context.receivedAt > this.askTimeoutMs) {
                 this.removeContext(messageId);
             }
         }

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

@@ -1,103 +1,37 @@
-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. */
+/** One correlated blocking wait; admitted before send so a fast reply cannot race it. */
 export class ReplyWait {
     waiter = null;
-    pi;
     lifecycle;
     timeoutMs;
-    constructor(pi, lifecycle, timeoutMs) {
-        this.pi = pi;
+    constructor(lifecycle, timeoutMs) {
         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) {
+        if (this.waiter?.from === id) {
             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) {
+        if (!waiter || sender.id !== 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");
@@ -106,54 +40,29 @@ export class ReplyWait {
             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 { from, replyTo, signal } = options;
+            const timeout = 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 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"));
-                }
+                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));
-                    }
+                    cleanup();
+                    resolve(message);
                 },
                 reject: (error) => {
                     cleanup();
@@ -165,9 +74,9 @@ export class ReplyWait {
     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.
+        // A delivery failure may reject before its reply branch is joined.
         reply.catch(() => {
-            /* The original error is propagated below after cleanup. */
+            // The transaction joins this branch after settling delivery.
         });
         try {
             if (signal?.aborted === true) {
@@ -193,7 +102,7 @@ export class ReplyWait {
                 await reply;
             }
             catch {
-                /* Preserve the delivery failure rather than its cleanup rejection. */
+                // Preserve the delivery failure rather than its cleanup rejection.
             }
             throw error;
         }

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

@@ -1,3 +1,2 @@
 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

@@ -1,7 +1,5 @@
-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;
@@ -11,30 +9,23 @@ export class IntercomSessionEvents {
         this.owners = owners;
     }
     async start(reason, ctx) {
-        const { lifecycle, bridges, awareness, connection, topics, delivery } = this.owners;
-        bridges.start();
+        const { lifecycle, connection, delivery } = this.owners;
         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();
+        const { connection, delivery, wait, lifecycle, replies, journal } = this.owners;
         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()]);
+        await connection.shutdown();
         delivery.reset();
         replies.reset();
         journal.reset();
@@ -65,7 +56,7 @@ export class IntercomSessionEvents {
                 replyTo: context.message.id,
                 attachments: [{ type: "context", name: RECIPIENT_TURN_FAILED_ATTACHMENT, content: error }],
             });
-            if (result.delivered && !isDurableSupervisorQuestion(context.message)) {
+            if (result.delivered) {
                 journal.retire(context.message.id);
             }
         }
@@ -74,7 +65,7 @@ export class IntercomSessionEvents {
         }
     }
     registerSessionBoundaries() {
-        const { lifecycle, connection, journal, awareness } = this.owners;
+        const { lifecycle, connection, journal } = this.owners;
         this.pi.on("session_start", async (event, ctx) => {
             await this.start(event.reason, ctx);
         });
@@ -91,13 +82,6 @@ export class IntercomSessionEvents {
             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)) {

package/dist/pi-intercom/tool-arguments.js

@@ -57,6 +57,10 @@ function queueError(params) {
     return;
 }
 export function validateIntercomArguments(params) {
+    if ((params.entryId !== undefined || params.offset !== undefined || params.limit !== undefined) &&
+        params.action !== "last") {
+        return toolError("'entryId', 'offset', and 'limit' are only valid for action='last'");
+    }
     if (params.scope !== undefined && params.action !== "list" && params.action !== "status") {
         return toolError("'scope' is only valid for action='list' or action='status'");
     }

package/dist/pi-intercom/tool-registration.js

@@ -1,95 +1,14 @@
-import { Type } from "../shared/native-typebox.js";
-import { activateTools } from "../shared/lazy-tools.js";
 import { throwIfToolError } from "./tool-results.js";
-import { intercomSchema, contactSupervisorSchema } from "./tool-schemas.js";
-import { renderContactCall, renderContactResult, renderIntercomCall, renderIntercomResult, } from "./ui/tool-renderers.js";
-function nativeResult(result) {
-    const success = throwIfToolError(result);
-    return { content: [...success.content], details: success.details, isError: false };
-}
-function registerContact(pi, supervisor) {
-    pi.registerTool({
-        name: "contact_supervisor",
-        label: "Contact Supervisor",
-        description: "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision only when this child cannot safely continue without a decision, approval, or product/API/scope clarification; this steers the supervisor at its next tool boundary and keeps the child alive for the reply. Use interview_request only when multiple structured answers are all required before safe progress; this also steers and waits. Use progress_update only for a discovery or change the supervisor needs while working; it steers at the next tool boundary without waiting for a reply. Skip starts, redundant status, and routine completion; retain material findings in the final result.",
-        promptSnippet: "Subagent-only: steer the supervisor for required decisions, structured interviews, or material discoveries needed during active work. Skip routine status and completion messages.",
-        promptGuidelines: [
-            "Use contact_supervisor with reason='need_decision' when a subagent cannot safely continue without a decision, approval, or product/API/scope clarification; it steers the supervisor and waits for the reply.",
-            "Use contact_supervisor with reason='interview_request' only when the child cannot safely continue until it receives multiple structured answers in one blocking steered exchange.",
-            "Use contact_supervisor with reason='progress_update' only for a discovery or change the supervisor needs while working. It steers at the next tool boundary without waiting. Skip starts, redundant narration, and routine completion; keep material findings in the final result.",
-            "Do not use contact_supervisor for routine completion handoffs; return the final subagent result normally.",
-        ],
-        parameters: contactSupervisorSchema,
-        async execute(_id, params, signal, _update, ctx) {
-            return nativeResult(await supervisor.execute(params, signal, ctx));
-        },
-        renderCall: renderContactCall,
-        renderResult: renderContactResult,
-    });
-}
-function registerLoader(pi) {
-    pi.registerTool({
-        name: "load_intercom",
-        label: "Load Intercom",
-        description: "Enable local peer coordination: list/check sessions before shared-state work, send or reply to messages, and inspect/publish topics. Does not send a message or check peers itself.",
-        parameters: Type.Object({}),
-        async execute() {
-            if (!pi.getAllTools().some((tool) => tool.name === "intercom" && tool.namespace === undefined)) {
-                throw new Error("Intercom is excluded from this session.");
-            }
-            activateTools(pi, ["intercom"]);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Intercom enabled. Use intercom({action:'list'}) to check peers, or status, pending, reply, send, ask and topics for coordination.",
-                    },
-                ],
-                details: {},
-            };
-        },
-    });
-}
-function registerMessaging(pi, tools) {
+import { intercomSchema } from "./tool-schemas.js";
+export function registerIntercomTools(pi, tools) {
     pi.registerTool({
         name: "intercom",
-        defaultActive: false,
         label: "Intercom",
-        description: `Send a message to another pi session running on this machine.
-Use this to communicate findings, request help, or coordinate work with other sessions.
-Non-blocking send defaults to steer for guidance, answers, corrections, or blockers that may affect active work. Use queue only when delay is intentional; use ask only when this process must remain alive waiting for the reply.
-
-Usage:
-  intercom({ action: "list" })                    → List sessions in this repository and its worktrees
-  intercom({ action: "list", scope: "all" })      → List connected sessions across every project
-  intercom({ action: "send", to: "session-name", message: "..." })  → Send live coordination (defaults to steer)
-  intercom({ action: "ask", to: "session-name", delivery: "steer", message: "..." })   → Blocking wait only when sender must stay alive
-  intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
-  intercom({ action: "pending" })                                      → List unresolved inbound asks
-  intercom({ action: "status" })                  → Show connection status
-  intercom({ action: "subscribe", topic: "project/work", awaitRelease: true }) → Opt into a topic
-  intercom({ action: "publish", topic: "project/work", message: "Current self-contained state" }) → Quiet latest state
-  intercom({ action: "topics" }) → Inspect topics and current resource owners`,
-        promptSnippet: "Coordinate with local Pi sessions. Non-blocking send defaults to steer for live agent guidance; queue only for intentional delay and ask only for a required blocking reply.",
-        promptGuidelines: [
-            "Intercom list/status defaults to the current Git repository and its worktrees. Use scope='all' only when intentionally discovering sessions in other projects.",
-            "Action='send' defaults to delivery='steer' for agent-to-agent guidance, answers, corrections, blockers, or other context that may affect active work.",
-            "Use delivery='queue' only when delay is intentional. For routine status, explicitly subscribe/publish topics: updates replace quiet inspectable state outside model context, not passive conversation messages. Topic blockers/decisions and awaited ownership releases interrupt; direct messages always bypass subscriptions.",
-            "Treat inbound steered messages as supplemental coordination within the active task: incorporate relevant context and continue; replace the task only when the message explicitly says so.",
-            "Use action='reply' for an active inbound ask. Otherwise respond with send plus steer; use blocking ask only when this process must stay alive and cannot safely continue without the answer.",
-        ],
+        description: "Discover and message connected Pi sessions in your collaboration group; main sessions can also reach other mains, across projects. Use list for unambiguous targets. Send defaults to steer at the next tool boundary; queue defers; passive never wakes the model. Ask waits for a correlated reply; reply answers the active or single pending ask (specify replyTo when ambiguous). Pending lists asks; status shows connection and inbound queue state. Last reads a peer's original completed assistant response without waking it; page using entryId and nextOffset. Broker acceptance is not recipient persistence, consumption, or task completion.",
         parameters: intercomSchema,
         async execute(_id, params, signal, _update, ctx) {
-            return nativeResult(await tools.execute(params, signal, ctx));
+            const result = throwIfToolError(await tools.execute(params, signal, ctx));
+            return { content: [...result.content], details: result.details };
         },
-        renderCall: renderIntercomCall,
-        renderResult: renderIntercomResult,
     });
 }
-export function registerIntercomTools(pi, tools, supervisor) {
-    if (supervisor) {
-        registerContact(pi, supervisor);
-    }
-    registerLoader(pi);
-    registerMessaging(pi, tools);
-}

package/dist/pi-intercom/tool-schemas.js

@@ -1,64 +1,17 @@
 import { StringEnum } from "@earendil-works/pi-ai";
-import { Type } from "../shared/native-typebox.js";
-export const contactSupervisorSchema = Type.Object({
-    reason: StringEnum(["need_decision", "progress_update", "interview_request"], {
-        description: "Contact reason: 'need_decision' and 'interview_request' steer the supervisor and wait for a reply; 'progress_update' steers a material discovery without waiting for a reply",
-    }),
-    message: Type.Optional(Type.String({
-        description: "Decision request, optional interview note, or meaningful progress update for the supervisor",
-    })),
-    interview: Type.Optional(Type.Object({
-        title: Type.Optional(Type.String()),
-        description: Type.Optional(Type.String()),
-        questions: Type.Array(Type.Object({
-            id: Type.String(),
-            type: StringEnum(["single", "multi", "text", "image", "info"], {
-                description: "Question type: single, multi, text, image, or info",
-            }),
-            question: Type.String(),
-            options: Type.Optional(Type.Array(Type.Unknown())),
-            context: Type.Optional(Type.String()),
-        })),
-    }, { description: "Structured interview request for reason='interview_request'" })),
-});
+import { Type } from "../agent/typebox.js";
 export const intercomSchema = Type.Object({
-    action: StringEnum([
-        "list",
-        "send",
-        "ask",
-        "reply",
-        "pending",
-        "status",
-        "subscribe",
-        "unsubscribe",
-        "publish",
-        "topics",
-    ], {
-        description: "Direct messages: list/send/ask/reply/pending/status. Quiet state: subscribe/unsubscribe/publish/topics.",
+    action: StringEnum(["list", "send", "ask", "reply", "pending", "status", "last"], {
+        description: "List, send, ask, reply, pending asks, connection status, or last completed assistant response.",
     }),
     scope: Type.Optional(StringEnum(["project", "all"], {
-        description: "For list/status: 'project' (default) shows this Git repository and its worktrees; 'all' includes sessions in other projects.",
+        description: "For list/status: 'all' (default) includes every reachable session; 'project' further filters this repository and its worktrees.",
     })),
     to: Type.Optional(Type.String({
         description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
     })),
-    topic: Type.Optional(Type.String({
-        description: "Exact opt-in topic for subscribe/unsubscribe/publish/topics; no automatic subscriptions.",
-    })),
-    event: Type.Optional(StringEnum(["update", "blocker", "decision", "release"], {
-        description: "Publish: update is quiet current state. Blockers/decisions interrupt subscribers; release interrupts only those awaiting release.",
-    })),
-    resource: Type.Optional(Type.String({
-        description: "Publish: resource this session is using (advisory ownership, not a lock).",
-    })),
-    ownership: Type.Optional(StringEnum(["held", "released"], {
-        description: "Publish: this session's declared resource state. Disconnect never implies released.",
-    })),
-    awaitRelease: Type.Optional(Type.Boolean({
-        description: "Subscribe: interrupt when this topic explicitly releases ownership.",
-    })),
     message: Type.Optional(Type.String({
-        description: "Message for send/ask/reply, or self-contained latest state for publish",
+        description: "Message for send/ask/reply",
     })),
     attachments: Type.Optional(Type.Array(Type.Object({
         type: StringEnum(["file", "snippet", "context"]),
@@ -76,6 +29,13 @@ export const intercomSchema = Type.Object({
         description: "For delivery='queue': 'stack' keeps all messages; 'replace' keeps only the latest undelivered message for the same threadId.",
     })),
     threadId: Type.Optional(Type.String({ description: "Stable topic key for queueMode='replace'." })),
+    entryId: Type.Optional(Type.String({ description: "Last response entry ID for stable paging." })),
+    offset: Type.Optional(Type.Integer({ minimum: 0, description: "Last response character offset (UTF-16)." })),
+    limit: Type.Optional(Type.Integer({
+        minimum: 1,
+        maximum: 16384,
+        description: "Last response page size; default/max 16384 characters.",
+    })),
     passive: Type.Optional(Type.Boolean({
         description: "For action='send' only: legacy alias for delivery='passive'. Discouraged for agent-to-agent messages.",
     })),