jeo-code 0.6.35 → 0.6.37

package/CHANGELOG.md

@@ -6,6 +6,33 @@ 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.37] - 2026-06-20
+_Two dead-end fixes: the boxed prompt's ↑/↓ now recalls input history on a soft-wrapped one-liner (only a genuine multi-line draft gets in-box caret nav), and every terminating Spec-first stage (deep-interview, ralplan, team) now surfaces a user-visible answer instead of silently stalling — re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot._
+
+### Fixed
+- **The boxed prompt's ↑/↓ recalls input history again on a soft-wrapped line.** A long single line that the box wraps to several visual rows is no longer treated as multi-line: ↑/↓ fall through to readline's history recall (the dominant REPL expectation) instead of dragging the wrapped tail up a visual row. In-box vertical caret nav (textarea feel) is now gated behind a GENUINE multi-line draft — one carrying an explicit Shift+Enter / pasted break, stored as the private-use `MULTILINE_SENTINEL` — and still yields the arrows to an open slash list or the Ctrl+O history panel. New `isGenuineMultilineDraft` / `shouldBoxVerticalNav` helpers make the gate unit-testable independent of the live readline/PTY wiring.
+- **Every terminating Spec-first workflow stage now surfaces a user-visible answer.** Three stages could previously reach a terminal state with no message explaining the outcome:
+  - **`team`** routes all subagent output through the engine `log()`/`io.output` sink (zero raw `console.log` in `executeTaskWithAgent`) and prints a `<role> report:` header followed by every line of the subagent's reason on success.
+  - **`deep-interview`** gates its `[Handoff Ready]` / `onProgress(complete)` signal on a real frozen seed: `freezeSeed` now returns `Promise<boolean>`, and a freeze failure emits `[HOLD]` and keeps the interview open instead of falsely claiming the requirement is crystallized.
+  - **`ralplan`** reports a discarded revision: an invalid `[ITERATE]` revision now logs `discarding the revision; the [ITERATE] verdict stands` instead of silently surfacing the stale verdict.
+
+### Verified
+- `scripts/mem-probe.ts` (2000 LaunchTui turns) shows a flat post-GC heap — per-turn slope **−556 bytes/turn**, returning to its settled floor — with a single `exit` listener and zero `process` SIGINT/listener accumulation; `scripts/tmux-verify.sh smoke` boots `jeo --tmux` to a clean input box + model bar (EXIT 0). `bun run typecheck` is clean and `bun test` is **1751 pass / 0 fail** across 216 files, including the new `test/box-vertical-nav.test.ts` and the no-answer-deadend targeted suite (`team-run`/`team-schema`/`team-subagent`/`deep-interview`/`deep-interview-noninteractive`/`workflow-integrity`/`approve`/`parse-role-gate-verdict` → 71 pass / 0 fail).
+
+
+## [0.6.36] - 2026-06-20
+_When `jeo --tmux` flips the mouse on so you can drag-select, the drag now actually lands on the system clipboard — the in-session tmux profile sets `set-clipboard on` + a local `copy-command` on the CURRENT session only — plus `/help` documents the drag-to-copy and the Shift/Option-drag escape hatch, re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot._
+
+### Fixed
+- **A `--tmux` mouse drag-select now reaches the system clipboard instead of vanishing.** Turning the mouse on (so on-screen text can be selected) re-routes a drag into tmux copy-mode, where the selection used to die inside tmux's own buffer — `cmd/ctrl+v` got nothing. The launch path now applies the same clipboard repair to the CURRENT session that `tmuxProfileCommands` applies to jeo-owned sessions: new `currentTmuxClipboardCommands(env, deps)` emits `set-option set-clipboard on` (lets the copy-mode selection escape via OSC 52) and, when a local clipboard tool is on PATH, `set-option copy-command <tool>` (pipes the drag-select straight to `pbcopy` / `wl-copy` / `xclip` / `xsel` / `clip` for terminals that don't honor OSC 52). Both are written **session-locally — never `-t` or `-g`** — so the user's other tmux sessions are untouched; `JEO_TMUX_PROFILE=0` opts out, and `copy-command` is skipped when no tool is found.
+
+### Changed
+- **`/help` documents the drag-to-copy behavior and its escape hatch.** Two hotkey rows now explain that a drag selects on-screen text (copies on `cmd/ctrl+c`, and auto-copies to the system clipboard under `--tmux`) and that **Shift-drag** (iTerm/macOS: **Option-drag**) forces the terminal's own selection when tmux owns the mouse.
+
+### Verified
+- `scripts/mem-probe.ts` (2000 LaunchTui turns) shows a flat post-GC heap — per-turn slope **−541 bytes/turn**, returning to its settled floor — with zero `process` SIGINT/listener accumulation; `scripts/tmux-verify.sh smoke` boots `jeo --tmux` to a clean input box + model bar (EXIT 0). `bun run typecheck` clean and `bun test` **1748 pass / 0 fail** across 215 files, including the new `currentTmuxClipboardCommands` session-local / no-tool / opt-out cases in `test/tmux.test.ts`.
+
+
 ## [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._
 

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.37]** (2026-06-20) — Two dead-end fixes: the boxed prompt's ↑/↓ now recalls input history on a soft-wrapped one-liner (only a genuine multi-line draft gets in-box caret nav), and every terminating Spec-first stage (deep-interview, ralplan, team) now surfaces a user-visible answer instead of silently stalling — re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
+- **[0.6.36]** (2026-06-20) — When `jeo --tmux` flips the mouse on so you can drag-select, the drag now actually lands on the system clipboard — the in-session tmux profile sets `set-clipboard on` + a local `copy-command` on the CURRENT session only — plus `/help` documents the drag-to-copy and the Shift/Option-drag escape hatch, re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
 - **[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.
 
 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.37]** (2026-06-20) — Two dead-end fixes: the boxed prompt's ↑/↓ now recalls input history on a soft-wrapped one-liner (only a genuine multi-line draft gets in-box caret nav), and every terminating Spec-first stage (deep-interview, ralplan, team) now surfaces a user-visible answer instead of silently stalling — re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
