jeo-code 0.6.18 → 0.6.19

package/CHANGELOG.md

@@ -6,6 +6,20 @@ 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.19] - 2026-06-18
+_Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint._
+
+### Changed
+- **Post-turn hooks execute ONCE per multi-call batch instead of once per result.** A project-wide checker hook (`tsc --noEmit`/lint/test) whose `match.tool` matched every edit in a batch previously re-ran N times sequentially — the dominant in-loop latency multiplier on multi-edit turns. `runPostTurnHooksForBatch` now groups the batch's calls, invokes each matching hook a single time, and runs distinct hooks concurrently. A hook matching several calls receives a back-compatible payload (`{event,tool,args,success,output}` plus a `calls[]` array of every matched call) so a payload-aware per-file hook can still iterate the changed files in one invocation; a single match keeps the exact legacy shape. The single-call `runPostTurnHooks` is retained as a thin wrapper for direct callers/tests.
+- **Tool-result bodies are formatted in parallel.** The per-result loop that serialized body formatting (and any oversized-body spill to a disk artifact) is replaced by a `Promise.all` over the batch, so independent formatting/disk writes overlap.
+
+### Performance
+- **Local `.jeo/hooks.json` is mtime/size-cached.** The per-project hook override was re-read and re-parsed (`fs.readFile` + `JSON.parse`) on every `loadHooks` call — once per pre-tool check and once per post-turn batch. It is now cached keyed by absolute path → mtime/size (bounded LRU, cap 32) and only re-read when the file actually changes, so any external write is still picked up immediately without a stale serve.
+
+### Fixed
+- **Wrapped colored text keeps its color on every continuation row.** `wrapTextWithAnsi` is now SGR-stateful: a color opened before a wrap point is re-applied at the start of each continuation line and closed at its end, so a wrapped colored span stays tinted on every row (the reported "color breaks when the line wraps") instead of losing its tint after the first line — and never bleeds into the padding or box border. Plain uncolored text is left byte-for-byte unchanged.
+
+
 ## [0.6.18] - 2026-06-17
 _Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior._
 

package/README.ja.md

@@ -200,11 +200,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -200,11 +200,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -200,11 +200,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -200,11 +200,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.6.18",
+  "version": "0.6.19",
 
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",

package/src/agent/engine.ts

