@yagni-app/code 0.2.0 → 0.3.0

package/dist/extension/chipEditor.js

@@ -17,7 +17,7 @@
  * literal text is the source of truth, so undo/cursor/history and the
  * chip→model mapping all share one string and can't desync.
  *
- * Validated against pi 0.83.0 (spike, 5/5): the subclass owns `onPasteImage`
+ * Validated against pi 0.84.1 (spike, 5/5): the subclass owns `onPasteImage`
  * because `setCustomEditorComponent` only fills it when unset, and jiti aliases
  * the extension's pi imports to the same module instance pi uses.
  */
@@ -29,6 +29,7 @@ import { tmpdir } from "node:os";
 import { join, basename, isAbsolute } from "node:path";
 import { randomUUID } from "node:crypto";
 import { logImagePaste } from "./diagnostics.js";
+import { cancelActiveRuns } from "./pipeline/runRegistry.js";
 /** Matches the `[Image #N]` chip token in the editor text. */
 const CHIP_RE = /\[Image #(\d+)\]/g;
 /** Inverse-video wrap so the chip token reads as a chip, not plain text. */
@@ -64,58 +65,98 @@ const IMAGE_MAGIC = [
     [[0x47, 0x49, 0x46, 0x38], "image/gif"], // GIF8
     [[0x52, 0x49, 0x46, 0x46], "image/webp"], // RIFF (webp container)
 ];
+/** A text paste this long is prose, not a dragged file list — bail early. */
+const MAX_PASTED_PATHS = 20;
 /**
- * Recognize a pasted temp-image path written by a Ghostty-based terminal
- * (cmux, Ghostty). Those terminals name the file `clipboard-<ts>-<id>.<ext>`
- * in the system temp dir. We match strictly — clipboard- prefix, image
- * extension, real file, and genuine image magic bytes — so a path the user
- * typed by hand (e.g. /Users/me/photo.png) is never silently converted.
- * Returns the decoded image, or null when the pasted text is not one such path.
+ * Split a pasted payload into path tokens the way terminals produce them:
+ * Finder/desktop drag-drop inserts absolute paths with backslash-escaped
+ * spaces (POSIX) or quote-wrapped paths (Windows Terminal), multiple files
+ * separated by whitespace. Returns [] when the payload can't be a path list
+ * (e.g. an unbalanced quote from ordinary prose like "don't").
  */
-export function readPastedImagePath(pastedText) {
-    const trimmed = pastedText.trim();
-    if (trimmed.includes("\n") || trimmed.includes(" "))
-        return null; // one token only
-    // Validate the RAW input first: an attacker could smuggle the `clipboard-`
-    // prefix through backslash escapes (e.g. `\c\l\i\p\b\o\a\r\d-`), so we
-    // must confirm the un-escaped form is a well-formed tmp image path before any
-    // unescaping or path resolution. cmux tmp paths contain no escapable chars
-    // (no spaces/metacharacters), so a legitimate paste has NO backslashes at all.
-    // On Windows the backslash IS the path separator (and cmd/PowerShell do no
-    // backslash-escaping), so the escape-smuggling rejection applies only where
-    // a backslash could be an escape: POSIX shells.
+function splitPathTokens(text) {
     const isWindows = process.platform === "win32";
-    if (!isWindows && trimmed.includes("\\"))
-        return null; // escapes => not a plain cmux tmp path
-    const path = trimmed;
-    if (isWindows ? !isAbsolute(path) : !path.startsWith("/"))
-        return null;
-    const name = basename(path);
-    if (!name.startsWith("clipboard-"))
-        return null;
-    const ext = name.split(".").pop()?.toLowerCase() ?? "";
-    if (!(ext in IMAGE_EXT_MIME))
-        return null;
-    if (!existsSync(path))
-        return null;
-    let bytes;
-    try {
-        bytes = readFileSync(path);
-    }
-    catch {
-        return null;
+    const tokens = [];
+    let cur = "";
+    let quote = null;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                cur += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        // POSIX shells escape spaces/metacharacters with a backslash; on Windows
+        // the backslash IS the path separator, so no unescaping there.
+        if (!isWindows && ch === "\\" && i + 1 < text.length) {
+            cur += text[++i];
+            continue;
+        }
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+            if (cur)
+                tokens.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += ch;
     }
-    if (bytes.length === 0)
+    if (quote !== null)
+        return [];
+    if (cur)
+        tokens.push(cur);
+    return tokens;
+}
+/**
+ * Recognize a pasted payload that is entirely image-file paths and decode
+ * them. This covers Finder/desktop drag-drop and Ghostty/cmux's Cmd+V
+ * (which writes the clipboard image to a `clipboard-*.png` temp file and
+ * pastes its path) — Claude Code parity: dragging a screenshot in becomes
+ * `[Image #N]`, not a literal path.
+ *
+ * Guardrails against converting something the user meant as text: the WHOLE
+ * paste must be path tokens, every token must be an absolute path to a real
+ * file with an image extension AND genuine image magic bytes, and the
+ * conversion is visible — each image becomes a chip in the prompt, so nothing
+ * is ever attached silently. Returns null when the paste is not such a list
+ * (caller passes it through as ordinary text).
+ */
+export function readPastedImagePaths(pastedText) {
+    const tokens = splitPathTokens(pastedText.trim());
+    if (tokens.length === 0 || tokens.length > MAX_PASTED_PATHS)
         return null;
-    for (const [magic, mime] of IMAGE_MAGIC) {
-        if (magic.every((b, i) => bytes[i] === b))
-            return { bytes, mimeType: mime };
+    const isWindows = process.platform === "win32";
+    const images = [];
+    for (const path of tokens) {
+        if (isWindows ? !isAbsolute(path) : !path.startsWith("/"))
+            return null;
+        const ext = basename(path).split(".").pop()?.toLowerCase() ?? "";
+        if (!(ext in IMAGE_EXT_MIME))
+            return null;
+        if (!existsSync(path))
+            return null;
+        let bytes;
+        try {
+            bytes = readFileSync(path);
+        }
+        catch {
+            return null;
+        }
+        const magic = IMAGE_MAGIC.find(([m]) => m.every((b, i) => bytes[i] === b));
+        if (!magic)
+            return null;
+        images.push({ bytes, mimeType: magic[1] });
     }
-    return null;
+    return images;
 }
 /**
  * Read an image from the system clipboard without forking pi. Best-effort and
- * cross-platform: native module if present, else osascript/pngpaste (macOS),
+ * cross-platform using ONLY tools the OS ships with: osascript (macOS),
  * wl-paste (Wayland), xclip (X11), PowerShell (Windows/WSL). Returns null when
  * the clipboard holds no image (caller then pastes text instead).
  */
@@ -145,7 +186,45 @@ function runBase64(command, args, timeoutMs = 3000) {
     return out.length > 0 ? out : null;
 }
 function readMacClipboardImage() {
-    // pngpaste writes the clipboard image to a PNG file (cleanest on macOS).
+    return readMacClipboardViaOsascript() ?? readMacClipboardViaPngpaste();
+}
+/**
+ * Parse osascript's clipboard dump — `«data PNGf89504E47…»` — into raw bytes.
+ * The 4-char tag after `«data ` is the pasteboard flavor; the hex that follows
+ * is the image. Returns null when the output holds no such dump.
+ */
+export function parseOsascriptImageHex(out) {
+    const m = /«data \w{4}((?:[0-9A-Fa-f]{2})+)»/.exec(out);
+    if (!m)
+        return null;
+    const bytes = Buffer.from(m[1], "hex");
+    return bytes.length > 0 ? bytes : null;
+}
+function readMacClipboardViaOsascript() {
+    // AppleScript ships with macOS, so this route needs no install (it is how
+    // Claude Code reads clipboard images too). Screenshots and browser
+    // "Copy image" put a PNG flavor on the pasteboard; try JPEG second.
+    for (const [cls, mime] of [
+        ["PNGf", "image/png"],
+        ["JPEG", "image/jpeg"],
+    ]) {
+        const res = spawnSync("osascript", ["-e", `the clipboard as «class ${cls}»`], {
+            timeout: 5000,
+            maxBuffer: 256 * 1024 * 1024, // the hex dump doubles the image size
+        });
+        if (res.error || res.status !== 0)
+            continue;
+        const out = Buffer.isBuffer(res.stdout) ? res.stdout.toString("utf8") : String(res.stdout ?? "");
+        const bytes = parseOsascriptImageHex(out);
+        if (bytes)
+            return { bytes, mimeType: mime };
+    }
+    return null;
+}
+function readMacClipboardViaPngpaste() {
+    // Optional fallback for pasteboard flavors osascript can't coerce to
+    // PNG/JPEG (e.g. TIFF-only sources) — pngpaste converts anything to PNG.
+    // Nice when installed, never required.
     const dest = join(tmpdir(), `yagni-clip-${randomUUID()}.png`);
     try {
         const res = spawnSync("pngpaste", [dest], { timeout: 3000 });
@@ -207,6 +286,15 @@ export class ChipEditor extends CustomEditor {
     stashed = [];
     chipCounter = 0;
     readImage;
+    /**
+     * Fired when Ctrl+C lands on an EMPTY prompt. pi's own binding is
+     * clear-editor (Esc is the interrupt key), but with nothing typed that is a
+     * no-op, and every peer harness (Claude Code, Codex, Gemini, Aider) treats a
+     * single Ctrl+C as "stop what's happening". The hook lets the extension wire
+     * exactly that; the key still falls through to pi afterwards, so clear and
+     * the 500ms double-press exit window are untouched.
+     */
+    onEmptyCtrlC;
     constructor(tui, theme, keybindings, readImage = defaultClipboardImageReader, options) {
         super(tui, theme, keybindings, options);
         this.readImage = readImage;
@@ -222,27 +310,31 @@ export class ChipEditor extends CustomEditor {
      * Kitty-protocol terminals that genuinely deliver the Cmd modifier.
      */
     handleInput(data) {
-        // Cmd+V on Ghostty-based terminals (cmux, Ghostty): the terminal writes the
-        // clipboard image to a temp file and pastes its PATH as bracketed text, so
-        // the payload arrives here as "\x1b[200~<path>\x1b[201~" (pi's Terminal
-        // re-wraps it). handlePaste is private and consumed inside super.handleInput,
-        // so we strip the markers here and convert a bare image path to a chip.
+        // Pasted image PATHS arrive as bracketed text ("\x1b[200~<paths>\x1b[201~",
+        // pi's Terminal re-wraps every paste): Finder/desktop drag-drop inserts the
+        // file's path, and Ghostty-based terminals (cmux, Ghostty) write a Cmd+V'd
+        // clipboard image to a temp file and paste ITS path. handlePaste is private
+        // and consumed inside super.handleInput, so we strip the markers here and
+        // convert an all-image-paths payload into chips.
         const unwrapped = unwrapBracketedPaste(data);
         if (unwrapped !== null) {
-            const image = readPastedImagePath(unwrapped);
+            const images = readPastedImagePaths(unwrapped);
             logImagePaste({
                 event: "paste_path",
-                outcome: image ? "ok" : "passthrough",
-                mimeType: image?.mimeType,
-                bytes: image?.bytes.length,
-                file: image ? unwrapped : undefined,
-                detail: image ? undefined : `not a lone image path: ${unwrapped.slice(0, 60)}`,
+                outcome: images ? "ok" : "passthrough",
+                imageCount: images?.length,
+                bytes: images?.reduce((sum, i) => sum + i.bytes.length, 0),
+                detail: images ? undefined : `not an image path list: ${unwrapped.slice(0, 60)}`,
             });
-            if (image) {
-                this.dropChip(image.bytes, image.mimeType);
+            if (images) {
+                images.forEach((image, i) => {
+                    if (i > 0)
+                        this.insertTextAtCursor(" ");
+                    this.dropChip(image.bytes, image.mimeType);
+                });
                 return;
             }
-            // Not a lone image path — re-wrap and let pi handle the paste normally.
+            // Not a list of image paths — re-wrap and let pi handle the paste normally.
             super.handleInput(data);
             return;
         }
@@ -251,6 +343,14 @@ export class ChipEditor extends CustomEditor {
             this.onPasteImage?.();
             return;
         }
+        // Ctrl+C on an empty prompt: fire the stop hook, then STILL hand the key to
+        // pi so its clear + double-press-exit tracking behave exactly as before.
+        if (matchesKey(data, "ctrl+c")) {
+            if (this.getText().length === 0)
+                this.onEmptyCtrlC?.();
+            super.handleInput(data);
+            return;
+        }
         super.handleInput(data);
     }
     async pasteChip() {
@@ -346,6 +446,20 @@ export function registerChipEditor(pi) {
             return;
         ctx.ui.setEditorComponent((tui, theme, keybindings) => {
             const editor = new ChipEditor(tui, theme, keybindings);
+            // Single Ctrl+C on an empty prompt = "stop what's happening" (peer-harness
+            // parity; pi's clear binding is a no-op with nothing typed): abort a
+            // streaming turn and cancel every in-flight /go run. pi still sees the
+            // key afterwards, so Ctrl+C twice within 500ms exits as always.
+            editor.onEmptyCtrlC = () => {
+                if (!ctx.isIdle())
+                    ctx.abort();
+                const cancelled = cancelActiveRuns();
+                if (cancelled.length > 0) {
+                    ctx.ui.notify(`Stopping ${cancelled.length} /go run${cancelled.length === 1 ? "" : "s"}: ${cancelled
+                        .map((r) => `[${r.runId.slice(0, 8)}] ${r.ticket}`)
+                        .join(", ")}. Work so far lands as WIP commits (see /go-status).`, "warning");
+                }
+            };
             liveChipEditors.add(new WeakRef(editor));
             return editor;
         });

package/dist/extension/claudeRules.d.ts

@@ -49,6 +49,4 @@ export interface BuildSectionOptions {
 export declare function buildClaudeRulesSection(rules: ClaudeRule[], opts?: BuildSectionOptions): string | null;
 /** Env-driven entry: dirs from YAGNI_CLAUDE_RULES_DIRS, null when off/empty. */
 export declare function claudeRulesSection(env: NodeJS.ProcessEnv, opts?: CollectRulesOptions & BuildSectionOptions): string | null;
-/** Append `section` to a system prompt exactly once; no-op without a section. */
-export declare function appendClaudeRules(systemPrompt: string, section: string | null): string;
 //# sourceMappingURL=claudeRules.d.ts.map

package/dist/extension/claudeRules.js

@@ -169,12 +169,4 @@ export function claudeRulesSection(env, opts = {}) {
         return null;
     }
 }
-/** Append `section` to a system prompt exactly once; no-op without a section. */
-export function appendClaudeRules(systemPrompt, section) {
-    if (!section)
-        return systemPrompt;
-    if (systemPrompt.includes(CLAUDE_RULES_HEADER))
-        return systemPrompt;
-    return `${systemPrompt}\n\n${section}`;
-}
 //# sourceMappingURL=claudeRules.js.map

package/dist/extension/cmux/dispatcher.d.ts

@@ -0,0 +1,25 @@
+import type { PiExtensionContextSnapshot } from "./state.js";
+export interface CommandResult {
+    ok: boolean;
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: unknown;
+    surfaceUnavailable?: boolean;
+}
+export declare function normalizedLaunchArgv(): string[];
+export declare function shouldPreserveEnvKey(key: string): boolean;
+export declare function hookEnvironment(cwd: string, includeSocketPassword?: boolean): NodeJS.ProcessEnv;
+export declare class CmuxDispatcher {
+    private static readonly surfaceUnavailableExitCode;
+    private controlQueues;
+    private unavailableSessions;
+    canDispatch(sessionId: string | null): boolean;
+    releaseSession(sessionId: string): void;
+    run(args: string[], cwd: string, input: string | undefined, context: PiExtensionContextSnapshot): Promise<CommandResult>;
+    private execute;
+    private spawnCmux;
+    private isSurfaceResolutionFailure;
+    private surfaceUnavailableResult;
+}
+//# sourceMappingURL=dispatcher.d.ts.map

package/dist/extension/cmux/dispatcher.js

@@ -0,0 +1,266 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+function resolveExecutable(name) {
+    const pathEnv = process.env.PATH || "";
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, name);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            if (fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch { }
+    }
+    return name;
+}
+function looksLikePiExecutable(value) {
+    const base = path.basename(value).toLowerCase();
+    return base === "pi" || base === "pi-coding-agent";
+}
+function looksLikePiScript(value) {
+    const normalized = value.replaceAll("\\", "/").toLowerCase();
+    const base = path.basename(normalized);
+    return (normalized.includes("/@earendil-works/pi-coding-agent/") ||
+        normalized.includes("/@mariozechner/pi-coding-agent/") ||
+        normalized.includes("/packages/coding-agent/") ||
+        ((base === "cli.js" || base === "cli.ts") &&
+            (normalized.includes("pi-coding-agent") || normalized.includes("coding-agent"))));
+}
+export function normalizedLaunchArgv() {
+    const raw = Array.isArray(process.argv) ? process.argv.map((value) => String(value)) : [];
+    if (raw.length === 0)
+        return [resolveExecutable("pi")];
+    if (looksLikePiExecutable(raw[0]))
+        return raw;
+    if (raw.length > 1 && looksLikePiScript(raw[1])) {
+        return [resolveExecutable("pi"), ...raw.slice(2)];
+    }
+    return [resolveExecutable("pi"), ...raw.slice(1)];
+}
+function base64NulSeparated(values) {
+    const bytes = [];
+    for (const value of values) {
+        bytes.push(Buffer.from(String(value), "utf8"));
+        bytes.push(Buffer.from([0]));
+    }
+    return Buffer.concat(bytes).toString("base64");
+}
+function secretLikeEnvKey(key) {
+    return /(TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTHORIZATION|COOKIE)/i.test(key);
+}
+function safePiEnvKey(key) {
+    return (key === "PI_CODING_AGENT_DIR" ||
+        key === "PI_CONFIG_DIR" ||
+        key === "PI_CODING_AGENT_SESSION_DIR" ||
+        (key.startsWith("PI_CODING_AGENT_") && !secretLikeEnvKey(key)));
+}
+function safeNodeEnvKey(key) {
+    return (key === "NODE_ENV" ||
+        key === "NODE_OPTIONS" ||
+        key === "NODE_PATH" ||
+        key === "NODE_NO_WARNINGS" ||
+        key === "NODE_EXTRA_CA_CERTS");
+}
+function safeCmuxEnvKey(key) {
+    if (key.startsWith("CMUX_TEST_PI_"))
+        return !secretLikeEnvKey(key);
+    if (key.startsWith("CMUX_AGENT_LAUNCH_"))
+        return !secretLikeEnvKey(key);
+    if (key === "CMUX_AGENT_HOOK_STATE_DIR")
+        return true;
+    if (key === "CMUX_PI_CMUX_BIN" || key === "CMUX_PI_HOOKS_DISABLED")
+        return true;
+    if (key === "CMUX_SURFACE_ID" || key === "CMUX_WORKSPACE_ID" || key === "CMUX_WINDOW_ID")
+        return true;
+    if (key === "CMUX_PANE_ID" || key === "CMUX_TAB_ID" || key === "CMUX_PANEL_ID")
+        return true;
+    if (key === "CMUX_SOCKET" || key === "CMUX_SOCKET_PATH")
+        return true;
+    if (key === "CMUX_BUNDLE_ID" || key === "CMUX_BUNDLED_CLI_PATH")
+        return true;
+    if (key === "CMUX_CLI_SENTRY_DISABLED" || key === "CMUX_DEBUG_LOG")
+        return true;
+    return false;
+}
+export function shouldPreserveEnvKey(key) {
+    if (safeCmuxEnvKey(key))
+        return true;
+    if (safePiEnvKey(key))
+        return true;
+    if (safeNodeEnvKey(key))
+        return true;
+    if (key === "PATH" || key === "HOME" || key === "PWD" || key === "SHELL")
+        return true;
+    if (key === "USER" || key === "LOGNAME" || key === "TMPDIR" || key === "TZ")
+        return true;
+    if (key === "LANG" || key.startsWith("LC_"))
+        return true;
+    if (key === "TERM" || key === "TERM_PROGRAM" || key === "TERM_PROGRAM_VERSION" || key === "COLORTERM")
+        return true;
+    if (key === "SSH_AUTH_SOCK")
+        return true;
+    if (key.startsWith("PI_") || key.startsWith("NODE_"))
+        return !secretLikeEnvKey(key);
+    return false;
+}
+export function hookEnvironment(cwd, includeSocketPassword = false) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value === undefined)
+            continue;
+        if (shouldPreserveEnvKey(key))
+            env[key] = value;
+    }
+    if (includeSocketPassword) {
+        const socketPassword = process.env.CMUX_SOCKET_PASSWORD;
+        if (socketPassword)
+            env.CMUX_SOCKET_PASSWORD = socketPassword;
+    }
+    if (!env.CMUX_AGENT_LAUNCH_ARGV_B64) {
+        const argv = normalizedLaunchArgv();
+        env.CMUX_AGENT_LAUNCH_KIND = "pi";
+        env.CMUX_AGENT_LAUNCH_EXECUTABLE = argv[0] || resolveExecutable("pi");
+        env.CMUX_AGENT_LAUNCH_ARGV_B64 = base64NulSeparated(argv);
+        env.CMUX_AGENT_LAUNCH_CWD = cwd || process.cwd();
+    }
+    return env;
+}
+function cmuxExecutable() {
+    return process.env.CMUX_PI_CMUX_BIN || "cmux";
+}
+export class CmuxDispatcher {
+    static surfaceUnavailableExitCode = 69;
+    controlQueues = new Map();
+    unavailableSessions = new Set();
+    canDispatch(sessionId) {
+        return !sessionId || !this.unavailableSessions.has(sessionId);
+    }
+    releaseSession(sessionId) {
+        this.unavailableSessions.delete(sessionId);
+    }
+    run(args, cwd, input, context) {
+        const sessionId = context.sessionId;
+        const previous = this.controlQueues.get(sessionId) || Promise.resolve();
+        const scheduled = previous.then(() => this.execute(args, cwd, input, context));
+        let tail;
+        tail = scheduled
+            .then(() => undefined, () => undefined)
+            .finally(() => {
+            if (this.controlQueues.get(sessionId) === tail)
+                this.controlQueues.delete(sessionId);
+        });
+        this.controlQueues.set(sessionId, tail);
+        return scheduled;
+    }
+    async execute(args, cwd, input, context) {
+        const sessionId = context.sessionId;
+        if (!this.canDispatch(sessionId)) {
+            return this.surfaceUnavailableResult();
+        }
+        const result = await this.spawnCmux(args, cwd, input);
+        if (this.isSurfaceResolutionFailure(result)) {
+            if (sessionId)
+                this.unavailableSessions.add(sessionId);
+            return { ...result, surfaceUnavailable: true };
+        }
+        return result;
+    }
+    spawnCmux(args, cwd, input) {
+        return new Promise((resolve) => {
+            let settled = false;
+            let stdout = "";
+            let stderr = "";
+            let inputError;
+            let timeout = null;
+            let terminateGrace = null;
+            let forceSettleTimeout = null;
+            let terminationError;
+            const appendOutput = (current, chunk) => {
+                const limit = 1024 * 1024;
+                if (current.length >= limit)
+                    return current;
+                return current + String(chunk).slice(0, limit - current.length);
+            };
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                if (terminateGrace)
+                    clearTimeout(terminateGrace);
+                if (forceSettleTimeout)
+                    clearTimeout(forceSettleTimeout);
+                resolve(result);
+            };
+            const terminatedResult = () => ({
+                ok: false,
+                status: null,
+                stdout,
+                stderr,
+                error: terminationError,
+            });
+            try {
+                const child = spawn(cmuxExecutable(), args, {
+                    env: hookEnvironment(cwd, true),
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                child.stdout.setEncoding("utf8");
+                child.stderr.setEncoding("utf8");
+                child.stdout.on("data", (chunk) => { stdout = appendOutput(stdout, chunk); });
+                child.stderr.on("data", (chunk) => { stderr = appendOutput(stderr, chunk); });
+                child.stdin.on("error", (error) => { inputError = error; });
+                const beginTermination = (error) => {
+                    if (terminationError)
+                        return;
+                    terminationError = error;
+                    child.stdin.destroy();
+                    try {
+                        child.kill("SIGTERM");
+                    }
+                    catch { }
+                    terminateGrace = setTimeout(() => {
+                        try {
+                            child.kill("SIGKILL");
+                        }
+                        catch { }
+                        forceSettleTimeout = setTimeout(() => {
+                            child.stdout.destroy();
+                            child.stderr.destroy();
+                            child.unref();
+                            settle(terminatedResult());
+                        }, 250);
+                    }, 250);
+                };
+                child.on("error", (error) => {
+                    settle(terminationError ? terminatedResult() : { ok: false, status: null, stdout, stderr, error });
+                });
+                child.on("close", (code) => {
+                    if (terminationError) {
+                        settle(terminatedResult());
+                        return;
+                    }
+                    const status = typeof code === "number" ? code : null;
+                    settle({ ok: status === 0 && inputError === undefined, status, stdout, stderr, error: inputError });
+                });
+                timeout = setTimeout(() => {
+                    beginTermination(new Error("cmux command timed out after 5000ms"));
+                }, 5000);
+                child.stdin.end(input);
+            }
+            catch (error) {
+                settle({ ok: false, status: null, stdout, stderr, error });
+            }
+        });
+    }
+    isSurfaceResolutionFailure(result) {
+        return !result.ok && result.status === CmuxDispatcher.surfaceUnavailableExitCode;
+    }
+    surfaceUnavailableResult() {
+        return { ok: false, status: null, stdout: "", stderr: "", surfaceUnavailable: true };
+    }
+}
+//# sourceMappingURL=dispatcher.js.map

package/dist/extension/cmux/hooks.d.ts

@@ -0,0 +1,12 @@
+import type { CmuxDispatcher, CommandResult } from "./dispatcher.js";
+import type { PiExtensionContextSnapshot } from "./state.js";
+type HookExtra = Record<string, unknown>;
+export declare function eventName(subcommand: string): string;
+export declare function surfaceTargetArgs(dispatcher: CmuxDispatcher, sessionId: string): string[] | null;
+export declare function rememberSurfaceTarget(dispatcher: CmuxDispatcher, sessionId: string, result: CommandResult): void;
+export declare function releaseSessionRuntime(dispatcher: CmuxDispatcher, sessionStates: Map<string, unknown>, sessionId: string): void;
+export declare function sendHook(dispatcher: CmuxDispatcher, subcommand: string, context: PiExtensionContextSnapshot, extra?: HookExtra): Promise<boolean>;
+export declare function ensureResumeBinding(dispatcher: CmuxDispatcher, context: PiExtensionContextSnapshot, sessionId: string): Promise<void>;
+export declare function clearResumeBinding(dispatcher: CmuxDispatcher, context: PiExtensionContextSnapshot, sessionId: string): Promise<void>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map