jeo-code 0.9.10 → 0.9.12

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

@@ -0,0 +1,66 @@
+import { createJobTool } from "../../agent/job-tool";
+import type { JobRegistry } from "../../agent/job-registry";
+
+export type JobsSlashLogger = (lines: string[]) => void;
+
+/** Run the interactive `/jobs` view over the launch session's existing registry. */
+export async function runJobsSlash(
+  input: string,
+  registry: JobRegistry,
+  cwd: string,
+  logLines: JobsSlashLogger = lines => console.log(lines.join("\n")),
+): Promise<void> {
+  const tokens = input.trim().split(/\s+/).filter(Boolean).slice(1);
+  const action = (tokens.shift() ?? "list").toLowerCase();
+  const args: Record<string, unknown> = { action };
+
+  if (action === "start") {
+    const command = tokens.join(" ").trim();
+    if (!command) {
+      logLines(["Usage: /jobs start <command>"]);
+      return;
+    }
+    args.command = command;
+  } else if (action === "list") {
+    if (tokens.length > 0) {
+      logLines(["Usage: /jobs [list|tail|await|cancel] [job-id ...]"]);
+      return;
+    }
+  } else if (action === "tail" || action === "cancel" || action === "await") {
+    const ids: string[] = [];
+    for (let index = 0; index < tokens.length; index++) {
+      const token = tokens[index]!;
+      if (token === "--timeout-ms" || token === "--timeout") {
+        const value = Number(tokens[++index]);
+        if (!Number.isFinite(value) || value <= 0) {
+          logLines([`Invalid timeout '${tokens[index] ?? ""}'. Use a positive number of milliseconds.`]);
+          return;
+        }
+        args.timeoutMs = value;
+        continue;
+      }
+      if (token.startsWith("--timeout-ms=") || token.startsWith("--timeout=")) {
+        const value = Number(token.slice(token.indexOf("=") + 1));
+        if (!Number.isFinite(value) || value <= 0) {
+          logLines([`Invalid timeout '${token}'. Use a positive number of milliseconds.`]);
+          return;
+        }
+        args.timeoutMs = value;
+        continue;
+      }
+      if (token.startsWith("--")) {
+        logLines([`Unknown /jobs option '${token}'.`]);
+        return;
+      }
+      ids.push(token);
+    }
+    if (ids.length > 0) args.ids = ids;
+  } else {
+    logLines([`Unknown /jobs action '${action}'. Use list | tail | await | cancel.`]);
+    return;
+  }
+
+  const result = await createJobTool(registry)(args, cwd);
+  if (result.output) logLines(result.output.split("\n"));
+  if (!result.success && result.error) logLines([`! ${result.error}`]);
+}

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

@@ -13,6 +13,8 @@ import type { Message } from "../../agent/loop";
 import { createSession, deleteSession, renameSession, loadSession, listSessions, sessionPath, resolveSessionRef } from "../../agent/session";
 import { SessionPicker, renderSessionPicker } from "../../tui/components/session-picker";
 import { formatTranscript } from "../../tui/components/transcript";
