jeo-code 0.7.1 → 0.7.2

package/CHANGELOG.md

@@ -6,6 +6,23 @@ 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.7.2] - 2026-06-22
+_Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6)._
+
+### Added
+- **Per-criterion `{verify: <command>}` directive for `ultragoal`.** An acceptance criterion authored with a trailing `{verify: <shell command>}` is now INDIVIDUALLY verifiable — `parseCriterion` (in `src/agent/seed.ts`) splits the directive off the criterion text (round-tripping unmangled through the seed's JSON-encoded list), and `ultragoal` runs that command and records a real PASS/FAIL in the ledger. Criteria without a directive stay UNVERIFIED on a green suite (honest by default, strengthenable on demand). The overall report now uses a status taxonomy: **FAILED** (suite red OR any checked criterion failed), **SUCCESS** (every criterion individually verified and passed), **PARTIAL** (some verified, others still unverified), and **SUITE_GREEN** (green suite, nothing individually proven). The verdict (`ok`) now reflects `status !== "FAILED"` rather than the raw suite result.
+
+### Changed
+- **The boxed prompt's stdin→readline byte rewriter is extracted into a pure function.** `filterPromptInputChunk` (in `src/commands/launch/input.ts`) now holds the FULL keystroke wiring — bracketed-paste folding across chunks, mouse/terminal-report swallowing, Shift+Enter → hard-break SENTINEL, combo-key normalization, and the boundary-aware Up/Down box navigation — so it is testable WITHOUT a live readline/PTY. `launch.ts`'s live handler is now a thin adapter over it, eliminating the duplicated decision logic that previously diverged from its `boxVerticalNavAction` helper.
+
+### Fixed
+- **The "↓ cuts the lower text" multi-line draft regression is now covered by direct byte-stream tests.** A new `test/prompt-key-filter.test.ts` (16 cases) drives raw escape sequences through `filterPromptInputChunk` exactly as the live `kfDataHandler` does — asserting which bytes reach readline and how the caret/paste state mutate — the closest automated stand-in for live-terminal verification of the box-navigation fix shipped in 0.7.1.
+
+### Verified
+- `bun run typecheck` clean; full suite **1826 pass / 0 fail** (222 files).
+- `scripts/mem-probe.ts` (2000 turns × 40 tools): no long-term leak (exit 0; settled heap floor flat at ~4.3 MB, net +0.49 MB, exit-listeners flat at 1).
+- `scripts/tmux-verify.sh battery`: **6/6 PASSED** on a fresh `jeo --tmux` boot (boot, `/help`, unknown `$skill`, `/agents`, `$ultragoal`, unresolved `/command`).
+
 ## [0.7.1] - 2026-06-22
 _TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6)._
 

package/README.ja.md

