@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.eed73bea

package/dist/resources/extensions/async-jobs/async-bash-tool.js

@@ -5,9 +5,9 @@
  * immediately. The LLM can continue working and check results later
  * with await_job.
  */
-import { getShellConfig, sanitizeCommand, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, } from "@gsd/pi-coding-agent";
+import { getShellConfig, sanitizeCommand, killProcessTree, SIGKILL_GRACE_MS, HARD_DEADLINE_MS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, } from "@gsd/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -22,37 +22,6 @@ function getTempFilePath() {
     const id = randomBytes(8).toString("hex");
     return join(tmpdir(), `pi-async-bash-${id}.log`);
 }
-/**
- * Kill a process and its children (cross-platform).
- * Uses process group kill on Unix; taskkill /F /T on Windows.
- */
-function killTree(pid) {
-    if (process.platform === "win32") {
-        try {
-            spawnSync("taskkill", ["/F", "/T", "/PID", String(pid)], {
-                timeout: 5_000,
-                stdio: "ignore",
-            });
-        }
-        catch {
-            try {
-                process.kill(pid, "SIGTERM");
-            }
-            catch { /* already exited */ }
-        }
-    }
-    else {
-        try {
-            process.kill(-pid, "SIGTERM");
-        }
-        catch {
-            try {
-                process.kill(pid, "SIGTERM");
-            }
-            catch { /* already exited */ }
-        }
-    }
-}
 export function createAsyncBashTool(getManager, getCwd) {
     return {
         name: "async_bash",
@@ -62,7 +31,7 @@ export function createAsyncBashTool(getManager, getCwd) {
             `Output is truncated to the last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB.`,
         promptSnippet: "Run a bash command in the background, returning a job ID immediately.",
         promptGuidelines: [
-            "Use async_bash for commands that take more than a few seconds (builds, tests, installs, large git operations).",
+            "Use async_bash for long-running builds, tests, installs, or operations that should run in the background so you can continue other work (the job ID lets you await_job later). Sync bash is uncapped — use async_bash when you want non-blocking behavior, not because of a timeout concern.",
             "After starting async jobs, continue with other work and use await_job when you need the results.",
             "await_job has a configurable timeout (default 120s) to prevent indefinite blocking — if it times out, jobs keep running and you can check again later.",
             "For long-running processes (SSH, deploys, training) that may take minutes+, prefer async_bash with periodic await_job polling over a single long await.",
@@ -122,36 +91,25 @@ function executeBashInBackground(command, cwd, signal, timeout) {
         });
         let timedOut = false;
         let timeoutHandle;
-        let sigkillHandle;
         let hardDeadlineHandle;
-        /** Grace period (ms) between SIGTERM and SIGKILL. */
-        const SIGKILL_GRACE_MS = 5_000;
-        /** Hard deadline (ms) after SIGKILL to force-resolve the promise. */
-        const HARD_DEADLINE_MS = 3_000;
         if (timeout !== undefined && timeout > 0) {
             timeoutHandle = setTimeout(() => {
                 timedOut = true;
+                // killProcessTree owns the SIGTERM -> grace -> SIGKILL escalation, so a
+                // SIGTERM-immune child is actually force-killed rather than left running.
                 if (child.pid)
-                    killTree(child.pid);
-                // If the process ignores SIGTERM, escalate to SIGKILL
-                sigkillHandle = setTimeout(() => {
-                    if (child.pid) {
-                        // killTree already uses taskkill /F /T on Windows
-                        killTree(child.pid);
-                    }
-                    // Hard deadline: if even SIGKILL doesn't trigger 'close',
-                    // force-resolve so the job doesn't hang forever (#2186).
-                    hardDeadlineHandle = setTimeout(() => {
-                        const output = Buffer.concat(chunks).toString("utf-8");
-                        safeResolve(output
-                            ? `${output}\n\nCommand timed out after ${timeout} seconds (force-killed)`
-                            : `Command timed out after ${timeout} seconds (force-killed)`);
-                    }, HARD_DEADLINE_MS);
-                    if (typeof hardDeadlineHandle === "object" && "unref" in hardDeadlineHandle)
-                        hardDeadlineHandle.unref();
-                }, SIGKILL_GRACE_MS);
-                if (typeof sigkillHandle === "object" && "unref" in sigkillHandle)
-                    sigkillHandle.unref();
+                    killProcessTree(child.pid);
+                // Hard deadline: a D-state (uninterruptible-I/O) child never emits 'close'
+                // even after SIGKILL, so force-resolve the promise rather than hang (#2186).
+                // Fires after the full grace window so SIGKILL has had its chance first.
+                hardDeadlineHandle = setTimeout(() => {
+                    const output = Buffer.concat(chunks).toString("utf-8");
+                    safeResolve(output
+                        ? `${output}\n\nCommand timed out after ${timeout} seconds (force-killed)`
+                        : `Command timed out after ${timeout} seconds (force-killed)`);
+                }, SIGKILL_GRACE_MS + HARD_DEADLINE_MS);
+                if (typeof hardDeadlineHandle === "object" && "unref" in hardDeadlineHandle)
+                    hardDeadlineHandle.unref();
             }, timeout * 1000);
         }
         const chunks = [];
@@ -182,7 +140,19 @@ function executeBashInBackground(command, cwd, signal, timeout) {
             child.stderr.on("data", onData);
         const onAbort = () => {
             if (child.pid)
-                killTree(child.pid);
+                killProcessTree(child.pid);
+            // Arm the same hard-deadline force-resolve the timeout path uses, so a
+            // cancelled D-state child (never emits 'close' even after SIGKILL) can't
+            // hang the job promise forever. safeResolve is idempotent, so the real
+            // 'close' still wins if the child does exit.
+            if (!hardDeadlineHandle) {
+                hardDeadlineHandle = setTimeout(() => {
+                    const output = Buffer.concat(chunks).toString("utf-8");
+                    safeResolve(output ? `${output}\n\nCommand aborted (force-killed)` : "Command aborted (force-killed)");
+                }, SIGKILL_GRACE_MS + HARD_DEADLINE_MS);
+                if (typeof hardDeadlineHandle === "object" && "unref" in hardDeadlineHandle)
+                    hardDeadlineHandle.unref();
+            }
         };
         if (signal.aborted) {
             onAbort();
@@ -193,8 +163,6 @@ function executeBashInBackground(command, cwd, signal, timeout) {
         child.on("error", (err) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
-            if (sigkillHandle)
-                clearTimeout(sigkillHandle);
             if (hardDeadlineHandle)
                 clearTimeout(hardDeadlineHandle);
             signal.removeEventListener("abort", onAbort);
@@ -203,8 +171,6 @@ function executeBashInBackground(command, cwd, signal, timeout) {
         child.on("close", (code) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
-            if (sigkillHandle)
-                clearTimeout(sigkillHandle);
             if (hardDeadlineHandle)
                 clearTimeout(hardDeadlineHandle);
             signal.removeEventListener("abort", onAbort);

package/dist/resources/extensions/async-jobs/await-tool.js

@@ -21,7 +21,7 @@ export function createAwaitTool(getManager) {
         label: "Await Background Job",
         description: "Wait for background jobs to complete. Provide specific job IDs or omit to wait for the next job that finishes. Returns results of completed jobs.",
         parameters: schema,
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+        async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
             const manager = getManager();
             const { jobs: jobIds, timeout } = params;
             const timeoutMs = ((timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1000);
@@ -54,37 +54,75 @@ export function createAwaitTool(getManager) {
                     };
                 }
             }
-            // Suppress follow-up notifications for all watched jobs upfront.
+            // If all watched jobs are already done, suppress follow-up and return immediately.
             // suppressFollowUp() cancels the pending delivery timer (if any), which
             // handles both the within-turn case (job completes while we await) and
             // the cross-turn case (job already completed before await_job was called).
             // Previously this only set j.awaited = true, which missed the cross-turn
             // case because the queueMicrotask had already fired (#3787).
-            for (const j of watched)
-                manager.suppressFollowUp(j.id);
-            // If all watched jobs are already done, return immediately
             const running = watched.filter((j) => j.status === "running");
             if (running.length === 0) {
-                const result = formatResults(watched);
-                return { content: [{ type: "text", text: result }], details: undefined };
+                for (const j of watched)
+                    manager.suppressFollowUp(j.id);
+                return { content: [{ type: "text", text: renderCompleted(watched) }], details: undefined };
             }
-            // Wait for at least one to complete, or timeout
+            // Wait for at least one to complete, timeout, or abort signal
             const TIMEOUT_SENTINEL = Symbol("timeout");
+            const ABORT_SENTINEL = Symbol("abort");
+            // The race timer and abort listener are explicitly torn down once the race
+            // settles (below) so a completion- or timeout-won race never leaks a pending
+            // timer or a lingering abort listener — the listener holds a closure over the
+            // race resolver, so { once: true } alone (which only detaches on fire) is not
+            // enough when ESC never happens.
+            let raceTimer;
+            let abortListener;
             const timeoutPromise = new Promise((resolve) => {
-                const timer = setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs);
+                raceTimer = setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs);
                 // Allow the process to exit even if the timer is pending
-                if (typeof timer === "object" && "unref" in timer)
-                    timer.unref();
+                if (typeof raceTimer === "object" && "unref" in raceTimer)
+                    raceTimer.unref();
+            });
+            const abortPromise = new Promise((resolve) => {
+                if (!signal || signal.aborted) {
+                    resolve(ABORT_SENTINEL);
+                }
+                else {
+                    abortListener = () => resolve(ABORT_SENTINEL);
+                    signal.addEventListener("abort", abortListener, { once: true });
+                }
             });
             const raceResult = await Promise.race([
                 Promise.race(running.map((j) => j.promise)).then(() => "completed"),
                 timeoutPromise,
+                abortPromise,
             ]);
+            // Tear down race resources now that a winner is decided.
+            if (raceTimer)
+                clearTimeout(raceTimer);
+            if (abortListener && signal)
+                signal.removeEventListener("abort", abortListener);
+            const aborted = raceResult === ABORT_SENTINEL;
             const timedOut = raceResult === TIMEOUT_SENTINEL;
             // Collect all completed results (more may have finished while waiting)
             const completed = watched.filter((j) => j.status !== "running");
             const stillRunning = watched.filter((j) => j.status === "running");
-            let result = formatResults(completed);
+            // Suppress follow-up ONLY for completed jobs — leave stillRunning unsuppressed
+            // so deliverResult/onJobComplete can resurface their results later.
+            for (const j of completed)
+                manager.suppressFollowUp(j.id);
+            if (aborted) {
+                // ESC ended the wait, not the jobs: still-running jobs keep going and
+                // resurface via onJobComplete (they were deliberately not suppressed above).
+                const runningDesc = stillRunning.map((j) => `${j.id} (${j.label})`).join(", ");
+                const interrupt = stillRunning.length > 0
+                    ? `Wait interrupted. Still running: ${runningDesc} — results will surface when complete.`
+                    : "Wait interrupted.";
+                const text = completed.length > 0
+                    ? `${renderCompleted(completed)}\n\n${interrupt}`
+                    : interrupt;
+                return { content: [{ type: "text", text }], details: undefined };
+            }
+            let result = renderCompleted(completed);
             if (stillRunning.length > 0) {
                 result += `\n\n**Still running:** ${stillRunning.map((j) => `${j.id} (${j.label})`).join(", ")}`;
             }
@@ -97,6 +135,36 @@ export function createAwaitTool(getManager) {
         },
     };
 }
+/**
+ * Render completed jobs for the await_job result, de-duplicating against
+ * follow-ups that have already been delivered to context.
+ *
+ * A job's follow-up fires ~immediately (setTimeout(0)) once it settles, so when
+ * await_job runs in a LATER turn the result is already in context. Reprinting it
+ * inline produces the same output twice. Jobs already `delivered` are therefore
+ * acknowledged on a single line instead of having their full output reprinted;
+ * not-yet-delivered jobs (the within-turn case, where suppressFollowUp won the
+ * race) are rendered in full as before.
+ */
+function renderCompleted(jobs) {
+    if (jobs.length === 0)
+        return "No completed jobs.";
+    const fresh = jobs.filter((j) => !j.delivered);
+    const alreadyDelivered = jobs.filter((j) => j.delivered);
+    const sections = [];
+    if (fresh.length > 0)
+        sections.push(formatResults(fresh));
+    if (alreadyDelivered.length > 0) {
+        const names = alreadyDelivered
+            .map((j) => `${j.id} (${j.label})`)
+            .join(", ");
+        const sentence = alreadyDelivered.length === 1
+            ? `This job already finished and its result was shown above when it completed, so there is nothing new to report: ${names}.`
+            : `These jobs already finished and their results were shown above when they completed, so there is nothing new to report: ${names}.`;
+        sections.push(sentence);
+    }
+    return sections.join("\n\n");
+}
 function formatResults(jobs) {
     if (jobs.length === 0)
         return "No completed jobs.";

package/dist/resources/extensions/async-jobs/index.js

@@ -98,9 +98,74 @@ export default function AsyncJobs(pi) {
                 });
                 return;
             }
+            const ctx = _ctx;
             const running = manager.getRunningJobs();
             const recent = manager.getRecentJobs(10);
             const completed = recent.filter((j) => j.status !== "running");
+            // Interactive kill-picker when there are running jobs and a UI is available
+            if (running.length > 0 && ctx.hasUI) {
+                // Kill-picker loop: each iteration shows live running jobs.
+                // Step 1 picks a job (neutral label — selecting does NOT cancel yet);
+                // step 2 confirms before the destructive cancel. Labels deliberately
+                // omit a live elapsed time: ctx.ui.select renders the option strings
+                // once and never refreshes them, so a "(24s)" baked into the label
+                // would freeze and mislead. Accurate elapsed times are shown in the
+                // post-picker summary (rebuilt fresh) instead.
+                const DONE = "Close";
+                while (true) {
+                    const liveJobs = manager.getRunningJobs();
+                    if (liveJobs.length === 0)
+                        break;
+                    // Map display label -> job id so we never parse ids back out of
+                    // free-form label text.
+                    const labelToId = new Map();
+                    for (const j of liveJobs) {
+                        labelToId.set(`${j.id} — ${j.label} (running)`, j.id);
+                    }
+                    const options = [...labelToId.keys(), DONE];
+                    const choice = await ctx.ui.select("Background jobs — pick one to cancel, Escape to close", options);
+                    // ESC returns undefined; headless may return string[]; DONE closes
+                    if (!choice || typeof choice !== "string" || choice === DONE)
+                        break;
+                    const id = labelToId.get(choice);
+                    if (!id)
+                        break;
+                    const job = liveJobs.find((j) => j.id === id);
+                    const confirmed = await ctx.ui.confirm("Cancel background job?", `This will stop ${id}${job ? ` — ${job.label}` : ""}. Other jobs keep running.`);
+                    if (!confirmed)
+                        continue;
+                    const r = manager.cancel(id);
+                    ctx.ui.notify(r === "cancelled" ? `Job ${id} cancelled.` : `Job ${id}: ${r}`, r === "cancelled" ? "success" : "warning");
+                }
+                // After picker, send a summary of any still-running jobs
+                const stillRunning = manager.getRunningJobs();
+                const summaryLines = ["## Background Jobs"];
+                if (stillRunning.length > 0) {
+                    summaryLines.push("", "### Running");
+                    for (const job of stillRunning) {
+                        const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(0);
+                        summaryLines.push(`- **${job.id}** — ${job.label} (${elapsed}s)`);
+                    }
+                }
+                const recentCompleted = manager.getRecentJobs(10).filter((j) => j.status !== "running");
+                if (recentCompleted.length > 0) {
+                    summaryLines.push("", "### Recent");
+                    for (const job of recentCompleted) {
+                        const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(1);
+                        summaryLines.push(`- **${job.id}** — ${job.label} (${job.status}, ${elapsed}s)`);
+                    }
+                }
+                if (stillRunning.length === 0 && recentCompleted.length === 0) {
+                    summaryLines.push("", "No background jobs.");
+                }
+                pi.sendMessage({
+                    customType: "async_jobs_list",
+                    content: summaryLines.join("\n"),
+                    display: true,
+                });
+                return;
+            }
+            // Text-only display: headless/RPC mode, or no running jobs
             const lines = ["## Background Jobs"];
             if (running.length === 0 && completed.length === 0) {
                 lines.push("", "No background jobs.");

package/dist/resources/extensions/async-jobs/job-manager.js

@@ -53,6 +53,15 @@ export class AsyncJobManager {
         };
         job.promise = runFn(abortController.signal)
             .then((resultText) => {
+            if (job.status === "cancelled") {
+                // Already cancelled by cancel(). The runFn resolves (not rejects) even
+                // when aborted — async_bash's safeResolve returns "Command aborted"
+                // rather than throwing — so without this guard the status would be
+                // clobbered back to "completed", mislabeling a user-cancelled job.
+                // Mirrors the symmetric guard in the .catch branch below.
+                this.scheduleEviction(id);
+                return;
+            }
             job.status = "completed";
             job.resultText = resultText;
             this.scheduleEviction(id);
@@ -143,8 +152,10 @@ export class AsyncJobManager {
         const cb = this.onJobComplete;
         job.deliveryTimer = setTimeout(() => {
             job.deliveryTimer = undefined;
-            if (!job.awaited)
+            if (!job.awaited) {
+                job.delivered = true;
                 cb(job);
+            }
         }, 0);
         // Allow process to exit even if timer is pending
         if (typeof job.deliveryTimer === "object" && "unref" in job.deliveryTimer) {

package/dist/resources/extensions/bg-shell/bg-shell-command.js

@@ -3,7 +3,7 @@
  */
 import { Key } from "@gsd/pi-tui";
 import { shortcutDesc } from "../shared/terminal.js";
-import { processes, killProcess, getGroupStatus, cleanupAll, } from "./process-manager.js";
+import { processes, terminateProcess, getGroupStatus, cleanupAll, } from "./process-manager.js";
 import { generateDigest, getOutput, formatDigestText, } from "./output-formatter.js";
 import { formatUptime } from "./utilities.js";
 import { BgManagerOverlay } from "./overlay.js";
@@ -119,11 +119,11 @@ export function registerBgShellCommand(pi, state) {
                     ctx.ui.notify(`No process with id '${id}'`, "error");
                     return;
                 }
-                killProcess(id, "SIGTERM");
-                await new Promise(r => setTimeout(r, 300));
-                if (bg.alive) {
-                    killProcess(id, "SIGKILL");
-                    await new Promise(r => setTimeout(r, 200));
+                // Graceful ladder (SIGTERM → grace → SIGKILL) via killProcessTree.
+                terminateProcess(id);
+                const deadline = Date.now() + 6_000; // grace (5s) + slack
+                while (bg.alive && Date.now() < deadline) {
+                    await new Promise(r => setTimeout(r, 100));
                 }
                 if (!bg.alive)
                     processes.delete(id);

package/dist/resources/extensions/bg-shell/bg-shell-tool.js

@@ -4,7 +4,7 @@
 import { StringEnum, Type } from "@gsd/pi-ai";
 import { Text } from "@gsd/pi-tui";
 import { DEFAULT_READY_TIMEOUT } from "./types.js";
-import { processes, startProcess, killProcess, restartProcess, getInfo, getGroupStatus, persistManifest, } from "./process-manager.js";
+import { processes, startProcess, killProcess, terminateProcess, restartProcess, getInfo, getGroupStatus, persistManifest, } from "./process-manager.js";
 import { generateDigest, getHighlights, getOutput, formatDigestText, } from "./output-formatter.js";
 import { waitForReady } from "./readiness-detector.js";
 import { queryShellEnv, sendAndWait, runOnSession } from "./interaction.js";
@@ -22,7 +22,8 @@ export function registerBgShellTool(pi, state) {
             "signal (send OS signal), list (all processes with status), kill (terminate), restart (kill + relaunch), " +
             "group_status (health of a process group), highlights (significant output lines only).",
         promptGuidelines: [
-            "Use bg_shell to start long-running processes (servers, watchers, builds) that should not block the agent.",
+            "Use bg_shell for processes that STAY ALIVE and you interact with over time: servers, watchers, daemons, REPLs. For a command that runs to completion and exits (terraform apply, migrations, builds, tests, installs), use async_bash or sync bash instead — NOT bg_shell.",
+            "'wait_for_ready' is for long-lived processes that signal readiness (open a port / print a pattern). Never use it on a run-to-completion command: that command exits instead of becoming ready, so a clean exit-0 is reported as 'not ready'. If you see that, switch to async_bash.",
             "After starting a server, use 'wait_for_ready' to efficiently block until it's listening — avoids polling loops entirely.",
             "Use 'digest' instead of 'output' when you just need status — it returns a structured ~30-token summary instead of ~2000 tokens of raw output.",
             "Use 'highlights' to see only significant output (errors, URLs, results) — typically 5-15 lines instead of hundreds.",
@@ -511,11 +512,13 @@ export function registerBgShellTool(pi, state) {
                             isError: true, details: undefined,
                         };
                     }
-                    const killed = killProcess(params.id, "SIGTERM");
-                    await new Promise(r => setTimeout(r, 300));
-                    if (bg.alive) {
-                        killProcess(params.id, "SIGKILL");
-                        await new Promise(r => setTimeout(r, 200));
+                    // Graceful termination: SIGTERM → grace → SIGKILL via the shared
+                    // killProcessTree ladder (same path bash/async_bash/exec use), so a
+                    // stateful process gets a clean-shutdown window instead of a bare kill.
+                    const killed = terminateProcess(params.id);
+                    const deadline = Date.now() + 6_000; // grace (5s) + slack
+                    while (bg.alive && Date.now() < deadline) {
+                        await new Promise(r => setTimeout(r, 100));
                     }
                     const info = getInfo(bg);
                     if (!bg.alive)

package/dist/resources/extensions/bg-shell/overlay.js

@@ -4,7 +4,7 @@
 import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
 import { ERROR_PATTERNS, WARNING_PATTERNS } from "./types.js";
 import { formatUptime, formatTimeAgo } from "./utilities.js";
-import { processes, killProcess, cleanupAll, restartProcess, } from "./process-manager.js";
+import { processes, terminateProcess, cleanupAll, restartProcess, } from "./process-manager.js";
 export class BgManagerOverlay {
     tui;
     theme;
@@ -110,17 +110,20 @@ export class BgManagerOverlay {
             }
             return;
         }
-        // x or d = kill selected
+        // x or d = kill selected (graceful ladder via killProcessTree).
+        // Use a short interactive grace: the user explicitly asked to kill, so give the
+        // process a brief clean-shutdown window then force, and re-render AFTER that grace
+        // plus slack so the row reflects the SIGKILL escalation (a 300ms re-render against
+        // the default 5s grace would show the process still alive).
         if (data === "x" || data === "d") {
             const proc = procs[this.selected];
             if (proc && proc.alive) {
-                killProcess(proc.id, "SIGTERM");
+                const OVERLAY_KILL_GRACE_MS = 500;
+                terminateProcess(proc.id, OVERLAY_KILL_GRACE_MS);
                 setTimeout(() => {
-                    if (proc.alive)
-                        killProcess(proc.id, "SIGKILL");
                     this.invalidate();
                     this.tui.requestRender();
-                }, 300);
+                }, OVERLAY_KILL_GRACE_MS + 400);
             }
             return;
         }

package/dist/resources/extensions/bg-shell/process-manager.js

@@ -6,7 +6,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { getShellConfig, sanitizeCommand } from "@gsd/pi-coding-agent";
+import { getShellConfig, sanitizeCommand, killProcessTree } from "@gsd/pi-coding-agent";
 import { rewriteCommandWithRtk } from "../shared/rtk.js";
 import { MAX_BUFFER_LINES, MAX_EVENTS, DEAD_PROCESS_TTL, } from "./types.js";
 import { restoreWindowsVTInput, formatUptime } from "./utilities.js";
@@ -221,6 +221,38 @@ export function startProcess(opts) {
     return bg;
 }
 // ── Process Kill ───────────────────────────────────────────────────────────
+/**
+ * Gracefully terminate a process and its tree using the shared killProcessTree
+ * ladder (SIGTERM → grace window → SIGKILL), the same path bash/async_bash/exec
+ * use. This is the "I want it dead, cleanly" intent — use it for the `kill`
+ * action, `restart`, and session cleanup. For sending a SPECIFIC signal the
+ * agent chose on purpose (SIGINT, SIGHUP, …) use killProcess(), which delivers
+ * that exact signal once and does not escalate.
+ *
+ * `graceMs` overrides the SIGTERM→SIGKILL window (default: killProcessTree's 5s);
+ * session cleanup passes a shorter grace so it stays snappy between units.
+ *
+ * Returns false only when the process is unknown/already dead; the actual
+ * SIGKILL escalation fires asynchronously after the grace window, so callers
+ * should not assume the process is dead the instant this returns.
+ */
+export function terminateProcess(id, graceMs) {
+    const bg = processes.get(id);
+    if (!bg)
+        return false;
+    if (!bg.alive)
+        return true;
+    if (!bg.proc.pid) {
+        // No pid to target a tree; fall back to a direct graceful signal.
+        try {
+            bg.proc.kill("SIGTERM");
+        }
+        catch { /* already gone */ }
+        return true;
+    }
+    killProcessTree(bg.proc.pid, graceMs !== undefined ? { graceMs } : undefined);
+    return true;
+}
 export function killProcess(id, sig = "SIGTERM") {
     const bg = processes.get(id);
     if (!bg)
@@ -272,13 +304,14 @@ export async function restartProcess(id) {
         return null;
     const config = old.startConfig;
     const restartCount = old.restartCount + 1;
-    // Kill old process
+    // Kill old process via the graceful ladder, then wait for it to actually die.
+    // killProcessTree escalates SIGTERM → grace → SIGKILL asynchronously, so poll
+    // for death rather than assuming a fixed sleep is enough.
     if (old.alive) {
-        killProcess(id, "SIGTERM");
-        await new Promise(r => setTimeout(r, 300));
-        if (old.alive) {
-            killProcess(id, "SIGKILL");
-            await new Promise(r => setTimeout(r, 200));
+        terminateProcess(id);
+        const deadline = Date.now() + 6_000; // grace (5s) + slack
+        while (old.alive && Date.now() < deadline) {
+            await new Promise(r => setTimeout(r, 100));
         }
     }
     processes.delete(id);
@@ -328,24 +361,16 @@ export function pruneDeadProcesses() {
     }
 }
 export function cleanupAll() {
+    // Deliberately a bare, synchronous SIGKILL — not the graceful ladder. This runs
+    // from process 'exit'/signal handlers where timers no longer fire, so a deferred
+    // SIGKILL would never be delivered and children would be orphaned when we vanish.
+    // Immediate force-kill is the correct teardown semantics here.
     for (const [id, bg] of processes) {
         if (bg.alive)
             killProcess(id, "SIGKILL");
     }
     processes.clear();
 }
-/**
- * Kill all alive, non-persistent bg processes.
- * Called between auto-mode units to prevent orphaned servers from
- * keeping ports bound across task boundaries (#1209).
- */
-export function killSessionProcesses() {
-    for (const [id, bg] of processes) {
-        if (bg.alive && !bg.persistAcrossSessions) {
-            killProcess(id, "SIGTERM");
-        }
-    }
-}
 async function waitForProcessExit(bg, timeoutMs) {
     if (!bg.alive)
         return true;
@@ -359,20 +384,24 @@ async function waitForProcessExit(bg, timeoutMs) {
     });
     return !bg.alive;
 }
+/**
+ * Terminate the alive, non-persistent processes owned by a session, gracefully.
+ * Routes through the shared killProcessTree ladder (SIGTERM → grace → SIGKILL)
+ * via terminateProcess, with a short grace (default 300ms) so cleanup between
+ * units stays snappy; killProcessTree handles the SIGKILL escalation itself, so
+ * there is no separate force-kill pass here.
+ */
 export async function cleanupSessionProcesses(sessionFile, options) {
     const graceMs = Math.max(0, options?.graceMs ?? 300);
     const matches = Array.from(processes.values()).filter((bg) => bg.alive && !bg.persistAcrossSessions && bg.ownerSessionFile === sessionFile);
     if (matches.length === 0)
         return [];
     for (const bg of matches) {
-        killProcess(bg.id, "SIGTERM");
+        terminateProcess(bg.id, graceMs);
     }
     if (graceMs > 0) {
-        await Promise.all(matches.map((bg) => waitForProcessExit(bg, graceMs)));
-    }
-    for (const bg of matches) {
-        if (bg.alive)
-            killProcess(bg.id, "SIGKILL");
+        // Wait past the grace so the SIGKILL escalation has fired and exits are observed.
+        await Promise.all(matches.map((bg) => waitForProcessExit(bg, graceMs + 200)));
     }
     return matches.map((bg) => bg.id);
 }

package/dist/resources/extensions/bg-shell/readiness-detector.js

@@ -72,6 +72,17 @@ export async function waitForReady(bg, timeout, signal) {
             return { ready: false, detail: "Cancelled" };
         }
         if (!bg.alive) {
+            // A clean exit-0 means the command ran to completion — it was a batch
+            // command (e.g. terraform apply, a migration, a build), not a long-lived
+            // server. That is success, not a readiness failure; say so plainly and
+            // point at the right tool so the agent stops using wait_for_ready here.
+            if (bg.exitCode === 0) {
+                return {
+                    ready: false,
+                    detail: "Process completed (exit 0) before signaling readiness — it ran to completion rather than staying alive. " +
+                        "wait_for_ready is for long-lived servers/watchers; for a run-to-completion command use async_bash (or bg_shell 'run').",
+                };
+            }
             const stderrLines = bg.output.filter(l => l.stream === "stderr").slice(-5).map(l => l.line);
             const stderrContext = stderrLines.length > 0 ? `\nstderr:\n${stderrLines.join("\n").slice(0, 500)}` : "";
             return {