+- **[0.6.36]** (2026-06-20) — When `jeo --tmux` flips the mouse on so you can drag-select, the drag now actually lands on the system clipboard — the in-session tmux profile sets `set-clipboard on` + a local `copy-command` on the CURRENT session only — plus `/help` documents the drag-to-copy and the Shift/Option-drag escape hatch, re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
 - **[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.
 
 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.37]** (2026-06-20) — Two dead-end fixes: the boxed prompt's ↑/↓ now recalls input history on a soft-wrapped one-liner (only a genuine multi-line draft gets in-box caret nav), and every terminating Spec-first stage (deep-interview, ralplan, team) now surfaces a user-visible answer instead of silently stalling — re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
+- **[0.6.36]** (2026-06-20) — When `jeo --tmux` flips the mouse on so you can drag-select, the drag now actually lands on the system clipboard — the in-session tmux profile sets `set-clipboard on` + a local `copy-command` on the CURRENT session only — plus `/help` documents the drag-to-copy and the Shift/Option-drag escape hatch, re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
 - **[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.
 
 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.37]** (2026-06-20) — Two dead-end fixes: the boxed prompt's ↑/↓ now recalls input history on a soft-wrapped one-liner (only a genuine multi-line draft gets in-box caret nav), and every terminating Spec-first stage (deep-interview, ralplan, team) now surfaces a user-visible answer instead of silently stalling — re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
+- **[0.6.36]** (2026-06-20) — When `jeo --tmux` flips the mouse on so you can drag-select, the drag now actually lands on the system clipboard — the in-session tmux profile sets `set-clipboard on` + a local `copy-command` on the CURRENT session only — plus `/help` documents the drag-to-copy and the Shift/Option-drag escape hatch, re-verified leak-free (`mem-probe`) with a fresh `jeo --tmux` boot.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/commands/deep-interview.ts

