jeo-code 0.6.36 → 0.6.38

package/CHANGELOG.md

@@ -6,6 +6,39 @@ 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.38] - 2026-06-21
+_The OKF concept-bundle memory no longer silently drops what it learns: a legacy single-doc `MEMORY.md` (or a text-only distill fallback) can no longer shadow the concept bundle, break OKF conformance, or lose a turn's learnings — its content is folded into the concept merge and the stale blob is archived. Re-verified leak-free (`mem-probe`, 2000 turns, −570 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6)._
+
+### Fixed
+- **A text-only distill fallback no longer loses the turn's learnings.** When the model returns no extractable JSON, `distillSessionMemory` used to write the raw text to a single-doc `MEMORY.md` blob — but `memoryPromptSection` injects that blob ONLY when the concept bundle is empty (concepts always win), so once any concept existed the fallback's learnings were recorded yet never injected. Now, if a concept bundle already exists, the dead blob is suppressed and the prior concepts are kept as the durable memory (`skipped: "distill produced no JSON; kept existing concept bundle (legacy blob suppressed)"`).
+- **A lingering legacy `MEMORY.md` can no longer break OKF conformance.** A frontmatter-less single-doc `MEMORY.md` coexisting with the concept bundle made `validateBundle` non-conformant (`error: concept document missing YAML frontmatter block`) while the loader silently skipped it — an inconsistency that left the bundle permanently invalid (`migrateLegacyMemory` only runs on the explicit `jeo memory-migrate`). Distill now feeds the legacy doc's content into the concept-merge context so its learnings are absorbed, then archives it to `MEMORY.md.bak` on a successful JSON distill — off the active read path, with rollback preserved.
+- **Concept enumeration skips non-concept blobs.** `existingConcepts` now skips any `.md` without YAML frontmatter, so a stray `MEMORY.md` can never be mis-parsed as a concept during the merge.
+
+### Changed
+- **Distill prompt enforces concept granularity.** The merge prompt now forbids a catch-all "Project Memory Bundle" mega-concept and instructs one concept per distinct fact/command/gotcha/preference, so the bundle grows as discrete, cross-linkable concepts.
+- **Per-session injection budget raised** from 3,000 to 5,000 chars (`MEMORY_INJECT_MAX_CHARS`) so a healthy multi-concept bundle is injected in full.
+
+### Verified
+- `bun run typecheck` clean; full suite `1751 pass / 0 fail` (216 files).
+- Memory/OKF suites `57 pass / 0 fail` across `memory`, `memory-okf`, `memory-distill-okf`, `memory-migration-okf`, `memory-search-okf`, `memory-graph-okf`.
+- Live bundle proof: `validateBundle` flips `false (error: MEMORY.md)` → `true (no issues)` after the legacy archive, injection block intact (3,220 chars); bundle now holds discrete facts/commands/gotchas/preferences concepts + a valid `index.md`.
+- `scripts/mem-probe.ts` (2000 turns × 40 tools) reports no long-term leak (−570 bytes/turn, exit-listeners flat at 1); `scripts/tmux-verify.sh battery` passes 6/6 on a fresh `jeo --tmux` boot.
+
+
+## [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._
 

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.38]** (2026-06-21) — The OKF concept-bundle memory no longer silently drops what it learns: a legacy single-doc `MEMORY.md` (or a text-only distill fallback) can no longer shadow the concept bundle, break OKF conformance, or lose a turn's learnings — its content is folded into the concept merge and the stale blob is archived. Re-verified leak-free (`mem-probe`, 2000 turns, −570 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
+- **[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.
 
 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.38]** (2026-06-21) — The OKF concept-bundle memory no longer silently drops what it learns: a legacy single-doc `MEMORY.md` (or a text-only distill fallback) can no longer shadow the concept bundle, break OKF conformance, or lose a turn's learnings — its content is folded into the concept merge and the stale blob is archived. Re-verified leak-free (`mem-probe`, 2000 turns, −570 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
+- **[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.
 
 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.38]** (2026-06-21) — The OKF concept-bundle memory no longer silently drops what it learns: a legacy single-doc `MEMORY.md` (or a text-only distill fallback) can no longer shadow the concept bundle, break OKF conformance, or lose a turn's learnings — its content is folded into the concept merge and the stale blob is archived. Re-verified leak-free (`mem-probe`, 2000 turns, −570 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
+- **[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.
 
 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.38]** (2026-06-21) — The OKF concept-bundle memory no longer silently drops what it learns: a legacy single-doc `MEMORY.md` (or a text-only distill fallback) can no longer shadow the concept bundle, break OKF conformance, or lose a turn's learnings — its content is folded into the concept merge and the stale blob is archived. Re-verified leak-free (`mem-probe`, 2000 turns, −570 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
+- **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/memory.ts