@@ -193,11 +193,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.41]** (2026-06-21) — The non-streaming model path now inherits the v0.6.40 300s window: an unattended long-reasoning turn (compaction, ralplan, deep-interview, memory distill, goal-verify, subagent/autopilot steps) is no longer false-aborted at the old 120s wall cap. Re-verified leak-free (`mem-probe`, 2000 turns, −610 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.40]** (2026-06-21) — Wire-level stream heartbeat: ANY bytes from the provider (SSE keepalive/ping, filtered events) now re-arm the idle watchdog — a connected-but-quiet stream can no longer trip a false `stream idle` retry. Default idle window raised to 300s so Ollama/llama.cpp model-load silence no longer exhausts retries and stops the turn.
-- **[0.6.39]** (2026-06-21) — A long "thinking" phase no longer trips a false stream-idle retry: reasoning/thinking deltas now act as a stream heartbeat, so a model that streams thought tokens past the idle window before any visible text is no longer mistaken for a stalled stream and retried (which discarded the in-progress reasoning). Re-verified leak-free (`mem-probe`, 2000 turns, −525 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -193,11 +193,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.41]** (2026-06-21) — The non-streaming model path now inherits the v0.6.40 300s window: an unattended long-reasoning turn (compaction, ralplan, deep-interview, memory distill, goal-verify, subagent/autopilot steps) is no longer false-aborted at the old 120s wall cap. Re-verified leak-free (`mem-probe`, 2000 turns, −610 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.40]** (2026-06-21) — Wire-level stream heartbeat: ANY bytes from the provider (SSE keepalive/ping, filtered events) now re-arm the idle watchdog — a connected-but-quiet stream can no longer trip a false `stream idle` retry. Default idle window raised to 300s so Ollama/llama.cpp model-load silence no longer exhausts retries and stops the turn.
-- **[0.6.39]** (2026-06-21) — A long "thinking" phase no longer trips a false stream-idle retry: reasoning/thinking deltas now act as a stream heartbeat, so a model that streams thought tokens past the idle window before any visible text is no longer mistaken for a stalled stream and retried (which discarded the in-progress reasoning). Re-verified leak-free (`mem-probe`, 2000 turns, −525 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -195,11 +195,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.41]** (2026-06-21) — The non-streaming model path now inherits the v0.6.40 300s window: an unattended long-reasoning turn (compaction, ralplan, deep-interview, memory distill, goal-verify, subagent/autopilot steps) is no longer false-aborted at the old 120s wall cap. Re-verified leak-free (`mem-probe`, 2000 turns, −610 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.40]** (2026-06-21) — Wire-level stream heartbeat: ANY bytes from the provider (SSE keepalive/ping, filtered events) now re-arm the idle watchdog — a connected-but-quiet stream can no longer trip a false `stream idle` retry. Default idle window raised to 300s so Ollama/llama.cpp model-load silence no longer exhausts retries and stops the turn.
-- **[0.6.39]** (2026-06-21) — A long "thinking" phase no longer trips a false stream-idle retry: reasoning/thinking deltas now act as a stream heartbeat, so a model that streams thought tokens past the idle window before any visible text is no longer mistaken for a stalled stream and retried (which discarded the in-progress reasoning). Re-verified leak-free (`mem-probe`, 2000 turns, −525 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -193,11 +193,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.41]** (2026-06-21) — The non-streaming model path now inherits the v0.6.40 300s window: an unattended long-reasoning turn (compaction, ralplan, deep-interview, memory distill, goal-verify, subagent/autopilot steps) is no longer false-aborted at the old 120s wall cap. Re-verified leak-free (`mem-probe`, 2000 turns, −610 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.6.40]** (2026-06-21) — Wire-level stream heartbeat: ANY bytes from the provider (SSE keepalive/ping, filtered events) now re-arm the idle watchdog — a connected-but-quiet stream can no longer trip a false `stream idle` retry. Default idle window raised to 300s so Ollama/llama.cpp model-load silence no longer exhausts retries and stops the turn.
-- **[0.6.39]** (2026-06-21) — A long "thinking" phase no longer trips a false stream-idle retry: reasoning/thinking deltas now act as a stream heartbeat, so a model that streams thought tokens past the idle window before any visible text is no longer mistaken for a stalled stream and retried (which discarded the in-progress reasoning). Re-verified leak-free (`mem-probe`, 2000 turns, −525 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/seed.ts

@@ -50,3 +50,27 @@ export function parseSeedList(content: string, name: string): string[] {
 export function parseSeedAcceptanceCriteria(content: string): string[] {
   return parseSeedList(content, "acceptance_criteria");
 }
+/** A single acceptance criterion, optionally carrying an executable check command.
+ *  Authors make a criterion INDIVIDUALLY verifiable by appending a trailing
+ *  `{verify: <shell command>}` directive; ultragoal runs that command and records a
+ *  real PASS/FAIL instead of leaving the criterion UNVERIFIED. Criteria without a
+ *  directive stay honest-by-default (UNVERIFIED on a green suite). */
+export interface ParsedCriterion {
+  /** Human-readable criterion text with any {verify:...} directive stripped. */
+  text: string;
+  /** Optional shell command whose exit status proves this specific criterion. */
+  verify?: string;
+}
+
+const VERIFY_DIRECTIVE = /\s*\{verify:\s*([^}]+?)\s*\}\s*$/i;
+
+/** Split an optional trailing `{verify: <cmd>}` directive off a criterion string.
+ *  The directive lives INSIDE the JSON-encoded seed value, so it round-trips
+ *  unmangled through `yamlList`/`parseSeedList` like any other criterion text. */
+export function parseCriterion(raw: string): ParsedCriterion {
+  const match = raw.match(VERIFY_DIRECTIVE);
+  if (!match) return { text: raw.trim() };
+  const verify = match[1].trim();
+  const text = raw.replace(VERIFY_DIRECTIVE, "").trim();
+  return verify ? { text, verify } : { text };
+}

package/src/commands/launch/input.ts

@@ -504,4 +504,111 @@ export function decideCtrlC(
 ): CtrlCAction {
   if (msSinceLastCtrlC < collapseMs) return "ignore";
   return hasInput ? "clear" : "exit";
+}
+
+/** Shift+Enter encodings the box rewrites to a hard-break SENTINEL: the xterm
+ *  `modifyOtherKeys` form (`CSI 27;2;13~`) and the kitty keyboard-protocol form
+ *  (`CSI 13;2u`). Shared by the live input filter and its tests so they can't drift. */
+export const SHIFT_ENTER_SEQS: readonly string[] = ["\u001b[27;2;13~", "\u001b[13;2u"];
+
+/** Minimal readline view the prompt key-filter reads (and mutates `cursor` on a
+ *  vertical-nav "move"). The live filter passes the real readline interface; tests
+ *  pass a plain object. */
+export interface PromptKeyFilterRl {
+  line: string;
+  cursor: number;
+}
+
+/** Per-keystroke context the filter needs that is NOT derivable from the bytes:
+ *  the opt-in lone-LF Shift+Enter toggle, whether a slash dropdown / Ctrl+O history
+ *  panel currently owns the arrow keys, and the terminal width (for the box's
+ *  soft-wrap row model). */
+export interface PromptKeyFilterEnv {
+  loneLfShiftEnter: boolean;
+  slashMatchCount: number;
+  historyPanelOpen: boolean;
+  /** `process.stdout.columns ?? 80` — the raw column count BEFORE the box's own insets. */
+  columns: number;
+}
+
+/** Carried across chunks: a bracketed paste can span several stdin chunks, so the
+ *  in-paste flag must survive between filter calls. */
+export interface PromptKeyFilterState {
+  inPaste: boolean;
+}
+
+export interface PromptKeyFilterResult {
+  /** Bytes to forward to readline. */
+  out: string;
+  /** True when the whole chunk was consumed and NOTHING should be written (the
+   *  empty-line standalone-Backspace guard) — distinct from an empty `out`. */
+  drop: boolean;
+}
+
+/** The stdin → readline byte rewriter for the boxed multi-line prompt, extracted as a
+ *  pure function so the full keystroke wiring — paste folding, mouse/terminal-report
+ *  swallowing, Shift+Enter → SENTINEL, combo-key normalization, and the boundary-aware
+ *  Up/Down box navigation — is testable WITHOUT a live readline/PTY. The live filter in
+ *  `launch.ts` is a thin adapter over this: feed it each chunk, forward `out` unless
+ *  `drop`, and let it mutate `rl.cursor` (textarea caret moves) and `state.inPaste`.
+ *
+ *  The "swallow" branch is the fix for the "↓ cuts the lower text" bug: at the top/bottom
+ *  visual row of a GENUINE multi-line draft the key is consumed (no bytes emitted) so it
+ *  can't reach readline's input-history recall and wipe the message being composed. */
+export function filterPromptInputChunk(
+  data: string,
+  rl: PromptKeyFilterRl | null,
+  env: PromptKeyFilterEnv,
+  state: PromptKeyFilterState,
+): PromptKeyFilterResult {
+  // Empty-line Backspace guard: a standalone Backspace with an empty buffer is a no-op
+  // that some Bun readline builds turn into a spurious `close` (hard exit) — drop it
+  // before it reaches readline. Forwarded normally inside a paste or with text present.
+  if (!state.inPaste && isStandaloneBackspace(data) && !(rl?.line ?? "")) {
+    return { out: "", drop: true };
+  }
+  let out = "";
+  let i = 0;
+  while (i < data.length) {
+    if (!state.inPaste && data.startsWith(PASTE_START, i)) { state.inPaste = true; out += PASTE_START; i += PASTE_START.length; continue; }
+    if (state.inPaste && data.startsWith(PASTE_END, i)) { state.inPaste = false; out += PASTE_END; i += PASTE_END.length; continue; }
+    if (state.inPaste) {
+      if (data.startsWith("\r\n", i)) { out += MULTILINE_SENTINEL; i += 2; continue; }
+      if (data[i] === "\n" || data[i] === "\r") { out += MULTILINE_SENTINEL; i += 1; continue; }
+      out += data[i]; i += 1; continue;
+    }
+    const mouse = matchMouseReport(data, i);
+    if (mouse > 0) { i += mouse; continue; }
+    const report = matchTerminalReport(data, i);
+    if (report > 0) { i += report; continue; }
+    let matched = false;
+    for (const seq of SHIFT_ENTER_SEQS) {
+      if (data.startsWith(seq, i)) { out += MULTILINE_SENTINEL; i += seq.length; matched = true; break; }
+    }
+    if (matched) continue;
+    const combo = matchCursorCombo(data, i);
+    if (combo) { out += combo[1]; i += combo[0].length; continue; }
+    // Up/Down between the box's visual rows (textarea feel) for any MULTI-ROW draft;
+    // at the top/bottom edge a soft-wrapped one-liner falls through to history recall,
+    // but a genuine multi-line draft swallows the key (the "↓ cuts text" fix).
+    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 = rl?.line ?? "";
+      if (shouldBoxVerticalNav(line, { slashMatchCount: env.slashMatchCount, historyPanelOpen: env.historyPanelOpen }) && rl) {
+        const winCols = Math.max(24, env.columns - 1);
+        const textWidth = Math.max(1, Math.max(24, winCols) - 6);
+        const cur = typeof rl.cursor === "number" ? rl.cursor : line.length;
+        const action = boxVerticalNavAction(line.split(MULTILINE_SENTINEL).join("\n"), line, cur, textWidth, dir);
+        if (action.kind === "move") { rl.cursor = action.cursor; i += 3; continue; }
+        if (action.kind === "swallow") { i += 3; continue; } // keep the multi-line draft intact
+      }
+      out += data.slice(i, i + 3); i += 3; continue;
+    }
+    if (env.loneLfShiftEnter && data[i] === "\n") { out += MULTILINE_SENTINEL; i += 1; continue; } // lone LF = Shift+Enter (opt-in)
+    // Ctrl+L (form feed): the prompt redraw hotkey, handled on the process.stdin keypress
+    // listener — never forward it to readline as a literal char.
+    if (data[i] === "\u000c") { i += 1; continue; }
+    out += data[i]; i += 1;
+  }
+  return { out, drop: false };
 }