@@ -16,7 +16,7 @@ import { readTool, writeTool, editTool, bashTool, findTool, searchTool, lsTool,
 import { webSearchTool, setWebSearchActiveModel } from "./web-search";
 import { friendlyProviderError, isContextOverflowError, isRefusalError } from "../util/provider-error";
 import { isRateLimitError } from "../util/retry";
-import { runPreToolHooks, runPostTurnHooks } from "./hooks";
+import { runPreToolHooks, runPostTurnHooksForBatch } from "./hooks";
 import { truncateToolOutput, formatToolResultBody } from "./tool-output";
 export { TOOL_OUTPUT_MAX, READ_OUTPUT_MAX, TOOL_SPILL_THRESHOLD, MAX_TOOL_ARTIFACTS, truncateToolOutput, spillToolResult } from "./tool-output";
 import { StepBudget, dynamicStepBudgetConfig, resolveStepBudgetConfig, hashSignature, type StepBudgetConfig } from "./step-budget";
@@ -903,46 +903,53 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     }
 
     const processAndPushResults = async (indices: number[]) => {
-      const resultBlocks: string[] = [];
-      // Per-batch dedup of post-turn hook diagnostics: a whole-project `tsc` hook
-      // matching every edit in a batch yields identical output N times — show it
-      // once, cross-reference the rest (cycle 13).
-      const seenHookFeedback = new Set<string>();
+      // Surface completion to the TUI ledger in call order.
       for (const idx of indices) {
-        const call = toolCalls[idx];
-        const res = results[idx];
-
-        ev.onToolResult?.(call.tool, res.success, res.output);
-
-        const resultBody = await formatToolResultBody(call.tool, res.output, cwd);
-
-        const { diags: hookDiags, ran: hooksRan } = await runPostTurnHooks(
-          cwd,
-          call.tool,
-          call.arguments ?? {},
-          res.success,
-          res.output,
-          opts.signal,
-          ev.onNotice
-        );
-        // F1: a red hook becomes a pending failure the done guard enforces; a
-        // later hook run that completes CLEAN (ran > 0, zero diags) clears it.
-        if (hookDiags.length > 0) pendingHookFailure = hookDiags[hookDiags.length - 1].run;
-        else if (hooksRan > 0) pendingHookFailure = null;
+        ev.onToolResult?.(toolCalls[idx].tool, results[idx].success, results[idx].output);
+      }
+      // Format every result body in PARALLEL — independent work, and an oversized
+      // body may spill to a disk artifact; the previous per-result loop serialized
+      // both the formatting and the disk writes.
+      const bodies = await Promise.all(
+        indices.map(idx => formatToolResultBody(toolCalls[idx].tool, results[idx].output, cwd)),
+      );
+      // Run post-turn hooks ONCE for the whole batch instead of once per result: a
+      // project-wide `tsc`/lint/test hook matching every edit in the batch no longer
+      // re-executes N times sequentially (the dominant in-loop latency multiplier).
+      const { diags: hookDiags, ran: hooksRan } = await runPostTurnHooksForBatch(
+        cwd,
+        indices.map(idx => ({
+          tool: toolCalls[idx].tool,
+          args: toolCalls[idx].arguments ?? {},
+          success: results[idx].success,
+          output: results[idx].output,
+        })),
+        opts.signal,
+        ev.onNotice,
+      );
+      // F1: a red hook becomes a pending failure the done guard enforces; a later
+      // batch whose hooks complete CLEAN (ran > 0, zero diags) clears it.
+      if (hookDiags.length > 0) pendingHookFailure = hookDiags[hookDiags.length - 1].run;
+      else if (hooksRan > 0) pendingHookFailure = null;
 
-        // Append non-zero-exit hook diagnostics to THIS tool's result block so the
-        // model can self-correct. The tool's own ok/fail is unchanged (guard).
-        let resultBlock = `Tool [${call.tool}] result (${res.success ? "ok" : "fail"}):\n${resultBody}`;
+      const resultBlocks: string[] = indices.map((idx, i) =>
+        `Tool [${toolCalls[idx].tool}] result (${results[idx].success ? "ok" : "fail"}):\n${bodies[i]}`,
+      );
+      // Append the batch's hook diagnostics once so the model can self-correct. Two
+      // DISTINCT hooks with identical output collapse to one full block + a cross-ref.
+      if (hookDiags.length > 0) {
+        const seenHookFeedback = new Set<string>();
+        const diagLines: string[] = [];
         for (const d of hookDiags) {
           const key = `${d.run}\u0000${d.output}`;
           if (seenHookFeedback.has(key)) {
-            resultBlock += `\n[post-turn hook "${d.run}" — exit ${d.exitCode}: same diagnostics as above]`;
+            diagLines.push(`[post-turn hook "${d.run}" — exit ${d.exitCode}: same diagnostics as above]`);
           } else {
             seenHookFeedback.add(key);
-            resultBlock += `\n[post-turn hook "${d.run}" — exit ${d.exitCode}]:\n${truncateToolOutput(d.output)}`;
+            diagLines.push(`[post-turn hook "${d.run}" — exit ${d.exitCode}]:\n${truncateToolOutput(d.output)}`);
           }
         }
-        resultBlocks.push(resultBlock);
+        resultBlocks.push(diagLines.join("\n"));
       }
 
       history.push({ role: "assistant", content: responseText });

package/src/agent/hooks.ts

@@ -22,27 +22,56 @@ export interface PostTurnHookDiag {
   output: string;
 }
 
+// Local `.jeo/hooks.json` read cache, keyed by absolute path → mtime/size. The
+// global config is already mtime-cached in state.ts, but the per-project local
+// override was re-read (fs.readFile + JSON.parse) on every loadHooks call — once
+// per pre-tool hook check and once per post-turn batch. Cache the parsed outcome
+// and re-read only when the file's mtime/size changes (any external write bumps
+// both, so a stale entry is never served).
+type LocalHooks =
+  | { kind: "disabled" }
+  | { kind: "hooks"; hooks: NonNullable<HookConfig["hooks"]> }
+  | { kind: "fallback" };
+const localHooksCache = new Map<string, { mtimeMs: number; size: number; result: LocalHooks }>();
+const LOCAL_HOOKS_CACHE_CAP = 32;
+
+async function readLocalHooks(localPath: string): Promise<LocalHooks> {
+  let st: { mtimeMs: number; size: number };
+  try {
+    st = await fs.stat(localPath);
+  } catch {
+    localHooksCache.delete(localPath);
+    return { kind: "fallback" };
+  }
+  const hit = localHooksCache.get(localPath);
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.result;
+  let result: LocalHooks = { kind: "fallback" };
+  try {
+    const parsed = JSON.parse(await fs.readFile(localPath, "utf-8"));
+    if (parsed && typeof parsed === "object") {
+      if (parsed.enabled === false) result = { kind: "disabled" };
+      else if (Array.isArray(parsed.hooks)) result = { kind: "hooks", hooks: parsed.hooks };
+    }
+  } catch {
+    // Missing/invalid local file → fall back to the global config hooks.
+  }
+  if (localHooksCache.size >= LOCAL_HOOKS_CACHE_CAP && !localHooksCache.has(localPath)) {
+    const oldest = localHooksCache.keys().next().value;
+    if (oldest !== undefined) localHooksCache.delete(oldest);
+  }
+  localHooksCache.set(localPath, { mtimeMs: st.mtimeMs, size: st.size, result });
+  return result;
+}
+
 export async function loadHooks(cwd: string): Promise<NonNullable<HookConfig["hooks"]>> {
   const config = await readGlobalConfig();
   if (!config.hooks?.enabled) {
     return [];
   }
 
-  const localPath = path.join(cwd, ".jeo", "hooks.json");
-  try {
-    const content = await fs.readFile(localPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed && typeof parsed === "object") {
-      if (parsed.enabled === false) {
-        return [];
-      }
-      if (Array.isArray(parsed.hooks)) {
-        return parsed.hooks;
-      }
-    }
-  } catch (e) {
-    // If local file is missing or invalid, fall back to global
-  }
+  const local = await readLocalHooks(path.join(cwd, ".jeo", "hooks.json"));
+  if (local.kind === "disabled") return [];
+  if (local.kind === "hooks") return local.hooks;
 
   return config.hooks?.hooks || [];
 }
@@ -180,12 +209,32 @@ export async function runPreToolHooks(
   return { vetoed: false };
 }
 
-export async function runPostTurnHooks(
+/** One executed tool call fed to the post-turn hooks of a batch. */
+export interface PostTurnCall {
+  tool: string;
+  args: Record<string, any>;
+  success: boolean;
+  output: string;
+}
+
+function outputPreviewOf(output: string): string {
+  return output.length > 10000 ? output.slice(0, 10000) + "\n... (truncated)" : output;
+}
+
+/**
+ * Run post-turn hooks for a whole batch of executed tool calls, invoking each
+ * matching hook EXACTLY ONCE — not once per result. A project-wide checker
+ * (`tsc --noEmit`/lint/test) that matches every edit in a batch previously ran N
+ * times sequentially; now it runs a single time. Distinct hooks run concurrently.
+ *
+ * Payload back-compat: a hook that matches a single call gets the legacy
+ * `{event,tool,args,success,output}` shape; a hook matching several gets the same
+ * fields plus a `calls[]` array (every matched call) so a payload-aware per-file
+ * hook can still iterate the changed files in one invocation.
+ */
+export async function runPostTurnHooksForBatch(
   cwd: string,
-  tool: string,
-  args: Record<string, any>,
-  success: boolean,
-  output: string,
+  calls: readonly PostTurnCall[],
   signal?: AbortSignal,
   onNotice?: (msg: string) => void
 ): Promise<{ diags: PostTurnHookDiag[]; ran: number }> {
@@ -195,23 +244,29 @@ export async function runPostTurnHooks(
   let ran = 0;
   try {
     const hooks = await loadHooks(cwd);
-    const postTurnHooks = hooks.filter(
-      h => h.event === "post-turn" && hookMatchesTool(h.match?.tool, tool)
-    );
-
-    const outputPreview = output.length > 10000 ? output.slice(0, 10000) + "\n... (truncated)" : output;
-
-    for (const hook of postTurnHooks) {
-      const payload = {
-        event: "post-turn",
-        tool,
-        args,
-        success,
-        output: outputPreview,
-      };
+    const jobs = hooks
+      .filter(h => h.event === "post-turn")
+      .map(hook => ({ hook, matched: calls.filter(c => hookMatchesTool(hook.match?.tool, c.tool)) }))
+      .filter(j => j.matched.length > 0);
 
+    // Distinct hooks are independent commands → run them concurrently. Each hook
+    // itself runs once for the whole batch (the redundancy this fix removes).
+    const settled = await Promise.all(jobs.map(async ({ hook, matched }) => {
+      const payload = matched.length === 1
+        ? { event: "post-turn", tool: matched[0].tool, args: matched[0].args, success: matched[0].success, output: outputPreviewOf(matched[0].output) }
+        : {
+            event: "post-turn",
+            tool: matched.map(c => c.tool).join(","),
+            calls: matched.map(c => ({ tool: c.tool, args: c.args, success: c.success })),
+            success: matched.every(c => c.success),
+            output: outputPreviewOf(matched.map(c => c.output).join("\n")),
+          };
       const timeoutMs = hook.timeoutMs || 30000;
       const result = await runHookCommand(hook.run, payload, cwd, timeoutMs, signal);
+      return { hook, result };
+    }));
+
+    for (const { hook, result } of settled) {
       if (result.timedOut) {
         onNotice?.(`Post-turn hook "${hook.run}" timed out (advisory).`);
       } else if (result.aborted) {
@@ -235,6 +290,20 @@ export async function runPostTurnHooks(
   return { diags, ran };
 }
 
+/** Single-call convenience wrapper (kept for direct callers/tests). Delegates to
+ *  the batch runner with one call, preserving the legacy payload shape. */
+export async function runPostTurnHooks(
+  cwd: string,
+  tool: string,
+  args: Record<string, any>,
+  success: boolean,
+  output: string,
+  signal?: AbortSignal,
+  onNotice?: (msg: string) => void
+): Promise<{ diags: PostTurnHookDiag[]; ran: number }> {
+  return runPostTurnHooksForBatch(cwd, [{ tool, args, success, output }], signal, onNotice);
+}
+
 export async function runPostImplementationHooks(
   cwd: string,
   request: string,

package/src/tui/components/width.ts

@@ -185,13 +185,32 @@ export function sanitizeForFrame(s: string): string {
   return out;
 }
 
+/** Active SGR state after applying every SGR escape in `segment` to `prior`.
+ *  Pragmatic model (matches wrap-ansi): a full reset (`\x1b[0m` / `\x1b[m`) clears
+ *  the open set; any other SGR is appended. Good enough for the fg/bg/bold coloring
+ *  a TUI box actually uses; it does not model selective resets (e.g. `\x1b[22m`). */
+function sgrStateAfter(prior: string, segment: string): string {
+  if (!segment.includes("\x1b")) return prior;
+  let state = prior;
+  const re = /\x1b\[[0-9;]*m/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(segment))) {
+    state = m[0] === "\x1b[0m" || m[0] === "\x1b[m" ? "" : state + m[0];
+  }
+  return state;
+}
+
 /**
  * Hard-wrap text to `cols` display columns, breaking long words and preserving
- * existing newlines. SGR-aware (escapes don't consume width). Returns the wrapped
- * lines. Used by markdown/table rendering where alignment must be column-correct.
+ * existing newlines. SGR-aware (escapes don't consume width) AND SGR-stateful:
+ * a color opened before a wrap point is RE-APPLIED at the start of each continuation
+ * line and CLOSED at its end, so a wrapped colored span stays colored on every row
+ * instead of losing its tint after the first line (and never bleeds into the padding
+ * or box border). Returns the wrapped lines.
  */
 export function wrapTextWithAnsi(text: string, cols: number): string[] {
   const width = Math.max(1, cols);
+  const RESET = "\x1b[0m";
   const out: string[] = [];
   for (const rawLine of text.split("\n")) {
     if (visibleWidth(rawLine) <= width) {
@@ -199,16 +218,31 @@ export function wrapTextWithAnsi(text: string, cols: number): string[] {
       continue;
     }
     let rest = rawLine;
+    let active = ""; // SGR open at the wrap boundary, carried to the next line
     while (visibleWidth(rest) > width) {
       const head = truncateToWidth(rest, width);
-      // Advance past exactly the consumed substring (head may carry a trailing reset).
-      const consumed = head.endsWith("\x1b[0m") && !rest.endsWith("\x1b[0m")
-        ? head.slice(0, -"\x1b[0m".length)
-        : head;
-      out.push(head);
+      // Advance past exactly the consumed substring. truncateToWidth may append a
+      // SYNTHETIC trailing reset (frame safety) that is NOT in `rest` — including it
+      // would over-advance and drop real chars. `rest.startsWith(head)` means the
+      // reset is genuinely part of the source; otherwise strip the synthetic one.
+      const consumed = rest.startsWith(head)
+        ? head
+        : head.endsWith(RESET) && rest.startsWith(head.slice(0, -RESET.length))
+          ? head.slice(0, -RESET.length)
+          : head;
+      let line = active + head;
+      const next = sgrStateAfter(active, consumed);
+      // Close any color still open at the line end so it cannot tint the padding/border.
+      if (next && !line.endsWith(RESET)) line += RESET;
+      out.push(line);
+      active = next;
       rest = rest.slice(consumed.length);
     }
-    if (rest.length > 0) out.push(rest);
+    if (rest.length > 0) {
+      let line = active + rest;
+      if (active && !line.endsWith(RESET)) line += RESET;
+      out.push(line);
+    }
   }
   return out;
 }