jeo-code 0.6.9 → 0.6.11

package/CHANGELOG.md

@@ -6,6 +6,24 @@ 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.11] - 2026-06-16
+_Larger reasoning budgets, and terminal capability-response sequences kept out of the prompt._
+
+### Changed
+- **Larger thinking-token budgets across every level.** `thinkingMaxTokens` is raised (minimal 1k→4k, low 2k→8k, default 4k→16k, high 8k→24k, xhigh 16k→32k), along with the Anthropic (medium 4k→10k, high 10k→24k) and Gemini (low→4k, medium→10k, high→24k) per-provider budgets — so each reasoning level actually gets room to think.
+
+### Fixed
+- **Terminal capability-response sequences no longer corrupt the prompt.** The mouse-report filter (0.6.7) now also swallows Device-Attributes / mode replies that the outer terminal sends when tmux probes it on attach, on both the idle keypress path and the live-turn raw-stdin drain.
+
+## [0.6.10] - 2026-06-16
+_OKF memory-format foundation and a hardened bashTool subprocess drain._
+
+### Added
+- **OKF (Open Knowledge Format) v0.1 foundation** — a standalone schema/format layer for jeo memory: YAML-frontmatter parse/serialize with extension-key round-trip, concept-ID computation, and a tolerant v0.1 conformance validator (`src/agent/memory-okf.ts`). Sprint 01 only — it does not touch the existing distill/inject pipeline yet, and adds zero native dependencies. Design notes live under `docs/okf_mem/`.
+
+### Fixed
+- **bashTool subprocess draining hardened.** A shared `drainPipe` reader plus reader-cancellation, a SIGTERM→SIGKILL kill timer, and a brief pipe-linger ensure stdout/stderr fully drain before teardown — no file-descriptor or child-process leak across the normal, timed-out, and abandoned lifecycles (the subprocess-leak probe stays at baseline).
+
 ## [0.6.9] - 2026-06-16
 _Live streaming blocks size to their content and the viewport instead of a fixed rectangle._
 

package/README.ja.md

@@ -158,11 +158,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.11]** (2026-06-16) — Larger reasoning budgets, and terminal capability-response sequences kept out of the prompt.
+- **[0.6.10]** (2026-06-16) — OKF memory-format foundation and a hardened bashTool subprocess drain.
 - **[0.6.9]** (2026-06-16) — Live streaming blocks size to their content and the viewport instead of a fixed rectangle.
 - **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 - **[0.6.7]** (2026-06-16) — Mouse-report input corruption fixed under `jeo --tmux`, and a full-width TUI at one consistent width.
-- **[0.6.6]** (2026-06-16) — Vertical caret movement between input-box rows, a centered welcome banner, and a leaner `parseFlags`.
-- **[0.6.5]** (2026-06-16) — macOS combo-key editing in the boxed prompt, a fresh-start screen clear at launch, a proportional welcome banner, height-aware relayout — and `launch.ts` split into focused submodules.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -158,11 +158,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.11]** (2026-06-16) — Larger reasoning budgets, and terminal capability-response sequences kept out of the prompt.
+- **[0.6.10]** (2026-06-16) — OKF memory-format foundation and a hardened bashTool subprocess drain.
 - **[0.6.9]** (2026-06-16) — Live streaming blocks size to their content and the viewport instead of a fixed rectangle.
 - **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 - **[0.6.7]** (2026-06-16) — Mouse-report input corruption fixed under `jeo --tmux`, and a full-width TUI at one consistent width.
-- **[0.6.6]** (2026-06-16) — Vertical caret movement between input-box rows, a centered welcome banner, and a leaner `parseFlags`.
-- **[0.6.5]** (2026-06-16) — macOS combo-key editing in the boxed prompt, a fresh-start screen clear at launch, a proportional welcome banner, height-aware relayout — and `launch.ts` split into focused submodules.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -158,11 +158,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.11]** (2026-06-16) — Larger reasoning budgets, and terminal capability-response sequences kept out of the prompt.
+- **[0.6.10]** (2026-06-16) — OKF memory-format foundation and a hardened bashTool subprocess drain.
 - **[0.6.9]** (2026-06-16) — Live streaming blocks size to their content and the viewport instead of a fixed rectangle.
 - **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 - **[0.6.7]** (2026-06-16) — Mouse-report input corruption fixed under `jeo --tmux`, and a full-width TUI at one consistent width.