@@ -22,7 +22,7 @@ import { buildConceptGraph, expandByGraph, lintConceptGraph, type GraphLintRepor
 /** On-disk document cap — the distill prompt instructs the model to stay under it. */
 export const MEMORY_MAX_CHARS = 6_000;
 /** Per-session prompt injection budget. */
-export const MEMORY_INJECT_MAX_CHARS = 3_000;
+export const MEMORY_INJECT_MAX_CHARS = 5_000;
 /** Transcript slice fed to the distill call. */
 const TRANSCRIPT_MAX_CHARS = 12_000;
 /** A session shorter than this has nothing durable to learn. */
@@ -560,6 +560,7 @@ export async function distillSessionMemory(
         try {
           const content = await fs.readFile(file, "utf-8");
           const parsed = parseConcept(content);
+          if (!parsed.hasFrontmatter) continue; // skip MEMORY.md and other legacy blobs
           existingConcepts.push({
             type: parsed.frontmatter.type,
             title: parsed.frontmatter.title || "",
@@ -573,6 +574,11 @@ export async function distillSessionMemory(
         } catch {}
       }
     } catch {}
+    // A lingering single-doc MEMORY.md (legacy, or a prior text-only bootstrap
+    // fallback) is NOT a concept document — loadConcepts ignores it and it breaks
+    // OKF conformance. Feed its content into the merge context so its learnings
+    // are absorbed into concepts, then archive it on a successful JSON distill.
+    const legacyDoc = await loadMemory(cwd);
 
     const prompt: Message[] = [
       {
@@ -583,12 +589,21 @@ export async function distillSessionMemory(
           "Keep ONLY what helps future sessions in THIS repository: repo facts (structure, conventions, key files), " +
           "commands that work (build/test/run), gotchas (failures and their fixes), and user preferences. " +
           "Drop session-specific noise (one-off tasks, transient errors, conversational detail). " +
+          "CRITICAL RULES for concept granularity:\n" +
+          "  1. Create ONE concept per distinct fact/command/gotcha/preference — never combine multiple learnings into a single concept.\n" +
+          "  2. NEVER create a catch-all 'Project Memory Bundle' or similar mega-concept that lists many things. Split it.\n" +
+          "  3. Each Command concept covers exactly one command or workflow (e.g., 'bun test', NOT 'All bun commands').\n" +
+          "  4. Each Gotcha covers exactly one failure mode and its fix.\n" +
+          "  5. Each UserPreference covers exactly one observable preference.\n" +
+          "  6. RepoFact concepts describe structure/conventions — split by area (e.g., 'CLI entrypoint', 'Test setup').\n" +
+          "  7. If an existing concept is a mega-concept (lists many things), REPLACE it with properly split granular concepts.\n" +
+          "  8. Keep each concept body under 400 chars.\n\n" +
           "You must output a JSON object with a single key \"concepts\", which is an array of concept objects. " +
           "Each concept object must have the following fields:\n" +
           "  - \"type\": one of \"RepoFact\", \"Command\", \"Gotcha\", \"UserPreference\"\n" +
           "  - \"title\": a short, descriptive title (e.g., \"Bun test runner\")\n" +
           "  - \"description\": a brief one-line summary of the concept\n" +
-          "  - \"body\": the detailed markdown content/body of the concept\n" +
+          "  - \"body\": the detailed markdown content/body of the concept (≤400 chars)\n" +
           "  - \"tags\": an array of string tags (optional)\n" +
           "  - \"confidence\": one of \"high\", \"medium\", \"low\" (optional)\n" +
           "  - \"links\": an array of other concept paths/IDs this concept links to (optional)\n\n" +
@@ -598,6 +613,7 @@ export async function distillSessionMemory(
         role: "user",
         content:
           `Existing concepts:\n${JSON.stringify(existingConcepts, null, 2)}\n\n` +
+          (legacyDoc ? `Legacy single-doc memory to fold into concepts:\n${legacyDoc}\n\n` : "") +
           `Session transcript (tail):\n${transcriptTail(history)}`
       }
     ];
@@ -695,9 +711,25 @@ export async function distillSessionMemory(
       if (updatedConcepts.length > 0) {
         await updateLog(bundleDir, updatedConcepts);
       }
+      // Concepts now own the durable memory and the legacy blob (if any) was
+      // folded into the merge above. Archive a lingering MEMORY.md off the active
+      // read path so it can never break OKF conformance or shadow the bundle.
+      if (legacyDoc) {
+        await fs.rename(memoryFilePath(cwd), `${memoryFilePath(cwd)}.bak`).catch(() => {});
+      }
       await cleanupStalePendingFiles(bundleDir);
       return { updated: true };
     } else {
+      // JSON extraction failed (text-only models often wrap or drop the JSON).
+      // The single-doc MEMORY.md is a BOOTSTRAP fallback only: it is injected by
+      // memoryPromptSection ONLY when the OKF concept bundle is empty. Writing it
+      // while concepts already exist would (a) be silently ignored at injection
+      // (concepts win) — losing the learning — and (b) break OKF conformance
+      // (MEMORY.md has no frontmatter). So when a bundle exists, do NOT clobber
+      // it with a dead blob; keep the prior concepts as the durable memory.
+      if (existingConcepts.length > 0) {
+        return { updated: false, skipped: "distill produced no JSON; kept existing concept bundle (legacy blob suppressed)" };
+      }
       const doc = distilled.trim().slice(0, MEMORY_MAX_CHARS);
       if (!doc) return { updated: false, skipped: "model returned an empty document" };
       const file = memoryFilePath(cwd);

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.ts

@@ -136,6 +136,9 @@ import {
   matchTerminalReport,
   stripMouseReports,
   rewriteCursorCombos,
+  MULTILINE_SENTINEL,
+  isGenuineMultilineDraft,
+  shouldBoxVerticalNav,
   queuePromptInputChunk,
   captureLivePromptInputChunk,
   restoreQueuedLinesToPrefill,
@@ -203,6 +206,9 @@ export {
   matchTerminalReport,
   stripMouseReports,
   rewriteCursorCombos,
+  MULTILINE_SENTINEL,
+  isGenuineMultilineDraft,
+  shouldBoxVerticalNav,
   queuePromptInputChunk,
   captureLivePromptInputChunk,
   restoreQueuedLinesToPrefill,
@@ -1360,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"
@@ -1438,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;
@@ -2586,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;
 }