jeo-code 0.6.34 → 0.6.35

package/CHANGELOG.md

@@ -6,7 +6,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
-## [0.6.33] - 2026-06-19
+## [0.6.35] - 2026-06-20
+_The prompt's Ctrl+C now clears a non-empty input box on the first press and only exits on the next press of an empty box; plus app-driven system-clipboard copy (OSC 52 + local tool, tmux-aware), drag-and-drop image attachment, a Ctrl-L prompt re-anchor, and a SIGCONT resume repaint — verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot check._
+
+### Added
+- **System-clipboard COPY that survives SSH and tmux.** New `src/tui/clipboard.ts` puts text on the OS clipboard via OSC 52 (`ESC ] 52 ; c ; <base64> BEL`, wrapped in tmux DCS passthrough when inside tmux) with a local subprocess fallback (`pbcopy` / `wl-copy` / `xclip` / `xsel` / `clip`). The tmux profile (`launch/tmux.ts`) now sets `copy-command` so a `mouse on` drag-select releases the copy-mode selection straight to the system clipboard — making `cmd+v` work even where the outer terminal can't capture the drag.
+- **Drag-and-drop image attachment.** New `src/util/file-attachment.ts` recognises an image path dropped into the prompt (terminals deliver a drop as quoted/escaped text), validates it by magic bytes (not just extension), reads it, and rewrites the path token to the same `[image #N]` tag the Ctrl+V clipboard-image path uses — one consistent reference scheme for the model. Non-image / unreadable paths are left untouched.
+- **`clearVisible()` (`src/tui/terminal.ts`)** — a Ctrl-L redraw that erases the visible screen and homes the cursor (`2J` + `H`) while PRESERVING scrollback (no `3J`), used to re-anchor a prompt whose in-place footer drifted after the screen scrolled. Hotkey help (`/help`) now documents Ctrl-L, Ctrl-V, and drag-drop.
+
+### Changed
+- **Prompt Ctrl+C clears before it exits.** At the idle prompt, a first Ctrl+C with typed text (or a pending clipboard image / queued pasted batch) now WIPES the box and keeps you at the prompt; a Ctrl+C on the already-empty box hard-exits (130). A pure, unit-tested `decideCtrlC(hasInput, msSinceLastCtrlC, collapseMs?)` plus a 50 ms collapse window funnels the four delivery paths of one physical press (footer keypress, `process`/`rl` SIGINT, raw `\u0003` byte) into a single logical action, so one press can never clear AND then exit. In-turn abort, EOF, and modal-picker Ctrl+C remain hard exits.
+- **TUI repaints on resume from suspend (SIGCONT).** After `fg` brings jeo back from a Ctrl-Z / background stop, the live view now re-anchors itself instead of leaving a stale frame; the SIGCONT listener is registered only on non-Windows and removed on dispose (no listener leak).
+
+### Verified
+- `mem-probe` shows a flat post-GC heap (negative per-turn slope) with zero `process` SIGINT/listener accumulation, and `scripts/tmux-verify.sh smoke` boots `jeo --tmux` to a clean input box + model bar — full suite green (1747 tests) and `typecheck` clean.
+
+
 ## [0.6.34] - 2026-06-20
 _Per-session model memory — each saved session now remembers the model it was last using and restores it on `/resume` — plus clearer `jeo --tmux` attach diagnostics, a tmux session-name double-dash fix, and a more robust no-leak probe gate._
 
@@ -23,6 +38,7 @@ _Per-session model memory — each saved session now remembers the model it was
 - **`jeo --tmux` live.** `tmux-verify.sh smoke` OK + `battery` **6/6 PASSED** (boot, `/help`, unknown `$skill`, `/agents`, `$ultragoal`, unresolved `/command`).
 - **Green gates.** `bun run typecheck` clean; `bun test` **1714 pass / 0 fail** (211 files), including the new per-session-model round-trip (`test/session.test.ts`) and tmux attach-failure / double-dash cases (`test/tmux.test.ts`).
 
+## [0.6.33] - 2026-06-19
 _A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification._
 
 ### Changed

package/README.ja.md

@@ -200,11 +200,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
-- **[0.6.33]** (2026-06-19)
+- **[0.6.35]** (2026-06-20) — The prompt's Ctrl+C now clears a non-empty input box on the first press and only exits on the next press of an empty box; plus app-driven system-clipboard copy (OSC 52 + local tool, tmux-aware), drag-and-drop image attachment, a Ctrl-L prompt re-anchor, and a SIGCONT resume repaint — verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot check.
 - **[0.6.34]** (2026-06-20) — Per-session model memory — each saved session now remembers the model it was last using and restores it on `/resume` — plus clearer `jeo --tmux` attach diagnostics, a tmux session-name double-dash fix, and a more robust no-leak probe gate.
