@fitchmultz/pi-subagents 0.52.17 → 0.52.19

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

@@ -1,5 +1,5 @@
 import { spawn } from "child_process";
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import net from "net";
@@ -12,6 +12,7 @@ import {
   prepareBrokerSocketPath,
 } from "./paths.ts";
 import { isBrokerPidReused } from "./pid.ts";
+import { acquireSpawnClaim } from "./spawn-claim.ts";
 import { errorMessage, hasErrorCode } from "../../shared/unknown.ts";
 
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
@@ -85,8 +86,8 @@ export async function spawnBrokerIfNeeded(
     return;
   }
 
-  const ownsLock = acquireSpawnLock();
-  if (!ownsLock) {
+  const release = acquireSpawnClaim(BROKER_SPAWN_LOCK);
+  if (release === undefined) {
     await waitForBroker();
     return;
   }
@@ -138,7 +139,7 @@ export async function spawnBrokerIfNeeded(
         });
     });
   } finally {
-    releaseSpawnLock();
+    release();
   }
 }
 
@@ -153,26 +154,33 @@ export async function assertBrokerCanStart(): Promise<void> {
   await stopUnhealthyBrokerBeforeSpawn();
 }
 
-function readLivePid(pidPath: string): number | null {
-  if (!existsSync(pidPath)) {
-    return null;
-  }
+type BrokerOwner =
+  | { readonly kind: "absent" }
+  | { readonly kind: "live"; readonly pid: number }
+  | { readonly kind: "uncertain"; readonly reason: string };
+
+function readBrokerOwner(pidPath: string): BrokerOwner {
   let raw: string;
   try {
     raw = readFileSync(pidPath, "utf-8");
-  } catch {
-    return null;
+  } catch (error) {
+    return hasErrorCode(error, "ENOENT")
+      ? { kind: "absent" }
+      : { kind: "uncertain", reason: `Cannot read broker PID record: ${errorMessage(error)}` };
   }
-  const pid = parseInt(raw.trim(), 10);
-  if (!Number.isFinite(pid) || pid <= 0) {
-    return null;
+  const first = raw.trim().split("\n")[0] ?? "";
+  const pid = Number(first);
+  if (!/^[1-9]\d*$/.test(first) || !Number.isSafeInteger(pid)) {
+    return { kind: "uncertain", reason: "Broker PID record is invalid" };
   }
   try {
     process.kill(pid, 0);
   } catch (error) {
-    return hasErrorCode(error, "EPERM") ? pid : null;
+    return hasErrorCode(error, "ESRCH")
+      ? { kind: "absent" }
+      : { kind: "uncertain", reason: `Cannot establish broker PID ${pid}: ${errorMessage(error)}` };
   }
-  return isBrokerPidReused(pid, raw) ? null : pid;
+  return isBrokerPidReused(pid, raw) ? { kind: "absent" } : { kind: "live", pid };
 }
 
 async function previousBrokerWarning(): Promise<string | undefined> {
@@ -183,9 +191,10 @@ async function previousBrokerWarning(): Promise<string | undefined> {
       return "An older agent-directory Intercom broker is still running. Its peers are not part of shared same-user discovery until they reload with the updated extension. Existing sessions and accepted work are untouched; no legacy fallback is used.";
     }
   }
-  const previousPid = readLivePid(join(getPiAgentDir(), "intercom", "broker.pid"));
-  if (previousPid !== null) {
-    return `Older Intercom broker PID ${previousPid} may still own accepted work. Its peers need to reload with the updated extension to join shared same-user discovery. Nothing was stopped or replaced; no legacy fallback is used.`;
+  const previous = readBrokerOwner(join(getPiAgentDir(), "intercom", "broker.pid"));
+  if (previous.kind !== "absent") {
+    const owner = previous.kind === "live" ? `PID ${previous.pid}` : "with uncertain PID identity";
+    return `Older Intercom broker ${owner} may still own accepted work. Its peers need to reload with the updated extension to join shared same-user discovery. Nothing was stopped or replaced; no legacy fallback is used.`;
   }
   return undefined;
 }
@@ -194,13 +203,19 @@ export async function stopUnhealthyBrokerBeforeSpawn(): Promise<void> {
   if (await checkSocketConnectable()) {
     return;
   }
-  const pid = readLivePid(BROKER_PID);
-  if (pid === null) {
-    return;
+  const owner = readBrokerOwner(BROKER_PID);
+  switch (owner.kind) {
+    case "absent":
+      return;
+    case "live":
+      throw new Error(
+        `Intercom broker PID ${owner.pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`,
+      );
+    case "uncertain":
+      throw new Error(
+        `${owner.reason}; refusing to spawn a second broker while ownership is uncertain.`,
+      );
   }
-  throw new Error(
-    `Intercom broker PID ${pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`,
-  );
 }
 
 async function checkSocketConnectable(): Promise<boolean> {
@@ -227,63 +242,6 @@ function checkOneSocket(brokerSocket: string): Promise<boolean> {
   });
 }
 
-function acquireSpawnLock(): boolean {
-  const maxRetries = 5;
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      writeFileSync(BROKER_SPAWN_LOCK, `${process.pid}\n${Date.now()}\n`, { flag: "wx" });
-      return true;
-    } catch (error) {
-      if (!hasErrorCode(error, "EEXIST")) {
-        throw error;
-      }
-      if (isSpawnLockStale()) {
-        releaseSpawnLock();
-        continue;
-      }
-      return false;
-    }
-  }
-  return false;
-}
-
-function isSpawnLockStale(): boolean {
-  if (!existsSync(BROKER_SPAWN_LOCK)) {
-    return false;
-  }
-
-  try {
-    const [pidLine = "", createdAtLine = "0"] = readFileSync(BROKER_SPAWN_LOCK, "utf-8")
-      .trim()
-      .split("\n");
-    const pid = Number.parseInt(pidLine, 10);
-    const createdAt = Number.parseInt(createdAtLine, 10);
-    const ageMs = Date.now() - createdAt;
-
-    if (Number.isFinite(pid)) {
-      try {
-        process.kill(pid, 0);
-      } catch {
-        // The process that created the lock is gone.
-        return true;
-      }
-    }
-
-    return !Number.isFinite(createdAt) || ageMs > 10_000;
-  } catch {
-    // Unreadable lock contents are treated as stale so a new broker can start.
-    return true;
-  }
-}
-
-function releaseSpawnLock(): void {
-  try {
-    unlinkSync(BROKER_SPAWN_LOCK);
-  } catch {
-    // Another cleanup path may already have removed the lock.
-  }
-}
-
 async function waitForBroker(timeoutMs = 5000): Promise<void> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -294,5 +252,7 @@ async function waitForBroker(timeoutMs = 5000): Promise<void> {
     // Polling waits between probes rather than starting an unbounded batch.
     await sleep(100);
   }
