@fitchmultz/pi-subagents 0.52.19 → 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/bridge-presence.ts

@@ -18,11 +18,15 @@ interface PresenceOwner {
   readonly restored: (identity: Identity, expires: number) => void;
 }
 
+type PresencePhase =
+  | { readonly kind: "idle" }
+  | { readonly kind: "scheduled"; readonly timer: NodeJS.Timeout }
+  | { readonly kind: "running"; readonly task: Promise<void> }
+  | { readonly kind: "stopped"; readonly task: Promise<void> };
+
 export class PersistentPresence {
   private readonly registrations = new Map<string, Registration>();
-  private stopped = false;
-  private timer?: NodeJS.Timeout;
-  private running?: Promise<void> | undefined;
+  private phase: PresencePhase = { kind: "idle" };
   private readonly owner: PresenceOwner;
 
   constructor(owner: PresenceOwner) {
@@ -88,22 +92,30 @@ export class PersistentPresence {
   }
 
   start(): void {
-    if (!this.stopped && !this.running) {
-      clearTimeout(this.timer);
-      this.timer = setTimeout(() => {
-        this.running = this.maintain().finally(() => {
-          this.running = undefined;
-          if (!this.stopped) {
-            this.timer = setTimeout(() => this.start(), 15000);
-          }
-        });
-      }, 0);
+    if (this.phase.kind === "running" || this.phase.kind === "stopped") {
+      return;
+    }
+    this.schedule(0);
+  }
+
+  private schedule(delay: number): void {
+    if (this.phase.kind === "scheduled") {
+      clearTimeout(this.phase.timer);
     }
+    const timer = setTimeout(() => {
+      const task = this.maintain().finally(() => {
+        if (this.phase.kind !== "stopped") {
+          this.schedule(15000);
+        }
+      });
+      this.phase = { kind: "running", task };
+    }, delay);
+    this.phase = { kind: "scheduled", timer };
   }
 
   private async maintain(): Promise<void> {
     for (const registration of this.registrations.values()) {
-      if (this.stopped) {
+      if (this.phase.kind === "stopped") {
         return;
       }
       const identity = this.owner.clients().get(registration.fingerprint);
@@ -125,9 +137,16 @@ export class PersistentPresence {
     }
   }
 
-  async stop(): Promise<void> {
-    this.stopped = true;
-    clearTimeout(this.timer);
-    await this.running;
+  stop(): Promise<void> {
+    const phase = this.phase;
+    if (phase.kind === "stopped") {
+      return phase.task;
+    }
+    if (phase.kind === "scheduled") {
+      clearTimeout(phase.timer);
+    }
+    const task = phase.kind === "running" ? phase.task : Promise.resolve();
+    this.phase = { kind: "stopped", task };
+    return task;
   }
 }

package/src/pi-intercom/bridge-wake.ts

@@ -15,6 +15,12 @@ interface Candidate {
   readonly entry: PendingNotification;
 }
 
+type DeliveryPhase =
+  | { readonly kind: "idle" }
+  | { readonly kind: "scheduled"; readonly timer: NodeJS.Timeout }
+  | { readonly kind: "running" | "running-dirty"; readonly task: Promise<void> }
+  | { readonly kind: "stopped"; readonly task: Promise<void> };
+
 function actionable(entry: PendingNotification): boolean {
   const message = entry.message;
   if (entry.acknowledged || message.passive === true || message.delivery === "passive") {
@@ -39,9 +45,7 @@ export class WakeDeliveries {
   private readonly allowed: (identity: Identity) => boolean;
   private readonly deliveries = new Map<string, Delivery>();
   private readonly controller = new AbortController();
-  private timer?: NodeJS.Timeout;
-  private running?: Promise<void> | undefined;
-  private dirty = false;
+  private phase: DeliveryPhase = { kind: "idle" };
   private storageBackoff = 15000;
 
   constructor(stateDir: string | undefined, allowed: (identity: Identity) => boolean) {
@@ -83,10 +87,17 @@ export class WakeDeliveries {
     } catch {
       // The scheduled storage recovery fails closed; never let an event bypass durable admission.
     }
-    if (this.running) {
-      this.dirty = true;
-    } else {
-      this.schedule(Date.now());
+    const phase = this.phase;
+    switch (phase.kind) {
+      case "running":
+        this.phase = { kind: "running-dirty", task: phase.task };
+        return;
+      case "running-dirty":
+      case "stopped":
+        return;
+      case "idle":
+      case "scheduled":
+        this.schedule(Date.now());
     }
   }
 
@@ -101,31 +112,40 @@ export class WakeDeliveries {
   }
 
   private schedule(deadline: number): void {
-    clearTimeout(this.timer);
-    this.timer = setTimeout(
-      () => {
-        this.dirty = false;
-        let next = Infinity;
-        this.running = this.deliver()
-          .then((due) => {
-            next = due;
-            this.storageBackoff = 15000;
-            return;
-          })
-          .catch(() => {
-            log("wake_delivery", { result: "storage_unavailable" });
-            next = Date.now() + this.storageBackoff;
-            this.storageBackoff = Math.min(this.storageBackoff * 2, 300000);
-          })
-          .finally(() => {
-            this.running = undefined;
-            if (!this.controller.signal.aborted && (this.dirty || Number.isFinite(next))) {
-              this.schedule(this.dirty ? Date.now() : next);
-            }
-          });
-      },
+    if (this.phase.kind === "scheduled") {
+      clearTimeout(this.phase.timer);
+    }
+    const timer = setTimeout(
+      () => this.startDelivery(),
       Math.max(0, Math.min(deadline - Date.now(), 0x7fffffff)),
     );
+    this.phase = { kind: "scheduled", timer };
+  }
+
+  private startDelivery(): void {
+    let next = Infinity;
+    const task = this.deliver()
+      .then((due) => {
+        next = due;
+        this.storageBackoff = 15000;
+        return;
+      })
+      .catch(() => {
+        log("wake_delivery", { result: "storage_unavailable" });
+        next = Date.now() + this.storageBackoff;
+        this.storageBackoff = Math.min(this.storageBackoff * 2, 300000);
+      })
+      .finally(() => {
+        if (this.phase.kind === "stopped") {
+          return;
+        }
+        const dirty = this.phase.kind === "running-dirty";
+        this.phase = { kind: "idle" };
+        if (dirty || Number.isFinite(next)) {
+          this.schedule(dirty ? Date.now() : next);
+        }
+      });
+    this.phase = { kind: "running", task };
   }
 
   private authorized(delivery: Delivery): boolean {
@@ -267,14 +287,26 @@ export class WakeDeliveries {
     this.changed(false);
   }
 
-  async stop(): Promise<void> {
-    this.controller.abort();
-    clearTimeout(this.timer);
-    await this.running;
-    for (const delivery of this.deliveries.values()) {
-      delivery.mailbox.close();
+  stop(): Promise<void> {
+    const phase = this.phase;
+    if (phase.kind === "stopped") {
+      return phase.task;
     }
-    this.deliveries.clear();
-    this.state?.close();
+    if (phase.kind === "scheduled") {
+      clearTimeout(phase.timer);
+    }
+    const running =
+      phase.kind === "running" || phase.kind === "running-dirty" ? phase.task : undefined;
+    const task = Promise.resolve(running).then(() => {
+      for (const delivery of this.deliveries.values()) {
+        delivery.mailbox.close();
+      }
+      this.deliveries.clear();
+      this.state?.close();
+      return;
+    });
+    this.phase = { kind: "stopped", task };
+    this.controller.abort();
+    return task;
   }
 }

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-last.ts

@@ -18,6 +18,7 @@ import {
   type SessionInfo,
 } from "../types.ts";
 import { writeMessage } from "./framing.ts";
+import { PendingRequests } from "./pending-requests.ts";
 
 /** A peer's read of this session or, for a main, of its exited `parked` child. */
 export function lastRequest(msg: UnknownRecord): {
@@ -46,35 +47,25 @@ export class LastMessageRequests {
   constructor(timeoutMs: number) {
     this.timeoutMs = timeoutMs;
   }
-  private readonly pending = new Map<
-    string,
-    {
-      readonly resolve: (result: NativeReadResult) => void;
-      readonly reject: (error: Readonly<Error>) => void;
-      readonly timer: NodeJS.Timeout;
-    }
-  >();
+  private readonly pending = new PendingRequests<{
+    readonly resolve: (result: NativeReadResult) => void;
+    readonly reject: (error: Readonly<Error>) => void;
+  }>();
 
   fail(error: Readonly<Error>): void {
     this.lastMessages = false;
     this.receiptReads = false;
-    for (const pending of this.pending.values()) {
-      clearTimeout(pending.timer);
-      pending.reject(error);
-    }
-    this.pending.clear();
+    this.pending.fail(error);
   }
 
   receive(message: UnknownRecord): void {
     if (typeof message.requestId !== "string" || !isNativeReadResult(message.result)) {
       throw new Error("Invalid last-message response");
     }
-    const pending = this.pending.get(message.requestId);
+    const pending = this.pending.take(message.requestId);
     if (!pending) {
       return;
     }
-    clearTimeout(pending.timer);
-    this.pending.delete(message.requestId);
     pending.resolve(message.result);
   }
 
@@ -100,18 +91,16 @@ export class LastMessageRequests {
     }
     return new Promise((resolve, reject) => {
       const requestId = randomUUID();
-      const timer = setTimeout(() => {
-        this.pending.delete(requestId);
-        reject(new Error("Last-message read timeout"));
-      }, this.timeoutMs);
-      timer.unref();
-      this.pending.set(requestId, { resolve, reject, timer });
+      this.pending.set(
+        requestId,
+        { resolve, reject },
+        this.timeoutMs,
+        () => new Error("Last-message read timeout"),
+      );
       try {
         writeMessage(socket, { type: "last_request", requestId, to, query });
       } catch (error) {
-        clearTimeout(timer);
-        this.pending.delete(requestId);
-        reject(new Error(errorMessage(error)));
+        this.pending.take(requestId)?.reject(new Error(errorMessage(error)));
       }
     });
   }