+- **[0.6.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
-- **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -200,11 +200,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
-- **[0.6.33]** (2026-06-19)
+- **[0.6.35]** (2026-06-20) — The prompt's Ctrl+C now clears a non-empty input box on the first press and only exits on the next press of an empty box; plus app-driven system-clipboard copy (OSC 52 + local tool, tmux-aware), drag-and-drop image attachment, a Ctrl-L prompt re-anchor, and a SIGCONT resume repaint — verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot check.
 - **[0.6.34]** (2026-06-20) — Per-session model memory — each saved session now remembers the model it was last using and restores it on `/resume` — plus clearer `jeo --tmux` attach diagnostics, a tmux session-name double-dash fix, and a more robust no-leak probe gate.
+- **[0.6.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
-- **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -200,11 +200,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
-- **[0.6.33]** (2026-06-19)
+- **[0.6.35]** (2026-06-20) — The prompt's Ctrl+C now clears a non-empty input box on the first press and only exits on the next press of an empty box; plus app-driven system-clipboard copy (OSC 52 + local tool, tmux-aware), drag-and-drop image attachment, a Ctrl-L prompt re-anchor, and a SIGCONT resume repaint — verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot check.
 - **[0.6.34]** (2026-06-20) — Per-session model memory — each saved session now remembers the model it was last using and restores it on `/resume` — plus clearer `jeo --tmux` attach diagnostics, a tmux session-name double-dash fix, and a more robust no-leak probe gate.
+- **[0.6.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
-- **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -200,11 +200,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
-- **[0.6.33]** (2026-06-19)
+- **[0.6.35]** (2026-06-20) — The prompt's Ctrl+C now clears a non-empty input box on the first press and only exits on the next press of an empty box; plus app-driven system-clipboard copy (OSC 52 + local tool, tmux-aware), drag-and-drop image attachment, a Ctrl-L prompt re-anchor, and a SIGCONT resume repaint — verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot check.
 - **[0.6.34]** (2026-06-20) — Per-session model memory — each saved session now remembers the model it was last using and restores it on `/resume` — plus clearer `jeo --tmux` attach diagnostics, a tmux session-name double-dash fix, and a more robust no-leak probe gate.
+- **[0.6.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
-- **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.6.34",
+  "version": "0.6.35",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/commands/launch/input.ts

@@ -408,3 +408,30 @@ export function classifyMidTurnLine(line: string): "command" | "steer" | "empty"
   if (t === "/" || t === "$") return "empty";
   return /^[/$]/.test(t) ? "command" : "steer";
 }
+/** Default window (ms) over which the several delivery paths of ONE physical Ctrl+C
+ *  press — readline 'keypress', the rl/process 'SIGINT' event, and the raw \u0003 stdin
+ *  byte — collapse into a single logical action. A genuine second press (the user
+ *  reacting to the just-cleared box) is far slower than this, so it is never swallowed. */
+export const CTRLC_COLLAPSE_MS = 50;
+
+export type CtrlCAction = "ignore" | "clear" | "exit";
+
+/** Decide what a Ctrl+C at the idle prompt should do, given whether the input box
+ *  currently holds anything clearable (typed text, a pending clipboard image, or a
+ *  queued pasted batch) and how long ago the previous Ctrl+C was handled:
+ *
+ *   - within `collapseMs` of the last handled press → "ignore" (duplicate delivery of
+ *     the SAME keystroke; acting on both would let one press clear AND then exit).
+ *   - input present                                  → "clear" (wipe the box, stay put).
+ *   - box already empty                              → "exit" (hard terminal break, 130).
+ *
+ *  Pure so the "first Ctrl+C clears, next Ctrl+C exits" contract is unit-testable
+ *  without a live TTY. */
+export function decideCtrlC(
+  hasInput: boolean,
+  msSinceLastCtrlC: number,
+  collapseMs: number = CTRLC_COLLAPSE_MS,
+): CtrlCAction {
+  if (msSinceLastCtrlC < collapseMs) return "ignore";
+  return hasInput ? "clear" : "exit";
+}

package/src/commands/launch/slash-views.ts

@@ -15,11 +15,14 @@ export function hotkeysLines(): string[] {
     "  Ctrl-C     cancel the in-flight turn (press again at the prompt to exit)",
     "  Ctrl-D     exit the REPL",
     "  Ctrl-O     dump the full last response (untruncated, tables rendered) into scrollback",
+    "  Ctrl-L     redraw / re-anchor the prompt (recover the input box after the screen scrolls)",
     "  Ctrl-K / Ctrl-U / Ctrl-W   kill to end / start of line / previous word (emacs kill-ring)",
     "  Ctrl-Y / Alt-Y             yank / yank-pop the killed text",
     "  Ctrl-A / Ctrl-E            move to start / end of line",
     "  /          open the slash-command palette",
     "  @path      mention a file (Tab completes relative paths)",
+    "  Ctrl-V     paste a copied image from the clipboard into the next message",
+    "  drag-drop  drop an image file onto the box to attach it (its path becomes [image #N])",
   ];
 }
 

package/src/commands/launch/tmux.ts

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { type LaunchFlags } from "./flags";
+import { tmuxCopyCommand } from "../../tui/clipboard";
 
 function hashString(input: string): string {
   let hash = 2166136261;
@@ -155,6 +156,7 @@ export function tmuxProfileCommands(
   target: string,
   env: Record<string, string | undefined>,
   meta: { branch?: string; project?: string } = {},
+  deps: { platform?: NodeJS.Platform; which?: (bin: string) => string | null } = {},
 ): TmuxProfileCommand[] {
   const t = `=${target}:`;
   const commands: TmuxProfileCommand[] = [];
@@ -191,7 +193,20 @@ export function tmuxProfileCommands(
         args: ["set-window-option", "-t", t, "mode-style", "fg=colour231,bg=colour60"],
       },
     );
+    // Pipe the copy-mode selection straight to the SYSTEM clipboard tool
+    // (pbcopy / wl-copy / xclip / xsel). With `mouse on`, a mouse drag-select
+    // releases into copy-mode and `copy-command` lands it on the OS clipboard —
+    // so a tmux drag-select copies for `cmd+v` even where the outer terminal
+    // doesn't honor OSC 52. Skipped when no clipboard tool is on PATH.
+    const copyCmd = tmuxCopyCommand(deps.platform ?? process.platform, deps.which ?? ((bin: string) => Bun.which(bin)));
+    if (copyCmd) {
+      commands.push({
+        description: "pipe copy-mode selection to the system clipboard",
+        args: ["set-option", "-t", t, "copy-command", copyCmd],
+      });
+    }
   }
+
   return commands;
 }
 

package/src/commands/launch.ts

@@ -67,7 +67,9 @@ import { renderInputFrame, verticalCursorOffset, type HighlightRange } from "../
 import { renderStatusBar } from "../tui/components/status";
 import { detectColorLevel, ColorLevel, visibleWidth } from "../tui/components/color";
 import { readClipboardImage } from "../util/clipboard-image";
+import { attachImagePaths } from "../util/file-attachment";
 import { formatTranscript } from "../tui/components/transcript";
+import { copyTextToClipboard } from "../tui/clipboard";
 import { loadInputHistory, appendInputHistory } from "../agent/input-history";
 import type { ImageAttachment } from "../ai/types";
 import { renderMarkdownTables } from "../tui/components/markdown-table";
@@ -96,7 +98,7 @@ import {
   sessionPath,
   appendCompaction,
 } from "../agent/session";
-import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking, clearScreen, clearToEnd } from "../tui/terminal";
+import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking, clearScreen, clearVisible, clearToEnd } from "../tui/terminal";
 
 import {
   type LaunchFlags,
@@ -138,6 +140,7 @@ import {
   restoreQueuedLinesToPrefill,
   createInFlightAbortHarness,
   classifyMidTurnLine,
+  decideCtrlC,
 } from "./launch/input";
 import {
   gatedStdout,
@@ -1445,6 +1448,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           out += data.slice(i, i + 3); i += 3; continue;
         }
         if (loneLfShiftEnter && data[i] === "\n") { out += SENTINEL; i += 1; continue; } // lone LF = Shift+Enter (opt-in)
+        // Ctrl+L (form feed): consumed as the prompt "redraw / re-anchor" hotkey (handled on
+        // the process.stdin 'keypress' listener), so it must never reach readline as a literal
+        // char that would otherwise insert garbage / desync the box from rl.line.
+        if (data[i] === "\u000c") { i += 1; continue; }
         out += data[i]; i += 1;
       }
       kf.write(out);