@@ -567,7 +567,7 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
     let ambiguity = state.current_ambiguity ?? 1.0;
     let lastParsed: SocraticResponse | undefined;
 
-    const freezeSeed = async (parsed: SocraticResponse): Promise<void> => {
+    const freezeSeed = async (parsed: SocraticResponse): Promise<boolean> => {
       const readiness = freezeReadiness(parsed);
       if (!readiness.ok) throw new Error(`Refusing to freeze seed: ${readiness.reason}.`);
 
@@ -594,7 +594,7 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
           `[ERROR] Seed round-trip self-check FAILED — the acceptance criteria would not survive ultragoal's parser ` +
           `(writer/parser drift). NOT freezing the seed. Got back: ${JSON.stringify(parsedBack)}`,
         );
-        return;
+        return false;
       }
       await fs.writeFile(seedPath, seedContent, "utf-8");
       state!.current_phase = "complete";
@@ -603,6 +603,7 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
       state!.current_ambiguity = Math.min(state!.current_ambiguity ?? threshold, threshold);
       await writeWorkflowState("deep-interview", state!, cwd);
       log(`Saved frozen requirements spec seed to: ${seedPath}`);
+      return true;
     };
 
     while (round <= 10) {
@@ -629,12 +630,20 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
         const readiness = freezeReadiness(parsed);
         if (ambiguity <= threshold && readiness.ok) {
           log(`\n[SUCCESS] Ambiguity is <= ${(threshold * 100).toFixed(0)}%! Concluding requirements gather.`);
-          await freezeSeed(parsed);
-          log("\n[Handoff Ready] Requirement is crystallized. Next, run 'jeo ralplan' to build a plan.");
-          if (opts.onProgress) {
-            opts.onProgress({ skill: "deep-interview", phase: "complete" });
+          const frozen = await freezeSeed(parsed);
+          if (frozen) {
+            log("\n[Handoff Ready] Requirement is crystallized. Next, run 'jeo ralplan' to build a plan.");
+            if (opts.onProgress) {
+              opts.onProgress({ skill: "deep-interview", phase: "complete" });
+            }
+            break;
           }
-          break;
+          // Freeze failed (e.g. round-trip self-check): do NOT emit a false
+          // "crystallized" handoff. Fall through to the normal question loop
+          // below — it already asks the follow-up, pushes history, and bumps
+          // the round — so the interview simply stays open.
+          log("\n[HOLD] Could not freeze the requirements seed — see the error above. Keeping the interview open.");
+
         }
 
         let nextQuestion = parsed.nextQuestion?.trim() || interviewLanguage.acceptanceFollowup;

package/src/commands/launch/input.ts

@@ -51,6 +51,33 @@ export function isStandaloneBackspace(chunk: string): boolean {
   return chunk.length > 0 && /^[\x7f\b]+$/.test(chunk);
 }
 
+/** Private-use sentinel the input filter substitutes for an EXPLICIT line break
+ *  (Shift+Enter / a pasted newline) before the bytes reach readline, so the draft can
+ *  carry hard newlines through readline's single-line buffer. A line that merely
+ *  SOFT-WRAPS at the box width contains NO sentinel — that distinction is the whole
+ *  point of `isGenuineMultilineDraft`. */
+export const MULTILINE_SENTINEL = "\uE000";
+
+/** True when the draft has at least one EXPLICIT line break (a sentinel) — i.e. the
+ *  user deliberately made it multi-line. A long single line that the box soft-wraps to
+ *  several visual rows is NOT multi-line and returns false. */
+export function isGenuineMultilineDraft(line: string): boolean {
+  return line.includes(MULTILINE_SENTINEL);
+}
+
+/** Whether an Up/Down keystroke should move the caret BETWEEN the box's visual rows
+ *  (textarea feel) instead of falling through to readline's input-history recall. True
+ *  only for a genuinely multi-line draft with no slash dropdown or history panel owning
+ *  the arrows. A soft-wrapped one-liner returns false, so ↑ recalls the previous prompt
+ *  rather than dragging the wrapped tail up a visual row. */
+export function shouldBoxVerticalNav(
+  line: string,
+  opts: { slashMatchCount: number; historyPanelOpen: boolean },
+): boolean {
+  return isGenuineMultilineDraft(line) && opts.slashMatchCount === 0 && !opts.historyPanelOpen;
+}
+
+
 /**
  * macOS / fixterms combo-key normalization for the boxed prompt's line editor.
  *

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

@@ -23,6 +23,8 @@ export function hotkeysLines(): string[] {
     "  @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])",
+    "  drag       select on-screen text to copy — copies on cmd/ctrl+c; under --tmux a drag auto-copies to the system clipboard",
+    "  Shift-drag force the terminal's own selection when tmux owns the mouse (iTerm/macOS: Option-drag)",
   ];
 }
 

package/src/commands/launch/tmux.ts

@@ -106,8 +106,8 @@ export function shellQuote(arg: string): string {
  */
 export function shouldEnableCurrentTmuxMouse(env: Record<string, string | undefined>): boolean {
   return !!env.TMUX
-    && (env.JEO_TMUX_LAUNCHED ?? env.JEO_TMUX_LAUNCHED) !== "1"
-    && (env.JEO_TMUX_MOUSE ?? env.JEO_TMUX_MOUSE) !== "0";
+    && env.JEO_TMUX_LAUNCHED !== "1"
+    && env.JEO_TMUX_MOUSE !== "0";
 }
 
 /**
@@ -160,7 +160,7 @@ export function tmuxProfileCommands(
 ): TmuxProfileCommand[] {
   const t = `=${target}:`;
   const commands: TmuxProfileCommand[] = [];
-  if ((env.JEO_TMUX_MOUSE ?? env.JEO_TMUX_MOUSE) !== "0") {
+  if (env.JEO_TMUX_MOUSE !== "0") {
     commands.push({
       description: "enable tmux mouse scrolling (wheel-up → copy-mode over real history)",
       args: ["set-option", "-t", t, "mouse", "on"],
@@ -182,7 +182,7 @@ export function tmuxProfileCommands(
       args: ["set-option", "-t", t, "@jeo-project", meta.project],
     });
   }
-  if ((env.JEO_TMUX_PROFILE ?? env.JEO_TMUX_PROFILE) !== "0") {
+  if (env.JEO_TMUX_PROFILE !== "0") {
     commands.push(
       {
         description: "enable tmux clipboard integration",
@@ -210,6 +210,40 @@ export function tmuxProfileCommands(
   return commands;
 }
 
+/**
+ * Clipboard set-options for the CURRENT (foreign) tmux session that the in-session
+ * `jeo --tmux` path turns `mouse on` for. Enabling the mouse re-routes a plain
+ * drag into copy-mode, so without these a drag-select no longer lands anywhere:
+ *  - `set-clipboard on` lets the copy-mode selection reach the outer terminal via OSC52;
+ *  - `copy-command` pipes that selection straight to the local clipboard tool
+ *    (pbcopy / wl-copy / xclip / xsel / clip), so a drag-select copies for `cmd+v`
+ *    even where OSC52 is not honored.
+ * Applied WITHOUT `-t` (the current session only — never -g, so the user's other
+ * sessions are untouched). `JEO_TMUX_PROFILE=0` opts out; `copy-command` is skipped
+ * when no clipboard tool is on PATH. This is the in-session analogue of the
+ * clipboard block in {@link tmuxProfileCommands} for jeo-owned sessions.
+ */
+export function currentTmuxClipboardCommands(
+  env: Record<string, string | undefined>,
+  deps: { platform?: NodeJS.Platform; which?: (bin: string) => string | null } = {},
+): TmuxProfileCommand[] {
+  if (env.JEO_TMUX_PROFILE === "0") return [];
+  const commands: TmuxProfileCommand[] = [
+    {
+      description: "enable tmux clipboard integration",
+      args: ["set-option", "set-clipboard", "on"],
+    },
+  ];
+  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", "copy-command", copyCmd],
+    });
+  }
+  return commands;
+}
+
 /**
  * Resolve a git worktree path (gjc `--worktree <path>` parity). If the path
  * already exists it is reused as-is; otherwise a new worktree is created on a

package/src/commands/launch.ts

@@ -118,6 +118,7 @@ import {
   shouldEnableCurrentTmuxMouse,
   tmuxLaunchCommand,
   tmuxProfileCommands,
+  currentTmuxClipboardCommands,
   resolveWorktree,
   shellQuote,
   type TmuxCreateResult,
@@ -135,6 +136,9 @@ import {
   matchTerminalReport,
   stripMouseReports,
   rewriteCursorCombos,
+  MULTILINE_SENTINEL,
+  isGenuineMultilineDraft,
+  shouldBoxVerticalNav,
   queuePromptInputChunk,
   captureLivePromptInputChunk,
   restoreQueuedLinesToPrefill,
@@ -186,6 +190,7 @@ export {
   shouldEnableCurrentTmuxMouse,
   tmuxLaunchCommand,
   tmuxProfileCommands,
+  currentTmuxClipboardCommands,
   resolveWorktree,
   shellQuote,
   type TmuxCreateResult,
@@ -201,6 +206,9 @@ export {
   matchTerminalReport,
   stripMouseReports,
   rewriteCursorCombos,
+  MULTILINE_SENTINEL,
+  isGenuineMultilineDraft,
+  shouldBoxVerticalNav,
   queuePromptInputChunk,
   captureLivePromptInputChunk,
   restoreQueuedLinesToPrefill,
@@ -420,6 +428,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       const tmuxBin = Bun.which("tmux");
       if (tmuxBin) {
         try { Bun.spawnSync([tmuxBin, "set-option", "mouse", "on"]); } catch { /* best-effort */ }
