@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/pi-intercom/message-format.ts

@@ -39,39 +39,6 @@ export function previewText(value: unknown, maxLength = 72): string | undefined
   }
   return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
 }
-function metadataField(text: string, pattern: Readonly<RegExp>): string | undefined {
-  return text.match(pattern)?.[1]?.trim();
-}
-function namedPreview(label: string, value: string | undefined): string | undefined {
-  return value === undefined || value === "" ? undefined : `${label}=${value}`;
-}
 export function pendingAskPreview(message: Message): string {
-  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/src/pi-intercom/outbound.ts

@@ -284,10 +284,25 @@ export class IntercomOutbound {
     | { readonly target: string; readonly health: SessionInfo | null }
     | { readonly error: ToolResultLike }
   > {
-    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/src/pi-intercom/reply-tracker.ts

@@ -49,10 +49,6 @@ function pendingSenderOptions(
     .join(", ");
 }
 
-export function isDurableSupervisorQuestion(message: Message): boolean {
-  return message.content.text.includes(`Question ID: ${message.id}`);
-}
-
 function matchingSender(
   contexts: readonly IntercomContext[],
   to: string,
@@ -155,8 +151,7 @@ export class ReplyTracker {
   }
 
   expireSender(sessionId: string): number {
-    const expires = (context: IntercomContext) =>
-      context.from.id === sessionId && !isDurableSupervisorQuestion(context.message);
+    const expires = (context: IntercomContext) => context.from.id === sessionId;
     let expired = 0;
     for (const [messageId, context] of this.pendingAsks) {
       if (expires(context)) {
@@ -223,15 +218,6 @@ export class ReplyTracker {
     this.removeContext(replyTo);
   }
 
-  get hasReplyContext(): boolean {
-    return (
-      this.pendingAsks.size > 0 ||
-      this.pendingTurnContexts.length > 0 ||
-      this.currentTurnContext !== null ||
-      this.activeAgentContext !== null
-    );
-  }
-
   listPending(now = Date.now()): IntercomContext[] {
     this.pruneExpired(now);
     return Array.from(this.pendingAsks.values()).sort((a, b) => a.receivedAt - b.receivedAt);
@@ -262,10 +248,7 @@ export class ReplyTracker {
 
   private pruneExpired(now: number): void {
     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/src/pi-intercom/reply-wait.ts

@@ -1,26 +1,14 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
 import type { Message } from "./types.ts";
 import type { IntercomClient, SendResult } from "./broker/client.ts";
 import type { IntercomTransport } from "./transport.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
-import { RECIPIENT_TURN_FAILED_ATTACHMENT } from "./runtime-types.ts";
 import { asError } from "./validation.ts";
 import { AskDeliveryError } from "./tool-results.ts";
-import {
-  cancelSupervisorQuestion,
-  readQuestionState,
-  saveQuestionAnswer,
-  type SupervisorQuestion,
-} from "../runs/shared/supervisor-questions.ts";
-
-type Lifecycle = Readonly<Pick<IntercomLifecycle, "live" | "markActivity">>;
 
+type Lifecycle = Readonly<Pick<IntercomLifecycle, "markActivity">>;
 interface ReplyWaiter {
   readonly from: string;
   readonly replyTo: string;
-  readonly question?: ReadonlyInput<SupervisorQuestion>;
-  readonly retryNotification?: () => void;
   readonly resolve: (message: Message) => void;
   readonly reject: (error: Readonly<Error>) => void;
 }
@@ -28,7 +16,6 @@ export interface ReplyWaitOptions {
   readonly from: string;
   readonly replyTo: string;
   readonly signal?: AbortSignal;
-  readonly question?: ReadonlyInput<SupervisorQuestion>;
 }
 export interface AskTransaction {
   readonly to: string;
@@ -37,46 +24,26 @@ export interface AskTransaction {
   readonly signal?: AbortSignal;
   readonly onSent: (result: SendResult) => void;
 }
-/** 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 {
   private waiter: ReplyWaiter | null = null;
-  private readonly pi: ExtensionAPI;
   private readonly lifecycle: Lifecycle;
   private readonly timeoutMs: number;
-  constructor(pi: ExtensionAPI, lifecycle: Lifecycle, timeoutMs: number) {
-    this.pi = pi;
+  constructor(lifecycle: Lifecycle, timeoutMs: number) {
     this.lifecycle = lifecycle;
     this.timeoutMs = timeoutMs;
   }
   get waiting(): boolean {
     return this.waiter !== null;
   }
-  get durable(): boolean {
-    return this.waiter?.question !== undefined;
-  }
   isWaitingFor(id: string): boolean {
     return this.waiter?.replyTo === id;
   }
-  retarget(id: string, from: string): void {
-    if (this.waiter?.replyTo === id) {
-      this.waiter = { ...this.waiter, from };
-    }
-  }
-  clearRetry(id: string): void {
-    if (this.waiter?.replyTo === id) {
-      this.waiter = { ...this.waiter, retryNotification: undefined };
-    }
-  }
-  retry(id: string, retryNotification: () => void): void {
-    if (this.waiter?.replyTo === id) {
-      this.waiter = { ...this.waiter, retryNotification };
-    }
-  }
   reject(error: Readonly<Error>): void {
     this.waiter?.reject(error);
   }
   peerDisconnected(id: string): void {
-    if (this.waiter?.from === id && !this.waiter.question) {
+    if (this.waiter?.from === id) {
       this.reject(new Error(`Reply peer disconnected before answering: ${id}`));
     }
   }
@@ -85,65 +52,14 @@ export class ReplyWait {
     message: Message,
     onMatch: () => void,
   ): boolean {
-    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;
   }
-  private poll(question: ReadonlyInput<SupervisorQuestion>, replyTo: string): void {
-    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));
-    }
-  }
-  private saveAnswer(
-    question: ReadonlyInput<SupervisorQuestion> | undefined,
-    message: Message,
-  ): boolean {
-    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: ReplyWaitOptions): Promise<Message> {
     if (this.waiter) {
       throw new Error("Already waiting for a reply");
@@ -152,56 +68,33 @@ 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();
@@ -213,9 +106,9 @@ export class ReplyWait {
   async transact(activeClient: IntercomTransport, transaction: AskTransaction): Promise<Message> {
     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) {
@@ -239,7 +132,7 @@ export class ReplyWait {
       try {
         await reply;
       } catch {
-        /* Preserve the delivery failure rather than its cleanup rejection. */
+        // Preserve the delivery failure rather than its cleanup rejection.
       }
       throw error;
     }

package/src/pi-intercom/runtime-types.ts

@@ -1,37 +1,10 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type {
-  Attachment,
-  Message,
-  MessageDelivery,
-  QueueMode,
-  SessionInfo,
-  TopicUpdate,
-} from "./types.ts";
+import type { Attachment, Message, MessageDelivery, QueueMode, SessionInfo } from "./types.ts";
 
-export interface ChildOrchestratorMetadata {
-  readonly orchestratorTarget: string;
-  readonly runId: string;
-  readonly agent: string;
-  readonly index: string;
-  readonly sessionName?: string;
-}
-export interface SubagentCompletion {
-  readonly completionId?: string;
-  readonly runId: string;
-  readonly status: string;
-  readonly children: readonly {
-    readonly agent: string;
-    readonly index: number;
-    readonly status: string;
-    readonly intercomTarget: string;
-  }[];
-}
 export interface InboundMessageEntry {
   readonly from: SessionInfo;
   readonly message: Message;
   readonly replyCommand?: string;
   readonly bodyText: string;
-  readonly subagentCompletion?: SubagentCompletion & { readonly ownerSessionId: string };
 }
 export interface PendingInboundMessage extends InboundMessageEntry {
   readonly flushDelivery: "auto" | "passive" | "steer";
@@ -46,30 +19,14 @@ export type InboundCheckpoint =
     };
 export type RequestedDelivery = MessageDelivery | "auto";
 export type InboundDelivery = "trigger" | "followUp" | "steer" | "passive";
-export type ContactSupervisorReason = "need_decision" | "progress_update" | "interview_request";
 export type IntercomSessionScope = "project" | "all";
 export interface ToolResultLike {
   readonly content: readonly { readonly type: "text"; readonly text: string }[];
   readonly isError?: boolean;
   readonly details?: Readonly<Record<string, unknown>>;
 }
-export interface ContactSupervisorToolParams {
-  readonly reason: ContactSupervisorReason;
-  readonly message?: string;
-  readonly interview?: unknown;
-}
 export interface IntercomToolParams {
-  readonly action:
-    | "list"
-    | "send"
-    | "ask"
-    | "reply"
-    | "pending"
-    | "status"
-    | "subscribe"
-    | "unsubscribe"
-    | "publish"
-    | "topics";
+  readonly action: "list" | "send" | "ask" | "reply" | "pending" | "status" | "last";
   readonly scope?: IntercomSessionScope;
   readonly to?: string;
   readonly message?: string;
@@ -79,19 +36,9 @@ export interface IntercomToolParams {
   readonly queueMode?: QueueMode;
   readonly threadId?: string;
   readonly passive?: boolean;
-  readonly topic?: string;
-  readonly event?: TopicUpdate["event"];
-  readonly resource?: string;
-  readonly ownership?: TopicUpdate["ownership"];
-  readonly awaitRelease?: boolean;
-}
-export type ToolRenderTheme = ExtensionContext["ui"]["theme"];
-export interface ToolRenderContext {
-  readonly args?: unknown;
-  readonly isError?: boolean;
-  readonly expanded?: boolean;
+  readonly entryId?: string;
+  readonly offset?: number;
+  readonly limit?: number;
 }
 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/src/pi-intercom/session-events.ts

@@ -3,15 +3,10 @@ import type { IntercomLifecycle } from "./lifecycle.ts";
 import type { IntercomConnection } from "./connection.ts";
 import type { InboundDeliveryOwner } from "./inbound-delivery.ts";
 import type { InboundJournal } from "./inbound-journal.ts";
-import { isDurableSupervisorQuestion, type ReplyTracker } from "./reply-tracker.ts";
+import type { ReplyTracker } from "./reply-tracker.ts";
 import type { ReplyWait } from "./reply-wait.ts";
-import type { IntercomTopics } from "./topics.ts";
-import type { SubagentEventBridges } from "./subagent-events.ts";
-import type { IntercomSupervisor } from "./supervisor.ts";
-import type { PeerAwareness } from "./peer-awareness.ts";
 import { RECIPIENT_TURN_FAILED_ATTACHMENT } from "./runtime-types.ts";
 import { getAssistantErrorMessage, inboundIdFromCustomMessage } from "./message-format.ts";
-import { restoreLazyTools } from "../shared/lazy-tools.ts";
 // The native lifecycle orchestrator explicitly owns these transitions, not other owner operations.
 type Lifecycle = Readonly<
   Pick<
@@ -38,10 +33,7 @@ type Connection = Readonly<
   >
 >;
 type Journal = Readonly<
-  Pick<
-    InboundJournal,
-    "clearNative" | "consume" | "reconcileConsumed" | "reconcileTools" | "reset" | "retire"
-  >
+  Pick<InboundJournal, "clearNative" | "consume" | "reconcileConsumed" | "reset" | "retire">
 >;
 type ReplyWaitHandle = Readonly<Pick<ReplyWait, "reject">>;
 type InboundDeliveryHandle = Readonly<
@@ -50,7 +42,6 @@ type InboundDeliveryHandle = Readonly<
     "clearTimer" | "drain" | "flush" | "redeliver" | "reset" | "schedule" | "start"
   >
 >;
-type TopicOwner = Readonly<Pick<IntercomTopics, "start">>;
 type Replies = Readonly<
   Pick<ReplyTracker, "beginTurn" | "currentTurn" | "endAgent" | "endTurn" | "reset">
 >;
@@ -62,10 +53,6 @@ interface SessionOwners {
   readonly journal: Journal;
   readonly replies: Replies;
   readonly wait: ReplyWaitHandle;
-  readonly topics: TopicOwner;
-  readonly bridges: Readonly<Pick<SubagentEventBridges, "start" | "stop" | "drain">>;
-  readonly supervisor: Readonly<Pick<IntercomSupervisor, "drain">> | null;
-  readonly awareness: Readonly<Pick<PeerAwareness, "reset" | "beforeStart">> | null;
 }
 /** Native phase ordering is centralized here; each resource is cleaned by its owner. */
 export class IntercomSessionEvents {
@@ -76,31 +63,23 @@ export class IntercomSessionEvents {
     this.owners = owners;
   }
   private async start(reason: string, ctx: ExtensionContext): Promise<void> {
-    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);
     }
   }
   private async shutdown(): Promise<void> {
-    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();
@@ -133,7 +112,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);
       }
     } catch {
@@ -141,7 +120,7 @@ export class IntercomSessionEvents {
     }
   }
   private registerSessionBoundaries(): void {
-    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);
     });
@@ -158,13 +137,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/src/pi-intercom/tool-arguments.ts

@@ -96,6 +96,12 @@ function queueError(params: IntercomToolParams): ToolResultLike | undefined {
   return;
 }
 export function validateIntercomArguments(params: IntercomToolParams): ToolResultLike | undefined {
+  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'");
   }