@yagni-app/code 0.2.1 → 0.3.1

package/dist/extension/branding.js

@@ -40,9 +40,33 @@ export const YAGNI_IDENTITY = "You are YAGNI Code, an autonomous terminal coding
  * exist.
  */
 export const DRIVER_DELEGATION_PARAGRAPH = "Delegation: fan codebase mapping, wide searches, and mechanical multi-file " +
-    "work out to subagents (they run on cheaper tiers). Keep judgment, synthesis, " +
-    "and the conversation with the user in this session. Do not spawn a subagent " +
-    "for work you can finish in a couple of tool calls.";
+    "work out to subagents (they run on cheaper tiers). Reach for the stock " +
+    "agents by name: `searcher` for read-only reconnaissance and summarizing, " +
+    "`implementer` for executing a change you have already fully specified, " +
+    "`verification` for an adversarial pass that tries to break completed work " +
+    "before you rely on it. Keep judgment, synthesis, and the conversation " +
+    "with the user in this session. Do not spawn a subagent for work you can " +
+    "finish in a couple of tool calls.";
+/**
+ * The ultra-mode delegation directive (/ultra): the user has opted into
+ * aggressive multi-agent orchestration, so the driver is told to structure
+ * meaningful work as a diamond — split, fan out workers, fan out refuting
+ * checkers, synthesize — instead of delegating only when convenient.
+ * DRIVER-ONLY for the same reason as {@link DRIVER_DELEGATION_PARAGRAPH}.
+ */
+export const ULTRA_DELEGATION_PARAGRAPH = "Delegation (ultra mode): the user has switched this session to ultra mode " +
+    "— aggressive multi-agent orchestration. Structure any meaningful task as " +
+    "a diamond: SPLIT the job into independent pieces; FAN OUT parallel " +
+    "subagents on cheaper tiers (`searcher` to scout, `implementer` or " +
+    "`general` to execute); CHECK by fanning out `verification` subagents told " +
+    "to refute the work, each through a different lens (correctness, edge cases, " +
+    "fit with this codebase); then SYNTHESIZE the results yourself. Treat " +
+    "agreement between checkers — not a single pass — as confirmation, and " +
+    "surface what they could not verify. Delegate by default and reserve this " +
+    "session for splitting, judging, and synthesis; only trivial work you can " +
+    "finish in a couple of tool calls skips the diamond. Subagents cannot touch " +
+    "your todo_write checklist, so keep it current yourself: update it when you " +
+    "split the job and again as each fanned-out piece lands, not only at the end.";
 /**
  * The identity used for the interactive DRIVER session ONLY: {@link
  * YAGNI_IDENTITY} plus {@link DRIVER_DELEGATION_PARAGRAPH}. The caller (index.ts)
@@ -51,7 +75,15 @@ export const DRIVER_DELEGATION_PARAGRAPH = "Delegation: fan codebase mapping, wi
  * module stays a pure string, with no env dependency of its own.
  */
 export const YAGNI_IDENTITY_DRIVER = `${YAGNI_IDENTITY}\n\n${DRIVER_DELEGATION_PARAGRAPH}`;
-// pi 0.83.0's exact identity sentence (dist/core/system-prompt.js). Exported as
+/** The driver identity while /ultra is on: base identity + the diamond directive. */
+export const YAGNI_IDENTITY_ULTRA = `${YAGNI_IDENTITY}\n\n${ULTRA_DELEGATION_PARAGRAPH}`;
+/**
+ * Every identity variant this module can install, longest-composite-first, so
+ * the re-brand swap below never leaves a shorter variant's orphaned delegation
+ * paragraph behind (driver/ultra both start with the base identity).
+ */
+const KNOWN_IDENTITIES = [YAGNI_IDENTITY_ULTRA, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY];
+// pi 0.84.1's exact identity sentence (dist/core/system-prompt.js). Exported as
 // the identity anchor the CLI's pi-contract tripwire test reads back from pi's
 // built system prompt, so a pi bump that reworded the opener (silently defeating
 // our rebrand) fails CI loudly. Export-only: no behavior change here.