+        // Enabling the mouse re-routes a drag into copy-mode; set-clipboard +
+        // copy-command make that drag-select actually land on the system clipboard.
+        for (const c of currentTmuxClipboardCommands(process.env)) {
+          try { Bun.spawnSync([tmuxBin, ...c.args]); } catch { /* best-effort */ }
+        }
       }
     }
   }
@@ -1353,7 +1366,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // readline sees them — readline inserts it as an ordinary character (no per-line
   // submit/race), the box renders it as a real line break, and it is expanded back to
   // "\n" on submit. On for any interactive TTY; JEO_NO_MULTILINE=1 reads stdin directly.
-  const SENTINEL = "\uE000";
+  const SENTINEL = MULTILINE_SENTINEL;
   const SHIFT_ENTER_SEQS = ["\u001b[27;2;13~", "\u001b[13;2u"];
   // Multi-line input filter is ON for any interactive TTY: reliable multi-line paste
   // (fills the box, submits intact into the user card) is the default. The lone-"\n"
@@ -1431,14 +1444,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         // Option/Cmd+Backspace) into the canonical control bytes it DOES act on.
         const combo = matchCursorCombo(data, i);
         if (combo) { out += combo[1]; i += combo[0].length; continue; }
-        // Up/Down inside a multi-line / wrapped draft move the caret between the box's
-        // visual rows (textarea feel). Only when no slash list or history panel owns ↑/↓,
-        // and only away from the top/bottom edge — at the edge the keys fall through to
-        // readline so ↑/↓ still recalls input history.
+        // Up/Down inside a GENUINELY multi-line draft (explicit Shift+Enter breaks →
+        // SENTINEL) move the caret between the box's visual rows (textarea feel). A
+        // single line that merely SOFT-WRAPS is NOT treated as multi-line: ↑/↓ fall
+        // through to readline so they recall input history — the dominant REPL
+        // expectation. (Without this gate, ↑ on a wrapped one-liner jumped the caret up
+        // a visual row instead of recalling the previous prompt, so the last wrapped
+        // word appeared to "follow the caret up".) Skipped when a slash list or history
+        // panel owns ↑/↓, and at the top/bottom edge the keys still reach history.
         if ((data.startsWith("\u001b[", i) || data.startsWith("\u001bO", i)) && (data[i + 2] === "A" || data[i + 2] === "B")) {
           const dir = data[i + 2] === "A" ? "up" : "down";
           const line = activeRl?.line ?? "";
-          if (line.length > 0 && navMatches.length === 0 && promptHistoryLines == null && activeRl) {
+          if (shouldBoxVerticalNav(line, { slashMatchCount: navMatches.length, historyPanelOpen: promptHistoryLines != null }) && activeRl) {
             const winCols = Math.max(24, (process.stdout.columns ?? 80) - 1);
             const textWidth = Math.max(1, Math.max(24, winCols) - 6);
             const cur = typeof activeRl.cursor === "number" ? activeRl.cursor : line.length;
@@ -2579,6 +2596,35 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         return;
       }
       if (!previewArmed || pickerActive) return;
+      // Drag-and-drop file attach: a terminal delivers a dropped file as its PATH typed
+      // into the box, wrapped in a bracketed paste. On paste-end, swap any readable image
+      // path LIVE for the same `[image #N]` tag Ctrl+V uses, so the box shows the tag
+      // instead of a long raw filesystem path. Non-image / unreadable paths and ordinary
+      // text pastes match nothing and are a no-op. Submit-time attach (below) still covers
+      // terminals that deliver a drop WITHOUT bracketing it.
+      if (key?.name === "paste-end" && !pasteInFlight && !pasteLineFired) {
+        pasteInFlight = true;
+        // Defer one tick: the dropped bytes reach readline through the keyFilter
+        // PassThrough, so rl.line is only settled after the current stream turn.
+        setImmediate(() => {
+          void (async () => {
+            try {
+              const rli = rl as unknown as { line: string; cursor: number };
+              const before = rli.line;
+              const dropped = await attachImagePaths(before, pendingImages.length + 1);
+              if (dropped.images.length === 0 || dropped.text === before) return;
+              pendingImages.push(...dropped.images);
+              rli.line = dropped.text;
+              rli.cursor = dropped.text.length; // drop lands at the caret (line end in the common case)
+              typedLine = dropped.text;
+              if (previewArmed) drawFooter(previewLines(typedLine, navIdx));
+            } finally {
+              pasteInFlight = false;
+            }
+          })();
+        });
+        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") {

package/src/commands/ralplan.ts

@@ -257,6 +257,12 @@ export async function runRalplanEngine(opts: RalplanEngineOptions = {}): Promise
         cleanPlan = revised;
         await fs.writeFile(planPath, cleanPlan, "utf-8");
         gate = await runConsensusCriticGate({ cwd, seedContent, plan: cleanPlan, signal: opts.signal });
+      } else {
+        // The revision did not parse as a schema/role-valid plan, so it cannot be
+        // re-gated — the original [ITERATE] verdict stands. Report this explicitly
+        // instead of silently discarding the revision attempt (which otherwise
+        // surfaces only as the unchanged "verdict: ITERATE" failure below).
+        log(`[ralplan] The revised plan was not schema/role-valid — discarding the revision; the [ITERATE] verdict stands.`);
       }
     }
     ralplanState.plan_path = planPath;

package/src/commands/team.ts

@@ -347,6 +347,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         cwd,
         roleId: roleByIndex[activeIndex],
         strictMutations: opts.strictMutations ?? false,
+        log,
       });
 
       if (opts.signal?.aborted) {
@@ -393,13 +394,14 @@ export async function runTeamCommand(args: string[] = []): Promise<void> {
   }
 }
 
