@fitchmultz/pi-subagents 0.52.20 → 0.52.21

package/src/agent/runner.ts

@@ -10,8 +10,9 @@ import {
   type Result,
   type AccountingState,
 } from "./contracts.ts";
-import { launchAt, missing, read, runDirectory, write } from "./storage.ts";
-import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.ts";
+import { commandIdentity, launchAt, read, runDirectory, write } from "./storage.ts";
+import { ownIdentity, shells, signalProcess } from "./process.ts";
+import { ParentCheck } from "./parent-check.ts";
 import { errorText, loadSDK } from "./host.ts";
 import { Parking, type ParkOutcome, type Runtime } from "./parking.ts";
 import { accountingFields, UsageIndex } from "./usage.ts";
@@ -20,17 +21,6 @@ import { childRuntime } from "./child-runtime.ts";
 import { ActorObservation, type ObservationStats } from "./observation.ts";
 import { DirectoryWatch, Wake } from "./wake.ts";
 
-function commandIdentity(file: string): string | undefined {
-  try {
-    const stat = fs.statSync(file, { bigint: true });
-    return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
-  } catch (error) {
-    if (missing(error)) {
-      return;
-    }
-    throw error;
-  }
-}
 function completionStatus(
   stopping: boolean,
   message: AssistantMessage | undefined,
@@ -53,7 +43,11 @@ const failureReason = (
   message?.errorMessage ??
   (message ? undefined : "Native run produced no terminal assistant message.");
 class Actor {
-  private active?: Promise<void> | undefined;
+  private work:
+    | { readonly kind: "idle" }
+    | { readonly kind: "running"; readonly launch: Launch; readonly task: Promise<void> } = {
+    kind: "idle",
+  };
   private stopping = false;
   private stopDeadline?: NodeJS.Timeout;
   private nextParentCheck = 0;
@@ -63,7 +57,6 @@ class Actor {
   private readonly wake = new Wake();
   // A deferred run waits for an idle session, which has no command-file event.
   private retry = false;
-  private current?: Launch | undefined;
   private readonly errors: string[] = [];
   private readonly started = new Set<string>();
   // Actor-local validation metadata only; never retain command prompts or receipt authority.
@@ -151,7 +144,10 @@ class Actor {
     this.stopping = true;
     this.wake.raise();
     write(path.join(this.dir, `stopping-${this.token}.json`), { at: Date.now() });
-    write(path.join(this.dir, "stop-acknowledged.json"), { at: Date.now(), id: this.current?.id });
+    write(path.join(this.dir, "stop-acknowledged.json"), {
+      at: Date.now(),
+      id: this.work.kind === "running" ? this.work.launch.id : undefined,
+    });
     this.session?.abort().catch((error: unknown) => {
       this.errors.push(errorText(error));
     });
@@ -181,29 +177,33 @@ class Actor {
     if (!session) {
       throw new Error("Native child session is not ready.");
     }
-    this.current = launch;
     const baseline = new Set(session.sessionManager.getEntries().map((entry) => entry.id));
+    const task = Promise.resolve().then(() => this.executeRun(launch, session, baseline));
+    this.work = { kind: "running", launch, task };
     this.observation?.working(true);
-    this.active = (async () => {
-      try {
-        if (
-          launch.provider !== this.initial.provider ||
-          launch.model !== this.initial.model ||
-          launch.thinking !== this.initial.thinking
-        ) {
-          throw new Error("Continuation model snapshot changed unexpectedly.");
-        }
-        await session.prompt(launch.prompt, { expandPromptTemplates: false });
-        await session.waitForIdle();
-        this.saveResult(launch, baseline);
-      } catch (error) {
-        this.saveResult(launch, baseline, errorText(error));
-      } finally {
-        this.active = undefined;
-        this.current = undefined;
-        this.observation?.working(false);
+  }
+  private async executeRun(
+    launch: Launch,
+    session: AgentSession,
+    baseline: ReadonlySet<string>,
+  ): Promise<void> {
+    try {
+      if (
+        launch.provider !== this.initial.provider ||
+        launch.model !== this.initial.model ||
+        launch.thinking !== this.initial.thinking
+      ) {
+        throw new Error("Continuation model snapshot changed unexpectedly.");
       }
-    })();
+      await session.prompt(launch.prompt, { expandPromptTemplates: false });
+      await session.waitForIdle();
+      this.saveResult(launch, baseline);
+    } catch (error) {
+      this.saveResult(launch, baseline, errorText(error));
+    } finally {
+      this.work = { kind: "idle" };
+      this.observation?.working(false);
+    }
   }
   private commandLaunch(command: Command): Launch | undefined {
     const receipt = path.join(this.dir, "admissions", `${command.id}.json`);
@@ -235,7 +235,7 @@ class Actor {
     }
     if (
       command.action === "run" &&
-      (this.stopping || this.active !== undefined || !session.isIdle)
+      (this.stopping || this.work.kind === "running" || !session.isIdle)
     ) {
       this.retry = true;
       return;
@@ -260,33 +260,31 @@ class Actor {
     this.applyCommand(command, launch, session);
   }
   private staleCommand(command: Command, launch: Launch, session: AgentSession): boolean {
-    // Unbound legacy Stops cannot safely target this generation either.
-    if (command.action === "stop") {
-      return command.actorToken !== this.token;
+    switch (command.action) {
+      case "stop":
+        return command.actorToken !== this.token;
+      case "steer":
+        return this.work.kind !== "running" || session.isIdle || this.work.launch.id !== launch.id;
+      case "run":
+        return false;
     }
-    return (
-      command.action === "steer" &&
-      (this.active === undefined || session.isIdle || this.current?.id !== launch.id)
-    );
   }
   private applyCommand(command: Command, launch: Launch, session: AgentSession): void {
-    if (command.action === "stop") {
-      this.stop();
-      return;
+    switch (command.action) {
+      case "stop":
+        this.stop();
+        return;
+      case "run":
+        this.run(launch);
+        return;
+      case "steer":
+        // Synchronous native queue admission cannot turn into an idle prompt after an await.
+        session.agent.steer({
+          role: "user",
+          content: [{ type: "text", text: command.prompt }],
+          timestamp: Date.now(),
+        });
     }
-    if (command.action === "run") {
-      this.run(launch);
-      return;
-    }
-    if (command.prompt === undefined) {
-      throw new Error("Missing guidance.");
-    }
-    // Synchronous native queue admission cannot turn into an idle prompt after an await.
-    session.agent.steer({
-      role: "user",
-      content: [{ type: "text", text: command.prompt }],
-      timestamp: Date.now(),
-    });
   }
   private pendingCommand(file: string): Command | undefined {
     const identity = commandIdentity(file);
@@ -328,7 +326,7 @@ class Actor {
         this.errors.push(errorText(error));
       });
     }
-    return this.stopping && this.active === undefined && (this.session?.isIdle ?? true);
+    return this.stopping && this.work.kind === "idle" && (this.session?.isIdle ?? true);
   }
   /** Durable command readiness, not elapsed time, defines admission. */
   private async admitCommands(runtime: Runtime, parked: Parking): Promise<void> {
@@ -368,14 +366,14 @@ class Actor {
       this.parking = await parked.park(runtime, {
         signal: owner.signal,
         pi: this.context?.pi,
-        busy: this.stopping || this.active !== undefined || this.observation?.watched === true,
+        busy: this.stopping || this.work.kind === "running" || this.observation?.watched === true,
         // Raced commands and viewers keep this actor resident; the loop admits after release.
         quiet: () => {
           const queued = this.pending().some((command) => this.commandLaunch(command));
           if (queued) {
             this.wake.raise();
           }
-          const idle = this.active === undefined && !this.stopping;
+          const idle = this.work.kind === "idle" && !this.stopping;
           return !queued && idle && this.observation?.watched !== true;
         },
         errors: this.errors,
@@ -386,7 +384,7 @@ class Actor {
     return this.parking !== "resident";
   }
   private failure(error: unknown, unopened?: string): void {
-    const launch = this.current ?? this.initial;
+    const launch = this.work.kind === "running" ? this.work.launch : this.initial;
     const result: Result = {
       id: launch.id,
       owner: launch.owner,
@@ -482,7 +480,9 @@ class Actor {
       process.on("SIGTERM", this.stop);
       process.on("SIGINT", this.stop);
       await this.admitCommands(runtime, parked);
-      await this.active;
+      if (this.work.kind === "running") {
+        await this.work.task;
+      }
     } catch (error) {
       this.failure(error, parked?.opened === true ? undefined : parkedToken);
     } finally {

package/src/agent/storage.ts

@@ -119,18 +119,31 @@ export function latest(base: string, initial: Launch): Launch {
 export function conversation(base: string, launch: Launch): string {
   return runDirectory(base, launch.rootId);
 }
+/** Metadata only: replacing command bytes invalidates the actor's parsed-command cache. */
+export function commandIdentity(file: string): string | undefined {
+  try {
+    const stat = fs.statSync(file, { bigint: true });
+    return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+  } catch (error) {
+    if (missing(error)) {
+      return;
+    }
+    throw error;
+  }
+}
 export function enqueue(
   base: string,
   launch: Launch,
-  action: Command["action"],
-  options: Pick<Command, "prompt" | "actorToken"> = {},
+  input:
+    | { readonly action: "run" }
+    | { readonly action: "steer"; readonly prompt: string }
+    | { readonly action: "stop"; readonly actorToken: string },
 ): string {
-  const id = action === "run" ? launch.id : randomUUID();
+  const id = input.action === "run" ? launch.id : randomUUID();
   const command: Command = {
     id,
     runId: launch.id,
-    action,
-    ...options,
+    ...input,
     createdAt: Date.now(),
   };
   write(path.join(conversation(base, launch), "commands", `${id}.json`), command, true);

package/src/agent/view.ts

@@ -5,7 +5,7 @@ import { readOutputPage } from "../shared/output-page.ts";
 import { actor, alive, observeAlive } from "./process.ts";
 import {
   admissionSchema,
-  commandSchema,
+  commandMetadataSchema,
   exitSchema,
   successorSchema,
   wakeFailureSchema,
@@ -16,9 +16,6 @@ import type { RunsInput } from "./tool-schemas.ts";
 import { conversation, read, runDirectory } from "./storage.ts";
 import { published } from "./notifications.ts";
 import { accountingFields, accountingState, readCanonicalResult, readResult } from "./usage.ts";
-import { Type } from "./typebox.ts";
-
-const commandMetadataSchema = Type.Pick(commandSchema, ["id", "runId", "action", "createdAt"]);
 interface Guidance {
   id: string;
   runId: string;

package/src/pi-intercom/broker/broker.ts

@@ -34,8 +34,9 @@ import {
   shouldReplaceDelivery,
 } from "./snapshots.ts";
 
+import { ReplaceDeliveries } from "./replace-deliveries.ts";
+
 const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
-const REPLACE_DELIVERY_DELAY_MS = 1500;
 
 interface ConnectedSession extends ParkablePeer {
   info: SessionInfo;
@@ -45,18 +46,11 @@ interface ConnectedSession extends ParkablePeer {
   readonly receiptReads: boolean;
 }
 
-interface PendingReplaceDelivery {
-  readonly fromId: string;
-  readonly toId: string;
-  readonly message: Message;
-  readonly timer: NodeJS.Timeout;
-}
-
 class IntercomBroker {
   private readonly sessions = new Map<string, ConnectedSession>();
   private readonly lastMessages = new LastMessageRelay(this.sessions);
   private readonly parking = new ParkedSessions(this.sessions, this.deliverMessage.bind(this));
-  private readonly pendingReplaceDeliveries = new Map<string, PendingReplaceDelivery>();
+  private readonly replacements = new ReplaceDeliveries(this.deliverMessage.bind(this));
   private readonly server: net.Server;
   private shutdownTimer: NodeJS.Timeout | null = null;
   private readonly socketPath: string;
@@ -201,7 +195,7 @@ class IntercomBroker {
     this.lastMessages.disconnected(sessionId);
     if (!this.parking.closed(session)) {
       this.sessions.delete(sessionId);
-      this.clearPendingReplaceDeliveries(sessionId);
+      this.replacements.disconnected(sessionId);
       this.broadcast({ type: "session_left", sessionId }, session.info);
     }
     this.scheduleShutdownCheck();
@@ -417,10 +411,6 @@ class IntercomBroker {
     };
   }
 
-  private replaceKey(fromId: string, toId: string, threadId: string): string {
-    return `${fromId}\0${toId}\0${threadId}`;
-  }
-
   private queueReplaceDelivery(
     fromId: string,
     toId: string,
@@ -431,17 +421,7 @@ class IntercomBroker {
     if (validationError !== null) {
       return { id: message.id, accepted: false, delivered: false, reason: validationError };
     }
-    const key = this.replaceKey(fromId, toId, message.threadId ?? "");
-    const existing = this.pendingReplaceDeliveries.get(key);
-    if (existing) {
-      clearTimeout(existing.timer);
-    }
-    const timer = setTimeout(() => {
-      this.pendingReplaceDeliveries.delete(key);
-      this.deliverMessage(toId, from, message);
-    }, REPLACE_DELIVERY_DELAY_MS);
-    timer.unref();
-    this.pendingReplaceDeliveries.set(key, { fromId, toId, message, timer });
+    this.replacements.stage(fromId, toId, from, message);
     return {
       id: message.id,
       accepted: true,
@@ -451,18 +431,6 @@ class IntercomBroker {
     };
   }
 
-  private clearPendingReplaceDeliveries(sessionId: string): void {
-    for (const [key, pending] of this.pendingReplaceDeliveries) {
-      if (
-        pending.toId === sessionId ||
-        (pending.fromId === sessionId && pending.message.expectsReply === true)
-      ) {
-        clearTimeout(pending.timer);
-        this.pendingReplaceDeliveries.delete(key);
-      }
-    }
-  }
-
   /** One admission rule; retained input is checked as the uncompacted envelope any later
    * transport generation accepts. */
   private validateDeliveryPayload(

package/src/pi-intercom/broker/client-park.ts

@@ -4,20 +4,41 @@ import { writeMessage } from "./framing.ts";
 /** Parking negotiation and its single outstanding broker acknowledgement. */
 export class ParkRequests {
   supported = false;
-  private acknowledged?: ((parked: boolean) => void) | undefined;
+  private state:
+    | { readonly kind: "idle" }
+    | {
+        readonly kind: "pending";
+        readonly promise: Promise<boolean>;
+        readonly resolve: (parked: boolean) => void;
+      } = { kind: "idle" };
   settle(parked: boolean): void {
-    this.acknowledged?.(parked);
+    const state = this.state;
+    this.state = { kind: "idle" };
+    if (state.kind === "pending") {
+      state.resolve(parked);
+    }
   }
   /** True once the broker retains later input; false when it cannot or the socket closed. */
   request(socket: () => net.Socket, on: boolean): Promise<boolean> {
-    return new Promise((resolve) => {
-      this.acknowledged = on && this.supported ? resolve : undefined;
+    if (on && this.state.kind === "pending") {
+      return this.state.promise;
+    }
+    const { promise, resolve, reject } = Promise.withResolvers<boolean>();
+    this.settle(false);
+    if (on && this.supported) {
+      this.state = { kind: "pending", promise, resolve };
+    }
+    try {
       if (this.supported) {
         writeMessage(socket(), { type: on ? "park" : "unpark" });
       }
-      if (this.acknowledged === undefined) {
+      if (this.state.kind === "idle") {
         resolve(false);
       }
-    });
+    } catch (error) {
+      this.state = { kind: "idle" };
+      reject(error);
+    }
+    return promise;
   }
 }

package/src/pi-intercom/broker/client.ts

@@ -63,6 +63,10 @@ function messageDelivery(options: SendOptions): MessageDelivery | undefined {
   return "steer";
 }
 
+type ClientPhase =
+  | { readonly kind: "idle" | "connected" }
+  | { readonly kind: "connecting" | "closing"; readonly task: Promise<void> };
+
 export class IntercomClient extends EventEmitter {
   private connection: BrokerConnection | null = null;
   private _sessionId: string | null = null;
@@ -80,8 +84,7 @@ export class IntercomClient extends EventEmitter {
     readonly reject: (e: Readonly<Error>) => void;
     readonly reader: SnapshotReader;
   }>();
-  private connecting = false;
-  private disconnecting = false;
+  private phase: ClientPhase = { kind: "idle" };
   private readonly sendTimeoutMs: number;
   private readonly listTimeoutMs: number;
 
@@ -111,13 +114,13 @@ export class IntercomClient extends EventEmitter {
   isConnected(): boolean {
     return (
       (this._sessionId ?? "").length > 0 &&
-      !this.disconnecting &&
+      this.phase.kind !== "closing" &&
       this.connection?.isActive() === true
     );
   }
 
   private requireActiveSocket(): net.Socket {
-    if (this.disconnecting) {
+    if (this.phase.kind === "closing") {
       throw new Error("Client disconnecting");
     }
     const connection = this.connection;
@@ -131,60 +134,71 @@ export class IntercomClient extends EventEmitter {
   }
 
   async connect(session: Omit<SessionInfo, "id">, requestedId?: string): Promise<void> {
-    if (this.connection || this.connecting) {
+    if (this.connection || this.phase.kind !== "idle") {
       throw new Error("Already connected");
     }
-    this.connecting = true;
+    const task = this.establish(session, requestedId);
+    this.phase = { kind: "connecting", task };
     try {
-      const socket = await connectBrokerSocket();
-      const connection = new BrokerConnection(socket, {
-        message: (message) => this.handleBrokerMessage(message),
-        error: (error) => {
-          this.emit("error", error);
-        },
-        closed: (error, expected) => {
-          if (this.connection !== connection) {
-            return;
-          }
-          const established = this._sessionId !== null;
-          this.connection = null;
-          this._sessionId = null;
-          this._topicsSupported = false;
-          this.parking.settle(false);
-          this.guardedDeliverySupported = false;
-          this.wakes.supported = false;
-          this.disconnecting = false;
-          this.failPending(error);
-          if (established && !expected) {
-            this.emit("disconnected", error);
-          }
-        },
-      });
-      this.connection = connection;
-      const { topics, subscriptions, ...identity } = session;
-      try {
-        await connection.start({
-          type: "register",
-          session: identity,
-          requestedId,
-          topicFrames: true,
-          lastMessages: true,
-          parking: true,
-          receiptReads: 1,
-          guardedDelivery: 1,
-          ...this.wakes.registration(),
-        });
-      } catch (error) {
-        if (this.connection === connection) {
-          this.connection = null;
-        }
-        throw error;
-      }
-      if (this.supportsTopics) {
-        await this.restoreTopics(topics, subscriptions);
-      }
+      await task;
     } finally {
-      this.connecting = false;
+      if (this.phase.kind === "connecting" && this.phase.task === task) {
+        this.phase = { kind: this.isConnected() ? "connected" : "idle" };
+      }
+    }
+  }
+
+  private async establish(session: Omit<SessionInfo, "id">, requestedId?: string): Promise<void> {
+    const socket = await connectBrokerSocket();
+    const connection = new BrokerConnection(socket, {
+      message: (message) => this.handleBrokerMessage(message),
+      error: (error) => {
+        this.emit("error", error);
+      },
+      closed: (error, expected) => {
+        if (this.connection !== connection) {
+          return;
+        }
+        const established = this._sessionId !== null;
+        this.connection = null;
+        this._sessionId = null;
+        this._topicsSupported = false;
+        this.parking.settle(false);
+        this.guardedDeliverySupported = false;
+        this.wakes.supported = false;
+        if (this.phase.kind === "connected") {
+          this.phase = { kind: "idle" };
+        }
+        this.failPending(error);
+        if (established && !expected) {
+          this.emit("disconnected", error);
+        }
+      },
+    });
+    this.connection = connection;
+    if (this.phase.kind === "closing") {
+      await connection.disconnect();
+      throw new Error("Client disconnecting");
+    }
+    const { topics, subscriptions, ...identity } = session;
+    try {
+      await connection.start({
+        type: "register",
+        session: identity,
+        requestedId,
+        topicFrames: true,
+        lastMessages: true,
+        parking: true,
+        receiptReads: 1,
+        guardedDelivery: 1,
+        ...this.wakes.registration(),
+      });
+    } catch (error) {
+      await connection.disconnect();
+      throw error;
+    }
+    if (this.supportsTopics) {
+      await this.restoreTopics(topics, subscriptions);
     }
   }
 
@@ -334,14 +348,30 @@ export class IntercomClient extends EventEmitter {
     return this.parking.request(() => this.requireActiveSocket(), on);
   }
 
-  async disconnect(): Promise<void> {
-    const connection = this.connection;
-    if (!connection) {
-      return;
+  disconnect(): Promise<void> {
+    const phase = this.phase;
+    if (phase.kind === "closing") {
+      return phase.task;
     }
-    this.disconnecting = true;
+    const connecting = phase.kind === "connecting" ? phase.task : undefined;
+    const task = Promise.resolve().then(() => this.close(connecting));
+    this.phase = { kind: "closing", task };
+    return task;
+  }
+
+  private async close(connecting: Promise<void> | undefined): Promise<void> {
     this.failPending(new Error("Client disconnected"));
-    await connection.disconnect();
+    try {
+      await this.connection?.disconnect();
+      try {
+        await connecting;
+      } catch {
+        // The connect caller owns acquisition failure; close still joins any acquired socket.
+      }
+      await this.connection?.disconnect();
+    } finally {
+      this.phase = { kind: "idle" };
+    }
   }
 
   listSessions(): Promise<SessionInfo[]> {
@@ -495,7 +525,7 @@ export class IntercomClient extends EventEmitter {
     readonly subscriptions?: SessionInfo["subscriptions"] | undefined;
     readonly topics?: readonly TopicUpdate[] | undefined;
   }): void {
-    if (this.disconnecting) {
+    if (this.phase.kind === "closing") {
       return;
     }