@fitchmultz/pi-subagents 0.51.0 → 0.52.1

package/src/pi-intercom/inbound.ts

@@ -106,7 +106,21 @@ export class IntercomInbound {
     }
     this.owners.delivery.queue(entry, "passive");
   }
+  /** Counted synchronously so a parking fence observes frames received before its ack. */
+  receiving = 0;
   async receive(ctx: ExtensionContext, from: SessionInfo, input: Message): Promise<void> {
+    this.receiving++;
+    try {
+      await this.receiveCounted(ctx, from, input);
+    } finally {
+      this.receiving--;
+    }
+  }
+  private async receiveCounted(
+    ctx: ExtensionContext,
+    from: SessionInfo,
+    input: Message,
+  ): Promise<void> {
     const generation = this.lifecycle.generation;
     const restore = this.owners.delivery.restoring;
     if (restore) {

package/src/pi-intercom/index.ts

@@ -13,6 +13,20 @@ import { IntercomInspection } from "./inspection.ts";
 import { IntercomTools } from "./tools.ts";
 import { IntercomSessionEvents } from "./session-events.ts";
 import { registerIntercomTools } from "./tool-registration.ts";
+import { isParkRequest, PARK, PARKED_HISTORY, WAKE } from "../shared/parking.ts";
+import type { NativeHistory } from "./last-message.ts";
+
+/** The agent runtime answers for its exited parked child from the captured native session. */
+function parkedHistory(pi: ExtensionAPI, peer: string): Promise<NativeHistory | undefined> {
+  let history: Promise<NativeHistory | undefined> | undefined;
+  pi.events.emit(PARKED_HISTORY, {
+    peer,
+    reply: (found: Promise<NativeHistory | undefined>) => {
+      history = found;
+    },
+  });
+  return history ?? Promise.reject(new Error("No agent runtime owns parked history."));
+}
 
 export default function piIntercomExtension(pi: ExtensionAPI): void {
   const config = loadConfig();
@@ -34,6 +48,10 @@ export default function piIntercomExtension(pi: ExtensionAPI): void {
         new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }),
       );
     },
+    parkedHistory: (peer) => parkedHistory(pi, peer.id),
+    wake: (peer) => {
+      pi.events.emit(WAKE, peer);
+    },
   });
   const delivery = new InboundDeliveryOwner(pi, lifecycle, journal, {
     replies,
@@ -59,4 +77,27 @@ export default function piIntercomExtension(pi: ExtensionAPI): void {
     wait,
   }).register();
   registerIntercomTools(pi, tools);
+  pi.events.on(PARK, (request) => {
+    if (isParkRequest(request)) {
+      request.reply(request.park ? connection.park() : connection.unpark());
+    }
+  });
+  // Native fork sleep readiness; it vetoes only this package's own parking, never other saves.
+  Reflect.apply(pi.on.bind(pi), undefined, [
+    "working_session_save",
+    () =>
+      !connection.parking
+        ? undefined
+        : {
+            blockers: [
+              inbound.receiving > 0 && "intercom is receiving a message",
+              journal.size > 0 && "intercom inbound messages await delivery",
+              replies.listPending().length > 0 && "intercom asks await replies",
+              wait.waiting && "intercom is waiting for a reply",
+              (delivery.restoring !== undefined || delivery.batching) &&
+                "intercom delivery is restoring",
+              connection.reconnected && "intercom reconnected while parking",
+            ].filter((blocker) => typeof blocker === "string"),
+          },
+  ]);
 }

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

@@ -7,7 +7,7 @@ import {
   type SessionInfo,
 } from "./types.ts";
 
-type NativeHistory = ExtensionContext["sessionManager"];
+export type NativeHistory = Pick<ExtensionContext["sessionManager"], "getBranch">;
 function completedResponse(
   manager: NativeHistory,
   entryId?: string,

package/src/shared/parking.ts

@@ -0,0 +1,22 @@
+import type { NativeHistory } from "../pi-intercom/last-message.ts";
+import { isRecord } from "./unknown.ts";
+
+/** A child actor asks its intercom to fence broker input before parking, or to release it. */
+export const PARK = "pi-subagents:park";
+export interface ParkRequest {
+  readonly park: boolean;
+  readonly reply: (parked: Promise<boolean>) => void;
+}
+/** A main intercom wakes or reads an exited parked child through the agent runtime. */
+export const WAKE = "pi-subagents:wake";
+export const PARKED_HISTORY = "pi-subagents:parked-history";
+export interface HistoryRequest {
+  readonly peer: string;
+  readonly reply: (history: Promise<NativeHistory | undefined>) => void;
+}
+export function isParkRequest(value: unknown): value is ParkRequest {
+  return isRecord(value) && typeof value.park === "boolean" && typeof value.reply === "function";
+}
+export function isHistoryRequest(value: unknown): value is HistoryRequest {
+  return isRecord(value) && typeof value.peer === "string" && typeof value.reply === "function";
+}

package/src/shared/post-exit-stdio-guard.ts

@@ -5,6 +5,9 @@ import { hasErrorCode } from "./unknown.ts";
 
 const BIRTH_FIELDS = ["lstart=", "pgid="];
 
+// macOS ships /bin/ps; resolving "ps" through PATH can spawn once per missing entry.
+export const PS_COMMAND = process.platform === "darwin" ? "/bin/ps" : "ps";
+
 interface AgentProcessExit {
   readonly pid?: number;
   readonly code: number | null;
@@ -75,7 +78,7 @@ function psOptions(zone: string | undefined) {
 
 function readPsFields(pid: number, fields: readonly string[], zone?: string): string | undefined {
   try {
-    return execFileSync("ps", psArguments(pid, fields), {
+    return execFileSync(PS_COMMAND, psArguments(pid, fields), {
       ...psOptions(zone),
       stdio: ["ignore", "pipe", "ignore"],
     })
@@ -93,7 +96,7 @@ function observePsFields(
   zone?: string,
 ): Promise<string | undefined> {
   return new Promise((resolve) => {
-    execFile("ps", psArguments(pid, fields), psOptions(zone), (error, stdout) => {
+    execFile(PS_COMMAND, psArguments(pid, fields), psOptions(zone), (error, stdout) => {
       resolve(error ? undefined : stdout.trim().replace(/\s+/g, " "));
     });
   });