-async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string; strictMutations?: boolean }): Promise<boolean> {
+async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string; strictMutations?: boolean; log: (line: string) => void }): Promise<boolean> {
+  const log = ctx.log;
   const config = await readGlobalConfig();
   const role = getSubagentRole(ctx.roleId, config) ?? defaultSubagentRole();
   const renderOpts: RalphRenderOptions = { color: !!process.stdout.isTTY, indexed: true };
   const model = resolveSubagentModel(role.id, config);
   const maxSteps = resolveSubagentMaxSteps(role.id, config);
-  console.log(`  └─ Subagent: ${role.title} · model ${model} · ≤${maxSteps} steps`);
+  log(`  └─ Subagent: ${role.title} · model ${model} · ≤${maxSteps} steps`);
 
   const contextTokens = catalogMetadata(model)?.contextTokens;
 
@@ -428,13 +430,13 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
     events: {
       onAssistant: (_raw, invocation) => {
         if (!invocation) {
-          console.log(formatRalphStreamEvent("error", "invalid tool-call json; retrying", renderOpts));
+          log(formatRalphStreamEvent("error", "invalid tool-call json; retrying", renderOpts));
         } else if (invocation.tool !== "done") {
-          console.log(formatRalphStreamEvent("step", `tool ${invocation.tool} requested`, renderOpts));
+          log(formatRalphStreamEvent("step", `tool ${invocation.tool} requested`, renderOpts));
         }
       },
       onStep: async step => {
-        console.log(formatRalphStreamEvent("step", `${role.title} thinking ${step}/${maxSteps}`, renderOpts));
+        log(formatRalphStreamEvent("step", `${role.title} thinking ${step}/${maxSteps}`, renderOpts));
         try {
           await maybeCompact(history, { model, contextTokens });
         } catch (err) {
@@ -446,27 +448,27 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
           if (tool === "write" || tool === "edit" || tool === "mkdir" || tool === "delete") fileMutations++;
           else if (tool === "bash") bashRuns++;
         }
-        console.log(formatRalphStreamEvent(ok ? "complete" : "error", `tool ${tool}`, renderOpts));
+        log(formatRalphStreamEvent(ok ? "complete" : "error", `tool ${tool}`, renderOpts));
       },
-      onNotice: msg => console.log(formatRalphStreamEvent("step", msg, renderOpts)),
+      onNotice: msg => log(formatRalphStreamEvent("step", msg, renderOpts)),
     },
   });
 
   const reason = result.doneReason?.trim() || `${role.title} did not converge within ${result.steps} steps`;
   if (!result.done) {
-    console.log(formatRalphStreamEvent("error", reason, renderOpts));
+    log(formatRalphStreamEvent("error", reason, renderOpts));
     return false;
   }
 
   const contract = validateSubagentDoneReason(role, reason);
   if (!contract.ok) {
-    console.log(formatRalphStreamEvent("error", `${role.title} report incomplete: missing ${contract.missing?.join(", ")}`, renderOpts));
+    log(formatRalphStreamEvent("error", `${role.title} report incomplete: missing ${contract.missing?.join(", ")}`, renderOpts));
     return false;
   }
 
   const gate = parseRoleGateVerdict(role.id, reason);
   if (!gate.ok) {
-    console.log(formatRalphStreamEvent("error", gate.message ?? `${role.title} blocked execution`, renderOpts));
+    log(formatRalphStreamEvent("error", gate.message ?? `${role.title} blocked execution`, renderOpts));
     return false;
   }
 
@@ -483,11 +485,17 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
     const hardFail = ctx.strictMutations && bashRuns === 0;
     // Round-12: separate the tones so a passing advisory run doesn't masquerade
     // as a stream:error — only a real hard-fail is red; an advisory note is warn.
-    console.log(formatRalphStreamEvent(hardFail ? "error" : "warn", msg, renderOpts));
+    log(formatRalphStreamEvent(hardFail ? "error" : "warn", msg, renderOpts));
     if (hardFail) {
       return false;
     }
   }
-  console.log(formatRalphStreamEvent("complete", `${role.title} finished task`, renderOpts));
+  // Surface the subagent's ACTUAL report to the user — not just a "finished"
+  // status. Previously `reason` was consumed only for validation/gating and the
+  // report content was discarded, so `team` runs produced no visible answer.
+  log(formatRalphStreamEvent("complete", `${role.title} finished task`, renderOpts));
+  log(`\n${role.title} report:`);
+  log(reason); // log() already splits multi-line strings across the io.output sink
+
   return true;
 }