jeo-code 0.6.13 → 0.6.15

package/CHANGELOG.md

@@ -6,6 +6,26 @@ 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.15] - 2026-06-17
+_Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt._
+
+### Added
+- **Concept-level memory search & budget-aware injection (OKF Sprint 03).** `memoryPromptSection(cwd, query?)` now loads the OKF concept bundle and selects what to inject by priority — high-confidence core facts first, then query relevance (the one-shot task text is wired in as the query), then stable order — dropping whole lowest-priority concepts to fit `MEMORY_INJECT_MAX_CHARS` (3000) instead of truncating mid-string. New exported helpers `loadConcepts` / `scoreConcept` / `searchConcepts`. The `index.md` rebuild now emits progressive-disclosure `- [title](/relpath) — description` rows. Injection-hardening (DATA framing, fence neutralization) and the `MEMORY.md` fallback are retained.
+
+### Changed
+- **End-of-turn Todos receipt tells the truth.** A successful `finish` shows the Todos checklist fully complete so it agrees with the `done` badge (the model's last `todo` call often forgets to flip the final items, and the once-per-turn done gate can't force it); cancel/error finishes pass `ok:false` so any unfinished items stay honestly shown. The live frame is unchanged, so in-progress work still renders truthfully.
+
+
+## [0.6.14] - 2026-06-16
+_Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn._
+
+### Fixed
+- **Malformed `concepts` arrays no longer discard the whole distillation batch.** A text-only / small model can emit stray non-object array elements (`null`, strings, numbers) or non-string `type`/`title` fields. Each element is now validated and its persistence wrapped in a per-concept `try`/`catch`, so one bad concept is skipped instead of throwing out of the loop into the outer catch — which previously silently dropped every valid learning distilled in that run. Junk frontmatter fields (`description`/`tags`/`body`/`confidence`/`links`) are coerced to safe defaults so the written file stays OKF-conformant.
+- **Per-chunk stream-idle stalls now retry instead of failing the turn.** A `stream idle for <ms>ms (no chunk)` stall (provider load or long time-to-first-token) is treated as transient and retried like a timeout, while the hard overall wall-clock cap (`stream exceeded the overall deadline`) still fails fast. The idle-stall error message now explains the cause and remediation.
+
+### Added
+- **`JEO_STREAM_IDLE_MS` opt-in override.** Reasoning workloads whose "thinking" phase can legitimately emit no visible token for longer than the 120s default can raise the per-chunk idle threshold without a code change.
+
 ## [0.6.13] - 2026-06-16
 _`team` engine: concrete uncommitted-work reporting and stricter empty-run handling._
 

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.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
+- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 - **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 - **[0.6.12]** (2026-06-16) — OKF-backed memory distillation — session learnings become structured concept files.
 - **[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.
 
 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.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
+- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 - **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 - **[0.6.12]** (2026-06-16) — OKF-backed memory distillation — session learnings become structured concept files.
 - **[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.
 
 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.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
+- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 - **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 - **[0.6.12]** (2026-06-16) — OKF-backed memory distillation — session learnings become structured concept files.
 - **[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.
 
 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.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
+- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 - **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 - **[0.6.12]** (2026-06-16) — OKF-backed memory distillation — session learnings become structured concept files.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/memory.ts

@@ -3,10 +3,12 @@
  * (plan/gjc-inheritance.md B6; gjc memories/ 2-phase consolidation 참조).
  *
  * Session end distills durable learnings (repo facts, commands that work,
- * gotchas, user preferences) into `.jeo/memory/MEMORY.md` with ONE model call,
- * merging into the existing doc. The next session injects the doc back into
- * the system prompt under a hard char cap — local-first (nullclaw/zeroclaw),
- * no remote backend, disable with JEO_NO_MEMORY=1.
+ * gotchas, user preferences) into the OKF concept bundle under `.jeo/memory/`
+ * (type-partitioned `facts/`, `commands/`, … dirs) with ONE model call, upserting
+ * each concept; a legacy single `MEMORY.md` doc is the fallback when the model
+ * returns plain text. The next session reads the bundle back (bundle-first, then
+ * MEMORY.md) and injects it into the system prompt under a hard char cap —
+ * local-first (nullclaw/zeroclaw), no remote backend, disable with JEO_NO_MEMORY=1.
  */
 import * as fs from "node:fs/promises";
 import { spawn as nodeSpawn } from "node:child_process";
@@ -47,16 +49,181 @@ export async function loadMemory(cwd: string): Promise<string> {
   }
 }
 
+/** Render a single index.md-style section: a `## header` followed by one bullet
+ *  per concept (`**title**: description`), with the concept body indented beneath. */
+function renderConceptSection(header: string, list: { title: string; description: string; body: string }[]): string {
+  const lines = [`## ${header}`];
+  for (const c of list) {
+    lines.push(`- **${c.title}**${c.description ? `: ${c.description}` : ""}`);
+    if (c.body) {
+      for (const bodyLine of c.body.split("\n")) lines.push(`  ${bodyLine}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/** A loaded OKF concept: frontmatter fields + body + bundle-relative path. */
+export interface Concept {
+  type: string;
+  title: string;
+  description: string;
+  body: string;
+  tags: string[];
+  /** high | medium | low — distiller defaults to "high"; drives core selection. */
+  confidence: string;
+  /** Bundle-relative path, e.g. `commands/bun-test.md`. */
+  relPath: string;
+}
+
+/** Read every concept document in the bundle into structured `Concept`s. Reserved
+ *  files (index.md/log.md) and raw/ payloads are skipped; unparseable or
+ *  frontmatter-less files are ignored (lenient consumption). */
+export async function loadConcepts(cwd: string): Promise<Concept[]> {
+  return loadConceptsFromBundle(path.join(cwd, ".jeo", "memory"));
+}
+
+async function loadConceptsFromBundle(bundleDir: string): Promise<Concept[]> {
+  const files = await findMarkdownFiles(bundleDir);
+  const concepts: Concept[] = [];
+  for (const file of files) {
+    const relPath = path.relative(bundleDir, file).replace(/\\/g, "/");
+    if (isReservedFile(relPath)) continue;
+    let parsed;
+    try {
+      parsed = parseConcept(await fs.readFile(file, "utf-8"));
+    } catch {
+      continue;
+    }
+    if (!parsed.hasFrontmatter) continue;
+    const fm = parsed.frontmatter;
+    concepts.push({
+      type: (fm.type as string) || "RepoFact",
+      title: (fm.title as string) || path.basename(file, ".md"),
+      description: (fm.description as string) || "",
+      body: parsed.body.trim(),
+      tags: Array.isArray(fm.tags) ? fm.tags.filter((t): t is string => typeof t === "string") : [],
+      confidence: typeof fm.confidence === "string" ? fm.confidence : "high",
+      relPath,
+    });
+  }
+  return concepts;
+}
+
+/** Tokenize a free-text query into distinct lowercased keywords (len ≥ 3). */
+function tokenize(query?: string): string[] {
+  if (!query) return [];
+  return Array.from(new Set((query.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter(t => t.length >= 3)));
+}
+
+/** Relevance score of a concept against query tokens. Field weights mirror
+ *  llm-wiki's retrieval bias (title ≫ tags ≫ type/description ≫ body). 0 = no hit. */
+export function scoreConcept(concept: Concept, tokens: string[]): number {
+  if (tokens.length === 0) return 0;
+  const title = concept.title.toLowerCase();
+  const desc = concept.description.toLowerCase();
+  const body = concept.body.toLowerCase();
+  const type = concept.type.toLowerCase();
+  const tags = concept.tags.map(t => t.toLowerCase());
+  let score = 0;
+  for (const t of tokens) {
+    if (title.includes(t)) score += 5;
+    if (tags.some(tag => tag.includes(t))) score += 3;
+    if (type.includes(t)) score += 2;
+    if (desc.includes(t)) score += 2;
+    if (body.includes(t)) score += 1;
+  }
+  return score;
+}
+
+/** Search the bundle's concepts for a query, returning the relevant ones (score > 0)
+ *  highest-score first. A type/tags/title/body keyword match all contribute. */
+export function searchConcepts(concepts: Concept[], query: string): { concept: Concept; score: number }[] {
+  const tokens = tokenize(query);
+  return concepts
+    .map(concept => ({ concept, score: scoreConcept(concept, tokens) }))
+    .filter(r => r.score > 0)
+    .sort((a, b) => b.score - a.score);
+}
+
+/** Priority order for injection: high-confidence "core" concepts first, then by
+ *  query relevance (descending), preserving input order as a stable tiebreak. */
+function priorityOrder(concepts: Concept[], query?: string): Concept[] {
+  const tokens = tokenize(query);
+  return concepts
+    .map((concept, i) => ({ concept, i, core: concept.confidence === "high", score: scoreConcept(concept, tokens) }))
+    .sort((a, b) => {
+      if (a.core !== b.core) return a.core ? -1 : 1;
+      if (b.score !== a.score) return b.score - a.score;
+      return a.i - b.i;
+    })
+    .map(s => s.concept);
+}
+
+/** Group items by their `type` into ordered `{ header, list }` sections: TYPE_LAYOUT
+ *  order first, then any unknown types under their raw type name (lenient). The one
+ *  place that encodes the section ordering — shared by render and index. */
+function groupByTypeLayout<T extends { type: string }>(items: T[]): { header: string; list: T[] }[] {
+  const byType = new Map<string, T[]>();
+  for (const it of items) {
+    const list = byType.get(it.type) ?? [];
+    list.push(it);
+    byType.set(it.type, list);
+  }
+  const sections: { header: string; list: T[] }[] = [];
+  const rendered = new Set<string>();
+  for (const { type, header } of TYPE_LAYOUT) {
+    rendered.add(type);
+    const list = byType.get(type);
+    if (list && list.length > 0) sections.push({ header, list });
+  }
+  for (const [type, list] of byType) {
+    if (rendered.has(type) || list.length === 0) continue;
+    sections.push({ header: type, list });
+  }
+  return sections;
+}
+
+/** Render a set of concepts as a compact markdown block grouped by type in
+ *  TYPE_LAYOUT order, with any unknown types appended under their raw type name. */
+function renderConcepts(concepts: Concept[]): string {
+  return groupByTypeLayout(concepts)
+    .map(({ header, list }) => renderConceptSection(header, list))
+    .join("\n\n");
+}
+
+/** Greedily select concepts (in priority order) whose grouped render stays within
+ *  `budget` chars, dropping the lowest-priority concepts first. At least the
+ *  top-priority concept is always kept (the framing/backstop cap still applies). */
+function selectWithinBudget(concepts: Concept[], query: string | undefined, budget: number): Concept[] {
+  const ordered = priorityOrder(concepts, query);
+  const selected: Concept[] = [];
+  for (const c of ordered) {
+    if (renderConcepts([...selected, c]).length <= budget) selected.push(c);
+  }
+  if (selected.length === 0 && ordered.length > 0) selected.push(ordered[0]!);
+  return selected;
+}
+
 /** System-prompt block carrying prior-session learnings; "" when empty or disabled.
+ *  Selection (Sprint 03): always-included high-confidence core + concepts most
+ *  relevant to `query` (the current task), chosen whole within MEMORY_INJECT_MAX_CHARS
+ *  (lowest-priority dropped first) — never a mid-concept string truncation. Falls
+ *  back to the legacy single MEMORY.md doc when no concept bundle exists.
  *  The memory text is MODEL-DISTILLED from session transcripts (which include tool
  *  outputs — file contents, web results), so it is injection-hardened like subagent
  *  reports: tag-breakout sequences are neutralized and the block is framed as DATA. */
-export async function memoryPromptSection(cwd: string): Promise<string> {
+export async function memoryPromptSection(cwd: string, query?: string): Promise<string> {
   if (jeoEnv("NO_MEMORY") === "1") return "";
-  let memory = await loadMemory(cwd);
+  // Prefer the OKF concept bundle (budget-selected); fall back to legacy MEMORY.md.
+  const concepts = await loadConcepts(cwd);
+  let memory = concepts.length > 0
+    ? renderConcepts(selectWithinBudget(concepts, query, MEMORY_INJECT_MAX_CHARS))
+    : await loadMemory(cwd);
   if (!memory) return "";
+  // Backstop: legacy MEMORY.md is a single blob (not concept-selectable), and a
+  // pathological single concept can exceed the budget — hard-cap either way.
   if (memory.length > MEMORY_INJECT_MAX_CHARS) {
-    memory = memory.slice(0, MEMORY_INJECT_MAX_CHARS) + "\n…(memory truncated — full doc in .jeo/memory/MEMORY.md)";
+    memory = memory.slice(0, MEMORY_INJECT_MAX_CHARS) + "\n…(memory truncated — full doc in .jeo/memory/)";
   }
   // Neutralize the fence tags so distilled content can never close the block and
   // smuggle instruction-shaped text into the bare system prompt.
@@ -120,33 +287,20 @@ async function findMarkdownFiles(dir: string): Promise<string[]> {
 }
 
 async function rebuildIndex(bundleDir: string): Promise<void> {
-  const files = await findMarkdownFiles(bundleDir);
-  const concepts: { type: string; title: string; relPath: string }[] = [];
-  for (const file of files) {
-    const relPath = path.relative(bundleDir, file);
-    if (isReservedFile(relPath)) continue;
-    try {
-      const content = await fs.readFile(file, "utf-8");
-      const parsed = parseConcept(content);
-      concepts.push({
-        type: (parsed.frontmatter.type as string) || "RepoFact",
-        title: (parsed.frontmatter.title as string) || path.basename(file, ".md"),
-        relPath,
-      });
-    } catch {
-      // ignore
-    }
-  }
+  const concepts = await loadConceptsFromBundle(bundleDir);
 
-  let body = "# Index\n\n";
-  for (const { type, header } of TYPE_LAYOUT) {
-    const list = concepts.filter(c => c.type === type);
-    if (list.length === 0) continue;
-    body += `## ${header}\n`;
+  // Progressive-disclosure index: a link per concept plus its one-line description,
+  // grouped by type (TYPE_LAYOUT order first, then any unknown types — lenient).
+  const section = (header: string, list: Concept[]): string => {
+    let out = `## ${header}\n`;
     for (const c of list) {
-      body += `- [${c.title}](/${c.relPath.replace(/\\/g, "/")})\n`;
+      out += `- [${c.title}](/${c.relPath})${c.description ? ` — ${c.description}` : ""}\n`;
     }
-    body += "\n";
+    return out + "\n";
+  };
+  let body = "# Index\n\n";
+  for (const { header, list } of groupByTypeLayout(concepts)) {
+    body += section(header, list);
   }
 
   const indexContent = serializeConcept({ okf_version: "0.1" }, body.trim());
@@ -302,60 +456,76 @@ export async function distillSessionMemory(
       await fs.mkdir(bundleDir, { recursive: true });
       const updatedConcepts: { title: string; type: string }[] = [];
 
-      for (const concept of parsedJson.concepts) {
-        if (!concept.type || !concept.title) continue;
-        // Unknown types fall back to facts/ (lenient — OKF tolerates extra types).
-        const dir = DIR_BY_TYPE[concept.type] ?? "facts";
-
-        const targetDir = path.join(bundleDir, dir);
-        await fs.mkdir(targetDir, { recursive: true });
-
-        let slug = slugify(concept.title);
-        let relPath = `${dir}/${slug}.md`;
-        let fullPath = path.join(bundleDir, relPath);
-
-        let suffix = 1;
-        while (true) {
-          try {
-            const existingContent = await fs.readFile(fullPath, "utf-8");
-            const parsed = parseConcept(existingContent);
-            const existingTitle = parsed.frontmatter.title || "";
-            if (existingTitle === concept.title) {
+      for (const raw of parsedJson.concepts) {
+        // A text-only / small model (the default antigravity backend) can emit
+        // stray non-object array elements (null, strings, numbers) or non-string
+        // type/title fields. Validate each element and isolate per-concept failures:
+        // one malformed concept must NEVER throw out of the loop, because the outer
+        // catch would then discard every valid learning distilled in this run.
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+        const concept = raw as {
+          type?: unknown; title?: unknown; description?: unknown; body?: unknown;
+          tags?: unknown; confidence?: unknown; links?: unknown;
+        };
+        const type = typeof concept.type === "string" ? concept.type.trim() : "";
+        const title = typeof concept.title === "string" ? concept.title.trim() : "";
+        if (!type || !title) continue;
+        try {
+          // Unknown types fall back to facts/ (lenient — OKF tolerates extra types).
+          const dir = DIR_BY_TYPE[type] ?? "facts";
+
+          const targetDir = path.join(bundleDir, dir);
+          await fs.mkdir(targetDir, { recursive: true });
+
+          let slug = slugify(title);
+          let relPath = `${dir}/${slug}.md`;
+          let fullPath = path.join(bundleDir, relPath);
+
+          let suffix = 1;
+          while (true) {
+            try {
+              const existingContent = await fs.readFile(fullPath, "utf-8");
+              const parsed = parseConcept(existingContent);
+              const existingTitle = parsed.frontmatter.title || "";
+              if (existingTitle === title) {
+                break;
+              }
+              slug = `${slugify(title)}-${suffix}`;
+              relPath = `${dir}/${slug}.md`;
+              fullPath = path.join(bundleDir, relPath);
+              suffix++;
+            } catch {
               break;
             }
-            slug = `${slugify(concept.title)}-${suffix}`;
-            relPath = `${dir}/${slug}.md`;
-            fullPath = path.join(bundleDir, relPath);
-            suffix++;
-          } catch {
-            break;
           }
-        }
-
-        let existingFm = {};
-        try {
-          const existingContent = await fs.readFile(fullPath, "utf-8");
-          existingFm = parseConcept(existingContent).frontmatter;
-        } catch {}
-
-        const frontmatter = {
-          ...existingFm,
-          type: concept.type,
-          title: concept.title,
-          description: concept.description || "",
-          tags: concept.tags || [],
-          timestamp: new Date().toISOString(),
-          confidence: concept.confidence || "high",
-          last_verified: new Date().toISOString().split("T")[0],
-          links: concept.links || [],
-        };
 
-        const serialized = serializeConcept(frontmatter, concept.body || "");
-        const tmpPath = `${fullPath}.tmp-${process.pid}`;
-        await fs.writeFile(tmpPath, serialized, "utf-8");
-        await fs.rename(tmpPath, fullPath);
-
-        updatedConcepts.push({ title: concept.title, type: concept.type });
+          let existingFm = {};
+          try {
+            const existingContent = await fs.readFile(fullPath, "utf-8");
+            existingFm = parseConcept(existingContent).frontmatter;
+          } catch {}
+
+          const frontmatter = {
+            ...existingFm,
+            type,
+            title,
+            description: typeof concept.description === "string" ? concept.description : "",
+            tags: Array.isArray(concept.tags) ? concept.tags.filter((t): t is string => typeof t === "string") : [],
+            timestamp: new Date().toISOString(),
+            confidence: typeof concept.confidence === "string" ? concept.confidence : "high",
+            last_verified: new Date().toISOString().split("T")[0],
+            links: Array.isArray(concept.links) ? concept.links.filter((l): l is string => typeof l === "string") : [],
+          };
+
+          const serialized = serializeConcept(frontmatter, typeof concept.body === "string" ? concept.body : "");
+          const tmpPath = `${fullPath}.tmp-${process.pid}`;
+          await fs.writeFile(tmpPath, serialized, "utf-8");
+          await fs.rename(tmpPath, fullPath);
+
+          updatedConcepts.push({ title, type });
+        } catch {
+          // Skip just this concept; keep distilling the rest of the batch.
+        }
       }
 
       await rebuildIndex(bundleDir);

package/src/ai/model-manager.ts

@@ -356,7 +356,9 @@ const DEFAULT_CALL_TIMEOUT_MS = 120_000;
 
 /** Per-chunk idle cap for streaming: a stream that emits NOTHING for this long is
  *  aborted, but a healthy long generation (chunks keep arriving) runs unbounded —
- *  unlike a single wall-clock cap that would kill a long-but-active stream. */
+ *  unlike a single wall-clock cap that would kill a long-but-active stream.
+ *  Opt-in override via JEO_STREAM_IDLE_MS for reasoning workloads whose "thinking"
+ *  phase can legitimately emit no visible token for longer than the default. */
 const STREAM_IDLE_TIMEOUT_MS = 120_000;
 
 /** Combine two abort signals into one. Preserves BOTH even when `AbortSignal.any`
@@ -418,7 +420,7 @@ async function nextMaybeIdle(iter: AsyncIterator<string>, idle?: StreamIdleOptio
       idle.onIdle?.();
       reject(new Error(deadlineFires
         ? `stream exceeded the overall deadline (JEO_STREAM_MAX_MS) — slow-drip stream aborted`
-        : `stream idle for ${idle.idleMs}ms (no chunk)`));
+        : `stream idle for ${idle.idleMs}ms (no chunk) — provider sent no token within the idle window (load or long thinking); retrying. Raise JEO_STREAM_IDLE_MS or lower the thinking level if this persists.`));
     }, waitMs);
   });
   try {
@@ -435,6 +437,15 @@ export function streamMaxMs(env?: Record<string, string | undefined>): number |
   return Number.isFinite(n) && n > 0 ? n : undefined;
 }
 
+/** Per-chunk idle cap (ms) from the environment, falling back to the built-in default.
+ *  Lets reasoning workloads whose "thinking" phase emits no visible token for a long
+ *  time raise the stall threshold via JEO_STREAM_IDLE_MS without a code change. */
+export function streamIdleMs(env?: Record<string, string | undefined>): number {
+  const raw = jeoEnv("STREAM_IDLE_MS", env);
+  const n = raw !== undefined ? parseInt(raw, 10) : NaN;
+  return Number.isFinite(n) && n > 0 ? n : STREAM_IDLE_TIMEOUT_MS;
+}
+
 export async function* retryableStream(
   makeIter: () => AsyncIterator<string>,
   retry: RetryOptions,
@@ -475,7 +486,7 @@ export function createModelManager(): ModelManager {
         };
         const maxMs = streamMaxMs();
         yield* retryableStream(makeIter, retry, {
-          idleMs: STREAM_IDLE_TIMEOUT_MS,
+          idleMs: streamIdleMs(),
           ...(maxMs !== undefined ? { deadlineAt: Date.now() + maxMs } : {}),
           onIdle: () => attempt?.abort(),
         });

package/src/commands/launch.ts

@@ -396,7 +396,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const protocol = buildToolProtocol(allowedTools);
   const preamble = flags.systemPrompt ?? "You are the jeo, an interactive coding agent.\nAccomplish the user's request by calling tools and verifying your work.";
   // Prior-session learnings (B6 경험 증류) — "" when absent or JEO_NO_MEMORY=1.
-  const memoryBlock = await memoryPromptSection(cwd);
+  // The one-shot task text (flags.message) seeds relevance search so the most
+  // pertinent concepts win the injection budget; interactive boots with no query
+  // (high-confidence core concepts are always prioritized regardless).
+  const memoryBlock = await memoryPromptSection(cwd, flags.message || undefined);
 
   const baseSystemPrompt =
     preamble + "\n\n" + protocol + "\n\n" +
@@ -679,7 +682,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           else console.log(msg);
         },
         onHardExit: () => {
-          if (tui) tui.finish("Cancelled.");
+          if (tui) tui.finish("Cancelled.", { ok: false });
           process.exit(130);
         },
       });
@@ -812,7 +815,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
     } catch (err) {
       if (tui) {
-        tui.finish(`! ${friendlyProviderError(err)}`);
+        tui.finish(`! ${friendlyProviderError(err)}`, { ok: false });
         interactiveTurnActive = false;
       }
       throw err;

package/src/tui/app.ts

@@ -359,12 +359,16 @@ export class LaunchTui {
     try { this.write(`\x1b]2;jeo: ${this.turnTitle}\x07`); } catch { /* terminal gone */ }
   }
 
-  /** Render the task plan as a status-colored checklist; empty when no plan. */
-  private renderPlan(color: boolean): string[] {
+  /** Render the task plan as a status-colored checklist; empty when no plan. When
+   *  `complete` (the success-finish receipt), every still-open item is shown done so the
+   *  checklist agrees with the `done` badge — the model's last `todo` call often forgets
+   *  to flip the final items, and the once-per-turn done gate can't force it. The LIVE
+   *  frame never passes `complete`, so in-progress work still renders truthfully. */
+  private renderPlan(color: boolean, complete = false): string[] {
     if (this.todos.length === 0) return [];
     const steps = this.todos.map(t => ({
       label: t.title,
-      state: (t.status === "done" ? "done" : t.status === "in_progress" ? "active" : "pending") as StepState,
+      state: (complete || t.status === "done" ? "done" : t.status === "in_progress" ? "active" : "pending") as StepState,
     }));
     const header = formatStepHeader(steps, { unicode: this.unicode, color, label: "Todos" });
     return [header, ...formatStepTimeline(steps, { unicode: this.unicode, color, highlightActive: true, maxRows: 8, badges: false })];
@@ -984,8 +988,11 @@ export class LaunchTui {
     return this.theme.color ? chalk.bold(accentPaint(this.theme)("jeo")) : "jeo";
   }
 
-  /** Collapse the live region to static final output. */
-  finish(reply: string): void {
+  /** Collapse the live region to static final output. `ok` (default true) marks a
+   *  SUCCESSFUL turn — its Todos receipt is shown fully complete. Cancel/error finishes
+   *  pass `ok:false` so the checklist truthfully keeps any unfinished items. */
+  finish(reply: string, opts: { ok?: boolean } = {}): void {
+    const ok = opts.ok !== false;
     this.finished = true;
     this.hudPhase = "done";
     if (this.timer) {
@@ -1014,7 +1021,7 @@ export class LaunchTui {
     const finalLines: string[] = [];
     // jeo-ref final-report order: the ANSWER leads; the Todos checklist follows it
     // (done = checked + struck through), so the plan reads as a completion receipt.
-    const planLines = this.renderPlan(this.theme.color);
+    const planLines = this.renderPlan(this.theme.color, ok);
     if (!this.inline) {
       // Inline scrollback already reads as a ✓/✗ checklist; the step timeline +
       // compact strip + flow line would just repeat it (gjc-style slim summary).

package/src/util/retry.ts

@@ -56,7 +56,13 @@ export function defaultRetryable(err: unknown): boolean {
     lowerMessage.includes("timeout") ||
     lowerMessage.includes("overloaded") ||
     lowerMessage.includes("rate limit") ||
-    lowerMessage.includes("rate_limit")
+    lowerMessage.includes("rate_limit") ||
+    // A per-chunk stream-idle stall ("stream idle for <ms>ms (no chunk)") is a
+    // transient stall (provider load / long TTFT) — retry it like a timeout. The
+    // OVERALL-deadline message ("stream exceeded the overall deadline") is a hard
+    // wall-clock cap and is deliberately NOT matched here (it must fail fast).
+    lowerMessage.includes("stream idle") ||
+    lowerMessage.includes("no chunk")
   ) {
     return true;
   }