+import { importGjcSession, listGjcSessions, type GjcSessionLeaf } from "../../agent/gjc-session-import";
+import { SelectList, renderSelectList, type SelectItem } from "../../tui/components/select-list";
 
 export interface SessionSlashCtx {
   cwd: string;
@@ -54,6 +56,56 @@ export interface SessionSlashResult {
 
 }
 
+interface GjcResumeRequest {
+  sessionId?: string;
+  leafId?: string;
+  anyCwd: boolean;
+  error?: string;
+}
+
+function parseGjcResumeArgument(arg: string): GjcResumeRequest | undefined {
+  const tokens = arg.trim().split(/\s+/).filter(Boolean);
+  if (!tokens.some(token => token.toLowerCase().startsWith("gajae:"))) return undefined;
+
+  let refToken: string | undefined;
+  let anyCwd = false;
+  for (const token of tokens) {
+    if (token === "--any-cwd") {
+      anyCwd = true;
+      continue;
+    }
+    if (refToken !== undefined) {
+      return { anyCwd, error: `Unexpected argument '${token}'.` };
+    }
+    refToken = token;
+  }
+
+  if (!refToken || !refToken.toLowerCase().startsWith("gajae:")) {
+    return { anyCwd, error: "Use /resume gajae:<session-id>[#<leaf-entry-id>] [--any-cwd]." };
+  }
+
+  const reference = refToken.slice("gajae:".length);
+  if (!reference) return { anyCwd };
+  const pieces = reference.split("#");
+  if (pieces.length > 2 || !pieces[0]) {
+    return { anyCwd, error: "Malformed GJC reference. Use gajae:<session-id>[#<leaf-entry-id>]." };
+  }
+
+  return {
+    sessionId: pieces[0],
+    ...(pieces[1] ? { leafId: pieces[1] } : {}),
+    anyCwd,
+  };
+}
+
+function gjcResumeItems(pool: GjcSessionLeaf[]): SelectItem<GjcSessionLeaf>[] {
+  return pool.map(item => ({
+    value: item,
+    label: `${item.sessionId}#${item.leafId || "(no-leaf)"}`,
+    hint: item.selected ? "selected leaf" : item.cwd,
+  }));
+}
+
 /**
  * Handle `/session [new|drop|delete|rename <title>|resume [id]|list|info]`
  * (default: list + current-session summary). Extracted verbatim from
@@ -126,9 +178,13 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
   }
   if (sub === "resume") {
     const arg = tokens.slice(1).join(" ").trim();
-    const applyResume = async (rid: string): Promise<void> => {
+    const applyResume = async (
+      rid: string,
+      loaded?: Awaited<ReturnType<typeof loadSession>>,
+    ): Promise<void> => {
       try {
-        const { header, messages } = await loadSession(rid, cwd);
+        const loadedSession = loaded ?? await loadSession(rid, cwd);
+        const { header, messages } = loadedSession;
         history.length = 1;
         for (const m of messages) history.push(m);
         sessionId = rid;
@@ -181,6 +237,94 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
         console.log(`! ${(err as Error).message}`);
       }
     };
+    const gjcRequest = parseGjcResumeArgument(arg);
+    if (gjcRequest) {
+      if (gjcRequest.error) {
+        console.log(`! ${gjcRequest.error}`);
+        return result();
+      }
+
+      const importOne = async (source: GjcSessionLeaf | undefined): Promise<void> => {
+        if (!source) return;
+        try {
+          const imported = await importGjcSession({
+            sessionId: gjcRequest.sessionId ?? source.sessionId,
+            ...(gjcRequest.leafId || source.leafId ? { leafId: gjcRequest.leafId ?? source.leafId } : {}),
+            cwd,
+            anyCwd: gjcRequest.anyCwd,
+          });
+          console.log(
+            `(imported GJC v5 session ${imported.sourceSessionId}#${imported.sourceLeafId} as Jeo session ${imported.sessionId}${imported.reused ? " (reused)" : ""})`,
+          );
+          await applyResume(imported.sessionId);
+        } catch (err) {
+          console.log(`! GJC /resume failed: ${(err as Error).message}`);
+        }
+      };
+
+      if (gjcRequest.sessionId) {
+        await importOne({
+          rootPath: "",
+          sourcePath: "",
+          sessionId: gjcRequest.sessionId,
+          leafId: gjcRequest.leafId ?? "",
+          cwd,
+          selected: false,
+        });
+        return result();
+      }
+
+      let sourcePool: GjcSessionLeaf[];
+      try {
+        sourcePool = await listGjcSessions({ cwd, anyCwd: gjcRequest.anyCwd });
+      } catch (err) {
+        console.log(`! GJC /resume listing failed: ${(err as Error).message}`);
+        return result();
+      }
+      if (sourcePool.length === 0) {
+        console.log("(no GJC v5 sessions for this workspace)");
+        console.log("Usage: /resume gajae:<session-id>[#<leaf-entry-id>] [--any-cwd]");
+        return result();
+      }
+
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        const picker = new SelectList(gjcResumeItems(sourcePool));
+        let selected: SelectItem<GjcSessionLeaf> | undefined;
+        await runSelectPicker(
+          (cols, rows) => renderSelectList(picker, {
+            title: "Import a GJC v5 session",
+            cols,
+            rows: Math.max(8, rows),
+            unicode: true,
+            color: true,
+          }),
+          (ch, key) => {
+            if (key?.name === "up") { picker.up(); return false; }
+            if (key?.name === "down") { picker.down(); return false; }
+            if (key?.name === "pageup") { picker.page(-1); return false; }
+            if (key?.name === "pagedown") { picker.page(1); return false; }
+            if (key?.name === "backspace") { picker.backspace(); return false; }
+            if (key?.name === "escape" || (key?.ctrl && key.name === "c")) return true;
+            if (key?.name === "return" || key?.name === "enter") {
+              selected = picker.selected();
+              return true;
+            }
+            if (ch && ch >= " " && !key?.ctrl && !key?.meta) picker.typeChar(ch);
+            return false;
+          },
+        );
+        await importOne(selected?.value);
+        return result();
+      }
+
+      console.log("GJC v5 sessions — resume with /resume gajae:<session-id>[#<leaf-entry-id>]:");
+      for (const source of sourcePool.slice(0, 20)) {
+        const selected = source.selected ? " *" : "";
+        console.log(` ${source.sessionId}#${source.leafId || "(no-leaf)"}${selected}  ${source.cwd}`);
+      }
+      console.log("Add --any-cwd to include sessions from other workspaces.");
+      return result();
+    }
     if (arg) {
       // gjc-parity: resolve `arg` as a full id OR a short id prefix before resuming.
       const resolved = await resolveSessionRef(arg, cwd);

package/src/commands/launch.ts

@@ -46,6 +46,7 @@ import { renderWelcome, playWelcomeSweep } from "../tui/components/welcome";
 import { jeoEnv } from "../util/env";
 import { renderUpdateBox } from "../tui/components/update-box";
 import { consumeLaunchWhatsNew } from "../util/whats-new";
+import { runWhatsNewCommand } from "./whats-new";
 import { maybeBell } from "../util/notify";
 import { supportsUnicode } from "../tui/components/capability";
 import pkg from "../../package.json";
@@ -225,6 +226,7 @@ import {
 } from "./launch/code-slash";
 import { handleUndoSlash } from "./launch/git-slash";
 import { runSessionSlash } from "./launch/session-slash";
+import { runJobsSlash } from "./launch/jobs-slash";
 import { runModelSlash } from "./launch/model-slash";
 import { runRouteSlash } from "./launch/route-slash";
 import { runComputerSlash } from "./launch/computer-slash";
@@ -1396,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
@@ -1438,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.
@@ -2416,7 +2424,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // protocol nor xterm modifyOtherKeys. JEO_NO_MULTILINE=1 fully disables the
   // filter (reads stdin directly).
   const multilineInput = !!process.stdin.isTTY && jeoEnv("NO_MULTILINE") !== "1";
-  const loneLfShiftEnter = jeoEnv("MULTILINE") !== "0";
+  // tmux-owned panes can translate the plain Enter key to LF after the launcher's
+  // keyboard modes are enabled. In that mode LF must remain readline's submit key;
+  // explicit Shift+Enter escape sequences still become MULTILINE_SENTINEL below.
+  const loneLfShiftEnter =
+    jeoEnv("MULTILINE") !== "0" && jeoEnv("TMUX_LAUNCHED") !== "1";
   const expandSentinel = (s: string): string => (multilineInput ? s.split(SENTINEL).join("\n") : s);
   // Prompt-scoped process listeners (stdin data/keypress, stdout resize). Registered
   // once per launch but previously anonymous and never removed — benign for a single
@@ -2551,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,
@@ -4323,6 +4338,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         logLines(handoffLines(res, process.stdout.columns));
         continue;
       }
+      if (input === "/changelog" || input.startsWith("/changelog ")) {
+        const args = input.slice("/changelog".length).trim().split(/\s+/).filter(Boolean)
+          .map(arg => arg === "--full" ? "--all" : arg);
+        await runWhatsNewCommand(args);
+        continue;
+      }
+      if (input === "/jobs" || input.startsWith("/jobs ")) {
+        await runJobsSlash(input, jobRegistry, cwd, lines => logLines(lines));
+        continue;
+      }
       if (input === "/session" || input.startsWith("/session ")) {
         const result = await runSessionSlash(input, {
           cwd, history, noSession: flags.noSession, sessionId, sessionModel, rl,

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/tui/components/slash.ts

@@ -27,7 +27,8 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/drop", usage: "/drop", description: "Delete the current session and start a new one", group: "session" },
   { command: "/session", usage: "/session [info|delete]", description: "Show current session info, or delete it", group: "session" },
   { command: "/rename", usage: "/rename <title>", description: "Rename the current session", group: "session" },
-  { command: "/resume", usage: "/resume [id]", description: "Resume a saved session in this REPL", group: "session" },
+  { command: "/resume", usage: "/resume [id|gajae:<session-id>[#<leaf>]] [--any-cwd]", description: "Resume a saved session or import a read-only GJC v5 session", group: "session" },
+  { command: "/changelog", usage: "/changelog [--full]", description: "Show recent release notes (use --full for the complete changelog)", group: "system" },
   { command: "/retry", usage: "/retry", description: "Retry the last request", group: "session" },
   { command: "/undo", usage: "/undo", description: "Undo the last jeo auto-commit and restore the working tree", group: "session" },
   { command: "/history", usage: "/history [n|all]", description: "Re-print the worked turn history (prompts, tool steps, replies) into scrollback", group: "session" },
@@ -53,6 +54,7 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/search", usage: "/search <pat> [glob]", description: "Search the repo for a pattern", group: "code" },
 
   { command: "/sessions", usage: "/sessions", description: "List saved sessions", group: "session" },
+  { command: "/jobs", usage: "/jobs [list|tail|await|cancel]", description: "List, inspect, await, or cancel background jobs in this session", group: "system" },
   { command: "/usage", usage: "/usage", description: "Show cumulative token usage for this session", group: "system" },
   { command: "/context", usage: "/context", description: "Show context token usage breakdown", group: "system" },
   { command: "/tools", usage: "/tools", description: "Show the tools currently visible to the agent", group: "system" },

package/src/tui/components/welcome.ts

@@ -9,8 +9,8 @@ import { parseChangelogSections, changelogText } from "../../util/whats-new";
 function getLatestChangelogItems(): { version: string; items: string[] } {
   try {
     const sections = parseChangelogSections(changelogText);
-    if (sections.length > 0) {
-      const latest = sections[0];
+    const latest = sections.find(section => section.groups.some(group => group.items.length > 0));
+    if (latest) {
       const items: string[] = [];
       for (const g of latest.groups) {
         for (const item of g.items) {

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) };
 }