@@ -2008,13 +2015,48 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     out.write(s);
   };
 
-  // ESC at the prompt: wipe the typed text (and detach any pending clipboard
-  // images — their `[image #N]` tags live in that text) instead of leaving stale
-  // input. Ctrl+C is no longer a line editor shortcut; it hard-exits below.
+  // Ctrl-L "redraw / re-anchor" recovery. The boxed footer paints IN PLACE relative to
+  // the last parked cursor row; if the terminal scrolled for any reason the app did not
+  // drive (a stray async stdout write, a tmux pane reflow, a wheel-scroll past the margin),
+  // that anchor goes stale and subsequent repaints land on the wrong rows — the box looks
+  // frozen and typed text never appears, even though readline IS still capturing every key
+  // ("화면이 밀려서 입력이 안 보이는" 상태). This wipes the VISIBLE screen (scrollback kept),
+  // re-reserves the footer at the top, and repaints from readline's live buffer, so the box
+  // and caret snap back and whatever was already typed shows immediately.
+  const redrawPromptFooter = () => {
+    if (!previewArmed) return;
+    try {
+      const rows = process.stdout.rows ?? 24;
+      footerRendered = 0;
+      footerParkedRow = 0;
+      lastFooterKey = "";
+      lastDrawnLines = [];
+      out.write(clearVisible());
+      footerRows = previewRowsFor(rows);
+      const initial = Math.max(1, Math.min(footerRows, COMPACT_FOOTER_ROWS));
+      if (initial > 1) out.write("\n".repeat(initial - 1) + cursorUp(initial - 1));
+      out.write(toColumn(1));
+      footerRendered = initial;
+      footerWantRows = initial;
+      drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));
+    } catch { /* ignore redraw races */ }
+  };
+
+  // ESC — and a FIRST Ctrl+C while the box is non-empty — wipe the typed text (and
+  // detach any pending clipboard images, whose `[image #N]` tags live in that text)
+  // instead of leaving stale input. A Ctrl+C on the already-empty box hard-exits
+  // (see handleCtrlC below).
+  /** True when the prompt box holds anything a clear/Ctrl+C would discard: typed
+   *  text, a pending clipboard image, or a queued pasted batch. Single source of the
+   *  "is there input?" predicate shared by clearTypedInput and the Ctrl+C decision. */
+  const promptHasContent = (): boolean => {
+    const line = (rl as unknown as { line?: string }).line;
+    return (line?.length ?? 0) > 0 || pendingImages.length > 0 || queuedPromptInput.pastedLines.length > 0;
+  };
   const clearTypedInput = (): boolean => {
     const rli = rl as unknown as { line: string; cursor: number; _refreshLine?: () => void };
     const hadPastedQueue = queuedPromptInput.pastedLines.length > 0;
-    if ((rli.line?.length ?? 0) === 0 && pendingImages.length === 0 && !hadPastedQueue) return false;
+    if (!promptHasContent()) return false;
     // ESC is the escape hatch for an accidental giant paste: drop the queued batch.
     if (hadPastedQueue) {
       const dropped = queuedPromptInput.pastedLines.splice(0).length;
@@ -2031,9 +2073,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     if (previewArmed) drawFooter(previewLines(""));
     return true;
   };
-  // Ctrl+C at the prompt is a hard terminal break (exit code 130), not a line
+  // A Ctrl+C on an EMPTY prompt is a hard terminal break (exit code 130), not a line
   // editor shortcut. `/exit` remains the graceful session-save path; ^C is the
-  // emergency "get me back to my shell now" path and must work on the first press.
+  // emergency "get me back to my shell now" path. A first Ctrl+C with text in the box
+  // CLEARS it instead (handleCtrlC); the next Ctrl+C on the now-empty box exits.
   const forceExitFromCtrlC = () => {
     try {
       disarmPreview();
@@ -2044,15 +2087,28 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     }
     process.exit(130);
   };
-  const forceExitOnCtrlCByte = (chunk: string | Uint8Array) => {
+  // Prompt Ctrl+C: a single press clears a non-empty box; on an empty box it exits.
+  // `lastCtrlCAt` collapses the duplicate deliveries of one physical press (keypress
+  // + SIGINT + raw byte) so a single Ctrl+C can't clear AND then immediately exit.
+  let lastCtrlCAt = 0;
+  const handleCtrlC = () => {
+    const now = Date.now();
+    const action = decideCtrlC(promptHasContent(), now - lastCtrlCAt);
+    if (action === "ignore") return; // duplicate delivery of the same press
+    lastCtrlCAt = now;
+    if (action === "clear") clearTypedInput(); // had input → wipe it, stay at the prompt
+    else forceExitFromCtrlC(); // empty → hard exit (130)
+  };
+  const handleCtrlCByte = (chunk: string | Uint8Array) => {
     const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
-    if (text.includes("\u0003")) forceExitFromCtrlC();
+    if (text.includes("\u0003")) handleCtrlC();
   };
   // Bun/readline can deliver Ctrl+C as readline SIGINT, process SIGINT, or (tmux)
-  // a raw \u0003 byte before readline resolves the question; wire all three.
-  process.on("SIGINT", forceExitFromCtrlC);
-  process.stdin.on("data", forceExitOnCtrlCByte);
-  rl.on("SIGINT", forceExitFromCtrlC);
+  // a raw \u0003 byte before readline resolves the question; funnel all three through
+  // handleCtrlC (clear-or-exit + de-duplication) so the behavior is identical.
+  process.on("SIGINT", handleCtrlC);
+  process.stdin.on("data", handleCtrlCByte);
+  rl.on("SIGINT", handleCtrlC);
 
   const runSelectPicker = async <T>(
     render: (cols: number, rows: number) => string[],
@@ -2519,10 +2575,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     process.once("exit", () => out.write("\x1b[?25h")); // safety net: never leave the cursor hidden
     const footerKeypressHandler = (_ch: string, key: { name?: string; ctrl?: boolean; meta?: boolean } | undefined) => {
       if (key?.ctrl && key.name === "c") {
-        forceExitFromCtrlC();
+        handleCtrlC();
         return;
       }
       if (!previewArmed || pickerActive) return;
+      // Ctrl+L: redraw / re-anchor the prompt. The recovery for a footer whose in-place
+      // anchor drifted after the screen scrolled (typed text stops showing in the box).
+      if (key?.ctrl && key.name === "l") {
+        redrawPromptFooter();
+        return;
+      }
       // Ctrl+O: toggle a reversible, scrollable detail panel inside the footer
       // (expand on the first press, FOLD on the next). ↑↓/PgUp/PgDn scroll it while
       // open — long/CJK content is fully reachable, nothing is clipped. The live-turn
@@ -2592,7 +2654,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         clearTypedInput();
         return;
       }
-      // Ctrl+C hard-exits above; keep this guard for defensive ordering only.
+      // Ctrl+C is handled above (clear-or-exit); keep this guard for defensive ordering only.
       if (key?.ctrl && key.name === "c") return;
       previewPending = true;
       setImmediate(() => {
@@ -2840,6 +2902,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       pendingSelection = undefined;
       navMatches = [];
       navIdx = -1;
+      // File attachment: a dragged-and-dropped image file arrives as its path in
+      // the typed text. Read any image path(s), attach them, and swap the path for
+      // an [image #N] tag (continuing the clipboard-image numbering) — the same
+      // scheme Ctrl+V uses. Skipped for slash commands and `!` shell escapes.
+      if (input && !input.startsWith("/") && !input.startsWith("!")) {
+        const dropped = await attachImagePaths(input, pendingImages.length + 1);
+        if (dropped.images.length > 0) {
+          pendingImages.push(...dropped.images);
+          input = dropped.text;
+          console.log(chalk.dim(`(attached ${dropped.images.length} image file${dropped.images.length > 1 ? "s" : ""} from path)`));
+        }
+      }
       if (input === "/exit" || input === "/quit") break;
       if (input === "") {
         if (pendingImages.length === 0) continue;
@@ -3180,16 +3254,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
         try {
           const text = await exportSession(sessionId, "markdown", cwd);
-          const clip = process.platform === "darwin" ? "pbcopy" : Bun.which("wl-copy") ? "wl-copy" : Bun.which("xclip") ? "xclip" : "";
-          if (clip && Bun.which(clip)) {
-            const proc = Bun.spawn(clip === "xclip" ? [clip, "-selection", "clipboard"] : [clip], { stdin: "pipe" });
-            proc.stdin.write(text);
-            await proc.stdin.end();
-            await proc.exited;
-            console.log(`(transcript copied to clipboard — ${text.length} chars)`);
+          // Copy via BOTH OSC 52 (reaches the outer terminal over SSH/tmux) and a
+          // local clipboard tool (pbcopy / wl-copy / xclip / xsel / clip) — the union
+          // makes `cmd+v` find the transcript regardless of where the terminal runs.
+          const copied = await copyTextToClipboard(text);
+          if (copied.osc52 || copied.local) {
+            const via = [copied.local ? "system tool" : "", copied.osc52 ? "OSC52" : ""].filter(Boolean).join(" + ");
+            console.log(`(transcript copied to clipboard via ${via} — ${text.length} chars)`);
           } else {
             console.log(text);
-            console.log("(no clipboard tool found — transcript printed above)");
+            console.log("(no clipboard path available — transcript printed above)");
           }
         } catch (err) {
           console.log(`! dump failed: ${(err as Error).message}`);
@@ -4270,8 +4344,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       disarmPreview();
       out.write("\x1b[?25h\n");
     } catch { /* best effort */ }
-    process.removeListener("SIGINT", forceExitFromCtrlC);
-    process.stdin.off("data", forceExitOnCtrlCByte);
+    process.removeListener("SIGINT", handleCtrlC);
+    process.stdin.off("data", handleCtrlCByte);
     drainPromptListeners();
     restorePromptRawMode();
     process.exit(130);
@@ -4286,8 +4360,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // gjc-parity resume pointer (logs/gjc-tui-study analysis Gap C): leave the exact
   // resume command in scrollback on exit, mirroring the --list handler's convention.
   if (sessionId && !flags.noSession) console.log(formatResumeHint(sessionId));
-  process.removeListener("SIGINT", forceExitFromCtrlC);
-  process.stdin.off("data", forceExitOnCtrlCByte);
+  process.removeListener("SIGINT", handleCtrlC);
+  process.stdin.off("data", handleCtrlCByte);
   drainPromptListeners();
   restorePromptRawMode();
   gracefulReadlineClose = true;

package/src/tui/app.ts

@@ -1008,6 +1008,13 @@ export class LaunchTui {
     // force a full repaint instead of diffing against stale line positions.
     if (this.tty) {
       process.stdout.on("resize", this.onResize);
+      // Suspend (Ctrl-Z) → resume (fg): SIGWINCH is lost while the process is stopped,
+      // so a terminal resized mid-suspend would resume with stale geometry and a torn
+      // frame. SIGCONT fires on resume; force a re-measure + full repaint. POSIX only
+      // (Windows has no SIGCONT — registering it would throw).
+      if (process.platform !== "win32") {
+        process.on("SIGCONT", this.onResume);
+      }
     }
     // Animate the spinner + elapsed clock while the model is thinking.
     this.timer = setInterval(() => {
@@ -1063,6 +1070,17 @@ export class LaunchTui {
     } catch { /* resize race — next tick repaints */ }
   }
 
+  /** Resume from suspend (SIGCONT after Ctrl-Z). The terminal may have been resized
+   *  while the process was stopped — that SIGWINCH is dropped, so the cached geometry
+   *  is stale. Invalidate lastCols/lastRows so resizeRepaint cannot early-return on a
+   *  same-looking measurement, then re-measure and fully repaint at the current size. */
+  private readonly onResume = (): void => {
+    if (this.finished) return;
+    this.lastCols = -1;
+    this.lastRows = -1;
+    this.resizeRepaint();
+  };
+
   /** gjc-style agent identity: a bold accent `jeo` name label on its own line that leads
    *  every assistant segment — thought blocks (onAssistant) and the final reply (finish). */
   private agentLabel(): string {
@@ -1086,6 +1104,9 @@ export class LaunchTui {
     }
     if (this.tty) {
       process.stdout.removeListener("resize", this.onResize);
+      if (process.platform !== "win32") {
+        process.removeListener("SIGCONT", this.onResume);
+      }
     }
     if (this.usedAltScreen) {
       // Leave the alt screen (restores the main buffer + scrollback), then print the

package/src/tui/clipboard.ts

@@ -0,0 +1,145 @@
+/**
+ * System-clipboard COPY for the jeo TUI.
+ *
+ * Why this exists — the terminal reality:
+ *  - `cmd+c` / `cmd+v` are owned by the terminal emulator + OS, NOT the app. A
+ *    terminal program cannot bind them. `cmd+v` already works: jeo enables
+ *    bracketed paste (DECSET 2004), so a paste arrives as data on stdin. `cmd+c`
+ *    copies whatever the user has SELECTED with the mouse — that selection is the
+ *    terminal's, and the only way an app can put text on the system clipboard
+ *    itself is the OSC 52 escape (or a local clipboard subprocess).
+ *  - Under tmux `mouse on`, a mouse drag is captured by tmux's copy-mode instead
+ *    of the terminal, so `cmd+c` no longer copies the dragged text. The fix lives
+ *    in the tmux profile (`copy-command`, see launch/tmux.ts): it pipes the
+ *    copy-mode selection straight to the system clipboard tool.
+ *
+ * This module gives jeo an app-driven "copy to the system clipboard" that works
+ * locally AND across SSH/tmux:
+ *  - OSC 52 (`ESC ] 52 ; c ; <base64> BEL`) asks the OUTER terminal to set its
+ *    clipboard — the only mechanism that survives an SSH hop. Wrapped in tmux DCS
+ *    passthrough when running inside tmux so it reaches the real terminal.
+ *  - A local clipboard subprocess (pbcopy / wl-copy / xclip / xsel / clip) as a
+ *    belt-and-suspenders path when jeo runs on the same machine as the terminal.
+ */
+
+/** Max base64 payload pushed through OSC 52. Many terminals silently drop very
+ *  large clipboard writes (xterm's default is ~100KB of selection data); past
+ *  this we skip OSC 52 and rely on the local clipboard tool instead. */
+export const OSC52_MAX_BASE64 = 100_000;
+
+/**
+ * Resolve the local system-clipboard WRITE command for a platform, or null when
+ * no tool is available. Pure (the `which` probe is injected) so it is testable
+ * without touching the host.
+ *  - macOS: `pbcopy`.
+ *  - Windows: `clip` (clip.exe).
+ *  - Linux/BSD: Wayland `wl-copy` first, then X11 `xclip`, then `xsel`.
+ */
+export function systemClipboardCopyCommand(
+  platform: NodeJS.Platform,
+  which: (bin: string) => string | null,
+): string[] | null {
+  if (platform === "darwin") return which("pbcopy") ? ["pbcopy"] : null;
+  if (platform === "win32") return ["clip"]; // clip.exe always ships with Windows
+
+  if (which("wl-copy")) return ["wl-copy"];
+  if (which("xclip")) return ["xclip", "-selection", "clipboard"];
+  if (which("xsel")) return ["xsel", "--clipboard", "--input"];
+  return null;
+}
+
+/**
+ * The single shell command string tmux's `copy-command` option runs to push a
+ * copy-mode selection onto the system clipboard, or null when no tool exists.
+ * With `copy-command` set + `mouse on`, a mouse drag-select (and right-click
+ * paste menus, in terminals that surface them) lands directly on the system
+ * clipboard — bypassing OSC 52's terminal-support requirement. Shares the
+ * resolver above so the REPL `/dump` path and the tmux profile never diverge.
+ */
+export function tmuxCopyCommand(
+  platform: NodeJS.Platform,
+  which: (bin: string) => string | null,
+): string | null {
+  const argv = systemClipboardCopyCommand(platform, which);
+  return argv ? argv.join(" ") : null;
+}
+
+export interface Osc52Options {
+  /** Wrap in tmux DCS passthrough so the sequence reaches the OUTER terminal. */
+  tmux?: boolean;
+  /** Clipboard selection: `c` = system clipboard (default), `p` = primary. */
+  clipboard?: "c" | "p";
+}
+
+/**
+ * Build the OSC 52 clipboard-SET escape for `text`, or "" when the base64 payload
+ * exceeds {@link OSC52_MAX_BASE64} (caller falls back to a local tool). When
+ * `tmux` is set the whole sequence is wrapped in DCS passthrough (`ESC P tmux ; …
+ * ESC \`) with every inner ESC doubled, the tmux contract for forwarding an
+ * escape to the terminal underneath it.
+ */
+export function osc52Sequence(text: string, opts: Osc52Options = {}): string {
+  const b64 = Buffer.from(text, "utf8").toString("base64");
+  if (b64.length > OSC52_MAX_BASE64) return "";
+  const target = opts.clipboard ?? "c";
+  const inner = `\x1b]52;${target};${b64}\x07`;
+  if (!opts.tmux) return inner;
+  // tmux passthrough: inner ESCs are doubled; the trailing ESC \ is the DCS
+  // terminator and is appended AFTER the doubling, never itself doubled.
+  return `\x1bPtmux;${inner.replace(/\x1b/g, "\x1b\x1b")}\x1b\\`;
+}
+
+export interface CopyToClipboardDeps {
+  /** Write the OSC 52 escape to the terminal (defaults to process.stdout). */
+  write?: (s: string) => void;
+  /** Spawn a local clipboard subprocess (defaults to Bun.spawn). */
+  spawn?: (cmd: string[], opts: { stdin: "pipe" }) => { stdin: { write(s: string): void; end(): unknown }; exited: Promise<number> };
+  /** Probe for a binary on PATH (defaults to Bun.which). */
+  which?: (bin: string) => string | null;
+  /** Host platform (defaults to process.platform). */
+  platform?: NodeJS.Platform;
+  /** True when running inside tmux (defaults to !!process.env.TMUX). */
+  insideTmux?: boolean;
+}
+
+export interface CopyResult {
+  /** OSC 52 escape was emitted to the terminal. */
+  osc52: boolean;
+  /** A local clipboard subprocess accepted the text. */
+  local: boolean;
+}
+
+/**
+ * Copy `text` to the system clipboard via BOTH available paths: OSC 52 (works
+ * over SSH/tmux) and a local clipboard subprocess (works on the same host). Both
+ * are best-effort; the union maximizes the chance the user's `cmd+v` finds the
+ * text regardless of where the terminal actually runs. Returns which paths fired.
+ */
+export async function copyTextToClipboard(text: string, deps: CopyToClipboardDeps = {}): Promise<CopyResult> {
+  const platform = deps.platform ?? process.platform;
+  const which = deps.which ?? ((bin: string) => Bun.which(bin));
+  const insideTmux = deps.insideTmux ?? !!process.env.TMUX;
+  const write = deps.write ?? ((s: string) => { try { process.stdout.write(s); } catch { /* terminal gone */ } });
+  const spawn = deps.spawn ?? ((cmd, opts) => Bun.spawn(cmd, opts) as ReturnType<NonNullable<CopyToClipboardDeps["spawn"]>>);
+
+  const result: CopyResult = { osc52: false, local: false };
+
+  const seq = osc52Sequence(text, { tmux: insideTmux });
+  if (seq) {
+    write(seq);
+    result.osc52 = true;
+  }
+
+  const cmd = systemClipboardCopyCommand(platform, which);
+  if (cmd) {
+    try {
+      const proc = spawn(cmd, { stdin: "pipe" });
+      proc.stdin.write(text);
+      await proc.stdin.end();
+      const code = await proc.exited;
+      if (code === 0) result.local = true;
+    } catch { /* local tool unavailable / failed — OSC 52 may still have worked */ }
+  }
+
+  return result;
+}

package/src/tui/terminal.ts

@@ -29,6 +29,16 @@ export function clearScreen(): string {
   return `${ESC}2J${ESC}3J${ESC}H`;
 }
 
+/** Erase the VISIBLE screen (2J) and home the cursor (H), but PRESERVE the scrollback
+ *  buffer (no 3J). This is the readline/shell "Ctrl-L redraw" clear: the on-screen
+ *  transcript is wiped and the prompt is repainted from the top, yet scrolling up still
+ *  reveals prior output. Use it to RE-ANCHOR a prompt whose in-place footer drifted after
+ *  the terminal scrolled — recovering a "typing does not show in the box" state without
+ *  destroying history (unlike `clearScreen`, which also drops scrollback). */
+export function clearVisible(): string {
+  return `${ESC}2J${ESC}H`;
+}
+
 export function hideCursor(): string {
   return `${ESC}?25l`;
 }

package/src/util/file-attachment.ts

@@ -0,0 +1,158 @@
+/**
+ * File ATTACHMENT support for the REPL input box.
+ *
+ * Terminals deliver a dragged-and-dropped file as *text* on stdin: the emulator
+ * inserts the file's path (often shell-quoted or with backslash-escaped spaces)
+ * at the caret, exactly as if the user typed it. So "attach a file by dropping it
+ * into the box" reduces to: recognise an image path inside the submitted text,
+ * read the bytes, and turn it into an {@link ImageAttachment} — replacing the raw
+ * path token with the same `[image #N]` tag the Ctrl+V clipboard path uses, so the
+ * model receives one consistent reference scheme regardless of how the image got
+ * attached.
+ *
+ * Only paths with a known image extension are considered, so ordinary prose is
+ * never mistaken for a file. Non-image / unreadable paths are left untouched.
+ */
+import { readFile } from "node:fs/promises";
+import type { ImageAttachment } from "../ai/types";
+
+const IMAGE_EXT_RE = /\.(?:png|jpe?g|gif|webp|bmp)$/i;
+
+/** Detect an image media type from magic bytes, or null when the bytes are not a
+ *  recognised image. Used as the authoritative check (extension only gates the
+ *  candidate scan; the bytes decide). */
+export function imageMediaTypeFromBytes(bytes: Uint8Array): string | null {
+  const b = bytes;
+  if (b.length >= 8 && b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) return "image/png";
+  if (b.length >= 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return "image/jpeg";
+  if (b.length >= 6 && b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x38) return "image/gif";
+  if (
+    b.length >= 12 &&
+    b[0] === 0x52 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x46 &&
+    b[8] === 0x57 && b[9] === 0x45 && b[10] === 0x42 && b[11] === 0x50
+  ) return "image/webp";
+  if (b.length >= 2 && b[0] === 0x42 && b[1] === 0x4d) return "image/bmp";
+  return null;
+}
+
+/** Build an {@link ImageAttachment} from raw image bytes, or null when the bytes
+ *  are not a recognised image format. */
+export function attachmentFromImageBytes(bytes: Uint8Array): ImageAttachment | null {
+  const mediaType = imageMediaTypeFromBytes(bytes);
+  if (!mediaType) return null;
+  return { mediaType, data: Buffer.from(bytes).toString("base64") };
+}
+
+
+/**
+ * Decode one drag-and-drop path token into a usable filesystem path:
+ *  - strips matching single/double quotes,
+ *  - unescapes backslash-escaped characters (macOS escapes spaces as `\ `),
+ *  - resolves a `file://` URI (with percent-decoding).
+ * Returns the cleaned path.
+ */
+export function decodeDroppedPath(token: string): string {
+  let s = token.trim();
+  if ((s.startsWith("'") && s.endsWith("'")) || (s.startsWith('"') && s.endsWith('"'))) {
+    return s.slice(1, -1);
+  }
+  if (s.startsWith("file://")) {
+    let rest = s.slice("file://".length);
+    // file://host/path — drop an (almost always empty / "localhost") authority.
+    if (rest.startsWith("/") === false && rest.includes("/")) rest = rest.slice(rest.indexOf("/"));
+    try { return decodeURIComponent(rest); } catch { return rest; }
+  }
+  // Bare token: unescape `\<char>` (shell-style drag escaping).
+  return s.replace(/\\(.)/g, "$1");
+}
+
+export interface PathToken {
+  /** The exact substring matched in the source text (used for replacement). */
+  raw: string;
+  /** The decoded filesystem path. */
+  path: string;
+  start: number;
+  end: number;
+}
+
+/**
+ * Scan `text` for image-file path tokens (quoted, `file://`, or bare with
+ * backslash-escaped spaces). Only tokens whose decoded path ends in a known image
+ * extension are returned, so normal prose never matches. Tokens are returned in
+ * source order with their `[start, end)` offsets for in-place replacement.
+ */
+export function findImagePathTokens(text: string): PathToken[] {
+  const tokens: PathToken[] = [];
+  // Order matters: quoted forms first (so an inner space is kept), then file://
+  // URIs, then a bare run that allows backslash-escaped characters.
+  const re = /'[^']*'|"[^"]*"|file:\/\/\S+|(?:\\.|\S)+/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text)) !== null) {
+    const raw = m[0];
+    const decoded = decodeDroppedPath(raw);
+    if (IMAGE_EXT_RE.test(decoded)) {
+      tokens.push({ raw, path: decoded, start: m.index, end: m.index + raw.length });
+    }
+  }
+  return tokens;
+}
+
+/** Reads a file's bytes, or null when it cannot be read. Injectable for tests. */
+export type FileReader = (path: string) => Promise<Uint8Array | null>;
+
+const defaultReader: FileReader = async (p) => {
+  try {
+    return new Uint8Array(await readFile(p));
+  } catch {
+    return null;
+  }
+};
+
+export interface AttachResult {
+  /** The input text with every successfully-attached image path replaced by its
+   *  `[image #N]` tag; unmatched / unreadable paths are left verbatim. */
+  text: string;
+  /** The newly-read image attachments, in source order. */
+  images: ImageAttachment[];
+}
+
+/**
+ * Resolve image file paths dropped into `text` into attachments.
+ *
+ * @param text         the submitted input line
+ * @param startNumber  the next `[image #N]` number to assign (1-based; pass
+ *                     `existingImages.length + 1` so dropped files continue the
+ *                     numbering started by Ctrl+V clipboard images)
+ * @param read         file reader (defaults to the real filesystem)
+ */
+export async function attachImagePaths(
+  text: string,
+  startNumber = 1,
+  read: FileReader = defaultReader,
+): Promise<AttachResult> {
+  const tokens = findImagePathTokens(text);
+  if (tokens.length === 0) return { text, images: [] };
+
+  const reads = await Promise.all(
+    tokens.map(async (t) => {
+      const bytes = await read(t.path);
+      return bytes ? attachmentFromImageBytes(bytes) : null;
+    }),
+  );
+
+  const images: ImageAttachment[] = [];
+  let out = "";
+  let cursor = 0;
+  let n = startNumber;
+  for (let i = 0; i < tokens.length; i++) {
+    const att = reads[i];
+    if (!att) continue; // not a real image / unreadable → leave the text as-is
+    const t = tokens[i]!;
+    out += text.slice(cursor, t.start) + `[image #${n}]`;
+    cursor = t.end;
+    images.push(att);
+    n += 1;
+  }
+  out += text.slice(cursor);
+  return { text: out, images };
+}