-- **[0.6.6]** (2026-06-16) — Vertical caret movement between input-box rows, a centered welcome banner, and a leaner `parseFlags`.
-- **[0.6.5]** (2026-06-16) — macOS combo-key editing in the boxed prompt, a fresh-start screen clear at launch, a proportional welcome banner, height-aware relayout — and `launch.ts` split into focused submodules.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -158,11 +158,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.11]** (2026-06-16) — Larger reasoning budgets, and terminal capability-response sequences kept out of the prompt.
+- **[0.6.10]** (2026-06-16) — OKF memory-format foundation and a hardened bashTool subprocess drain.
 - **[0.6.9]** (2026-06-16) — Live streaming blocks size to their content and the viewport instead of a fixed rectangle.
 - **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 - **[0.6.7]** (2026-06-16) — Mouse-report input corruption fixed under `jeo --tmux`, and a full-width TUI at one consistent width.
-- **[0.6.6]** (2026-06-16) — Vertical caret movement between input-box rows, a centered welcome banner, and a leaner `parseFlags`.
-- **[0.6.5]** (2026-06-16) — macOS combo-key editing in the boxed prompt, a fresh-start screen clear at launch, a proportional welcome banner, height-aware relayout — and `launch.ts` split into focused submodules.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/memory-okf.ts

