jeo-code 0.9.11 → 0.9.12

package/CHANGELOG.md

@@ -8,6 +8,20 @@ The README mirrors the latest 5 entries — regenerate with `bun run changelog:s
 
 ## [Unreleased]
 
+## [0.9.12] - 2026-08-02
+_Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`._
+
+### Fixed
+- **A lone `Esc` swallowed the next keystroke — including the first character of a command or a paste** (`src/commands/launch/input.ts`) — a standalone `Esc` byte is a valid bracketed-paste-marker prefix, so the prompt filter carried it and re-prepended it to the NEXT stdin chunk. Forwarded that way, readline's key decoder read `ESC` + `z` as meta-z and consumed the character: after clearing the box with Esc, typing `zebra` produced `ebra`, and typing `/route off` produced `route off` — no longer a slash command, so it was sent to the model as a prompt and routing stayed on (the "`jeo --tmux` 에서 `/route off` 가 안 먹힌다" report). A carried `Esc` that cannot begin an escape sequence is now dropped before readline sees it (jeo already owns Esc on its own raw-stdin keypress listener); an `ESC x` pair delivered in ONE chunk is still a real Alt/Meta chord and passes through untouched.
+- **The painted caret drifted right of the real insertion point in any draft containing emoji** (`src/tui/components/input-box.ts`) — the box mapped `rl.cursor` (UTF-16 code units) onto a CODE-POINT index, so every surrogate pair before the caret shifted it one column and `←` after an emoji appeared not to move at all. `wrapWithCursor`/`caretCells` now index by code unit (a surrogate pair keeps both offsets addressable), and every offset returned to readline by the Up/Down and row-Home/End helpers snaps to a whole character.
+- **A drag-and-dropped image left the next typed word glued to its tag** (`src/util/file-attachment.ts`) — `attachImagePaths` trimmed the tag's trailing space, so `[image #1]` + typing became `[image #1]please`, while the Ctrl+V path (`insertImageTag`) kept one space. Both attach paths now leave exactly one trailing space at end-of-draft with the caret parked after it. Dropped/typed `~/…` paths are also expanded to the home directory (gjc parity), so `~/Downloads/shot.png` attaches instead of being sent to the model as literal text.
+- **A paste made WHILE a turn was running lost its line structure** (`src/commands/launch/input.ts`, `src/commands/launch.ts`) — the live-turn capture trimmed every pasted line and space-joined them, so a pasted code block/stack trace arrived at the next prompt as one flattened line with its indentation gone, and a large paste split across stdin reads gained a stray space wherever the read boundary fell (`hello wo` + `rld` → `hello wo rld`). Mid-turn pastes now fold line breaks to the same `MULTILINE_SENTINEL` the idle path uses and append verbatim; the live box and the mid-turn steering/command paths expand that sentinel, so the model never sees the private-use character. `JEO_NO_MULTILINE=1` degrades to the old space join, which is the only mode where the sentinel is not expanded on submit.
+
+### Verified
+- Live in tmux (`jeo --tmux` inner process, real PTY, caret cell read back with `tmux display-message -p '#{cursor_x},#{cursor_y}'`): Esc → `zebra` stays `zebra`; Esc → `/route off` prints `routing: off (this session)`; `←` after `안녕하세요 테스트😀😀` steps 24 → 22 → 20 columns; a dropped `assets/icon.png` renders `look at [image #1] please` with the caret exactly at column 28; `~/…` and backslash-escaped paths attach.
+- Suites: input-box, vertical-cursor, box-vertical-nav, prompt-key-filter, row-home-end-filter, extended-key-decode, mouse/terminal-report filters, file-attachment, image-attachments, input-history, new-input-first, launch-flags, slash, tmux — 215 pass / 0 fail. `bun run typecheck` clean. (`test/team-subagent.test.ts` timeouts are pre-existing and reproduce with these changes stashed.)
+- Mid-turn paste: a bracketed paste delivered WHILE a turn runs kept its line breaks and indentation in the live box (`def run():` / `    return 1`), and a paste split across stdin reads no longer gains a stray space at the boundary.
+
 ## [0.9.11] - 2026-07-30
 _Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication._
 

package/README.ja.md

@@ -287,10 +287,10 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
 - **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
 - **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
-- **[0.9.8]** (2026-07-27) — The provider model list now persists and rehydrates, so an account's live models survive across launches (gjc parity).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -288,10 +288,10 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
 - **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
 - **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
-- **[0.9.8]** (2026-07-27) — The provider model list now persists and rehydrates, so an account's live models survive across launches (gjc parity).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -295,10 +295,10 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
 - **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
 - **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
