@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/shared/post-exit-stdio-guard.js

@@ -1,23 +1,30 @@
 import { execFileSync } from "node:child_process";
 import { readLinuxProcess } from "../pi-intercom/broker/pid.js";
+import { hasErrorCode } from "./unknown.js";
 /** Capture the detached group leader's birth identity; Pi may replace its command-line title. */
 export function readChildProcessIdentity(pid) {
-    if (!Number.isSafeInteger(pid) || pid <= 0)
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
         return undefined;
-    if (process.platform === "linux")
+    }
+    if (process.platform === "linux") {
         return readLinuxProcess(pid)?.identity;
+    }
     try {
         const identity = execFileSync("ps", ["-p", String(pid), "-o", "lstart=", "-o", "pgid="], {
-            encoding: "utf8", timeout: 1000, stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf8",
+            timeout: 1000,
+            stdio: ["ignore", "pipe", "ignore"],
             env: { ...process.env, LC_ALL: "C" },
-        }).trim().replace(/\s+/g, " ");
+        })
+            .trim()
+            .replace(/\s+/g, " ");
         return Number(identity.split(" ").at(-1)) === pid ? identity : undefined;
     }
     catch {
         return undefined;
     }
 }
-export function trySignalChild(child, signal) {
+function trySignalChild(child, signal) {
     try {
         return child.kill(signal);
     }
@@ -26,14 +33,15 @@ export function trySignalChild(child, signal) {
     }
 }
 export function isChildTreeAlive(child) {
-    if (child.pid) {
+    if (child.pid !== undefined && child.pid !== 0) {
         try {
             process.kill(-child.pid, 0);
             return true;
         }
         catch (error) {
-            if (error.code === "EPERM")
+            if (hasErrorCode(error, "EPERM")) {
                 return true;
+            }
         }
     }
     try {
@@ -45,7 +53,7 @@ export function isChildTreeAlive(child) {
 }
 /** Signal the detached child's process group, falling back if it is not a group leader. */
 export function trySignalChildTree(child, signal) {
-    if (child.pid) {
+    if (child.pid !== undefined && child.pid !== 0) {
         try {
             process.kill(-child.pid, signal);
             return true;
@@ -56,84 +64,107 @@ export function trySignalChildTree(child, signal) {
     }
     return trySignalChild(child, signal);
 }
-/** One lifetime for the owned process group, including descendants holding its pipes open. */
-export function attachChildProcessLifecycle(child) {
-    let closed = false;
-    let exited = false;
-    let stopping = false;
-    let settledCleanup = false;
-    let agentProcessExit;
-    let drainTimer;
-    let escalationTimer;
-    const clearDrain = () => {
-        clearTimeout(drainTimer);
-        drainTimer = undefined;
-    };
-    const clearTimers = () => {
-        clearDrain();
-        clearTimeout(escalationTimer);
-        escalationTimer = undefined;
-    };
-    const signalTree = () => {
+function activityEvent(type) {
+    return (type === "agent_start" ||
+        type === "turn_start" ||
+        type?.startsWith("message_") === true ||
+        type?.startsWith("tool_execution_") === true);
+}
+class OwnedChildLifecycle {
+    closed = false;
+    exited = false;
+    isStopping = false;
+    isSettledCleanup = false;
+    exit;
+    drainTimer;
+    escalationTimer;
+    child;
+    clearStdioGuard;
+    constructor(child) {
+        this.child = child;
+        this.clearStdioGuard = attachPostExitStdioGuard(child);
+        child.on("exit", (code, signal) => {
+            this.exited = true;
+            this.exit = { pid: child.pid, code, signal, at: Date.now() };
+            this.clearTimers();
+            // The leader may exit before resistant descendants release inherited stdio.
+            trySignalChildTree(child, "SIGKILL");
+        });
+        child.on("close", () => {
+            this.dispose();
+        });
+        child.on("error", () => {
+            this.dispose();
+        });
+    }
+    clearDrain() {
+        clearTimeout(this.drainTimer);
+        this.drainTimer = undefined;
+    }
+    clearTimers() {
+        this.clearDrain();
+        clearTimeout(this.escalationTimer);
+        this.escalationTimer = undefined;
+    }
+    signalTree() {
         // Pi print mode uses SIGTERM to dispose its own detached tool processes.
-        const sent = trySignalChildTree(child, "SIGTERM");
-        escalationTimer = setTimeout(() => {
-            if (isChildTreeAlive(child))
-                trySignalChildTree(child, "SIGKILL");
+        const sent = trySignalChildTree(this.child, "SIGTERM");
+        this.escalationTimer = setTimeout(() => {
+            if (isChildTreeAlive(this.child)) {
+                trySignalChildTree(this.child, "SIGKILL");
+            }
         }, 3000);
-        escalationTimer.unref();
+        this.escalationTimer.unref();
         return sent;
+    }
+    terminate = () => {
+        // Cancellation overrides pending or already-started successful settlement cleanup.
+        this.isSettledCleanup = false;
+        this.clearDrain();
+        if (!this.closed && !this.isStopping) {
+            this.isStopping = true;
+            this.signalTree();
+        }
     };
-    const terminate = () => {
-        // Cancellation overrides a pending or already-started successful settlement cleanup.
-        settledCleanup = false;
-        clearDrain();
-        if (closed || stopping)
+    dispose() {
+        this.closed = true;
+        this.clearTimers();
+        this.clearStdioGuard();
+    }
+    get stopping() {
+        return this.isStopping;
+    }
+    get agentProcessExit() {
+        return this.exit;
+    }
+    get settledCleanup() {
+        return this.isSettledCleanup;
+    }
+    observeEvent = (type) => {
+        if (this.closed || this.exited || this.isStopping) {
             return;
-        stopping = true;
-        signalTree();
-    };
-    const clearStdioGuard = attachPostExitStdioGuard(child, { idleMs: 2000, hardMs: 8000 });
-    child.on("exit", (code, signal) => {
-        exited = true;
-        agentProcessExit = { pid: child.pid, code, signal, at: Date.now() };
-        clearTimers();
-        // The leader may exit before resistant descendants release inherited stdio.
-        trySignalChildTree(child, "SIGKILL");
-    });
-    const dispose = () => {
-        closed = true;
-        clearTimers();
-        clearStdioGuard();
-    };
-    child.on("close", dispose);
-    child.on("error", dispose);
-    return {
-        terminate,
-        get stopping() { return stopping; },
-        get agentProcessExit() { return agentProcessExit; },
-        get settledCleanup() { return settledCleanup; },
-        observeEvent(type) {
-            if (closed || exited || stopping)
+        }
+        if (type === "agent_settled") {
+            if (this.drainTimer) {
                 return;
-            if (type === "agent_settled") {
-                if (drainTimer)
-                    return;
-                drainTimer = setTimeout(() => {
-                    drainTimer = undefined;
-                    stopping = true;
-                    settledCleanup = signalTree();
-                }, 1000);
-                drainTimer.unref();
             }
-            else if (type === "agent_start" || type === "turn_start" || type?.startsWith("message_") || type?.startsWith("tool_execution_")) {
-                clearDrain();
-            }
-        },
+            this.drainTimer = setTimeout(() => {
+                this.drainTimer = undefined;
+                this.isStopping = true;
+                this.isSettledCleanup = this.signalTree();
+            }, 1000);
+            this.drainTimer.unref();
+        }
+        else if (activityEvent(type)) {
+            this.clearDrain();
+        }
     };
 }
-export function attachPostExitStdioGuard(child, options) {
-    const { idleMs, hardMs } = options;
+/** One lifetime for the owned process group, including descendants holding its pipes open. */
+export function attachChildProcessLifecycle(child) {
+    return new OwnedChildLifecycle(child);
+}
+function attachPostExitStdioGuard(child) {
     let exited = false;
     let stdoutEnded = false;
     let stderrEnded = false;
@@ -144,13 +175,17 @@ export function attachPostExitStdioGuard(child, options) {
             try {
                 child.stdout?.destroy();
             }
-            catch { }
+            catch {
+                // The process has exited; failed pipe destruction must not prevent other cleanup.
+            }
         }
         if (!stderrEnded) {
             try {
                 child.stderr?.destroy();
             }
-            catch { }
+            catch {
+                // The process has exited; failed pipe destruction must not prevent other cleanup.
+            }
         }
     };
     const clearTimers = () => {
@@ -164,32 +199,37 @@ export function attachPostExitStdioGuard(child, options) {
         }
     };
     const armIdleTimer = () => {
-        if (!exited)
+        if (!exited) {
             return;
-        if (idleTimer)
+        }
+        if (idleTimer) {
             clearTimeout(idleTimer);
-        idleTimer = setTimeout(destroyUnendedStdio, idleMs);
-        idleTimer.unref?.();
+        }
+        idleTimer = setTimeout(destroyUnendedStdio, 2000);
+        idleTimer.unref();
     };
     child.stdout?.on("data", armIdleTimer);
     child.stderr?.on("data", armIdleTimer);
     child.stdout?.on("end", () => {
         stdoutEnded = true;
-        if (stdoutEnded && stderrEnded)
+        if (stderrEnded) {
             clearTimers();
+        }
     });
     child.stderr?.on("end", () => {
         stderrEnded = true;
-        if (stdoutEnded && stderrEnded)
+        if (stdoutEnded) {
             clearTimers();
+        }
     });
     child.on("exit", () => {
         exited = true;
         armIdleTimer();
-        if (hardTimer)
+        if (hardTimer) {
             return;
-        hardTimer = setTimeout(destroyUnendedStdio, hardMs);
-        hardTimer.unref?.();
+        }
+        hardTimer = setTimeout(destroyUnendedStdio, 8000);
+        hardTimer.unref();
     });
     child.on("close", clearTimers);
     child.on("error", clearTimers);

package/dist/shared/prompt-sections.js

@@ -1,4 +1,6 @@
 export function setPromptSection(options, name, content) {
+    // Pi owns this mutable prompt-building options object. This SDK hook updates
+    // sections and its legacy exact override in place; callers observe the same object.
     options.sections[name] = content;
     // Pi projects an earlier exact override instead of sections. Preserve its content;
     // this compatibility path replaces the leading prompt and cannot preserve its cache prefix.

package/dist/shared/session-entries.js

@@ -1,4 +1,4 @@
-/** Follow append-only parent links; rescan when entries were replaced or appended off the active branch. */
+/** Follow append-only parent links; rescan after replacement or append off the active branch. */
 export class SessionEntryCursor {
     manager;
     sessionId;
@@ -10,43 +10,78 @@ export class SessionEntryCursor {
         this.known.clear();
         this.anchor = undefined;
     }
-    read(manager) {
-        const sessionId = manager.getSessionId(), file = manager.getSessionFile?.(), count = manager.getEntryCount?.();
-        let reset = this.manager !== manager || this.sessionId !== sessionId || this.file !== file
-            || count !== undefined && count < this.known.size
-            || Boolean(this.anchor && manager.getEntry && manager.getEntry(this.anchor.id) !== this.known.get(this.anchor.id));
-        let entries;
-        if (!reset && count !== undefined && manager.getEntry && manager.getLeafId) {
-            const appended = [], visited = new Set();
-            let id = manager.getLeafId();
-            while (id && !this.known.has(id) && !visited.has(id)) {
-                visited.add(id);
-                const entry = manager.getEntry(id);
-                if (!entry)
-                    break;
-                appended.push(entry);
-                id = entry.parentId;
-            }
-            if (count === this.known.size + appended.length && (!id || this.known.has(id)))
-                entries = appended.reverse();
-        }
-        if (!entries) {
-            const all = manager.getEntries();
-            entries = all.filter((entry) => !this.known.has(entry.id));
-            if (all.length !== this.known.size + entries.length
-                || all.some((entry) => this.known.has(entry.id) && this.known.get(entry.id) !== entry))
-                reset = true;
-            if (reset) {
-                this.known.clear();
-                entries = all;
+    changed(snapshot) {
+        if (this.manager !== snapshot.manager ||
+            this.sessionId !== snapshot.sessionId ||
+            this.file !== snapshot.file) {
+            return true;
+        }
+        if (snapshot.count !== undefined && snapshot.count < this.known.size) {
+            return true;
+        }
+        return (this.anchor !== undefined &&
+            snapshot.manager.getEntry !== undefined &&
+            snapshot.manager.getEntry(this.anchor.id) !== this.known.get(this.anchor.id));
+    }
+    appendedBranch(manager) {
+        if (manager.getEntry === undefined || manager.getLeafId === undefined) {
+            return undefined;
+        }
+        const entries = [];
+        const visited = new Set();
+        let id = manager.getLeafId();
+        while (id !== null && id !== "" && !this.known.has(id) && !visited.has(id)) {
+            visited.add(id);
+            const entry = manager.getEntry(id);
+            if (!entry) {
+                break;
             }
+            entries.push(entry);
+            id = entry.parentId;
+        }
+        return { entries, tail: id };
+    }
+    appended(snapshot) {
+        if (snapshot.count === undefined) {
+            return undefined;
+        }
+        const branch = this.appendedBranch(snapshot.manager);
+        if (!branch) {
+            return undefined;
         }
-        for (const entry of entries)
+        const { entries, tail } = branch;
+        const connects = tail === null || tail === "" || this.known.has(tail);
+        return snapshot.count === this.known.size + entries.length && connects
+            ? entries.reverse()
+            : undefined;
+    }
+    rescan(manager, reset) {
+        const all = manager.getEntries();
+        const added = all.filter((entry) => !this.known.has(entry.id));
+        const replaced = all.length !== this.known.size + added.length ||
+            all.some((entry) => this.known.has(entry.id) && this.known.get(entry.id) !== entry);
+        return { entries: reset || replaced ? all : added, reset: reset || replaced };
+    }
+    read(manager) {
+        const snapshot = {
+            manager,
+            sessionId: manager.getSessionId(),
+            file: manager.getSessionFile?.(),
+            count: manager.getEntryCount?.(),
+        };
+        const changed = this.changed(snapshot);
+        const appended = changed ? undefined : this.appended(snapshot);
+        const result = appended ? { entries: appended, reset: false } : this.rescan(manager, changed);
+        if (result.reset) {
+            this.known.clear();
+        }
+        for (const entry of result.entries) {
             this.known.set(entry.id, entry);
-        this.anchor = entries.at(-1) ?? (reset ? undefined : this.anchor);
+        }
+        this.anchor = result.entries.at(-1) ?? (result.reset ? undefined : this.anchor);
         this.manager = manager;
-        this.sessionId = sessionId;
-        this.file = file;
-        return { entries, reset };
+        this.sessionId = snapshot.sessionId;
+        this.file = snapshot.file;
+        return result;
     }
 }

package/dist/shared/session-identity.js

@@ -1,14 +1,16 @@
 // Only delegation supplies this identity; Pi's ordinary fork/clone ancestry does not.
 export function resolveRootSessionId(sessionManager, env = process.env) {
     const rootId = env.PI_SUBAGENT_CHILD === "1" ? env.PI_SUBAGENT_ROOT_SESSION_ID : undefined;
-    const sessionId = rootId || sessionManager.getSessionId();
-    if (!sessionId)
+    const sessionId = rootId !== undefined && rootId !== "" ? rootId : sessionManager.getSessionId();
+    if (sessionId === null || sessionId === undefined || sessionId === "") {
         throw new Error("Root session identity is unavailable.");
+    }
     return sessionId;
 }
 export function resolveCurrentSessionId(sessionManager) {
     const sessionId = sessionManager.getSessionId();
-    if (!sessionId)
+    if (sessionId === null || sessionId === undefined || sessionId === "") {
         throw new Error("Current session identity is unavailable.");
+    }
     return sessionId;
 }