@@ -0,0 +1,275 @@
+/**
+ * OKF (Open Knowledge Format) v0.1 foundation for jeo memory — Sprint 01.
+ *
+ * Pure schema/format layer: YAML-frontmatter parse/serialize (extension keys
+ * round-trip preserved), concept-ID computation, and a tolerant v0.1
+ * conformance validator. This module deliberately does NOT touch the existing
+ * `memory.ts` distill/inject pipeline (Sprints 02–05 build on this contract).
+ *
+ * Design contract: docs/okf_mem/sprint-01-format-foundation/index.md
+ * Spec digest:     docs/okf_mem/concepts/okf-spec-digest.md
+ *
+ * Why a bespoke YAML subset (not a dep): OKF frontmatter is intentionally tiny
+ * — flat `key: value` pairs with scalars and inline `[a, b]` lists. A focused
+ * parser keeps jeo's zero-native-dependency promise and gives us exact
+ * round-trip control over extension keys (e.g. `confidence`, `last_verified`).
+ */
+
+/** jeo's agreed `type` vocabulary. OKF requires no central registry, but our
+ *  producers/consumers share these values so injection can filter/prioritize.
+ *  Unknown types are TOLERATED by the validator (lenient consumption). */
+export const JEO_TYPES = [
+  "RepoFact",
+  "Command",
+  "Gotcha",
+  "UserPreference",
+  "Reference",
+] as const;
+export type JeoType = (typeof JEO_TYPES)[number];
+
+/** Reserved OKF filenames — never concept documents. */
+export const RESERVED_FILES = ["index.md", "log.md"] as const;
+
+/** A parsed frontmatter value: scalar or inline list of strings. */
+export type FrontmatterValue = string | number | boolean | string[];
+/** Ordered frontmatter map (JS string-key insertion order is preserved). */
+export type Frontmatter = Record<string, FrontmatterValue>;
+
+export interface ParsedConcept {
+  /** Frontmatter map, key order preserved. Empty when no frontmatter block. */
+  frontmatter: Frontmatter;
+  /** Markdown body after the closing `---` (leading newline trimmed). */
+  body: string;
+  /** True when a `---`-delimited frontmatter block was found and parsed. */
+  hasFrontmatter: boolean;
+}
+
+// ── Concept identity ────────────────────────────────────────────────────────
+
+/** Concept ID = bundle-relative path with `.md` stripped and separators
+ *  normalized to `/` (OKF rule: `commands/bun-test.md` → `commands/bun-test`). */
+export function conceptId(bundleRelativePath: string): string {
+  const norm = bundleRelativePath.replace(/\\/g, "/").replace(/^\.?\/+/, "");
+  return norm.replace(/\.md$/i, "");
+}
+
+/** Basename of a bundle-relative path (handles both separators). */
+function basename(p: string): string {
+  const norm = p.replace(/\\/g, "/");
+  const i = norm.lastIndexOf("/");
+  return i === -1 ? norm : norm.slice(i + 1);
+}
+
+/** True when a path's filename is an OKF reserved file (`index.md`/`log.md`). */
+export function isReservedFile(bundleRelativePath: string): boolean {
+  const base = basename(bundleRelativePath).toLowerCase();
+  return (RESERVED_FILES as readonly string[]).includes(base);
+}
+
+/** kebab-case slug for a concept filename: lowercased, non-alphanumerics → `-`,
+ *  collapsed and trimmed. Empty input yields `untitled`. */
+export function slugify(title: string): string {
+  const slug = title
+    .normalize("NFKD")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-");
+  return slug || "untitled";
+}
+
+// ── Frontmatter parse / serialize (round-trip preserving) ────────────────────
+
+function unquote(raw: string): string {
+  const s = raw.trim();
+  if (s.length >= 2 && ((s[0] === '"' && s[s.length - 1] === '"') || (s[0] === "'" && s[s.length - 1] === "'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+/** Parse a single scalar token into the narrowest faithful JS value. */
+function parseScalar(raw: string): FrontmatterValue {
+  const s = raw.trim();
+  if (s.length === 0) return "";
+  // Quoted strings are ALWAYS strings (preserve e.g. okf_version "0.1").
+  if ((s[0] === '"' && s[s.length - 1] === '"') || (s[0] === "'" && s[s.length - 1] === "'")) {
+    return unquote(s);
+  }
+  if (s === "true") return true;
+  if (s === "false") return false;
+  // Integer or float (no leading zeros like 0.1 issue — that's a valid float).
+  if (/^-?\d+(\.\d+)?$/.test(s)) {
+    const n = Number(s);
+    if (Number.isFinite(n)) return n;
+  }
+  return s;
+}
+
+/** Parse one frontmatter value, supporting inline `[a, b, c]` lists. */
+function parseValue(raw: string): FrontmatterValue {
+  const s = raw.trim();
+  if (s.startsWith("[") && s.endsWith("]")) {
+    const inner = s.slice(1, -1).trim();
+    if (inner === "") return [];
+    return inner.split(",").map(item => unquote(item.trim()));
+  }
+  return parseScalar(s);
+}
+
+/**
+ * Parse an OKF concept document into `{ frontmatter, body, hasFrontmatter }`.
+ * Tolerant: a document without a `---` block yields an empty frontmatter and
+ * the whole text as body (conformance is judged separately by the validator).
+ */
+export function parseConcept(text: string): ParsedConcept {
+  const lines = text.split("\n");
+  // A frontmatter block must START at line 0 with a bare `---`.
+  if (lines[0]?.trim() !== "---") {
+    return { frontmatter: {}, body: text, hasFrontmatter: false };
+  }
+  let end = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      end = i;
+      break;
+    }
+  }
+  if (end === -1) {
+    // Opening `---` with no close: not a valid block — treat as bodyless content.
+    return { frontmatter: {}, body: text, hasFrontmatter: false };
+  }
+  const frontmatter: Frontmatter = {};
+  for (let i = 1; i < end; i++) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const colon = line.indexOf(":");
+    if (colon === -1) continue; // skip malformed lines tolerantly
+    const key = line.slice(0, colon).trim();
+    if (!key) continue;
+    frontmatter[key] = parseValue(line.slice(colon + 1));
+  }
+  const body = lines.slice(end + 1).join("\n").replace(/^\n+/, "");
+  return { frontmatter, body, hasFrontmatter: true };
+}
+
+/** True when a string scalar must be quoted to round-trip as a string
+ *  (i.e. would otherwise parse back as a number/bool, or has fragile edges). */
+function needsQuoting(s: string): boolean {
+  if (s === "") return true;
+  if (s === "true" || s === "false") return true;
+  if (/^-?\d+(\.\d+)?$/.test(s)) return true;
+  if (s !== s.trim()) return true; // leading/trailing whitespace
+  if (/[:#\[\]{}",']/.test(s)) return true;
+  return false;
+}
+
+function serializeScalar(v: string | number | boolean): string {
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  return needsQuoting(v) ? `"${v.replace(/"/g, '\\"')}"` : v;
+}
+
+function serializeValue(v: FrontmatterValue): string {
+  if (Array.isArray(v)) {
+    return `[${v.map(item => (needsQuoting(item) ? `"${item.replace(/"/g, '\\"')}"` : item)).join(", ")}]`;
+  }
+  return serializeScalar(v);
+}
+
+/**
+ * Serialize frontmatter + body back into an OKF concept document.
+ * Key order is preserved; `serialize(parse(x))` is idempotent for documents
+ * this module produced. Body gets exactly one blank line after the block.
+ */
+export function serializeConcept(frontmatter: Frontmatter, body: string): string {
+  const fmLines = Object.entries(frontmatter).map(([k, v]) => `${k}: ${serializeValue(v)}`);
+  const block = ["---", ...fmLines, "---"].join("\n");
+  const trimmedBody = body.replace(/^\n+/, "");
+  return trimmedBody ? `${block}\n\n${trimmedBody}` : `${block}\n`;
+}
+
+// ── OKF v0.1 conformance ─────────────────────────────────────────────────────
+
+export interface BundleFile {
+  /** Bundle-relative path, e.g. `commands/bun-test.md`. */
+  path: string;
+  /** Raw file contents. */
+  content: string;
+}
+
+export interface ConformanceIssue {
+  path: string;
+  /** `error` fails conformance; `warning` is a lenient-guide hint only. */
+  level: "error" | "warning";
+  message: string;
+}
+
+export interface ConformanceReport {
+  conformant: boolean;
+  issues: ConformanceIssue[];
+}
+
+const ISO_DATE_HEADING = /^#{1,6}\s+(\d{4}-\d{2}-\d{2})/;
+
+/**
+ * Validate one file against OKF v0.1 + jeo conventions.
+ *
+ * Errors (reject conformance):
+ *  - non-reserved `.md` missing a parseable frontmatter block.
+ *  - frontmatter with missing or empty `type`.
+ *  - `log.md` date heading that is not ISO 8601 `YYYY-MM-DD`.
+ *
+ * Warnings (lenient guides — never reject):
+ *  - unknown `type` value.
+ *  - missing recommended fields (`title`, `description`).
+ */
+export function validateFile(file: BundleFile): ConformanceIssue[] {
+  const issues: ConformanceIssue[] = [];
+  const base = basename(file.path).toLowerCase();
+
+  if (base === "log.md") {
+    // Reserved: if present, date headings must be ISO 8601.
+    for (const line of file.content.split("\n")) {
+      const m = line.match(/^#{1,6}\s+\S+/);
+      if (!m) continue;
+      // Only enforce on headings that look like dates; tolerate prose headings.
+      if (/^#{1,6}\s+\d/.test(line) && !ISO_DATE_HEADING.test(line)) {
+        issues.push({ path: file.path, level: "error", message: `log.md date heading not ISO 8601 (YYYY-MM-DD): "${line.trim()}"` });
+      }
+    }
+    return issues;
+  }
+
+  if (base === "index.md") {
+    // Reserved: index.md needs no frontmatter; nothing to reject.
+    return issues;
+  }
+
+  // Concept document.
+  const parsed = parseConcept(file.content);
+  if (!parsed.hasFrontmatter) {
+    issues.push({ path: file.path, level: "error", message: "concept document missing YAML frontmatter block" });
+    return issues;
+  }
+  const type = parsed.frontmatter.type;
+  if (typeof type !== "string" || type.trim() === "") {
+    issues.push({ path: file.path, level: "error", message: "frontmatter `type` is required and must be non-empty" });
+  } else if (!(JEO_TYPES as readonly string[]).includes(type)) {
+    issues.push({ path: file.path, level: "warning", message: `unknown type "${type}" (tolerated; not in jeo vocabulary)` });
+  }
+  if (!parsed.frontmatter.title) {
+    issues.push({ path: file.path, level: "warning", message: "missing recommended field `title`" });
+  }
+  if (!parsed.frontmatter.description) {
+    issues.push({ path: file.path, level: "warning", message: "missing recommended field `description`" });
+  }
+  return issues;
+}
+
+/** Validate a whole bundle. Conformant iff there are zero `error`-level issues
+ *  (warnings never reject — OKF's tolerant consumption model). */
+export function validateBundle(files: BundleFile[]): ConformanceReport {
+  const issues = files.flatMap(validateFile);
+  return { conformant: !issues.some(i => i.level === "error"), issues };
+}

package/src/agent/tools.ts

@@ -587,6 +587,31 @@ export async function editTool(
   }
 }
 
+/** Drain a readable byte stream to a string, cancel-safe. We read via an explicit
+ *  reader (NOT `new Response(stream).text()`, whose read is uncancellable) so a caller
+ *  can cancel() to force the in-flight read to settle — essential when a SIGKILLed
+ *  process leaves a backgrounded grandchild holding the pipe's write end open, so it
+ *  never hits EOF (proven by scripts/subproc-probe.ts ABANDON mode). An optional
+ *  (caller-throttled) onChunk drives the live output view. */
+async function drainPipe(
+  r: ReadableStreamDefaultReader<Uint8Array>,
+  onChunk?: (partial: string) => void,
+): Promise<string> {
+  const dec = new TextDecoder();
+  let out = "";
+  try {
+    for (;;) {
+      const { done, value } = await r.read();
+      if (done) break;
+      out += dec.decode(value, { stream: true });
+      onChunk?.(out);
+    }
+    out += dec.decode();
+    onChunk?.(out);
+  } catch { /* cancelled reader surfaces here; return what we have */ }
+  return out;
+}
+
 export async function bashTool(
   command: string,
   cwd: string = process.cwd(),
@@ -612,6 +637,10 @@ export async function bashTool(
     // Run the command using Bun's native spawn
     const proc = Bun.spawn(["bash", "-c", command], {
       cwd: runCwd,
+      // Detach stdin (no inherited TTY): a command that reads stdin (`cat`, `read`,
+      // a REPL, an interactive prompt) then gets immediate EOF and exits instead of
+      // blocking the whole turn forever waiting for input that never comes.
+      stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
       // Inherit the parent env; merge caller-supplied (sanitized) vars on top.
@@ -621,90 +650,93 @@ export async function bashTool(
     let timedOut = false;
     let aborted = false;
     const TIMEOUT_MS = timeoutMs;
+    // Grace after the SHELL exits before we force the pipe readers closed: a finished
+    // command's buffered tail flushes far inside this window; only a backgrounded
+    // grandchild that inherited the pipe (`cmd &`, daemons, `nohup`) keeps it open
+    // past it — and that one must not stall the turn.
+    const PIPE_LINGER_MS = 500;
     let killTimer: ReturnType<typeof setTimeout> | undefined;
+    let stdoutReader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+    let stderrReader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+    // Force EOF on both pipe readers. The drain loops `await r.read()`, which NEVER
+    // returns `done` while ANY process holds the write end open — a SIGKILLed shell
+    // can leave a backgrounded grandchild clutching the FD, so killing the shell is
+    // not enough (proven by scripts/subproc-probe.ts ABANDON mode). cancel() resolves
+    // the in-flight read immediately, unwinding the drains so the call returns instead
+    // of hanging forever. Cheap to call repeatedly; harmless before the readers exist.
+    const cancelReaders = () => {
+      try { stdoutReader?.cancel(); } catch {}
+      try { stderrReader?.cancel(); } catch {}
+    };
     const timer = setTimeout(() => {
       timedOut = true;
-      // Graceful first (SIGTERM), then force-kill (SIGKILL) if it ignores it.
+      // Graceful first (SIGTERM), then force-kill (SIGKILL) if it ignores it. At the
+      // SIGKILL step ALSO cut the readers: the old code killed the shell but never
+      // cancelled the readers, so an orphan-held pipe outlived the deadline and the
+      // turn hung forever (the reported freeze).
       try { proc.kill(); } catch {}
-      killTimer = setTimeout(() => { try { proc.kill(9); } catch {} }, 3_000);
+      killTimer = setTimeout(() => { try { proc.kill(9); } catch {} cancelReaders(); }, 3_000);
     }, TIMEOUT_MS);
     // Abort wiring: if the turn is cancelled, SIGKILL the child immediately AND cancel
-    // both pipe readers so the drain loops below unwind at once. We own the readers
-    // explicitly (rather than `for await` / `new Response`, whose hidden iterator locks
-    // we cannot cancel): cancel() resolves the in-flight read({ done:true }) immediately,
-    // unwinding each loop even when the killed child's pipe is slow to hit EOF. Cancelling
-    // stderr also prevents a hang — after kill(9) its pipe never sees EOF, so awaiting an
-    // uncancellable Response would block forever. Without all this the child is orphaned,
-    // holding two pipe FDs (proven by scripts/subproc-probe.ts ABANDON mode: +1 fd & +1
-    // child per call).
-    let stdoutReader: ReadableStreamDefaultReader<Uint8Array> | undefined;
-    let stderrReader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+    // both pipe readers so the drain loops unwind at once.
     const onAbort = () => {
       aborted = true;
       try { proc.kill(9); } catch {}
-      try { stdoutReader?.cancel(); } catch {}
-      try { stderrReader?.cancel(); } catch {}
+      cancelReaders();
     };
     if (signal) {
       if (signal.aborted) onAbort();
       else signal.addEventListener("abort", onAbort, { once: true });
     }
 
-    // Drain a pipe to a string, cancel-safe. An optional onChunk sink receives the
-    // running output (throttled by the caller) to drive the live DIMMED bash view.
-    const drainAll = async (
-      r: ReadableStreamDefaultReader<Uint8Array>,
-      onChunk?: (partial: string) => void,
-    ): Promise<string> => {
-      const dec = new TextDecoder();
-      let out = "";
-      try {
-        for (;;) {
-          if (aborted) break;
-          const { done, value } = await r.read();
-          if (done) break;
-          out += dec.decode(value, { stream: true });
-          onChunk?.(out);
-        }
-        out += dec.decode();
-        onChunk?.(out);
-      } catch { /* cancelled reader surfaces here; return what we have */ }
-      return out;
-    };
+    // Start BOTH drains concurrently so neither pipe can fill its 64KB buffer and
+    // deadlock the child (a child blocks on write() once an unread pipe fills up).
+    // cancelReaders() (abort/timeout) unwinds an in-flight read, so no aborted-flag
+    // poll is needed inside the shared drainPipe.
+    stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader() as ReadableStreamDefaultReader<Uint8Array>;
     stderrReader = (proc.stderr as ReadableStream<Uint8Array>).getReader() as ReadableStreamDefaultReader<Uint8Array>;
-    const stderrPromise = drainAll(stderrReader).catch(() => "");
-    let stdout = "";
+    let lastEmit = 0;
+    const stdoutPromise = drainPipe(
+      stdoutReader,
+      onProgress
+        ? (partial) => {
+            // Throttle the live sink to ~80ms.
+            const now = Date.now();
+            if (now - lastEmit >= 80) { lastEmit = now; onProgress(partial); }
+          }
+        : undefined,
+    ).catch(() => "");
+    const stderrPromise = drainPipe(stderrReader).catch(() => "");
+
     try {
-      if (onProgress) {
-        // Throttle the live sink to ~80ms; drainAll owns the cancel-safe read loop.
-        let lastEmit = 0;
-        stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader() as ReadableStreamDefaultReader<Uint8Array>;
-        stdout = await drainAll(stdoutReader, (partial) => {
-          const now = Date.now();
-          if (now - lastEmit >= 80) { lastEmit = now; onProgress(partial); }
-        });
-        onProgress(stdout);
-      } else if (!aborted) {
-        stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader() as ReadableStreamDefaultReader<Uint8Array>;
-        stdout = await drainAll(stdoutReader);
-      }
+      // Wait for the SHELL to exit. Bounded: the timeout path SIGTERMs then SIGKILLs,
+      // so even a foreground command that blocks (e.g. on /dev/tty) cannot exceed
+      // TIMEOUT_MS (+3s grace).
       if (!aborted) await proc.exited;
-    } catch (streamErr) {
-      // A cancelled stdout reader (from onAbort) surfaces here; swallow it so we can
-      // return a clean aborted result rather than a stream-internal error.
-      if (!aborted) throw streamErr;
+      // The shell exited, but a backgrounded grandchild can keep the pipes open
+      // indefinitely; without forcing them closed the drains hang the whole turn.
+      // Give a finished command's tail a brief grace to flush, then cut the readers
+      // in the finally below — so a daemon-spawning command returns ~PIPE_LINGER_MS
+      // after the shell exits instead of stalling until the timeout.
+      if (!aborted && !timedOut) {
+        await Promise.race([
+          Promise.all([stdoutPromise, stderrPromise]),
+          new Promise<void>(resolve => setTimeout(resolve, PIPE_LINGER_MS)),
+        ]);
+      }
     } finally {
       clearTimeout(timer);
       if (killTimer) clearTimeout(killTimer);
       if (signal) signal.removeEventListener("abort", onAbort);
-      // Belt-and-suspenders: if we are leaving for ANY reason (normal exit, stdout-loop
-      // throw, abort) and the child is somehow still alive, reap it so no orphaned
-      // process or pipe FD survives the call.
+      // Reap a still-alive child (normal exit, abort, or timeout) so no orphaned
+      // process survives, then force any pipe still held open (backgrounded
+      // grandchild) closed so the awaits below cannot hang.
       if (proc.exitCode === null && proc.signalCode === null) { try { proc.kill(9); } catch {} }
-      // Always settle the stderr reader to release its pipe FD.
-      await stderrPromise;
+      cancelReaders();
     }
+    const stdout = await stdoutPromise;
     const stderr = await stderrPromise;
+    if (onProgress) onProgress(stdout);
 
     let output = [stdout, stderr].filter(Boolean).join("\n");
     const MAX_OUTPUT = 100_000;
@@ -740,22 +772,41 @@ async function spawnTextWithTimeout(
   cwd: string,
   timeoutMs = 60_000,
 ): Promise<{ stdout: string; stderr: string; exitCode: number | null; timedOut: boolean }> {
-  const proc = Bun.spawn(cmd, { cwd, stdout: "pipe", stderr: "pipe" });
+  // stdin detached so a command that reads stdin gets EOF instead of blocking.
+  const proc = Bun.spawn(cmd, { cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
   let timedOut = false;
   let killTimer: ReturnType<typeof setTimeout> | undefined;
+  const stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader() as ReadableStreamDefaultReader<Uint8Array>;
+  const stderrReader = (proc.stderr as ReadableStream<Uint8Array>).getReader() as ReadableStreamDefaultReader<Uint8Array>;
+  const cancelReaders = () => {
+    try { stdoutReader.cancel(); } catch {}
+    try { stderrReader.cancel(); } catch {}
+  };
+  const stdoutPromise = drainPipe(stdoutReader);
+  const stderrPromise = drainPipe(stderrReader);
   const timer = setTimeout(() => {
     timedOut = true;
     try { proc.kill(); } catch {}
-    killTimer = setTimeout(() => { try { proc.kill(9); } catch {} }, 3_000);
+    killTimer = setTimeout(() => { try { proc.kill(9); } catch {} cancelReaders(); }, 3_000);
   }, timeoutMs);
   try {
     await proc.exited;
+    // Brief grace for a finished command's tail to flush, then cut any pipe still held
+    // open by a backgrounded grandchild so the awaits below cannot hang the turn.
+    if (!timedOut) {
+      await Promise.race([
+        Promise.all([stdoutPromise, stderrPromise]),
+        new Promise<void>(resolve => setTimeout(resolve, 500)),
+      ]);
+    }
   } finally {
     clearTimeout(timer);
     if (killTimer) clearTimeout(killTimer);
+    if (proc.exitCode === null && proc.signalCode === null) { try { proc.kill(9); } catch {} }
+    cancelReaders();
   }
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
+  const stdout = await stdoutPromise;
+  const stderr = await stderrPromise;
   return { stdout, stderr, exitCode: proc.exitCode, timedOut };
 }
 

package/src/ai/model-manager.ts

@@ -68,11 +68,11 @@ export function providerModelFor(model: string): string {
 
 /** Map the configured thinking level to a default max-token budget. */
 export function thinkingMaxTokens(level?: "minimal" | "low" | "medium" | "high" | "xhigh"): number {
-  if (level === "minimal") return 1000;
-  if (level === "low") return 2000;
-  if (level === "high") return 8000;
-  if (level === "xhigh") return 16000;
-  return 4000;
+  if (level === "minimal") return 4000;
+  if (level === "low") return 8000;
+  if (level === "high") return 24000;
+  if (level === "xhigh") return 31999;
+  return 16000;
 }
 
 /** Map the thinking level to an OpenAI reasoning-effort tier. `minimal` maps to `low`

package/src/ai/providers/anthropic.ts

@@ -77,8 +77,8 @@ function anthropicSystemBlocks(
 function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"], maxTokens: number): number | undefined {
   let budget: number;
   switch (effort) {
-    case "medium": budget = 4096; break;
-    case "high": budget = 10000; break;
+    case "medium": budget = 10000; break;
+    case "high": budget = 24000; break;
     default: return undefined;
   }
   return Math.min(budget, Math.max(1024, maxTokens - 1024));

package/src/ai/providers/gemini.ts

@@ -17,9 +17,9 @@ export function geminiThinkingBudget(model: string, effort?: CallOptions["reason
   const floor = m.includes("pro") ? 128 : 0; // pro-class cannot fully disable thinking
   let budget: number;
   switch (effort) {
-    case "low": budget = 1024; break;
-    case "medium": budget = 4096; break;
-    case "high": budget = 8192; break;
+    case "low": budget = 4000; break;
+    case "medium": budget = 10000; break;
+    case "high": budget = 24000; break;
     case "minimal":
     default: budget = floor;
   }

package/src/commands/launch/input.ts

@@ -104,16 +104,45 @@ export function matchMouseReport(data: string, i: number): number {
   return 0;
 }
 
-/** Remove every terminal MOUSE-REPORT sequence from a plain (non-paste) input segment.
- *  The live-turn drain (`queuePromptInputChunk`) reads RAW stdin, so a wheel/click report
- *  buffered during a running turn would otherwise have its printable remnant (`[M`, SGR
- *  digits) fed into the next prompt — the same "값 입력" corruption the keyFilter blocks
- *  on the idle path. */
+/** Byte length of a terminal CAPABILITY-RESPONSE sequence beginning at `data[i]`, else 0.
+ *  These are REPLIES the terminal sends to capability queries — Primary/Secondary Device
+ *  Attributes (`ESC[?…c` / `ESC[>…c` / `ESC[=…c`), XTVERSION and other DCS replies
+ *  (`ESC P…ST`), and OSC replies like a color query (`ESC]11;rgb:…ST`). jeo never sends
+ *  these queries, but tmux probes the OUTER terminal on attach, and the outer terminal's
+ *  answers can land on stdin (the leaked `62;4;9;22c…>|xterm.js(…)` garbage in the prompt).
+ *  They are never typed input, so the whole sequence is swallowed. A reply split across
+ *  chunks (no terminator yet) consumes the tail rather than leaking it. */
+export function matchTerminalReport(data: string, i: number): number {
+  // CSI device-attribute / mode replies: ESC [ (? | > | =) … <final letter>.
+  if (data.startsWith("\u001b[?", i) || data.startsWith("\u001b[>", i) || data.startsWith("\u001b[=", i)) {
+    let j = i + 3;
+    while (j < data.length && !/[A-Za-z]/.test(data[j]!)) j++; // params: digits ; : $ → final letter
+    return (j < data.length ? j + 1 : data.length) - i;
+  }
+  // DCS (ESC P … ) or OSC (ESC ] … ) reply — terminated by ST (ESC \) or BEL.
+  if (data.startsWith("\u001bP", i) || data.startsWith("\u001b]", i)) {
+    let j = i + 2;
+    while (j < data.length) {
+      if (data[j] === "\u0007") return j + 1 - i;                       // BEL
+      if (data[j] === "\u001b" && data[j + 1] === "\\") return j + 2 - i; // ST
+      j++;
+    }
+    return data.length - i; // unterminated tail (split chunk) — consume the rest
+  }
+  return 0;
+}
+
+/** Remove every terminal MOUSE-REPORT and CAPABILITY-RESPONSE sequence from a plain
+ *  (non-paste) input segment. The live-turn drain (`queuePromptInputChunk`) reads RAW
+ *  stdin, so a wheel/click report or a tmux-probed device-attribute reply buffered during
+ *  a running turn would otherwise have its printable remnant (`[M`, SGR digits, or
+ *  `62;4;9;22c…`) fed into the next prompt — the same "값 입력" corruption the keyFilter
+ *  blocks on the idle path. */
 export function stripMouseReports(s: string): string {
   let out = "";
   let i = 0;
   while (i < s.length) {
-    const m = matchMouseReport(s, i);
+    const m = matchMouseReport(s, i) || matchTerminalReport(s, i);
     if (m > 0) { i += m; continue; }
     out += s[i];
     i += 1;

package/src/commands/launch.ts

@@ -127,6 +127,7 @@ import {
   CURSOR_COMBO_REWRITES,
   matchCursorCombo,
   matchMouseReport,
+  matchTerminalReport,
   stripMouseReports,
   rewriteCursorCombos,
   queuePromptInputChunk,
@@ -175,6 +176,7 @@ export {
   CURSOR_COMBO_REWRITES,
   matchCursorCombo,
   matchMouseReport,
+  matchTerminalReport,
   stripMouseReports,
   rewriteCursorCombos,
   queuePromptInputChunk,
@@ -1268,6 +1270,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         // 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; }