@fitchmultz/pi-subagents 0.52.20 → 0.52.22

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-wake-state.ts

@@ -24,6 +24,13 @@ function integer(value: unknown): number {
   return value;
 }
 
+type WakeReservation =
+  | { readonly kind: "deferred"; readonly until: number }
+  | { readonly kind: "reserved"; readonly post: (action: () => Promise<void>) => Promise<void> };
+type AttemptPhase =
+  | { readonly kind: "idle" | "posting" | "settlementPending" | "closed" }
+  | Extract<WakeReservation, { readonly kind: "reserved" }>;
+
 /** One helper ledger, independent of identity, certificate, URL and credential rotation. */
 export class WakeState {
   private readonly db: DatabaseSync;
@@ -32,7 +39,7 @@ export class WakeState {
   private readonly inode: number;
   private readonly device: number;
   private readonly owner: WakeOwner;
-  private finishing = false;
+  private phase: AttemptPhase = { kind: "idle" };
 
   constructor(stateDir: string) {
     this.stateDir = stateDir;
@@ -212,14 +219,37 @@ export class WakeState {
     this.db.prepare("DELETE FROM wake_batches WHERE bucket=?").run(bucket);
   }
 
-  /** Persist quota and uncertainty BEFORE dispatch. Returning a deadline means no attempt admitted. */
-  reserve(bucket: string): number | undefined {
+  /** Persist quota and uncertainty before exposing a single-use POST reservation. */
+  reserve(bucket: string): WakeReservation {
     this.retrySettlement();
-    return this.transaction(() => this.reservation(bucket));
+    if (this.phase.kind !== "idle") {
+      throw new Error("A wake reservation is already active or its owner is closed.");
+    }
+    const until = this.transaction(() => this.reservation(bucket));
+    if (until !== undefined) {
+      return { kind: "deferred", until };
+    }
+    const reservation: Extract<WakeReservation, { readonly kind: "reserved" }> = {
+      kind: "reserved",
+      post: async (action) => {
+        if (this.phase !== reservation) {
+          throw new Error("This wake reservation is no longer available.");
+        }
+        this.phase = { kind: "posting" };
+        try {
+          await action();
+        } finally {
+          // Completion, rejection and abort all start the durable expiry window here.
+          this.settle();
+        }
+      },
+    };
+    this.phase = reservation;
+    return reservation;
   }
 
   retrySettlement(): void {
-    if (this.finishing) {
+    if (this.phase.kind === "settlementPending") {
       this.settle();
     }
   }
@@ -238,10 +268,10 @@ export class WakeState {
   }
 
   /** A failed settlement stays open and must be retried before this owner can dispatch again. */
-  settle(): void {
-    this.finishing = true;
+  private settle(): void {
+    this.phase = { kind: "settlementPending" };
     this.transaction(() => this.finishOwner(this.owner.name));
-    this.finishing = false;
+    this.phase = { kind: "idle" };
   }
 
   private finishOwner(owner: string): void {
@@ -314,6 +344,7 @@ export class WakeState {
     try {
       this.settle();
     } finally {
+      this.phase = { kind: "closed" };
       this.db.close();
       this.owner.close();
     }

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

@@ -211,19 +211,14 @@ export class WakeDeliveries {
         next = Math.min(next, due);
         continue;
       }
-      const deferred = state.reserve(key);
-      if (deferred !== undefined) {
-        next = Math.min(next, deferred);
+      const reservation = state.reserve(key);
+      if (reservation.kind === "deferred") {
+        next = Math.min(next, reservation.until);
         continue;
       }
       // ponytail: two cold Macs can each admit one wake. Literal cross-Mac single admission
       // requires a neutral quota authority governing every writer, not a URL hash or HTTP 2xx.
-      try {
-        await this.post(candidate);
-      } finally {
-        // Expiry starts after response/error/abort, never before COMMIT or connect/TLS.
-        state.settle();
-      }
+      await reservation.post(() => this.post(candidate));
       // Re-read ACKs and all groups after transport I/O; a snapshot must not wake already consumed mail.
       return Date.now();
     }

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;
   }
 }