jeo-code 0.6.12 → 0.6.14

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.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._
+
+### Changed
+- **`team` re-runs report concrete uncommitted work.** Instead of a speculative warning, the engine now probes the working tree with `git status --porcelain` and reports the actual uncommitted-file count, so you know whether real partial work is present before re-running on it.
+- **`--strict-mutations` fails a no-op mutating run.** A mutating role that performed no write/edit/bash is now a hard failure (`stream:error`) rather than silently passing; a bash-only run stays an advisory `stream:warn` (new tone) so a passing advisory doesn't masquerade as an error.
+
 ## [0.6.12] - 2026-06-16
 _OKF-backed memory distillation — session learnings become structured concept files._
 

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.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.
-- **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 
 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.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.
-- **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 
 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.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.
-- **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 
 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.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.
-- **[0.6.8]** (2026-06-16) — OAuth loopback callback host pinned to `localhost` to match provider-registered redirect URIs.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/memory.ts

@@ -302,60 +302,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/cli/runner.ts

@@ -70,9 +70,10 @@ export const COMMANDS: readonly CommandSpec[] = [
   {
     name: "team",
     summary: "Execute the planning blueprint (Executor subagent tools).",
+    usage: "team [--strict-mutations]",
     loader: async () => {
       const m = await import("../commands/team");
-      return async () => m.runTeamCommand();
+      return args => m.runTeamCommand(args);
     },
   },
   {

package/src/commands/team.ts

@@ -11,6 +11,7 @@ import {
 import { runAgentLoop } from "../agent/engine";
 import { maybeCompact } from "../agent/compaction";
 import { catalogMetadata } from "../ai";
+import { gitDirtyCount } from "./launch/tmux";
 import { readGlobalConfig } from "../agent/state";
 import {
   defaultSubagentRole,
@@ -26,7 +27,7 @@ import type { Message } from "../agent/loop";
 import { loadProjectContext, withProjectContext } from "../agent/context-files";
 import { categoryBadge } from "../tui/components/category-index";
 
-export type RalphStreamKind = "step" | "complete" | "error";
+export type RalphStreamKind = "step" | "complete" | "error" | "warn";
 
 export interface RalphRenderOptions {
   color?: boolean;
@@ -55,19 +56,20 @@ export function formatRalphTodoGuide(
   return lines;
 }
 
+const STREAM_TINTS = {
+  complete: chalk.green.bold,
+  error: chalk.red.bold,
+  warn: chalk.yellow.bold,
+  step: chalk.cyan.bold,
+} satisfies Record<RalphStreamKind, (s: string) => string>;
+
 export function formatRalphStreamEvent(kind: RalphStreamKind, message: string, opts: RalphRenderOptions = {}): string {
-  const label = kind === "complete" ? "complete" : kind === "error" ? "error" : "step";
-  if (!opts.color && !opts.indexed) return `  └─ stream:${label} ${message}`;
+  // ponytail: the label is always the kind itself — no mapping table needed.
+  if (!opts.color && !opts.indexed) return `  └─ stream:${kind} ${message}`;
   const color = opts.color === true;
   const badge = `${categoryBadge("subagent", { color })} `;
-  const tint = color
-    ? kind === "complete"
-      ? chalk.green.bold
-      : kind === "error"
-        ? chalk.red.bold
-        : chalk.cyan.bold
-    : (s: string) => s;
-  return `  ${badge}${tint(`stream:${label}`)} ${message}`;
+  const tint = color ? STREAM_TINTS[kind] : (s: string) => s;
+  return `  ${badge}${tint(`stream:${kind}`)} ${message}`;
 }
 
 export interface RalphSubagentPromptContext {
@@ -163,6 +165,9 @@ export interface TeamEngineOptions {
   io?: {
     output?: (line: string) => void;
   };
+  /** When true, a mutating role that finishes WITHOUT any successful
+   *  write/edit/bash fails the task instead of merely warning (round-11). */
+  strictMutations?: boolean;
 }
 
 export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok: boolean; reason?: string }> {
@@ -301,12 +306,17 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
     }
 
     // Round-8: a previous run halted on a task — its partial edits may still be
-    // on disk. Warn loudly before re-running on top of them, then clear the marker.
+    // on disk. Round-12: instead of a speculative warning, probe the working tree
+    // with `git status --porcelain` and report the CONCRETE uncommitted count so
+    // the user knows whether real partial work is present before re-running on it.
     if (teamState.current_phase === "failed" && teamState.failed_task) {
-      log(
-        `[WARN] The previous run FAILED on "${teamState.failed_task}" and may have left partial edits on disk. ` +
-        `Review the working tree before trusting this re-run — executing the task again on top of partial work can duplicate changes.`,
-      );
+      const dirty = gitDirtyCount(cwd);
+      const treeNote = dirty === undefined
+        ? `The working tree could not be inspected (not a git repo or git unavailable) — review it manually before trusting this re-run.`
+        : dirty > 0
+          ? `git reports ${dirty} uncommitted change(s) — these may include partial edits from the halted task; review (e.g. 'git status', 'git diff') before re-running, as executing the task again on top of partial work can duplicate changes.`
+          : `git reports a clean working tree — no partial edits from the halted task remain on disk, so this re-run starts from a known state.`;
+      log(`[WARN] The previous run FAILED on "${teamState.failed_task}". ${treeNote}`);
       teamState.current_phase = "executing";
       delete teamState.failed_task;
     }
@@ -336,6 +346,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         completed: teamState.completed_tasks ?? [],
         cwd,
         roleId: roleByIndex[activeIndex],
+        strictMutations: opts.strictMutations ?? false,
       });
 
       if (opts.signal?.aborted) {
@@ -374,14 +385,15 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
   }
 }
 
-export async function runTeamCommand(): Promise<void> {
-  const res = await runTeamEngine();
+export async function runTeamCommand(args: string[] = []): Promise<void> {
+  const strictMutations = args.includes("--strict-mutations") || args.includes("--strict");
+  const res = await runTeamEngine({ strictMutations });
   if (!res.ok) {
     process.exitCode = 1;
   }
 }
 
-async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string }): Promise<boolean> {
+async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string; strictMutations?: boolean }): Promise<boolean> {
   const config = await readGlobalConfig();
   const role = getSubagentRole(ctx.roleId, config) ?? defaultSubagentRole();
   const renderOpts: RalphRenderOptions = { color: !!process.stdout.isTTY, indexed: true };
@@ -465,7 +477,16 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
     const msg = bashRuns === 0
       ? `${role.title} completed WITHOUT any successful write/edit/bash — treat its changed-files claim as unverified.`
       : `${role.title} completed with only bash (no write/edit) — verify its changed-files claim independently.`;
-    console.log(formatRalphStreamEvent("error", msg, renderOpts));
+    // Round-11: under --strict-mutations, a mutating role that took NO action at
+    // all (no write/edit/bash) is a hard failure — an empty run must not pass as
+    // a completed task. bash-only stays advisory to avoid penalizing shell edits.
+    const hardFail = ctx.strictMutations && bashRuns === 0;
+    // Round-12: separate the tones so a passing advisory run doesn't masquerade
+    // as a stream:error — only a real hard-fail is red; an advisory note is warn.
+    console.log(formatRalphStreamEvent(hardFail ? "error" : "warn", msg, renderOpts));
+    if (hardFail) {
+      return false;
+    }
   }
   console.log(formatRalphStreamEvent("complete", `${role.title} finished task`, renderOpts));
   return true;

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;
   }