-  throw new Error("Broker failed to start within timeout");
+  throw new Error(
+    `Broker failed to start within timeout. Startup claim: ${BROKER_SPAWN_LOCK}. Live or uncertain owners are not reclaimed.`,
+  );
 }

package/src/pi-intercom/inbound-delivery.ts

@@ -185,7 +185,7 @@ export class InboundDeliveryOwner {
     const trigger = index === -1 ? undefined : rest.splice(index, 1)[0];
     const replyTarget = entries.find((entry) => entry.message.expectsReply === true) ?? trigger;
     if (replyTarget && this.journal.get(replyTarget.message.id) === replyTarget) {
-      this.hooks.replies.queueTurnContext({ ...replyTarget, receivedAt: Date.now() });
+      this.hooks.replies.queueTurnContext(replyTarget.message.id);
     }
     for (const entry of rest) {
       if (!this.live(generation)) {
@@ -295,11 +295,7 @@ export class InboundDeliveryOwner {
       this.journal.markNative(entry.message.id);
     }
     if (delivery !== "passive") {
-      this.hooks.replies.queueTurnContext({
-        from: entry.from,
-        message: entry.message,
-        receivedAt: Date.now(),
-      });
+      this.hooks.replies.queueTurnContext(entry.message.id);
     }
   }
   private nativeMessage(entry: InboundMessageEntry): Parameters<ExtensionAPI["sendMessage"]>[0] {

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/pi-intercom/reply-tracker.ts

@@ -93,9 +93,9 @@ function replyBySender(contexts: readonly IntercomContext[], to: string): Interc
 }
 export class ReplyTracker {
   private readonly pendingAsks = new Map<string, IntercomContext>();
-  private readonly pendingTurnContexts: IntercomContext[] = [];
-  private currentTurnContext: IntercomContext | null = null;
-  private activeAgentContext: IntercomContext | null = null;
+  private readonly pendingTurnIds: string[] = [];
+  private currentTurnId: string | null = null;
+  private activeAgentId: string | null = null;
   private readonly askTimeoutMs: number;
 
   constructor(askTimeoutMs = 10 * 60 * 1000) {
@@ -115,67 +115,66 @@ export class ReplyTracker {
     return context;
   }
 
-  queueTurnContext(context: IntercomContext): void {
-    if (context.message.expectsReply !== true) {
+  queueTurnContext(messageId: string): void {
+    if (!this.pendingAsks.has(messageId) || this.hasTurnContext(messageId)) {
       return;
     }
-    if (this.hasTurnContext(context.message.id)) {
-      return;
-    }
-    this.pendingTurnContexts.push(context);
+    this.pendingTurnIds.push(messageId);
   }
 
   beginTurn(now = Date.now()): void {
     this.pruneExpired(now);
-    this.currentTurnContext = this.pendingTurnContexts.shift() ?? null;
-    if (this.currentTurnContext) {
-      this.activeAgentContext = this.currentTurnContext;
+    this.currentTurnId = this.pendingTurnIds.shift() ?? null;
+    if (this.currentTurnId !== null) {
+      this.activeAgentId = this.currentTurnId;
     }
   }
 
   currentTurn(): IntercomContext | null {
-    return this.currentTurnContext ?? this.activeAgentContext;
+    const id = this.currentTurnId ?? this.activeAgentId;
+    return id === null ? null : (this.pendingAsks.get(id) ?? null);
   }
 
   endTurn(): void {
-    this.currentTurnContext = null;
+    this.currentTurnId = null;
   }
 
   endAgent(): void {
-    this.currentTurnContext = null;
-    this.activeAgentContext = null;
+    this.currentTurnId = null;
+    this.activeAgentId = null;
   }
 
   reset(): void {
     this.pendingAsks.clear();
-    this.pendingTurnContexts.length = 0;
-    this.currentTurnContext = null;
-    this.activeAgentContext = null;
+    this.pendingTurnIds.length = 0;
+    this.endAgent();
   }
 
   expireSender(sessionId: string): number {
-    const expires = (context: IntercomContext) => context.from.id === sessionId;
+    const expiring = new Set(
+      [...this.pendingAsks.values()]
+        .filter((context) => context.from.id === sessionId)
+        .map((context) => context.message.id),
+    );
     let expired = 0;
-    for (const [messageId, context] of this.pendingAsks) {
-      if (expires(context)) {
-        this.pendingAsks.delete(messageId);
-        expired += 1;
-      }
+    for (const messageId of expiring) {
+      this.pendingAsks.delete(messageId);
+      expired += 1;
     }
-    const beforeQueued = this.pendingTurnContexts.length;
-    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
-      const context = this.pendingTurnContexts[index];
-      if (context !== undefined && expires(context)) {
-        this.pendingTurnContexts.splice(index, 1);
+    const beforeQueued = this.pendingTurnIds.length;
+    for (let index = this.pendingTurnIds.length - 1; index >= 0; index -= 1) {
+      const id = this.pendingTurnIds[index];
+      if (id !== undefined && expiring.has(id)) {
+        this.pendingTurnIds.splice(index, 1);
       }
     }
-    expired += beforeQueued - this.pendingTurnContexts.length;
-    if (this.currentTurnContext && expires(this.currentTurnContext)) {
-      this.currentTurnContext = null;
+    expired += beforeQueued - this.pendingTurnIds.length;
+    if (this.currentTurnId !== null && expiring.has(this.currentTurnId)) {
+      this.currentTurnId = null;
       expired += 1;
     }
-    if (this.activeAgentContext && expires(this.activeAgentContext)) {
-      this.activeAgentContext = null;
+    if (this.activeAgentId !== null && expiring.has(this.activeAgentId)) {
+      this.activeAgentId = null;
       expired += 1;
     }
     return expired;
@@ -188,30 +187,23 @@ export class ReplyTracker {
     this.pruneExpired(now);
 
     const pending = Array.from(this.pendingAsks.values());
-    const contexts = this.currentTurnContext
-      ? [
-          this.currentTurnContext,
-          ...pending.filter(
-            (context) => context.message.id !== this.currentTurnContext?.message.id,
-          ),
-        ]
-      : pending;
-
     const replyTo = options.replyTo ?? "";
     const to = options.to ?? "";
     if (replyTo !== "") {
-      return explicitReply(contexts, replyTo, to);
+      return explicitReply(pending, replyTo, to);
     }
     if (to !== "") {
-      return replyBySender(contexts, to);
+      return replyBySender(pending, to);
     }
     return this.implicitReplyTarget(pending);
   }
 
   /** Without an explicit target, the turn context wins, then a sole pending ask. */
   private implicitReplyTarget(pending: readonly IntercomContext[]): IntercomContext {
-    if (this.currentTurnContext) {
-      return this.currentTurnContext;
+    const current =
+      this.currentTurnId === null ? undefined : this.pendingAsks.get(this.currentTurnId);
+    if (current) {
+      return current;
     }
     const [solePending] = pending;
     if (pending.length === 1 && solePending !== undefined) {
@@ -234,24 +226,24 @@ export class ReplyTracker {
 
   private hasTurnContext(messageId: string): boolean {
     return (
-      this.pendingTurnContexts.some((context) => context.message.id === messageId) ||
-      this.currentTurnContext?.message.id === messageId ||
-      this.activeAgentContext?.message.id === messageId
+      this.pendingTurnIds.includes(messageId) ||
+      this.currentTurnId === messageId ||
+      this.activeAgentId === messageId
     );
   }
 
   private removeContext(messageId: string): void {
     this.pendingAsks.delete(messageId);
-    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
-      if (this.pendingTurnContexts[index]?.message.id === messageId) {
-        this.pendingTurnContexts.splice(index, 1);
+    for (let index = this.pendingTurnIds.length - 1; index >= 0; index -= 1) {
+      if (this.pendingTurnIds[index] === messageId) {
+        this.pendingTurnIds.splice(index, 1);
       }
     }
-    if (this.currentTurnContext?.message.id === messageId) {
-      this.currentTurnContext = null;
+    if (this.currentTurnId === messageId) {
+      this.currentTurnId = null;
     }
-    if (this.activeAgentContext?.message.id === messageId) {
-      this.activeAgentContext = null;
+    if (this.activeAgentId === messageId) {
+      this.activeAgentId = null;
     }
   }
 

package/src/pi-intercom/session-events.ts

@@ -33,7 +33,7 @@ type Connection = Readonly<
   >
 >;
 type Journal = Readonly<
-  Pick<InboundJournal, "clearNative" | "consume" | "reconcileConsumed" | "reset" | "retire">
+  Pick<InboundJournal, "clearNative" | "consume" | "get" | "reconcileConsumed" | "reset" | "retire">
 >;
 type ReplyWaitHandle = Readonly<Pick<ReplyWait, "reject">>;
 type InboundDeliveryHandle = Readonly<
@@ -101,6 +101,8 @@ export class IntercomSessionEvents {
       client?.isConnected() !== true ||
       !context ||
       context.message.expectsReply !== true ||
+      // A native turn can start without consuming its queued input after an abort.
+      journal.get(context.message.id) !== undefined ||
       error === null ||
       error === ""
     ) {

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