@fitchmultz/pi-subagents 0.52.18 → 0.52.19

package/src/pi-intercom/lifecycle.ts

@@ -24,14 +24,21 @@ type ContextSnapshot = Readonly<Record<keyof ContextTarget, string | null>> &
     readonly guardedDelivery: 1 | null;
   };
 
+type ContextState =
+  | { readonly kind: "inactive"; readonly epoch: number }
+  | { readonly kind: "invalidated"; readonly epoch: number; readonly sessionId: string }
+  | {
+      readonly kind: "live";
+      readonly epoch: number;
+      readonly context: ExtensionContext;
+      readonly sessionId: string;
+      readonly incarnation: string;
+    };
+
 /** Owns native context validity and occupancy, never journal or socket state. */
 export class IntercomLifecycle {
-  private context: ExtensionContext | null = null;
-  private sessionId: string | null = null;
+  private state: ContextState = { kind: "inactive", epoch: 0 };
   private model = "unknown";
-  private disposed = true;
-  private epoch = 0;
-  private incarnation: string | null = null;
   private peerId: string | null = null;
   private guardedDelivery = false;
   private applicationGuard: string | undefined;
@@ -47,10 +54,10 @@ export class IntercomLifecycle {
     this.lineage = lineage;
   }
   get generation(): number {
-    return this.epoch;
+    return this.state.epoch;
   }
   get currentSessionId(): string | null {
-    return this.sessionId;
+    return this.state.kind === "inactive" ? null : this.state.sessionId;
   }
   get toolCount(): number {
     return this.tools.size;
@@ -88,7 +95,7 @@ export class IntercomLifecycle {
     request.respond(this.snapshot());
   }
   snapshot(): ContextSnapshot {
-    if (!this.live()) {
+    if (this.state.kind !== "live" || !this.live()) {
       return {
         version: 1,
         rootSessionId: null,
@@ -100,10 +107,10 @@ export class IntercomLifecycle {
     }
     return {
       version: 1,
-      rootSessionId: this.lineage?.rootSessionId ?? this.sessionId,
+      rootSessionId: this.lineage?.rootSessionId ?? this.state.sessionId,
       parentSessionId: this.lineage?.parentSessionId,
       peerId: this.peerId,
-      incarnation: this.incarnation,
+      incarnation: this.state.incarnation,
       connected: this.peerId !== null,
       guardedDelivery: this.guardedDelivery ? 1 : null,
       applicationGuard: this.applicationGuard,
@@ -135,39 +142,43 @@ export class IntercomLifecycle {
     );
   }
   start(ctx: ExtensionContext): number {
-    this.disposed = false;
-    this.epoch += 1;
-    this.context = ctx;
-    this.sessionId = ctx.sessionManager.getSessionId();
-    this.incarnation = randomUUID();
+    this.state = {
+      kind: "live",
+      epoch: this.state.epoch + 1,
+      context: ctx,
+      sessionId: ctx.sessionManager.getSessionId(),
+      incarnation: randomUUID(),
+    };
     this.applicationGuard = undefined;
     this.model = ctx.model?.id ?? "unknown";
     this.running = false;
     this.activity = 0;
     this.tools.clear();
     this.transport(null);
-    return this.epoch;
+    return this.state.epoch;
   }
   invalidate(): void {
-    this.disposed = true;
-    this.epoch += 1;
+    const epoch = this.state.epoch + 1;
+    this.state =
+      this.state.kind === "inactive"
+        ? { kind: "inactive", epoch }
+        : { kind: "invalidated", epoch, sessionId: this.state.sessionId };
     this.running = false;
     this.tools.clear();
     this.publishContext();
   }
   clear(): void {
-    this.context = null;
-    this.sessionId = null;
+    this.state = { kind: "inactive", epoch: this.state.epoch };
   }
   live(
-    ctx: ExtensionContext | null = this.context,
-    generation = this.epoch,
+    ctx: ExtensionContext | null = this.state.kind === "live" ? this.state.context : null,
+    generation = this.state.epoch,
   ): ExtensionContext | null {
-    if (this.disposed || generation !== this.epoch || !ctx) {
+    if (this.state.kind !== "live" || generation !== this.state.epoch || !ctx) {
       return null;
     }
     try {
-      if (this.sessionId !== null && ctx.sessionManager.getSessionId() !== this.sessionId) {
+      if (ctx.sessionManager.getSessionId() !== this.state.sessionId) {
         return null;
       }
       // Reading a native property detects invalidated contexts without modifying them.
@@ -240,12 +251,12 @@ export class IntercomLifecycle {
   }
   async registration(pendingAsks: number): Promise<Omit<SessionInfo, "id">> {
     const live = this.live();
-    if (!live || this.sessionId === null) {
+    if (!live || this.state.kind !== "live") {
       throw new Error("Intercom runtime not initialized");
     }
     return {
-      ...this.identity(this.sessionId),
-      incarnation: this.incarnation ?? undefined,
+      ...this.identity(this.state.sessionId),
+      incarnation: this.state.incarnation,
       guardedDelivery: 1,
       applicationGuard: this.applicationGuard,
       cwd: live.cwd,

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

@@ -19,6 +19,7 @@ interface ChildWithPipedStdio {
   readonly stdout: ChildProcess["stdout"];
   readonly stderr: ChildProcess["stderr"];
   readonly on: ChildProcess["on"];
+  readonly off: ChildProcess["off"];
 }
 
 interface ChildWithKill {
@@ -356,13 +357,17 @@ export function attachChildProcessLifecycle(
 }
 
 function attachPostExitStdioGuard(child: ChildWithPipedStdio): () => void {
-  let exited = false;
+  let state:
+    | { readonly kind: "waiting" }
+    | { readonly kind: "draining"; idle: NodeJS.Timeout | undefined; readonly hard: NodeJS.Timeout }
+    | { readonly kind: "closed" } = { kind: "waiting" };
   let stdoutEnded = false;
   let stderrEnded = false;
-  let idleTimer: NodeJS.Timeout | undefined;
-  let hardTimer: NodeJS.Timeout | undefined;
 
   const destroyUnendedStdio = () => {
+    if (state.kind !== "draining") {
+      return;
+    }
     if (!stdoutEnded) {
       try {
         child.stdout?.destroy();
@@ -377,55 +382,58 @@ function attachPostExitStdioGuard(child: ChildWithPipedStdio): () => void {
         // The process has exited; failed pipe destruction must not prevent other cleanup.
       }
     }
-  };
-
-  const clearTimers = () => {
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      idleTimer = undefined;
-    }
-    if (hardTimer) {
-      clearTimeout(hardTimer);
-      hardTimer = undefined;
-    }
+    cleanup();
   };
 
   const armIdleTimer = () => {
-    if (!exited) {
+    if (state.kind !== "draining") {
       return;
     }
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-    }
-    idleTimer = setTimeout(destroyUnendedStdio, 2000);
-    idleTimer.unref();
+    clearTimeout(state.idle);
+    state.idle = setTimeout(destroyUnendedStdio, 2000);
+    state.idle.unref();
   };
-
-  child.stdout?.on("data", armIdleTimer);
-  child.stderr?.on("data", armIdleTimer);
-  child.stdout?.on("end", () => {
+  const stdoutEnd = () => {
     stdoutEnded = true;
     if (stderrEnded) {
-      clearTimers();
+      cleanup();
     }
-  });
-  child.stderr?.on("end", () => {
+  };
+  const stderrEnd = () => {
     stderrEnded = true;
     if (stdoutEnded) {
-      clearTimers();
+      cleanup();
     }
-  });
-  child.on("exit", () => {
-    exited = true;
-    armIdleTimer();
-    if (hardTimer) {
+  };
+  const exited = () => {
+    if (state.kind !== "waiting") {
       return;
     }
-    hardTimer = setTimeout(destroyUnendedStdio, 8000);
-    hardTimer.unref();
-  });
-  child.on("close", clearTimers);
-  child.on("error", clearTimers);
-
-  return clearTimers;
+    const hard = setTimeout(destroyUnendedStdio, 8000);
+    hard.unref();
+    state = { kind: "draining", idle: undefined, hard };
+    armIdleTimer();
+  };
+  function cleanup(): void {
+    if (state.kind === "draining") {
+      clearTimeout(state.idle);
+      clearTimeout(state.hard);
+    }
+    state = { kind: "closed" };
+    child.stdout?.off("data", armIdleTimer);
+    child.stderr?.off("data", armIdleTimer);
+    child.stdout?.off("end", stdoutEnd);
+    child.stderr?.off("end", stderrEnd);
+    child.off("exit", exited);
+    child.off("close", cleanup);
+    child.off("error", cleanup);
+  }
+  child.stdout?.on("data", armIdleTimer);
+  child.stderr?.on("data", armIdleTimer);
+  child.stdout?.on("end", stdoutEnd);
+  child.stderr?.on("end", stderrEnd);
+  child.on("exit", exited);
+  child.on("close", cleanup);
+  child.on("error", cleanup);
+  return cleanup;
 }