package/src/commands/launch.ts

@@ -146,6 +146,7 @@ import {
   createInFlightAbortHarness,
   classifyMidTurnLine,
   decideCtrlC,
+  filterPromptInputChunk,
 } from "./launch/input";
 import {
   gatedStdout,
@@ -1394,7 +1395,6 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // 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 = 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"
   // Shift+Enter rule stays opt-in (JEO_MULTILINE=1) — it needs ghostty's
@@ -1435,73 +1435,25 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     //     `keybind = shift+enter=text:\n`, passes tmux unchanged even with extended-keys
     //     off) and the xterm "\x1b[27;2;13~" / kitty "\x1b[13;2u" sequences. Enter ("\r")
     //     passes through and submits.
-    let kfInPaste = false;
+    // Stateful across chunks (a bracketed paste can span several). The byte-rewrite logic
+    // lives in `filterPromptInputChunk` (pure + exported) so the full keystroke wiring is
+    // testable without a live readline/PTY; this handler is the thin live adapter.
+    const kfState = { inPaste: false };
     const kfDataHandler = (chunk: Buffer) => {
       const data = chunk.toString("utf8");
-      // Empty-line Backspace guard: a standalone Backspace with nothing to delete is a
-      // no-op, but some Bun readline builds emit a spurious `close` for it — which the
-      // REPL treats as a hard exit. Drop it before it reaches readline. (Inside a paste,
-      // or with text in the buffer, backspace is forwarded normally so editing works.)
-      if (!kfInPaste && isStandaloneBackspace(data) && !(activeRl?.line ?? "")) return;
-      let out = "";
-      let i = 0;
-      while (i < data.length) {
-        if (!kfInPaste && data.startsWith(PASTE_START, i)) { kfInPaste = true; out += PASTE_START; i += PASTE_START.length; continue; }
-        if (kfInPaste && data.startsWith(PASTE_END, i)) { kfInPaste = false; out += PASTE_END; i += PASTE_END.length; continue; }
-        if (kfInPaste) {
-          if (data.startsWith("\r\n", i)) { out += SENTINEL; i += 2; continue; }
-          if (data[i] === "\n" || data[i] === "\r") { out += SENTINEL; i += 1; continue; }
-          out += data[i]; i += 1; continue;
-        }
-        // Swallow MOUSE-REPORT sequences (tmux `mouse on` from --tmux, or a stale pane):
-        // their payload bytes would otherwise be typed into the prompt. Never in a paste.
-        const mouse = matchMouseReport(data, i);
-        if (mouse > 0) { i += mouse; continue; }
-        // Swallow TERMINAL CAPABILITY-RESPONSE sequences (DA1/DA2/XTVERSION/OSC replies):
-        // tmux probes the outer terminal on attach and its answers (`62;4;9;22c…>|xterm.js…`)
-        // can land on stdin; without this they spray into the prompt as typed text.
-        const report = matchTerminalReport(data, i);
-        if (report > 0) { i += report; continue; }
-        let matched = false;
-        for (const seq of SHIFT_ENTER_SEQS) {
-          if (data.startsWith(seq, i)) { out += SENTINEL; i += seq.length; matched = true; break; }
-        }
-        if (matched) continue;
-        // Normalize macOS/fixterms combo cursor keys readline ignores (Option/Cmd+arrow,
-        // 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 move the caret BETWEEN the box's visual rows (textarea feel) for any
-        // MULTI-ROW draft — explicit Shift+Enter breaks (→ SENTINEL) OR a long line the
-        // box soft-wraps. The decision is boundary-aware: an in-box visual row exists →
-        // move the caret there. With NO row to move to (↑ on the TOP row, ↓ on the BOTTOM
-        // row), a SOFT-WRAPPED one-liner falls through to readline to recall input history
-        // (the dominant REPL expectation), but a GENUINE multi-line draft SWALLOWS the key
-        // instead — falling through there would let readline's history nav WIPE the
-        // multi-line message being composed (the "↓ cuts the lower text" bug). Skipped
-        // entirely when a slash list or Ctrl+O history panel owns ↑/↓.
-
-        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 (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;
-            const action = boxVerticalNavAction(expandSentinel(line), line, cur, textWidth, dir);
-            if (action.kind === "move") { activeRl.cursor = action.cursor; i += 3; continue; }
-            if (action.kind === "swallow") { i += 3; continue; } // keep the multi-line draft intact
-          }
-          out += data.slice(i, i + 3); i += 3; continue;
-        }
-        if (loneLfShiftEnter && data[i] === "\n") { out += SENTINEL; i += 1; continue; } // lone LF = Shift+Enter (opt-in)
-        // Ctrl+L (form feed): consumed as the prompt "redraw / re-anchor" hotkey (handled on
-        // the process.stdin 'keypress' listener), so it must never reach readline as a literal
-        // char that would otherwise insert garbage / desync the box from rl.line.
-        if (data[i] === "\u000c") { i += 1; continue; }
-        out += data[i]; i += 1;
-      }
-      kf.write(out);
+      const result = filterPromptInputChunk(
+        data,
+        activeRl ? (activeRl as unknown as { line: string; cursor: number }) : null,
+        {
+          loneLfShiftEnter,
+          slashMatchCount: navMatches.length,
+          historyPanelOpen: promptHistoryLines != null,
+          columns: process.stdout.columns ?? 80,
+        },
+        kfState,
+      );
+      if (result.drop) return;
+      kf.write(result.out);
     };
     process.stdin.on("data", kfDataHandler);
     promptListenerCleanups.push(() => process.stdin.off("data", kfDataHandler));

