@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/src/pi-intercom/config.ts

@@ -1,12 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { Key, type KeyId } from "@earendil-works/pi-tui";
 import { getPiAgentDir } from "./agent-dir.ts";
 import { isRecord, isUnknownArray } from "./validation.ts";
 
 export interface IntercomConfig {
-  /** Toggle owned agents, or open peer messaging when the agent view is unavailable. */
-  readonly shortcut: KeyId;
   /** Broker command used to spawn the broker process (for example, Node or Bun). */
   readonly brokerCommand: string;
   /** Arguments passed to the broker command before the broker script path. */
@@ -25,7 +22,6 @@ export interface IntercomConfig {
   readonly listTimeoutMs: number;
 }
 const defaults: IntercomConfig = {
-  shortcut: Key.altShift("m"),
   brokerCommand: process.execPath,
   brokerArgs: [],
   confirmSend: false,
@@ -34,15 +30,6 @@ const defaults: IntercomConfig = {
   sendTimeoutMs: 8000,
   listTimeoutMs: 5000,
 };
-const namedKeys = new Set<string>(Object.values(Key).filter((key) => typeof key === "string"));
-function isShortcut(value: string): value is KeyId {
-  const prefix = value.match(/^(?:(?:ctrl|shift|alt|super)\+)+/)?.[0] ?? "";
-  const modifiers = prefix.split("+").filter(Boolean);
-  const key = value.slice(prefix.length);
-  return (
-    new Set(modifiers).size === modifiers.length && (namedKeys.has(key) || /^[a-z0-9]$/.test(key))
-  );
-}
 function configuredString(
   parsed: Readonly<Record<string, unknown>>,
   key: "brokerCommand" | "status",
@@ -65,19 +52,6 @@ function configuredString(
 function brokerCommand(parsed: Readonly<Record<string, unknown>>): string {
   return configuredString(parsed, "brokerCommand") ?? defaults.brokerCommand;
 }
-function configuredShortcut(parsed: Readonly<Record<string, unknown>>): KeyId {
-  if (!Object.hasOwn(parsed, "shortcut")) {
-    return defaults.shortcut;
-  }
-  if (typeof parsed.shortcut !== "string") {
-    throw new Error('"shortcut" must be a native key identifier');
-  }
-  const shortcut = parsed.shortcut.trim();
-  if (!isShortcut(shortcut)) {
-    throw new Error('"shortcut" must be a native key identifier, for example alt+shift+m');
-  }
-  return shortcut;
-}
 function configuredArgs(parsed: Readonly<Record<string, unknown>>): readonly string[] {
   if (!Object.hasOwn(parsed, "brokerArgs")) {
     return defaults.brokerArgs;
@@ -130,7 +104,6 @@ export function loadConfig(): IntercomConfig {
       throw new Error("Config must be a JSON object");
     }
     return {
-      shortcut: configuredShortcut(parsed),
       brokerCommand: brokerCommand(parsed),
       brokerArgs: configuredArgs(parsed),
       confirmSend: configuredBoolean(parsed, "confirmSend"),

package/src/pi-intercom/connection.ts

@@ -4,19 +4,17 @@ import type { IntercomTransport } from "./transport.ts";
 import { spawnBrokerIfNeeded } from "./broker/spawn.ts";
 import type { IntercomConfig } from "./config.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
-import type { IntercomTopics } from "./topics.ts";
-import type { Message, SessionInfo, TopicChange } from "./types.ts";
-import { asError, errorMessage } from "./validation.ts";
+import type { LastMessageQuery, Message, SessionInfo } from "./types.ts";
+import { readLastMessage } from "./last-message.ts";
+import { asError } from "./validation.ts";
 import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./session-targets.ts";
 
-export type ConnectionReason = "startup" | "background" | "tool" | "overlay" | "peer-awareness";
 type Lifecycle = Readonly<
   Pick<
     IntercomLifecycle,
     "currentSessionId" | "generation" | "health" | "identity" | "live" | "registration" | "status"
   >
 >;
-type TopicOwner = Readonly<Pick<IntercomTopics, "disconnected" | "presence" | "refresh">>;
 
 interface ConnectionHooks {
   readonly restoring: () => Promise<void> | undefined;
@@ -33,41 +31,23 @@ export class IntercomConnection {
   private connecting: Promise<IntercomTransport> | null = null;
   private connectingGeneration: number | null = null;
   private attempt = 0;
-  private syncError: string | undefined;
   private readonly lifecycle: Lifecycle;
   private readonly config: IntercomConfig;
-  private readonly topics: TopicOwner;
   private readonly hooks: ConnectionHooks;
-  constructor(
-    lifecycle: Lifecycle,
-    config: IntercomConfig,
-    topics: TopicOwner,
-    hooks: ConnectionHooks,
-  ) {
+  constructor(lifecycle: Lifecycle, config: IntercomConfig, hooks: ConnectionHooks) {
     this.lifecycle = lifecycle;
     this.config = config;
-    this.topics = topics;
     this.hooks = hooks;
   }
   get active(): IntercomTransport | null {
     return this.client;
   }
-  get topicSyncError(): string | undefined {
-    return this.syncError;
-  }
-  get isConnecting(): boolean {
-    return this.startupTimer !== null || this.connecting !== null;
-  }
-  clearTopicSyncError(): void {
-    this.syncError = undefined;
-  }
   start(ctx: ExtensionContext, generation: number): void {
     this.attempt = 0;
-    this.syncError = undefined;
     this.clearTimers();
     this.scheduleStartup(ctx, generation);
   }
-  clearStartup(): void {
+  private clearStartup(): void {
     if (this.startupTimer) {
       clearTimeout(this.startupTimer);
       this.startupTimer = null;
@@ -83,14 +63,14 @@ export class IntercomConnection {
     this.clearStartup();
     this.clearReconnect();
   }
-  scheduleStartup(ctx: ExtensionContext, generation: number): void {
+  private scheduleStartup(ctx: ExtensionContext, generation: number): void {
     this.clearStartup();
     this.startupTimer = setTimeout(() => {
       this.startupTimer = null;
       if (!this.lifecycle.live(ctx, generation)) {
         return;
       }
-      this.ensure("startup").catch(() => {
+      this.ensure().catch(() => {
         if (!this.lifecycle.live(ctx, generation)) {
           return;
         }
@@ -113,7 +93,7 @@ export class IntercomConnection {
         return;
       }
       this.attempt += 1;
-      this.ensure("background").catch(() => {
+      this.ensure().catch(() => {
         /* ensure owns the next retry after settlement. */
       });
     }, delay);
@@ -142,6 +122,35 @@ export class IntercomConnection {
       listTimeoutMs: this.config.listTimeoutMs,
     });
     this.client = next;
+    next.on(
+      "last_request",
+      (request: { readonly requestId: string; readonly query: LastMessageQuery }) => {
+        const ctx = this.lifecycle.live();
+        const id = next.sessionId;
+        if (this.client !== next || !ctx || id === null) {
+          next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
+          return;
+        }
+        try {
+          next.respondLast(
+            request.requestId,
+            readLastMessage(
+              ctx.sessionManager,
+              {
+                id,
+                ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
+                cwd: ctx.cwd,
+                model: ctx.model?.id ?? "unknown",
+                status: this.lifecycle.status(),
+              },
+              request.query,
+            ),
+          );
+        } catch (error) {
+          next.respondLast(request.requestId, { error: asError(error).message });
+        }
+      },
+    );
     next.on("message", (from: SessionInfo, message: Message) => {
       const ctx = this.lifecycle.live();
       if (this.client !== next || !ctx) {
@@ -155,7 +164,6 @@ export class IntercomConnection {
       if (this.client !== next) {
         return;
       }
-      this.topics.disconnected(id);
       this.hooks.peerLeft(id);
     });
     next.on("disconnected", (error: Readonly<Error>) => {
@@ -164,7 +172,6 @@ export class IntercomConnection {
       }
       this.hooks.disconnected(error);
       this.client = null;
-      this.topics.disconnected();
       this.clearReconnect();
       this.scheduleReconnect();
     });
@@ -173,63 +180,14 @@ export class IntercomConnection {
     });
     return next;
   }
-  private async restoreTopics(active: IntercomTransport): Promise<string | undefined> {
-    const changes: TopicChange[] = [
-      ...[...this.topics.presence().topics].map((topic): TopicChange => ({
-        action: "restore",
-        topic,
-      })),
-      ...[...this.topics.presence().subscriptions].map((subscription): TopicChange => ({
-        action: "restore",
-        subscription,
-      })),
-    ];
-    let failure: string | undefined;
-    for (const change of changes) {
-      try {
-        // Restore order preserves publication/subscription admission and bounded transport pressure.
-        // oxlint-disable-next-line no-await-in-loop
-        await active.updateTopics(change);
-      } catch (error) {
-        if (!active.isConnected()) {
-          throw error;
-        }
-        failure ??= errorMessage(error);
-      }
-    }
-    return failure;
-  }
-  private async synchronizeTopics(
-    next: IntercomTransport,
-    ctx: ExtensionContext,
-    generation: number,
-  ): Promise<void> {
-    if (!next.supportsTopics) {
-      this.topics.disconnected();
-      return;
-    }
-    const failure = await this.restoreTopics(next);
-    const sessions = await next.listSessions();
-    if (!this.lifecycle.live(ctx, generation)) {
-      return;
-    }
-    this.syncError = failure;
-    this.topics.refresh(sessions);
-    if (failure !== undefined && failure !== "" && next.sessionId !== null) {
-      this.topics.disconnected(next.sessionId);
-    }
-  }
   private async connect(
-    reason: ConnectionReason,
     ctx: ExtensionContext,
     generation: number,
     sessionId: string,
   ): Promise<IntercomTransport> {
     const next = this.createClient();
     try {
-      if (reason !== "peer-awareness") {
-        await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
-      }
+      await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
       await next.connect(
         await this.lifecycle.registration(this.hooks.pendingAsks()),
         nativePeerId(sessionId),
@@ -241,20 +199,19 @@ export class IntercomConnection {
       this.client = next;
       this.syncIdentity(ctx.sessionManager.getSessionId());
       this.attempt = 0;
-      await this.synchronizeTopics(next, ctx, generation);
       return next;
     } catch (error) {
       if (this.client === next) {
         this.client = null;
       }
-      // A failed topic snapshot can leave a registered socket alive; the attempt still owns it.
+      // A failed registration still owns its socket.
       await next.disconnect().catch((cleanupError: unknown) => {
         console.error("Intercom failed connection cleanup:", cleanupError);
       });
       throw asError(error);
     }
   }
-  async ensure(reason: ConnectionReason): Promise<IntercomTransport> {
+  async ensure(): Promise<IntercomTransport> {
     const generation = this.lifecycle.generation;
     const restoring = this.hooks.restoring();
     if (restoring) {
@@ -276,7 +233,7 @@ export class IntercomConnection {
     }
     this.clearReconnect();
     // Publish ownership before registration, which can synchronously invoke subscribers.
-    const attempt = Promise.resolve().then(() => this.connect(reason, ctx, generation, sessionId));
+    const attempt = Promise.resolve().then(() => this.connect(ctx, generation, sessionId));
     this.connecting = attempt;
     this.connectingGeneration = generation;
     return await this.finishAttempt(attempt, ctx, generation);

package/src/pi-intercom/identity.ts

@@ -1,49 +1,27 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ChildOrchestratorMetadata } from "./runtime-types.ts";
-function environmentText(name: string): string {
-  return process.env[name]?.trim() ?? "";
+
+export interface IntercomLineage {
+  readonly rootSessionId: string;
+  readonly parentSessionId: string;
 }
-export function readChildOrchestratorMetadata(): ChildOrchestratorMetadata | null {
-  const orchestratorTarget = environmentText("PI_SUBAGENT_ORCHESTRATOR_TARGET");
-  const runId = environmentText("PI_SUBAGENT_RUN_ID");
-  const agent = environmentText("PI_SUBAGENT_CHILD_AGENT");
-  const index = environmentText("PI_SUBAGENT_CHILD_INDEX");
-  if ([orchestratorTarget, runId, agent, index].includes("")) {
-    return null;
+export function readIntercomLineage(): IntercomLineage | undefined {
+  const rootSessionId = process.env.PI_INTERCOM_ROOT_SESSION_ID?.trim();
+  const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID?.trim();
+  if (rootSessionId === undefined && parentSessionId === undefined) {
+    return;
   }
-  const sessionName = environmentText("PI_SUBAGENT_INTERCOM_SESSION_NAME");
-  return {
-    orchestratorTarget,
-    runId,
-    agent,
-    index,
-    ...(sessionName !== "" ? { sessionName } : {}),
-  };
-}
-export function formatChildOrchestratorMessage(
-  kind: "ask" | "update" | "interview",
-  metadata: ChildOrchestratorMetadata,
-  message: string,
-): string {
-  const headings = {
-    ask: "Subagent needs a supervisor decision.",
-    interview: "Subagent requests a structured supervisor interview.",
-    update: "Subagent progress update.",
-  };
-  return [
-    headings[kind],
-    `Run: ${metadata.runId}`,
-    `Agent: ${metadata.agent}`,
-    `Child index: ${metadata.index}`,
-    metadata.sessionName !== undefined && metadata.sessionName !== ""
-      ? `Child intercom target: ${metadata.sessionName}`
-      : undefined,
-    "",
-    message,
-  ]
-    .filter((line) => line !== undefined)
-    .join("\n");
+  if (
+    rootSessionId === undefined ||
+    parentSessionId === undefined ||
+    rootSessionId === "" ||
+    parentSessionId === "" ||
+    rootSessionId !== parentSessionId
+  ) {
+    throw new Error("Intercom child launch requires matching root and parent native session IDs.");
+  }
+  return { rootSessionId, parentSessionId };
 }
+
 export function resolveIntercomPresenceName(
   sessionName: string | undefined,
   sessionId: string,
@@ -61,11 +39,5 @@ export function buildPresenceIdentity(
   pi: ExtensionAPI,
   sessionId: string,
 ): { readonly name: string } {
-  const name = process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME?.trim();
-  return {
-    name:
-      name !== undefined && name !== ""
-        ? name
-        : resolveIntercomPresenceName(pi.getSessionName(), sessionId),
-  };
+  return { name: resolveIntercomPresenceName(pi.getSessionName(), sessionId) };
 }

package/src/pi-intercom/inbound-delivery.ts

@@ -7,44 +7,30 @@ import type {
   InboundDelivery,
   InboundMessageEntry,
   PendingInboundMessage,
-  SubagentCompletion,
 } from "./runtime-types.ts";
-import { needsIntercom, requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.ts";
+import { requestedDelivery } from "./inbound-record.ts";
 import { isRecord } from "./validation.ts";
-import { activateTools } from "../shared/lazy-tools.ts";
 import { runCooperatively } from "../shared/cooperative.ts";
-import { listSupervisorQuestionsAsync } from "../runs/shared/supervisor-questions.ts";
 
-type Lifecycle = Readonly<
-  Pick<
-    IntercomLifecycle,
-    "currentSessionId" | "generation" | "isIdle" | "live" | "runtimeStarted" | "toolCount"
-  >
->;
+type Lifecycle = Readonly<Pick<IntercomLifecycle, "generation" | "isIdle" | "live" | "toolCount">>;
 type Journal = Readonly<
   Pick<
     InboundJournal,
-    | "discardObsolete"
     | "freshRuntime"
     | "get"
-    | "hasSeen"
     | "markNative"
     | "owns"
     | "queued"
     | "reconcileConsumed"
-    | "reconcileTools"
     | "reload"
     | "remember"
-    | "rememberCompletion"
     | "reset"
     | "restore"
     | "size"
     | "unconsumed"
   >
 >;
-type Replies = Readonly<
-  Pick<ReplyTracker, "hasReplyContext" | "markReplied" | "queueTurnContext" | "reset">
->;
+type Replies = Readonly<Pick<ReplyTracker, "queueTurnContext" | "reset">>;
 
 interface DeliveryHooks {
   readonly replies: Replies;
@@ -114,19 +100,7 @@ export class InboundDeliveryOwner {
     if (!this.lifecycle.live(ctx, generation)) {
       return;
     }
-    if (this.hooks.replies.hasReplyContext) {
-      const questions = await listSupervisorQuestionsAsync(ctx.sessionManager.getSessionId());
-      if (!this.lifecycle.live(ctx, generation)) {
-        return;
-      }
-      for (const question of questions) {
-        if (question.answer || question.state === "cancelled") {
-          this.hooks.replies.markReplied(question.questionId);
-        }
-      }
-    }
     this.journal.reconcileConsumed(ctx);
-    this.journal.reconcileTools();
   }
   schedule(delayMs = 200): void {
     if (!this.lifecycle.live()) {
@@ -238,12 +212,8 @@ export class InboundDeliveryOwner {
         continue;
       }
       this.send(entry, "steer", generation);
-      if (
-        requestedDelivery(entry.message) === "steer" &&
-        entry.from.id !== "subagent-result" &&
-        entry.from.id !== "subagent-control"
-      ) {
-        onDetach(this.detach(entry, !isBlockingSupervisorMessage(entry)));
+      if (requestedDelivery(entry.message) === "steer") {
+        onDetach(this.detach(entry, entry.message.expectsReply !== true));
       }
       yield;
     }
@@ -300,10 +270,10 @@ export class InboundDeliveryOwner {
     delivery: InboundDelivery,
     generation = this.lifecycle.generation,
   ): void {
-    if (this.lifecycle.runtimeStarted && !this.live(generation)) {
+    if (!this.live(generation)) {
       return;
     }
-    if (!this.journal.owns(entry) || this.journal.discardObsolete(entry)) {
+    if (!this.journal.owns(entry)) {
       return;
     }
     this.trackNative(entry, delivery);
@@ -324,9 +294,6 @@ export class InboundDeliveryOwner {
         message: entry.message,
         receivedAt: Date.now(),
       });
-      if (needsIntercom(entry)) {
-        activateTools(this.pi, ["intercom"]);
-      }
     }
   }
   private nativeMessage(entry: InboundMessageEntry): Parameters<ExtensionAPI["sendMessage"]>[0] {
@@ -336,18 +303,15 @@ export class InboundDeliveryOwner {
         : entry.from.name;
     const command = entry.replyCommand ?? "";
     const reply = command === "" ? "" : `\n\nTo reply, use the intercom tool: ${command}`;
-    const human = entry.message.human !== undefined;
     return {
-      customType: human ? "subagent-human-message" : "intercom_message",
-      content: human
-        ? `Direct user message to this agent (human origin, not peer advice). Respond in this conversation; the user sees it directly. Do not ask the parent to relay or approve it.\n\n${entry.bodyText}`
-        : `**📨 From ${sender}** (Native session cwd: ${entry.from.cwd})${reply}\n\n${entry.bodyText}`,
+      customType: "intercom_message",
+      content: `**📨 From ${sender}** (Native session cwd: ${entry.from.cwd})${reply}\n\n${entry.bodyText}`,
       display: true,
       details: { ...entry, bodyText: entry.bodyText },
     };
   }
   async detach(entry: InboundMessageEntry, attention = false): Promise<boolean> {
-    if (!attention && !isBlockingSupervisorMessage(entry)) {
+    if (!attention && entry.message.expectsReply !== true) {
       return false;
     }
     const requestId = randomUUID();
@@ -400,51 +364,4 @@ export class InboundDeliveryOwner {
       generation,
     );
   }
-  private localEntry(
-    sender: "subagent-control" | "subagent-result",
-    status: string,
-    data: { readonly text: string; readonly completion?: SubagentCompletion },
-  ): InboundMessageEntry {
-    const { text, completion } = data;
-    const sessionId = this.lifecycle.currentSessionId;
-    const completionId = completion?.completionId;
-    const entry: InboundMessageEntry = {
-      from: {
-        id: sender,
-        name: sender,
-        cwd: this.lifecycle.live()?.cwd ?? process.cwd(),
-        model: sender,
-        status,
-      },
-      message: {
-        id:
-          completionId !== undefined && completionId !== ""
-            ? `subagent-completion:${completionId}`
-            : randomUUID(),
-        timestamp: Date.now(),
-        content: { text },
-      },
-      bodyText: text,
-      ...(sender === "subagent-result" && completion && sessionId !== null
-        ? { subagentCompletion: { ...completion, ownerSessionId: sessionId } }
-        : {}),
-    };
-    return entry;
-  }
-  local(
-    sender: "subagent-control" | "subagent-result",
-    status: string,
-    data: { readonly text: string; readonly completion?: SubagentCompletion },
-  ): void {
-    const entry = this.localEntry(sender, status, data);
-    if (this.journal.hasSeen(entry.message.id)) {
-      return;
-    }
-    this.journal.rememberCompletion(entry);
-    if (this.batching) {
-      this.queue(entry, "steer");
-    } else {
-      this.send(entry, "trigger");
-    }
-  }
 }