@opengsd/gsd-pi 1.2.0-dev.b1abb545 → 1.2.0-dev.d6c5343c

package/dist/cli-style.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Terminal presentation helpers for CLI-side notices on stderr — warnings,
+ * hints, and names. Pairs with the extension-side glyph set in
+ * resources/extensions/shared/ui.ts. Adopt incrementally: banner-shaped CLI
+ * surfaces (worktree banners today; update checks et al. as they're touched)
+ * should render through these instead of ad-hoc chalk.
+ */
+/** Dim "[gsd] " line tag that prefixes CLI banner lines. */
+export declare function gsdTag(): string;
+/** A yellow warning fragment. */
+export declare function warn(text: string): string;
+/** A dim "what to do next" hint fragment. */
+export declare function hint(text: string): string;
+/** A cyan user-supplied name (worktree, branch, file). */
+export declare function name(text: string): string;
+/** One banner line: tagged warning followed by a tagged hint line. */
+export declare function bannerLines(warning: string, hintText: string): string;

package/dist/cli-style.js

@@ -0,0 +1,28 @@
+/**
+ * Terminal presentation helpers for CLI-side notices on stderr — warnings,
+ * hints, and names. Pairs with the extension-side glyph set in
+ * resources/extensions/shared/ui.ts. Adopt incrementally: banner-shaped CLI
+ * surfaces (worktree banners today; update checks et al. as they're touched)
+ * should render through these instead of ad-hoc chalk.
+ */
+import chalk from 'chalk';
+/** Dim "[gsd] " line tag that prefixes CLI banner lines. */
+export function gsdTag() {
+    return chalk.dim('[gsd] ');
+}
+/** A yellow warning fragment. */
+export function warn(text) {
+    return chalk.yellow(text);
+}
+/** A dim "what to do next" hint fragment. */
+export function hint(text) {
+    return chalk.dim(text);
+}
+/** A cyan user-supplied name (worktree, branch, file). */
+export function name(text) {
+    return chalk.cyan(text);
+}
+/** One banner line: tagged warning followed by a tagged hint line. */
+export function bannerLines(warning, hintText) {
+    return gsdTag() + warning + '\n' + gsdTag() + hint(hintText) + '\n\n';
+}

package/dist/cli.js

@@ -524,7 +524,7 @@ const authStorage = AuthStorage.create(authFilePath);
 markStartup('AuthStorage.create');
 loadStoredEnvKeys(authStorage);
 migratePiCredentials(authStorage);
-// Resolve models.json path with fallback to ~/.pi/agent/models.json
+// Resolve models.json path
 const { resolveModelsJsonPath } = await import('./models-resolver.js');
 const modelsJsonPath = resolveModelsJsonPath();
 const modelRegistry = ModelRegistry.create(authStorage, modelsJsonPath);

package/dist/headless-events.d.ts

@@ -5,6 +5,10 @@
  * and classifies commands as quick (single-turn) vs long-running.
  *
  * Also defines exit code constants and the status→exit-code mapping function.
+ *
+ * The stop/pause notice vocabulary itself (prefixes + message classifiers)
+ * lives in the Stop Notice module — the same module the emitters format with,
+ * so wording stays in lockstep with detection.
  */
 export declare const EXIT_SUCCESS = 0;
 export declare const EXIT_ERROR = 1;
@@ -42,8 +46,6 @@ export declare function mapStatusToExitCode(status: string): number;
  *
  * Blocked detection is separate — checked via isBlockedNotification.
  */
-export declare const PAUSED_PREFIXES: string[];
-export declare const TERMINAL_PREFIXES: string[];
 export declare const IDLE_TIMEOUT_MS = 15000;
 export declare const NEW_MILESTONE_IDLE_TIMEOUT_MS = 120000;
 export declare function canonicalHeadlessToolName(toolName: string | undefined): string;

package/dist/headless-events.js

@@ -5,7 +5,13 @@
  * and classifies commands as quick (single-turn) vs long-running.
  *
  * Also defines exit code constants and the status→exit-code mapping function.
+ *
+ * The stop/pause notice vocabulary itself (prefixes + message classifiers)
+ * lives in the Stop Notice module — the same module the emitters format with,
+ * so wording stays in lockstep with detection.
  */
+import { isBlockedNoticeMessage, isManualResolutionNotice, isPauseNotice, isTerminalNotice, } from './resources/extensions/gsd/stop-notice.js';
+import { canonicalToolName } from './resources/extensions/gsd/engine-hook-contract.js';
 // ---------------------------------------------------------------------------
 // Exit Code Constants
 // ---------------------------------------------------------------------------
@@ -65,40 +71,19 @@ export function mapStatusToExitCode(status) {
  *
  * Blocked detection is separate — checked via isBlockedNotification.
  */
-export const PAUSED_PREFIXES = ['auto-mode paused', 'step-mode paused'];
-export const TERMINAL_PREFIXES = [
-    'auto-mode stopped',
-    'step-mode stopped',
-    'auto-mode complete',
-    'no active milestone',
-    'auto-mode idle',
-];
 export const IDLE_TIMEOUT_MS = 15_000;
 // new-milestone is a long-running creative task where the LLM may pause
 // between tool calls (e.g. after mkdir, before writing files). Use a
 // longer idle timeout to avoid killing the session prematurely (#808).
 export const NEW_MILESTONE_IDLE_TIMEOUT_MS = 120_000;
 const INTERACTIVE_HEADLESS_TOOLS = new Set(['ask_user_questions', 'secure_env_collect']);
+// Delegates to the shared normalizer seam (engine-hook-contract.ts) instead of
+// a hand-rolled parser. Behavior differs from the old parser only on malformed
+// MCP names: `mcp____tool` (empty server) and `mcp__server__` (empty tool) are
+// now returned unchanged rather than partially stripped — neither can match a
+// real tool name, so detection behavior is unaffected.
 export function canonicalHeadlessToolName(toolName) {
-    const name = String(toolName ?? '');
-    if (!name.startsWith('mcp__'))
-        return name;
-    const toolSeparator = name.indexOf('__', 'mcp__'.length);
-    return toolSeparator >= 0 ? name.slice(toolSeparator + 2) : name;
-}
-function isManualResolutionNotification(message) {
-    return (message.includes('resolve manually and re-run /gsd auto') ||
-        message.includes('resolve conflicts manually and run /gsd auto to resume') ||
-        message.includes('resolve and run /gsd auto to resume'));
-}
-function isNonBlockingPauseNotification(message) {
-    return message.includes('idempotent advance: unit already active');
-}
-function isPauseNotification(message) {
-    return PAUSED_PREFIXES.some((prefix) => message.startsWith(prefix));
-}
-function isPauseNotificationRequiringIntervention(message) {
-    return isPauseNotification(message) && !isNonBlockingPauseNotification(message);
+    return canonicalToolName(String(toolName ?? ''));
 }
 function getCommandBlockContent(event) {
     if (event.type !== 'message_start' && event.type !== 'message_end')
@@ -122,20 +107,15 @@ export function isTerminalNotification(event) {
     if (event.type !== 'extension_ui_request' || event.method !== 'notify')
         return false;
     const message = String(event.message ?? '').toLowerCase();
-    return (TERMINAL_PREFIXES.some((prefix) => message.startsWith(prefix)) ||
-        isPauseNotification(message) ||
-        isManualResolutionNotification(message));
+    return isTerminalNotice(message) || isPauseNotice(message) || isManualResolutionNotice(message);
 }
 export function isBlockedNotification(event) {
     if (isBlockingCommandBlock(event))
         return true;
     if (event.type !== 'extension_ui_request' || event.method !== 'notify')
         return false;
-    const message = String(event.message ?? '').toLowerCase();
     // Recoverable pauses need operator intervention in headless mode.
-    return (message.includes('blocked:') ||
-        isPauseNotificationRequiringIntervention(message) ||
-        isManualResolutionNotification(message));
+    return isBlockedNoticeMessage(String(event.message ?? '').toLowerCase());
 }
 export function isMilestoneReadyNotification(event) {
     if (event.type !== 'extension_ui_request' || event.method !== 'notify')

package/dist/models-resolver.d.ts

@@ -1,20 +1,10 @@
 /**
- * Models.json resolution with fallback to ~/.pi/agent/models.json
+ * Models.json resolution for GSD.
  *
- * GSD uses ~/.gsd/agent/models.json, but for a smooth migration/development
- * experience, this module provides resolution logic that:
- *
- * 1. Reads ~/.gsd/agent/models.json if it exists
- * 2. Falls back to ~/.pi/agent/models.json if GSD file doesn't exist
- * 3. Merges both files if both exist (GSD takes precedence)
+ * Uses ~/.gsd/agent/models.json exclusively.
  */
 /**
- * Resolve the path to models.json with fallback logic.
- *
- * Priority:
- * 1. ~/.gsd/agent/models.json (exists) → return this path
- * 2. ~/.pi/agent/models.json (exists) → return this path (fallback)
- * 3. Neither exists → return GSD path (will be created)
+ * Resolve the path to models.json.
  *
  * @returns The path to use for models.json
  */

package/dist/models-resolver.js

@@ -1,35 +1,16 @@
 /**
- * Models.json resolution with fallback to ~/.pi/agent/models.json
+ * Models.json resolution for GSD.
  *
- * GSD uses ~/.gsd/agent/models.json, but for a smooth migration/development
- * experience, this module provides resolution logic that:
- *
- * 1. Reads ~/.gsd/agent/models.json if it exists
- * 2. Falls back to ~/.pi/agent/models.json if GSD file doesn't exist
- * 3. Merges both files if both exist (GSD takes precedence)
+ * Uses ~/.gsd/agent/models.json exclusively.
  */
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { agentDir } from './app-paths.js';
 const GSD_MODELS_PATH = join(agentDir, 'models.json');
-const PI_MODELS_PATH = join(homedir(), '.pi', 'agent', 'models.json');
 /**
- * Resolve the path to models.json with fallback logic.
- *
- * Priority:
- * 1. ~/.gsd/agent/models.json (exists) → return this path
- * 2. ~/.pi/agent/models.json (exists) → return this path (fallback)
- * 3. Neither exists → return GSD path (will be created)
+ * Resolve the path to models.json.
  *
  * @returns The path to use for models.json
  */
 export function resolveModelsJsonPath() {
-    if (existsSync(GSD_MODELS_PATH)) {
-        return GSD_MODELS_PATH;
-    }
-    if (existsSync(PI_MODELS_PATH)) {
-        return PI_MODELS_PATH;
-    }
     return GSD_MODELS_PATH;
 }

package/dist/resource-loader.js

@@ -701,9 +701,8 @@ function collectRelativeFiles(rootDir) {
     return files;
 }
 /**
- * Constructs a DefaultResourceLoader that loads extensions from both
- * ~/.gsd/agent/extensions/ (GSD's default) and ~/.pi/agent/extensions/ (pi's default).
- * This allows users to use extensions from either location.
+ * Constructs a DefaultResourceLoader that loads extensions from
+ * ~/.gsd/agent/extensions/ (GSD's default) only.
  */
 // Cache bundled extension keys at module load — avoids re-scanning the extensions
 // directory in buildResourceLoader() (already scanned by loader.ts for env var).
@@ -718,19 +717,8 @@ export async function buildResourceLoader(agentDir, options = {}) {
     const { DefaultResourceLoader } = await loadPiCodingAgentModule();
     const { sortExtensionPaths } = await import('./extension-sort.js');
     const registry = loadRegistry();
-    const piAgentDir = join(homedir(), '.pi', 'agent');
-    const piExtensionsDir = join(piAgentDir, 'extensions');
     const bundledKeys = getBundledExtensionKeys();
-    const piExtensionPaths = discoverExtensionEntryPaths(piExtensionsDir)
-        .filter((entryPath) => !bundledKeys.has(getExtensionKey(entryPath, piExtensionsDir)))
-        .filter((entryPath) => {
-        const manifest = readManifestFromEntryPath(entryPath);
-        if (!manifest)
-            return true;
-        return isExtensionEnabled(registry, manifest.id);
-    });
     const additionalExtensionPaths = [
-        ...piExtensionPaths,
         ...(options.additionalExtensionPaths ?? []),
     ];
     return new DefaultResourceLoader({

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-9a23824a70bd2722
+c63bf325c75b710f

package/dist/resources/GSD-WORKFLOW.md

@@ -470,13 +470,13 @@ key_decisions: []
 
 **After a slice completes:**
 1. Write slice `S##-SUMMARY.md` (compresses all task summaries).
-2. Write slice `S##-UAT.md` — a non-blocking human test script derived from the slice's must-haves and demo sentence. The agent does NOT wait for UAT results.
+2. Write slice `S##-UAT.md` — a human test script derived from the slice's must-haves and demo sentence.
 3. Mark the slice checkbox in `M###-ROADMAP.md` as `[x]`.
 4. Update `STATE.md` with new position.
 5. Update milestone `M###-SUMMARY.md` with the completed slice's contributions.
-6. Continue to next slice immediately. The user tests the UAT whenever convenient.
-7. If the user reports UAT failures later, create fix tasks in the current or a new slice.
-8. If all slices done → milestone complete.
+6. Continue to next slice immediately. UAT can run after slice completion; automatic milestone closure requires each slice assessment to record `PASS`.
+7. If UAT is missing or non-PASS at milestone closeout, run `/gsd dispatch uat`, request a slice-specific UAT rerun when needed, or create remediation work with `/gsd dispatch reassess`.
+8. If all slices are done and UAT plus milestone validation pass → milestone complete.
 
 ---
 
@@ -605,6 +605,7 @@ Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
 |---------|-----|
 | Bad task | Revert the task commit on the active branch |
 | Bad milestone squash | Revert the squash commit on the integration branch |
+| UAT missing or non-PASS at closeout | Run `/gsd dispatch uat`, request a slice-specific UAT rerun when needed, or create remediation work with `/gsd dispatch reassess` |
 | UAT failure after merge | Create follow-up fix tasks in the current or next milestone |
 
 ---

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.");