jeo-code 0.7.7 → 0.7.8

package/CHANGELOG.md

@@ -6,6 +6,19 @@ 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.8] - 2026-06-24
+_Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach._
+
+### Fixed
+- **The detached memory-distill worker always terminates itself.** `runMemoryDistillCommand` now wraps its work in `try/finally` and calls an injected `exit` (defaulting to `process.exit`) on every path — success, broken payload, and missing payload. `distillSessionMemory` caps the LLM call with a `Promise.race` timeout, but the race only *rejects*; it never aborts the underlying fetch, so a stalled provider socket kept the child's event loop alive and the `jeo memory-distill` worker lingered forever — one orphan per session, each pinning the full transcript in RSS (the observed "jeo bun" CPU/memory creep). An explicit exit closes the socket and reclaims the process.
+- **The live reasoning/output block re-wraps only its trailing window.** The wrap memo in `app.ts` keyed on the full (up-to-hundreds-of-KB) buffer, so every 120 ms tick and every stream delta copied + compared the whole growing string — O(len) per frame, O(len²) over a long reasoning/tool stream (the streaming slowdown). `liveBlockWrapKey` now slices the ≤16 KB tail first, then keys + wraps that: identical visible output, O(tail) per frame regardless of total size.
+- **The team loop no longer reprints the todo guide every iteration.** `runTeamEngine` printed `formatRalphTodoGuide` once per task — O(N²) lines that climbed the embedded-terminal renderer's CPU on a long task list. The guide prints once up front; per-task progress lines carry the rest.
+- **The readline caret stays aligned after an image attach.** Both the paste and Ctrl+V image-attach paths now call readline's internal `_refreshLine()` after swapping the `[image #n]` tag in (mirroring the slash/tab-completion accept paths), so the stale row/cursor model no longer offsets the real caret several columns on the next keystroke.
+
+### Verified
+- `bun run typecheck` clean; full suite green — 1914 pass / 0 fail across 229 files — including the new `runMemoryDistillCommand` always-exits assertions (success + no-payload paths) and the `liveBlockWrapKey` bounded-key / tail-collision tests.
+
+
 ## [0.7.7] - 2026-06-23
 _Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers._
 

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.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
 - **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
-- **[0.7.3]** (2026-06-22) — Provider catalog: the Tencent Cloud MaaS (international) `knownModels` list is broadened from a 4-id DeepSeek/MiniMax set to the full live-verified line-up across five families — DeepSeek, MiniMax, Zhipu GLM, Moonshot Kimi, and Hunyuan. Because the host exposes no `/v1/models` route, this hand-maintained list is the model picker's source of truth for the offline fallback.
 
 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.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
 - **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
-- **[0.7.3]** (2026-06-22) — Provider catalog: the Tencent Cloud MaaS (international) `knownModels` list is broadened from a 4-id DeepSeek/MiniMax set to the full live-verified line-up across five families — DeepSeek, MiniMax, Zhipu GLM, Moonshot Kimi, and Hunyuan. Because the host exposes no `/v1/models` route, this hand-maintained list is the model picker's source of truth for the offline fallback.
 
 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.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
 - **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
-- **[0.7.3]** (2026-06-22) — Provider catalog: the Tencent Cloud MaaS (international) `knownModels` list is broadened from a 4-id DeepSeek/MiniMax set to the full live-verified line-up across five families — DeepSeek, MiniMax, Zhipu GLM, Moonshot Kimi, and Hunyuan. Because the host exposes no `/v1/models` route, this hand-maintained list is the model picker's source of truth for the offline fallback.
 
 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.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
 - **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
-- **[0.7.3]** (2026-06-22) — Provider catalog: the Tencent Cloud MaaS (international) `knownModels` list is broadened from a 4-id DeepSeek/MiniMax set to the full live-verified line-up across five families — DeepSeek, MiniMax, Zhipu GLM, Moonshot Kimi, and Hunyuan. Because the host exposes no `/v1/models` route, this hand-maintained list is the model picker's source of truth for the offline fallback.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",
@@ -64,5 +64,6 @@
     "playwright": "^1.61.0",
     "typescript": "^5.6.3",
     "ws": "^8.21.0"