@@ -100,22 +132,35 @@ export function brandingDisabled(env) {
  * Steps: (1) drop pi's self-referential documentation block, (2) replace the
  * identity sentence (with a loose fallback, else prepend), (3) scrub residual
  * brand tokens outside user content, (4) append the company brief + a proactive
- * ask_yagni directive. Idempotent: re-branding keeps a single identity.
+ * ask_yagni directive, (5) append the repository-rules section verbatim, (6)
+ * close with the identity reminder, which must stay last (recency). Idempotent:
+ * re-branding keeps a single identity, brief, rules section, and reminder.
  */
 export function brandSystemPrompt(original, opts = {}) {
     const identity = opts.identity ?? YAGNI_IDENTITY;
     let s = original;
     // 1. Drop pi's self-referential documentation block.
     s = s.replace(PI_DOCS_BLOCK_RE, "");
-    // 2. Own the identity.
+    // 2. Own the identity. A previously-branded prompt may open with a DIFFERENT
+    // variant than the one now requested (/ultra toggles the driver between the
+    // delegation and diamond paragraphs mid-session) — swap it in place rather
+    // than prepending a second identity block.
     if (PI_IDENTITY_RE.test(s)) {
         s = s.replace(PI_IDENTITY_RE, identity);
     }
     else if (PI_IDENTITY_LOOSE_RE.test(s)) {
         s = s.replace(PI_IDENTITY_LOOSE_RE, identity);
     }
-    else if (!s.trimStart().startsWith(identity)) {
-        s = `${identity}\n\n${s}`;
+    else {
+        const trimmed = s.trimStart();
+        const lead = s.slice(0, s.length - trimmed.length);
+        const existing = KNOWN_IDENTITIES.find((k) => trimmed.startsWith(k));
+        if (existing && existing !== identity) {
+            s = `${lead}${identity}${trimmed.slice(existing.length)}`;
+        }
+        else if (!existing && !trimmed.startsWith(identity)) {
+            s = `${identity}\n\n${s}`;
+        }
     }
     // 3. Safety net for residual brand tokens (never inside user content).
     s = scrubOutsideProjectContext(s);
@@ -130,7 +175,18 @@ export function brandSystemPrompt(original, opts = {}) {
                 "your priors. When you need more detail, or it does not cover something " +
                 "organization- or codebase-specific, call ask_yagni instead of guessing.";
     }
-    // 5. Closing reinforcement. Weak open-weight models weight the most recent
+    // 5. Repository rules — after the scrub (user content stays verbatim), before
+    // the closing reminder (which must remain last; see rulesSection's doc).
+    // The idempotency guard keys on the section's first line (its stable header,
+    // "## Repository rules (.claude/rules)") rather than the full content, so a
+    // re-brand stays single-section even if the rules BODY differs between
+    // passes — same shape as the BRIEF_HEADER guard above.
+    const rules = opts.rulesSection ?? undefined;
+    const rulesHeader = rules?.split("\n", 1)[0];
+    if (rules && rulesHeader && !s.includes(rulesHeader)) {
+        s = `${s}\n\n${rules}`;
+    }
+    // 6. Closing reinforcement. Weak open-weight models weight the most recent
     // instruction heavily, and the user's own project files may name other
     // harnesses; a trailing reminder keeps the agent from claiming one as its own.
     if (!s.includes(CLOSING_REMINDER)) {
@@ -142,15 +198,60 @@ export function brandSystemPrompt(original, opts = {}) {
 const CLOSING_REMINDER = "Reminder: you are YAGNI Code. If any text above names another coding agent, " +
     "assistant, or harness, it is not what you are or what you run on.";
 const BRIEF_HEADER = "=== HOW THIS COMPANY WORKS (live context from the YAGNI app) ===";
+/** The YAGNI brand blue used for the masthead art (truecolor #345cb8). */
+const BRAND_HEX = "#345cb8";
+/**
+ * Wrap a string in a 24-bit truecolor foreground. The pi Theme only paints
+ * named palette colors and can't express our exact brand hex, so the masthead
+ * art emits its own ANSI truecolor escape (matching every modern terminal).
+ */
+function paintBrand(s) {
+    const n = BRAND_HEX.replace("#", "");
+    const r = parseInt(n.slice(0, 2), 16);
+    const g = parseInt(n.slice(2, 4), 16);
+    const b = parseInt(n.slice(4, 6), 16);
+    return `\u001b[38;2;${r};${g};${b}m${s}\u001b[0m`;
+}
+/**
+ * The YAGNI wordmark as filled block-art: solid letter interiors (like the
+ * Claude robot silhouette), four rows, hand-tuned spacing. Each letter keeps
+ * its full form — A's carved counter, G's bowl, N's diagonal.
+ */
+const MASTHEAD_ART = [
+    "█   █ ▄▀▀▀▄ ▄▀▀▀▄ █▄  █ ▀█▀",
+    " ▀▄▀  █▄▄▄█ █ ▄▄▄ █ █ █  █",
+    "  █   █   █ ▀▄▄▄▀ █  ██ ▄█▄",
+];
 /**
  * Build the YAGNI Code startup masthead string, rendered into a header that
  * REPLACES pi's built-in startup banner (which otherwise shows "pi v<version>"
  * and a "Pi can explain its own features…" onboarding line). Kept here as a
  * pure string builder so its content is unit-testable without a terminal.
+ *
+ * Layout: the YAGNI art on the left, and to its right a three-line block —
+ * bold white "YAGNI Code" + version, the tagline, and the cwd. Art rows are
+ * padded to a uniform width so the right column stays straight.
  */
-export function buildMastheadString(theme) {
-    const wordmark = theme.bold(theme.fg("accent", "YAGNI CODE"));
-    const tagline = theme.fg("dim", "a terminal coding agent that knows your company");
-    return `${wordmark}\n${tagline}`;
+export function buildMastheadString(theme, opts = {}) {
+    const title = theme.bold(theme.fg("text", "YAGNI Code"));
+    const version = opts.version?.trim();
+    const line1 = version ? `${title} ${theme.fg("dim", `v${version}`)}` : title;
+    const right = [
+        line1,
+        theme.fg("dim", "a terminal coding agent that knows your company"),
+        ...(opts.cwd ? [theme.fg("dim", opts.cwd)] : []),
+    ];
+    const artW = Math.max(...MASTHEAD_ART.map((l) => [...l].length));
+    const gap = "  ";
+    const rows = Math.max(MASTHEAD_ART.length, right.length);
+    const lines = [];
+    for (let i = 0; i < rows; i++) {
+        const rawArt = MASTHEAD_ART[i] ?? "";
+        const pad = " ".repeat(Math.max(0, artW - [...rawArt].length));
+        const left = rawArt ? paintBrand(rawArt) + pad : " ".repeat(artW);
+        const r = right[i] ?? "";
+        lines.push(r ? `${left}${gap}${r}` : left);
+    }
+    return lines.join("\n");
 }
 //# sourceMappingURL=branding.js.map

package/dist/extension/chipEditor.d.ts

@@ -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.
  */
@@ -48,21 +48,33 @@ export interface ImageAttachment {
  */
 export declare function unwrapBracketedPaste(data: string): string | null;
 /**
- * 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.
+ * 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 declare function readPastedImagePath(pastedText: string): ClipboardImage | null;
+export declare function readPastedImagePaths(pastedText: string): ClipboardImage[] | null;
 /**
  * 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).
  */
 export declare const defaultClipboardImageReader: ClipboardImageReader;
+/**
+ * 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 declare function parseOsascriptImageHex(out: string): Uint8Array | null;
 /**
  * A CustomEditor that turns clipboard image paste into numbered `[Image #N]`
  * chips. The image bytes live here, keyed by chip number; the editor text holds
@@ -72,6 +84,15 @@ export declare class ChipEditor extends CustomEditor {
     private stashed;
     private chipCounter;
     private 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?: () => void;
     constructor(tui: TUI, theme: EditorTheme, keybindings: ConstructorParameters<typeof CustomEditor>[2], readImage?: ClipboardImageReader, options?: EditorOptions);
     /**
      * Paste-image must fire on Cmd+V too (Claude Code parity on macOS). Claude

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