package/src/commands/ultragoal.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { readWorkflowState, writeWorkflowState, getLocalJeoDir, type WorkflowState } from "../agent/state";
 import { bashTool } from "../agent/tools";
-import { parseSeedAcceptanceCriteria } from "../agent/seed";
+import { parseSeedAcceptanceCriteria, parseCriterion } from "../agent/seed";
 
 export interface UltragoalEngineOptions {
   cwd?: string;
@@ -80,13 +80,16 @@ export async function runUltragoalEngine(opts: UltragoalEngineOptions = {}): Pro
 
   log(`Loaded ${criteria.length} acceptance criteria for verification.\n`);
 
-  // Round-7 #2 (architect ref 7-Round7Workflow): the previous per-criterion loop
-  // was verification THEATER — every criterion ran the same global `bun test`
-  // (or a guaranteed-green `--help` when the text mentioned run/cli) and a
-  // fabricated per-criterion ✅/❌ matrix was written to the ledger. Honest
-  // contract: run the suite ONCE as a global signal; individual criteria are
-  // UNVERIFIED unless individually proven. SUCCESS is not claimable from a
-  // signal that cannot fail for the cases it pretends to cover.
+  // Round-7 #2 (architect ref 7-Round7Workflow) + per-criterion verification:
+  // The suite still runs ONCE as a global signal — a green suite NEVER fabricates a
+  // per-criterion PASS (the old "run/cli → guaranteed-green --help" theater is gone).
+  // What's new: a criterion authored with a trailing `{verify: <command>}` directive
+  // is INDIVIDUALLY verifiable — ultragoal runs that command and records a real
+  // PASS/FAIL. Criteria without a directive stay UNVERIFIED on green (we never
+  // specifically proved them): honest by default, strengthenable on demand.
+  const parsed = criteria.map(parseCriterion);
+  const verifiableCount = parsed.filter(c => c.verify).length;
+
   log(`[CHECK] Running the verification suite once ('bun test') — a global signal, not per-criterion proof.`);
   if (opts.onProgress) {
     opts.onProgress({ skill: "ultragoal", phase: "verifying", detail: "Running verification suite" });
@@ -94,11 +97,33 @@ export async function runUltragoalEngine(opts: UltragoalEngineOptions = {}): Pro
   const suite = await bashTool("bun test", cwd);
   log(`  └─ Suite: ${suite.success ? "GREEN" : "FAILED"}`);
 
-  const results: { criterion: string; status: "unverified" | "failed"; note: string }[] = criteria.map(criterion =>
-    suite.success
-      ? { criterion, status: "unverified", note: "suite green — criterion not individually verified" }
-      : { criterion, status: "failed", note: "verification suite failed" },
-  );
+  if (opts.signal?.aborted) {
+    return { ok: false, reason: "aborted" };
+  }
+
+  // Per-criterion checks: only a criterion carrying a {verify:...} directive runs an
+  // individual command; everything else inherits the global suite signal.
+  const results: { criterion: string; status: "passed" | "unverified" | "failed"; note: string }[] = [];
+  for (const c of parsed) {
+    if (c.verify) {
+      if (opts.signal?.aborted) return { ok: false, reason: "aborted" };
+      if (opts.onProgress) {
+        opts.onProgress({ skill: "ultragoal", phase: "verifying", detail: `Verifying: ${c.text}` });
+      }
+      log(`[CHECK] ${c.text}\n  └─ $ ${c.verify}`);
+      const check = await bashTool(c.verify, cwd);
+      log(`     ${check.success ? "PASS" : "FAIL"}`);
+      results.push(
+        check.success
+          ? { criterion: c.text, status: "passed", note: `verified by \`${c.verify}\`` }
+          : { criterion: c.text, status: "failed", note: `\`${c.verify}\` exited non-zero` },
+      );
+    } else if (suite.success) {
+      results.push({ criterion: c.text, status: "unverified", note: "suite green — criterion not individually verified (add {verify: <cmd>})" });
+    } else {
+      results.push({ criterion: c.text, status: "failed", note: "verification suite failed" });
+    }
+  }
 
   if (opts.signal?.aborted) {
     return { ok: false, reason: "aborted" };
@@ -110,18 +135,37 @@ export async function runUltragoalEngine(opts: UltragoalEngineOptions = {}): Pro
   const reportPath = path.join(reportDir, "ultragoal-report.md");
 
   const totalCount = results.length;
-  const status = suite.success ? "SUITE_GREEN" : "FAILED";
+  const passedCount = results.filter(r => r.status === "passed").length;
+  const failedCount = results.filter(r => r.status === "failed").length;
+  const unverifiedCount = results.filter(r => r.status === "unverified").length;
+
+  // Overall status taxonomy:
+  //  FAILED      — the global suite is red, OR any individually-checked criterion failed.
+  //  SUCCESS     — every criterion was individually verified and passed (no UNVERIFIED left).
+  //  PARTIAL     — some criteria individually passed, but others remain UNVERIFIED.
+  //  SUITE_GREEN — suite green but NO criterion was individually verified (legacy honest default).
+  let status: string;
+  if (!suite.success || failedCount > 0) {
+    status = "FAILED";
+  } else if (passedCount > 0 && unverifiedCount === 0) {
+    status = "SUCCESS";
+  } else if (passedCount > 0) {
+    status = "PARTIAL";
+  } else {
+    status = "SUITE_GREEN";
+  }
 
   const reportContent =
     `# Ultragoal Verification Report: ${interviewState.slug}\n` +
     `Date: ${new Date().toISOString()}\n` +
-    `Status: ${status} — suite ${suite.success ? "green" : "FAILED"}; ${totalCount} acceptance criteria recorded (not individually verified)\n` +
+    `Status: ${status} — suite ${suite.success ? "green" : "FAILED"}; ` +
+      `${totalCount} criteria (${passedCount} verified, ${unverifiedCount} unverified, ${failedCount} failed)\n` +
     `Plan: ${teamState?.plan_path ?? "(team not run)"}\n` +
     `Execution: ${teamState?.current_phase === "complete" ? "team complete" : "team NOT complete — verified current disk state"}\n\n` +
     `## Criteria Record\n` +
     `| Criterion | Status | Note |\n` +
     `|---|---|---|\n` +
-    results.map(r => `| ${r.criterion} | ${r.status === "failed" ? "❌ FAILED" : "⚠️ UNVERIFIED"} | ${r.note} |`).join("\n") +
+    results.map(r => `| ${r.criterion} | ${r.status === "passed" ? "✅ PASSED" : r.status === "failed" ? "❌ FAILED" : "⚠️ UNVERIFIED"} | ${r.note} |`).join("\n") +
     `\n`;
 
   // Atomic temp+rename (zeroclaw): a torn report must not disagree with the state JSON.
@@ -144,18 +188,24 @@ export async function runUltragoalEngine(opts: UltragoalEngineOptions = {}): Pro
     plan_path: teamState?.plan_path,
     status,
     suite_green: suite.success,
+    passed: passedCount,
     total: totalCount,
   };
   await writeWorkflowState("ultragoal", ultragoalState, cwd);
 
   log(`\n[VERIFICATION COMPLETE] Report saved to: ${reportPath}`);
-  log(`Overall status: ${status} — ${totalCount} criteria recorded; none individually verified (add per-criterion checks for stronger claims).`);
+  log(
+    verifiableCount > 0
+      ? `Overall status: ${status} — ${passedCount}/${totalCount} criteria individually verified, ${unverifiedCount} unverified, ${failedCount} failed.`
+      : `Overall status: ${status} — ${totalCount} criteria recorded; none individually verified (add {verify: <cmd>} to a criterion for a real per-criterion check).`,
+  );
+
 
   if (opts.onProgress) {
     opts.onProgress({ skill: "ultragoal", phase: "complete" });
   }
 
-  return { ok: suite.success };
+  return { ok: status !== "FAILED" };
 }
 
 export async function runUltragoalCommand(): Promise<void> {