-  }
+  },
+  "packageManager": "pnpm@10.33.4+sha512.1c67b3b359b2d408119ba1ed289f34b8fc3c6873412bec6fd264fbdc82489e510fcbecb9ce9d22dae7f3b76269d8441046014bdca53b9979cd7a561ad631b800"
 }

package/src/agent/memory.ts

@@ -876,21 +876,37 @@ export async function spawnDetachedDistill(
 }
 
 /** CLI worker for the detached child: payload → distill → cleanup. Silent by design. */
-export async function runMemoryDistillCommand(args: string[]): Promise<void> {
-  const payloadPath = (args[0] ?? "").trim();
-  if (!payloadPath) return;
+export async function runMemoryDistillCommand(
+  args: string[],
+  // Injected for tests; the REAL detached worker must terminate ITSELF. distillSessionMemory
+  // caps the LLM call with a Promise.race timeout, but the race only REJECTS — it never aborts
+  // the underlying fetch. A stalled provider socket therefore stays open, the worker's event
+  // loop never drains, and the `jeo memory-distill` child lingers forever — one orphan per
+  // session, each pinning the full transcript in RSS. That is the observed "jeo bun" pileup
+  // (CPU/memory creeping up over time). An explicit exit closes the socket and reclaims it.
+  exit: (code: number) => void = (code) => process.exit(code),
+): Promise<void> {
   try {
-    const payloadContent = await fs.readFile(payloadPath, "utf-8");
-    const payload = JSON.parse(payloadContent) as { model?: string; messages?: Message[] };
-    const bundleDir = path.join(process.cwd(), ".jeo", "memory");
-    await saveRawPayload(bundleDir, payload);
-    if (Array.isArray(payload.messages)) {
-      await distillSessionMemory(payload.messages, process.cwd(), { model: payload.model });
+    const payloadPath = (args[0] ?? "").trim();
+    if (!payloadPath) return;
+    try {
+      const payloadContent = await fs.readFile(payloadPath, "utf-8");
+      const payload = JSON.parse(payloadContent) as { model?: string; messages?: Message[] };
+      const bundleDir = path.join(process.cwd(), ".jeo", "memory");
+      await saveRawPayload(bundleDir, payload);
+      if (Array.isArray(payload.messages)) {
+        await distillSessionMemory(payload.messages, process.cwd(), { model: payload.model });
+      }
+    } catch {
+      // best-effort — a broken payload must not leave error noise in a detached child
+    } finally {
+      await fs.unlink(payloadPath).catch(() => {});
     }
-  } catch {
-    // best-effort — a broken payload must not leave error noise in a detached child
   } finally {
-    await fs.unlink(payloadPath).catch(() => {});
+    // Guaranteed on every path (incl. the no-payload early return and a distill timeout):
+    // never leave the detached worker alive waiting on a dangling fetch.
+    exit(0);
   }
 }
 
+

package/src/commands/launch.ts

@@ -2650,7 +2650,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         setImmediate(() => {
           void (async () => {
             try {
-              const rli = rl as unknown as { line: string; cursor: number };
+              const rli = rl as unknown as { line: string; cursor: number; _refreshLine?: () => void };
               const before = rli.line;
               const dropped = await attachImagePaths(before, pendingImages.length + 1);
               if (dropped.images.length === 0 || dropped.text === before) return;
@@ -2658,6 +2658,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               rli.line = dropped.text;
               rli.cursor = dropped.text.length; // drop lands at the caret (line end in the common case)
               typedLine = dropped.text;
+              // Keep readline's internal screen model in step with the swapped-in tag so
+              // the caret is not offset on the next keystroke (mirrors the Ctrl+V path).
+              rli._refreshLine?.();
               if (previewArmed) drawFooter(previewLines(typedLine, navIdx));
             } finally {
               pasteInFlight = false;
@@ -2719,12 +2722,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             if (!img) return;
             pendingImages.push(img);
             const tag = `[image #${pendingImages.length}]`;
-            const rli = rl as unknown as { line: string; cursor: number };
+            const rli = rl as unknown as { line: string; cursor: number; _refreshLine?: () => void };
             const at = typeof rli.cursor === "number" ? rli.cursor : rli.line.length;
             const sep = rli.line.length > 0 && at > 0 && rli.line[at - 1] !== " " ? " " : "";
             rli.line = rli.line.slice(0, at) + sep + tag + " " + rli.line.slice(at);
             rli.cursor = at + sep.length + tag.length + 1;
             typedLine = rli.line;
+            // Sync readline's internal screen model to the injected tag (same as the
+            // slash/tab completion accept paths): without it readline's stale row/cursor
+            // model offsets the real caret several columns on the next keystroke — the
+            // "caret pushed past the tag after attaching an image" shift.
+            rli._refreshLine?.();
             if (previewArmed) drawFooter(previewLines(typedLine, navIdx));
           } finally {
             pasteInFlight = false;

package/src/commands/team.ts

@@ -346,7 +346,8 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
       const currentTask = teamState.pending_tasks[0];
       log(`\n${categoryBadge("progress")} Current task: "${currentTask}"`);
       const activeIndex = activeStepIndex(tasks.length, teamState.pending_tasks);
-      for (const line of formatRalphTodoGuide(tasks, activeIndex, teamState.completed_tasks ?? [], renderOpts)) log(line);
+      // Guide printed once above; per-task lines convey progress. No per-iteration
+      // reprint — it was O(N²) lines, climbing the embedded-terminal renderer's CPU.
 
       if (opts.onProgress) {
         opts.onProgress({ skill: "team", phase: "executing", detail: `Current task: ${currentTask}` });

package/src/tui/app.ts

@@ -126,6 +126,15 @@ export function tailForWrap(text: string, maxChars = FRAME_WRAP_TAIL_CHARS): str
   return text.length > maxChars ? text.slice(text.length - maxChars) : text;
 }
 
+/** Memoization key for a live-block wrap (Thinking / tool Output). Derived from the
+ *  TRAILING window only (see `tailForWrap`): the rendered rows depend solely on the
+ *  tail, so keying on the full streamed buffer just made every 120ms tick and every
+ *  delta copy + compare the whole growing string — O(len) per frame, i.e. O(len²) over
+ *  a long stream. Bounding the key to the ≤16KB tail keeps per-frame cost O(window). */
+export function liveBlockWrapKey(wrapW: number, text: string): string {
+  return `${wrapW}\u0000${tailForWrap(text)}`;
+}
+
 /** Max lines of a committed reasoning block kept in scrollback (gjc-style collapse): a
  *  long chain-of-thought is clipped with a "+N more" hint so it never floods the ledger. */
 export const THINKING_COMMIT_MAX_LINES = 12;
@@ -1300,14 +1309,18 @@ export class LaunchTui {
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
     if (!text.trim()) return [];
     const wrapW = Math.max(8, cols - 2);
-    // Memoize the wrap: only the spinner/clock change on most 120ms ticks, so re-wrapping
-    // this (up to 16KB) tail every frame just re-segments graphemes for no visible change.
-    // Per-label slot (Thinking / Output) keyed by wrap width + text — a real delta misses
-    // once and recomputes; an idle tick hits the cache. `rows` only gates the post-slice.
+    // Memoize the wrap on the TRAILING window only. The block displays just its last few
+    // wrapped rows, so wrap cost is already capped by `tailForWrap`. The cache KEY must be
+    // bounded too: keying on the full (up-to-hundreds-of-KB) `text` made every 120ms tick
+    // and every stream delta copy + compare the whole growing buffer — O(len) per frame, so
+    // O(len²) over a long reasoning/tool stream (the streaming slowdown). Slice first, then
+    // key + wrap the ≤16KB tail: identical visible output, O(tail) per frame regardless of
+    // total size. Per-label slot (Thinking / Output) keyed by wrap width + tail.
     let cache = this.liveBlockWrapCaches.get(cacheKey);
     if (!cache) { cache = lastValueCache<string[]>(); this.liveBlockWrapCaches.set(cacheKey, cache); }
-    const wrapped = cache(`${wrapW}\u0000${text}`, () =>
-      tailForWrap(text)
+    const tail = tailForWrap(text);
+    const wrapped = cache(liveBlockWrapKey(wrapW, text), () =>
+      tail
         .split("\n")
         .flatMap(l => wrapTextWithAnsi(l, wrapW))
         .filter(l => l.length > 0));