@fitchmultz/pi-subagents 0.49.1 → 0.51.0

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

@@ -1,4 +1,5 @@
 import { formatSessionTarget, resolveSessionTarget, shortSessionId } from "./session-targets.js";
+import { RecoveryError } from "./tool-results.js";
 function resolveBySenderTarget(contexts, to) {
     const sessions = contexts.map((context) => context.from);
     const resolution = resolveSessionTarget(sessions, to);
@@ -23,20 +24,17 @@ 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 !== "") {
-        throw new Error(tooShort);
+        throw new RecoveryError("ambiguous_reply_target", tooShort);
     }
     return resolveBySenderTarget(contexts, to);
 }
 function explicitReply(contexts, replyTo, to) {
     const target = contexts.find((context) => context.message.id === replyTo);
     if (!target) {
-        throw new Error(`No pending ask with replyTo "${replyTo}"`);
+        throw new RecoveryError("no_pending_reply", `No pending ask with replyTo "${replyTo}"`);
     }
     if (to !== "" &&
         !matchingSender(contexts, to).some((context) => context.message.id === target.message.id)) {
@@ -50,9 +48,9 @@ function replyBySender(contexts, to) {
         return matches[0];
     }
     if (matches.length > 1) {
-        throw new Error(`Multiple pending asks from "${to}" — use one of: ${pendingSenderOptions(matches, contexts)}.`);
+        throw new RecoveryError("ambiguous_reply_target", `Multiple pending asks from "${to}" — use one of: ${pendingSenderOptions(matches, contexts)}.`);
     }
-    throw new Error(`No pending ask from "${to}"`);
+    throw new RecoveryError("no_pending_reply", `No pending ask from "${to}"`);
 }
 export class ReplyTracker {
     pendingAsks = new Map();
@@ -104,7 +102,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)) {
@@ -154,19 +152,13 @@ export class ReplyTracker {
             return pending[0];
         }
         if (pending.length === 0) {
-            throw new Error("No active intercom context to reply to");
+            throw new RecoveryError("no_pending_reply", "No active intercom context to reply to");
         }
-        throw new Error("Multiple pending asks — specify `to`");
+        throw new RecoveryError("ambiguous_reply_target", "Multiple pending asks — specify `to`");
     }
     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 +184,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. */
+import { AskDeliveryError, RecoveryError } from "./tool-results.js";
+/** 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 RecoveryError("reply_timeout", `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/session-targets.d.ts

@@ -0,0 +1,24 @@
+export interface TargetIdentity {
+    readonly id: string;
+    readonly name?: string;
+}
+export interface ProjectSessionIdentity extends TargetIdentity {
+    readonly cwd: string;
+    readonly projectId?: string;
+}
+export declare const MIN_SESSION_TARGET_PREFIX_LENGTH = 8;
+export declare function nativePeerId(sessionId: string): string;
+export interface TargetResolution<T extends TargetIdentity> {
+    readonly status: "none" | "found" | "ambiguous" | "prefix_too_short";
+    readonly target?: T;
+    readonly matches: readonly T[];
+}
+export declare function shortSessionId(sessionId: string): string;
+export declare function resolveSessionProjectId(cwd: string): Promise<string>;
+export declare function formatSessionTarget(session: TargetIdentity, allSessions?: readonly TargetIdentity[]): string;
+export declare function formatTargetOptions(sessions: readonly TargetIdentity[], allSessions?: readonly TargetIdentity[]): string;
+export declare function targetDisplayName(session: TargetIdentity, allSessions?: readonly TargetIdentity[]): string;
+export declare 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 declare function filterProjectSessions<T extends ProjectSessionIdentity>(sessions: readonly T[], currentSessionId: string): T[];
+export declare function formatPeerAwarenessHint(sessions: readonly ProjectSessionIdentity[], currentSessionId: string): string | undefined;
+export declare function resolveSessionTarget<T extends TargetIdentity>(sessions: readonly T[], rawTarget: string): TargetResolution<T>;

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,17 @@
-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";
+import { registerCompactMessages, renderCompactResult } from "../shared/compact-cards.js";
+export function registerIntercomTools(pi, tools) {
+    registerCompactMessages(pi, ["intercom_message", "subagent-human-message"]);
     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: "Message connected Pi sessions in your group; mains also reach other mains across projects. List shows target IDs. Ask waits for a correlated reply; reply answers the active or sole pending ask. Pending lists asks; status shows connection and inbound queue. Last pages a peer's last completed response without waking it. Broker acceptance is not recipient persistence, consumption or completion.",
         parameters: intercomSchema,
+        renderResult: renderCompactResult,
         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-results.js

@@ -1,14 +1,12 @@
 export function failureDetails(reasonCode, nextActions, details = {}) {
     return { ...details, reasonCode, nextActions };
 }
-export function replyFailureReason(message) {
-    if (message.startsWith("No active intercom context") || message.startsWith("No pending ask")) {
-        return "no_pending_reply";
-    }
-    if (message.startsWith("Multiple pending asks") || message.includes("too short")) {
-        return "ambiguous_reply_target";
+export class RecoveryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
     }
-    return "reply_failed";
 }
 export function firstTextContent(result) {
     return (result.content

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

@@ -1,82 +1,28 @@
 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"]),
     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.",
-    })),
-    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: "all (default) or project (repo and worktrees)",
     })),
+    to: Type.Optional(Type.String({ description: "Session name or ID" })),
+    message: Type.Optional(Type.String()),
     attachments: Type.Optional(Type.Array(Type.Object({
         type: StringEnum(["file", "snippet", "context"]),
         name: Type.String(),
         content: Type.String(),
         language: Type.Optional(Type.String()),
     }))),
-    replyTo: Type.Optional(Type.String({
-        description: "Message ID to reply to (for threading or responding to an 'ask')",
-    })),
+    replyTo: Type.Optional(Type.String({ description: "Message ID to answer or thread" })),
     delivery: Type.Optional(StringEnum(["queue", "steer", "passive"], {
-        description: "Delivery mode. Omitted send delivery defaults to 'steer', which injects after the current tool call. Use 'queue' only to intentionally wait behind active work; 'passive' does not wake the recipient model.",
+        description: "steer (default) at next tool boundary; queue after active work; passive never wakes the model",
     })),
     queueMode: Type.Optional(StringEnum(["stack", "replace"], {
-        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'." })),
-    passive: Type.Optional(Type.Boolean({
-        description: "For action='send' only: legacy alias for delivery='passive'. Discouraged for agent-to-agent messages.",
+        description: "stack keeps all; replace keeps only the latest per threadId",
     })),
+    threadId: Type.Optional(Type.String()),
+    entryId: Type.Optional(Type.String()),
+    offset: Type.Optional(Type.Integer({ minimum: 0, description: "UTF-16 characters" })),
+    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 16384 })),
+    passive: Type.Optional(Type.Boolean({ description: "Legacy alias for delivery=passive" })),
 });