-- **[0.9.8]** (2026-07-27) — The provider model list now persists and rehydrates, so an account's live models survive across launches (gjc parity).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -287,10 +287,10 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
 - **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
 - **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
-- **[0.9.8]** (2026-07-27) — The provider model list now persists and rehydrates, so an account's live models survive across launches (gjc parity).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/commands/launch/input.ts

@@ -384,17 +384,35 @@ function feedLivePromptSegment(state: PromptInputQueue, segment: string): boolea
   return accepted;
 }
 
-function feedLivePromptPasteBody(state: PromptInputQueue, body: string): boolean {
+/** Pasted body captured while a TURN is running: pure DATA appended verbatim to the
+ *  draft the box will show when the turn ends.
+ *
+ *  Line breaks fold to {@link MULTILINE_SENTINEL} — the SAME contract the idle key
+ *  filter uses — so a pasted code block / stack trace keeps its structure (and its
+ *  indentation) instead of being flattened into one space-joined line. `multiline:
+ *  false` (JEO_NO_MULTILINE=1, no sentinel expansion on submit) degrades to a single
+ *  space so the sentinel can never leak into the model's input.
+ *
+ *  Nothing is trimmed and no separator is inserted between chunks: a large paste is
+ *  delivered over SEVERAL stdin reads, and the old per-chunk `trim()` + `join(" ")`
+ *  both dropped leading indentation and spliced a stray space into whatever word the
+ *  read boundary happened to split ("hello wo" + "rld" → "hello wo rld"). */
+function feedLivePromptPasteBody(state: PromptInputQueue, body: string, multiline: boolean): boolean {
   if (!body) return false;
   const normalized = stripPasteEscapes(body).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  const flattened = normalized.split("\n").map(part => part.trim()).filter(Boolean).join(" ");
-  if (!flattened) return false;
-  state.partial = state.partial ? `${state.partial} ${flattened}` : flattened;
+  const folded = normalized.split("\n").join(multiline ? MULTILINE_SENTINEL : " ");
+  if (!folded) return false;
+  state.partial += folded;
   return true;
 }
 
-export function captureLivePromptInputChunk(state: PromptInputQueue, chunk: string): boolean {
+export function captureLivePromptInputChunk(
+  state: PromptInputQueue,
+  chunk: string,
+  opts: { multiline?: boolean } = {},
+): boolean {
   if (!chunk) return false;
+  const multiline = opts.multiline !== false;
   let accepted = false;
   let rest = chunk;
   while (rest.length > 0) {
@@ -403,7 +421,7 @@ export function captureLivePromptInputChunk(state: PromptInputQueue, chunk: stri
       const body = end === -1 ? rest : rest.slice(0, end);
       if (end !== -1) state.inPaste = false;
       rest = end === -1 ? "" : rest.slice(end + PASTE_END.length);
-      if (feedLivePromptPasteBody(state, body)) accepted = true;
+      if (feedLivePromptPasteBody(state, body, multiline)) accepted = true;
     } else {
       const start = rest.indexOf(PASTE_START);
       const plain = start === -1 ? rest : rest.slice(0, start);
@@ -863,6 +881,7 @@ export function filterPromptInputChunk(
   // or a `\r\n` straddling this read boundary — is never half-interpreted. Carrying is
   // safe: the concatenation is re-parsed next call, so a tail that turns out NOT to be a
   // marker is simply emitted one chunk later.
+  const carriedEsc = state.carry === "\u001b";
   data = (state.carry ?? "") + data;
   state.carry = "";
   const markerTail = pasteMarkerTailLength(data);
@@ -890,6 +909,19 @@ export function filterPromptInputChunk(
   let out = "";
   let i = 0;
   while (i < data.length) {
+    // A lone Esc keystroke that the PREVIOUS chunk carried, now followed by bytes that
+    // cannot continue an escape sequence (`ESC [` / `ESC O`): drop the ESC instead of
+    // forwarding it. readline's key decoder otherwise holds a dangling ESC as a pending
+    // META prefix and merges it with the NEXT keystroke (Esc, then "z" → meta-z), which
+    // SWALLOWS that character — the "Esc 로 지운 뒤 첫 글자가 안 먹힘" bug (a pasted
+    // block's first character disappeared the same way). jeo owns Esc itself on the raw
+    // process.stdin keypress listener (clearTypedInput), so readline never needs the byte.
+    // Only a CARRIED Esc is dropped: an `ESC x` pair that arrived in ONE chunk is a real
+    // Alt/Meta chord (Alt+b, Alt+f, …) and still reaches readline untouched.
+    if (carriedEsc && i === 0 && data[0] === "\u001b" && (data.length === 1 || (data[1] !== "[" && data[1] !== "O"))) {
+      i += 1;
+      continue;
+    }
     if (!state.inPaste && data.startsWith(PASTE_START, i)) { state.inPaste = true; out += PASTE_START; i += PASTE_START.length; continue; }
     if (state.inPaste && data.startsWith(PASTE_END, i)) { state.inPaste = false; out += PASTE_END; i += PASTE_END.length; continue; }
     if (state.inPaste) {

package/src/commands/launch.ts

@@ -1398,7 +1398,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             !chunk.includes(PASTE_END);
           const captured = queueBusyInput?.(chunk) ?? false;
           if (typedEnter) {
-            const line = (queueBusySnapshot?.().text ?? "").trim();
+            // Expand the sentinel here too: a mid-turn paste keeps its line breaks in the
+            // draft, and the steering inbox / command dispatcher both take REAL text — a
+            // raw private-use sentinel would otherwise reach the model verbatim.
+            const line = expandSentinel(queueBusySnapshot?.().text ?? "").trim();
             if (line) {
               // A mid-turn /command or $skill is NOT a query for the model — steering it
               // would send the literal "/model" / "$skill" text to the LLM. Recognize it
@@ -1440,7 +1443,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           // inbox and surfaces as a `user` card (above). JEO_NO_LIVE_DRAFT=1 opts out.
           if (captured && jeoEnv("NO_LIVE_DRAFT") !== "1") {
             const draft = queueBusySnapshot?.().text ?? "";
-            tui.setLivePromptInput(draft);
+            // The live box renders REAL text: expand the sentinel (as the idle box and the
+            // highlight pass below already do) so a mid-turn pasted block shows as separate
+            // rows instead of a run of unprintable private-use glyphs.
+            tui.setLivePromptInput(expandSentinel(draft));
             // Mid-turn command preview: as you type a /command or $skill DURING a turn,
             // show its matches above the input box so command input visibly reacts
             // (idle-prompt parity). Cleared the moment the draft stops being command-shaped.
@@ -2557,7 +2563,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // (the user explicitly invoked them — no second Enter).
   const pendingMidTurnCommands: string[] = [];
   const queuedPromptInput: PromptInputQueue = { pendingLines: pendingStdinLines, partial: startupDraft ?? "", pastedLines: [], inPaste: false };
-  queueBusyInput = (chunk: string) => captureLivePromptInputChunk(queuedPromptInput, chunk);
+  // `multilineInput` gates the SENTINEL contract end to end: a mid-turn paste keeps its
+  // line breaks only when the submit path expands them again (it always does unless
+  // JEO_NO_MULTILINE=1, which degrades the same paste to space-joined text).
+  queueBusyInput = (chunk: string) => captureLivePromptInputChunk(queuedPromptInput, chunk, { multiline: multilineInput });
   queueBusyPasteActive = () => queuedPromptInput.inPaste;
   queueBusySnapshot = () => ({
     text: queuedPromptInput.partial,

package/src/tui/components/input-box.ts

@@ -11,7 +11,8 @@ export interface InputBoxOptions {
   attachmentLabel?: string;
   placeholder?: string;
   maxBodyRows?: number;
-  /** Caret offset in CHARACTERS into `line` (readline's rl.cursor). Defaults to end. */
+  /** Caret offset into `line` in UTF-16 CODE UNITS — exactly `rl.cursor`'s unit, so an
+   *  emoji/astral character before the caret no longer shifts it. Defaults to end. */
   cursor?: number;
   /** Accent painter for the border + `>` prompt mark (theme accent); default red/blue. */
   accent?: (s: string) => string;
@@ -47,6 +48,13 @@ export interface InputFrame {
  * caret's character offset to its (row, columnWidth) cell in the same pass — so the
  * box prompt can place the real terminal cursor exactly where the next glyph lands,
  * and arrow-key movement (readline updates rl.cursor) repositions it visibly.
+ *
+ * `cursor` is a UTF-16 CODE-UNIT offset — the same unit `rl.cursor` uses. Iteration is
+ * per CODE POINT (so an astral char/emoji is one glyph of its own display width), and
+ * the caret is matched against a parallel code-unit counter: without that, every
+ * surrogate pair BEFORE the caret shifted the painted caret one column right of the
+ * real insertion point (the "이모지가 있으면 입력 포인트가 밀려 보임" bug).
+ * `highlights` ranges stay CODE-POINT indexed (see `triggerHighlight` in launch.ts).
  */
 function wrapWithCursor(
   text: string,
@@ -59,8 +67,11 @@ function wrapWithCursor(
   let curW = 0;
   let row = 0;
   let col = 0;
-  const chars = Array.from(text.replace(/\r/g, ""));
-  const pos = Math.max(0, Math.min(cursor, chars.length));
+  const src = text.replace(/\r/g, "");
+  const chars = Array.from(src);
+  const pos = Math.max(0, Math.min(cursor, src.length));
+  let unit = 0; // UTF-16 offset of chars[i], matching `pos`
+  let placed = false;
   for (let i = 0; i <= chars.length; i++) {
     const ch = i < chars.length ? chars[i]! : "";
     const rendered = ch === "\t" ? "  " : ch;
@@ -71,7 +82,10 @@ function wrapWithCursor(
       cur = "";
       curW = 0;
     }
-    if (i === pos) {
+    // `>=` (not `===`) so a caret offset that lands INSIDE a surrogate pair — readline
+    // never parks there, but a resized/derived offset can — still resolves to a cell.
+    if (!placed && unit >= pos) {
+      placed = true;
       row = rows.length;
       col = curW;
     }
@@ -79,14 +93,20 @@ function wrapWithCursor(
       rows.push(cur);
       cur = "";
       curW = 0;
+      unit += 1;
       continue;
     }
     if (ch !== "") {
       const hl = highlights?.find(r => i >= r.start && i < r.end);
       cur += hl ? hl.paint(rendered) : rendered;
       curW += w;
+      unit += ch.length;
     }
   }
+  if (!placed) {
+    row = rows.length;
+    col = curW;
+  }
   rows.push(cur);
   return { rows, row, col };
 }
@@ -202,9 +222,12 @@ export function renderInputBox(line: string, opts: InputBoxOptions = {}): string
   return renderInputFrame(line, opts).lines;
 }
 /** Visual (row, display-col) of every caret position 0..N of `text` wrapped at `width`,
- *  using the SAME wrapping rule as the input box (`wrapWithCursor`). Index i is the caret
- *  sitting BEFORE char i (N = end of text); `cursor` offsets are code points, matching how
- *  `renderInputFrame` clamps `opts.cursor` against `Array.from(text)`. */
+ *  using the SAME wrapping rule as the input box (`wrapWithCursor`). Indexing is by
+ *  UTF-16 CODE UNIT — the unit `rl.cursor` uses — so `cells[rl.cursor]` is always the
+ *  cell readline's caret actually sits on, even in text containing astral characters
+ *  (emoji). A surrogate PAIR contributes two entries with the SAME cell: the pair's
+ *  start, plus the (never-parked-on) mid-pair offset, so every later index stays aligned
+ *  with the string's own offsets. */
 export interface CaretCell {
   row: number;
   col: number;
@@ -221,16 +244,29 @@ export function caretCells(text: string, width: number): CaretCell[] {
     // exact order wrapWithCursor uses, so cell rows match the rendered box rows.
     if (w > 0 && curW + w > width && curW > 0) { row += 1; curW = 0; }
     cells.push({ row, col: curW });
+    // Keep one entry PER CODE UNIT: the extra entry for a surrogate pair's low half
+    // repeats the pair's own cell, so it can never render (or return) a half-character
+    // caret position while keeping `cells[i]` addressable by a raw string offset.
+    for (let extra = 1; extra < ch.length; extra++) cells.push({ row, col: curW });
     if (ch === "\n") { row += 1; curW = 0; continue; }
     if (ch !== "") curW += w;
   }
   return cells;
 }
 
+/** Snap a derived caret offset off the low half of a surrogate pair (a full character is
+ *  the smallest unit the caret may sit on) — `caretCells` deliberately keeps those
+ *  offsets addressable, so every offset RETURNED to readline passes through here. */
+function snapToCharBoundary(text: string, offset: number): number {
+  const code = text.charCodeAt(offset);
+  return offset > 0 && code >= 0xdc00 && code <= 0xdfff ? offset - 1 : offset;
+}
+
 /** New caret offset after an Up/Down move within the wrapped input box, keeping the
  *  display column (textarea convention: snap to the nearest column ≤ the current one on the
  *  target row). Returns null when already on the top row (Up) or bottom row (Down), so the
- *  caller can fall through to readline's input-history recall. */
+ *  caller can fall through to readline's input-history recall. `cursor` and the returned
+ *  offset are UTF-16 code units (`rl.cursor`'s unit), never split a surrogate pair. */
 export function verticalCursorOffset(
   text: string,
   cursor: number,
@@ -255,7 +291,8 @@ export function verticalCursorOffset(
     // Largest column not past the current one — the standard column-preserving snap.
     if (c <= curCol && c > bestCol) { best = p; bestCol = c; }
   }
-  return best !== -1 ? best : firstOnRow;
+  const target = best !== -1 ? best : firstOnRow;
+  return snapToCharBoundary(text, target);
 }
 /** Caret offset at the START or END of the VISUAL ROW containing `cursor`, using the
  *  SAME wrapping rule as the input box (`caretCells`/`wrapWithCursor`). This is the
@@ -282,5 +319,5 @@ export function rowBoundaryOffset(
     if (p < start) start = p;
     if (p > end) end = p;
   }
-  return edge === "start" ? start : end;
+  return snapToCharBoundary(text, edge === "start" ? start : end);
 }

package/src/types/playwriter.d.ts

@@ -0,0 +1,15 @@
+// src/types/playwriter.d.ts
+// Declaration file to allow TypeScript to recognize the optional Playwriter CLI module.
+// This is only needed for the example automation script in scripts/playwriter-apply.ts.
+// The actual Playwriter package is expected to be installed globally or run via npx.
+
+declare module "playwriter" {
+  export class Playwriter {
+    /** Connect to the running Chrome extension bridge */
+    connect(): Promise<void>;
+    /** Open a new page (tab) in the connected browser */
+    newPage(): Promise<any>;
+    /** Disconnect from the bridge */
+    disconnect(): Promise<void>;
+  }
+}

package/src/util/file-attachment.ts

@@ -13,6 +13,8 @@
  * 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 * as os from "node:os";
+import * as path from "node:path";
 import { readFile, stat } from "node:fs/promises";
 import type { ImageAttachment } from "../ai/types";
 
@@ -108,13 +110,16 @@ export function attachmentFromImageBytes(bytes: Uint8Array): ImageAttachment | n
  * 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).
+ *  - resolves a `file://` URI (with percent-decoding),
+ *  - expands a leading `~` / `~/` to the home directory (gjc parity: a TYPED or
+ *    shell-copied `~/Downloads/shot.png` is a real, attachable path — without this it
+ *    silently failed to resolve and the raw text was sent to the model instead).
  * Returns the cleaned path.
  */
-export function decodeDroppedPath(token: string): string {
+export function decodeDroppedPath(token: string, home: string = os.homedir()): string {
   let s = token.trim();
   if ((s.startsWith("'") && s.endsWith("'")) || (s.startsWith('"') && s.endsWith('"'))) {
-    return s.slice(1, -1);
+    return expandHomePath(s.slice(1, -1), home);
   }
   if (s.startsWith("file://")) {
     let rest = s.slice("file://".length);
@@ -123,7 +128,15 @@ export function decodeDroppedPath(token: string): string {
     try { return decodeURIComponent(rest); } catch { return rest; }
   }
   // Bare token: unescape `\<char>` (shell-style drag escaping).
-  return s.replace(/\\(.)/g, "$1");
+  return expandHomePath(s.replace(/\\(.)/g, "$1"), home);
+}
+
+/** `~` / `~/rest` → the home directory. A bare `~user` form is left alone (jeo cannot
+ *  resolve another account's home portably). */
+function expandHomePath(p: string, home: string): string {
+  if (p === "~") return home;
+  if (p.startsWith("~/")) return path.join(home, p.slice(2));
+  return p;
 }
 
 export interface PathToken {
@@ -222,7 +235,14 @@ export async function attachImagePaths(
   out += text.slice(cursor);
   if (images.length === 0) return { text: out, images, cursor: out.length };
   // Collapse the spacing terminals add around a dropped path so the swapped-in tag
-  // (and the caret parked after it) is not pushed several columns to the right.
-  const normalized = normalizeImageTags(out);
+  // (and the caret parked after it) is not pushed several columns to the right, then
+  // guarantee EXACTLY ONE trailing space when the last tag ends the draft — identical
+  // to `insertImageTag`'s Ctrl+V contract. Without it `normalizeImageTags`'s trim left
+  // the caret hard against `]` and the next typed word glued onto the tag
+  // ("[image #1]please"); with it, both attach paths behave the same.
+  let normalized = normalizeImageTags(out);
+  const lastTag = `[image #${n - 1}]`;
+  const lastIdx = normalized.indexOf(lastTag);
+  if (lastIdx >= 0 && lastIdx + lastTag.length >= normalized.length) normalized += " ";
   return { text: normalized, images, cursor: caretAfterTag(normalized, n - 1) };
 }