jeo-code 0.6.17 → 0.6.19

package/CHANGELOG.md

@@ -6,6 +6,27 @@ 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._
+
+### Added
+- **Editable memory data-flow diagram (`docs/diagrams/memory-flow.drawio`).** A draw.io swimlane diagram traces the OKF memory system's actual runtime behavior end to end: the **WRITE** lane (session-exit `spawnDetachedDistill` → `distillSessionMemory` → one JSON-mode LLM call → per-concept atomic upsert into `facts/`/`commands/`/`gotchas/`/`preferences/`, with a plain-text legacy fallback, then `rebuildIndex`/`updateLog`), the **STORE** lane (the typed concept bundle, `index.md`/`log.md`, the cross-link graph, and the legacy `MEMORY.md`/`.bak`), the **READ** lane (`memoryPromptSection` → `JEO_NO_MEMORY`/`JEO_MEMORY_LEGACY` gates → `loadConcepts` → `selectWithinBudget` priority order with 1-hop graph expansion → `frameMemory` injection-hardening → `<project_memory>` injection), and the one-shot idempotent **MIGRATION** lane (`jeo memory-migrate`).
+- **README "Memory flow" section (all four languages).** A new section in `README.md` / `README.ko.md` / `README.ja.md` / `README.zh.md` explains the local-first distilled memory model and embeds a GitHub-renderable Mermaid version of the write/store/read/migration flow, links the editable `.drawio`, and documents the `JEO_NO_MEMORY` / `JEO_MEMORY_LEGACY` toggles and the migration's rollback path.
+
 ## [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._
 

package/README.ja.md

@@ -119,6 +119,48 @@ jeo ultragoal
 
 非ゼロ終了したフックの出力はモデルが読むツール結果に付加され(バッチ内で重複排除)、フックが赤のまま `done` を呼ぶとフック名付きでプッシュバックされます。
 
+## メモリフロー
+
+`jeo` は `.jeo/memory/` 配下に **ローカルファースト・蒸留されたプロジェクトメモリ** を保持します(リモートバックエンドなし、ネイティブ依存ゼロ)。過去のセッションは [OKF](docs/okf_mem/) コンセプトバンドルへ蒸留され、次のセッションは関連性の高い予算内のスライスだけをシステムプロンプトへ再注入します — 指示ではなく DATA として堅牢化されます。`JEO_NO_MEMORY=1` ですべて無効化。
+
+📐 **編集可能な図:** [`docs/diagrams/memory-flow.drawio`](docs/diagrams/memory-flow.drawio)([draw.io](https://app.diagrams.net) / デスクトップアプリで開く) — 書き込み/保存/読み込み/移行の全スイムレーン。概要:
+
+```mermaid
+flowchart LR
+  subgraph WRITE["WRITE — session-end distill (detached, best-effort)"]
+    direction TB
+    W1["session exit / ^C^C"] --> W2["spawnDetachedDistill()<br/>payload + detached child, returns instantly"]
+    W2 --> W3["distillSessionMemory()<br/>load bundle · transcriptTail · ONE LLM call (JSON)"]
+    W3 --> WD{"concepts JSON<br/>parsed?"}
+    WD -->|yes| WY["per concept: upsert by title,<br/>atomic write into facts/ commands/<br/>gotchas/ preferences/"]
+    WD -->|no| WN["plain text →<br/>legacy MEMORY.md"]
+    WY --> WR["rebuildIndex() index.md<br/>updateLog() log.md"]
+  end
+
+  subgraph STORE[".jeo/memory/ — OKF concept bundle"]
+    direction TB
+    S1["facts/ · commands/ · gotchas/ · preferences/<br/>(YAML frontmatter + body)"]
+    S2["index.md · log.md · cross-link graph (Sprint 04)"]
+    S3["MEMORY.md (legacy fallback)<br/>MEMORY.md.bak (rollback)"]
+  end
+
+  subgraph READ["READ — memoryPromptSection(cwd, query)"]
+    direction TB
+    R1["session start (query = task text)"] --> R2{"bundle has<br/>concepts?"}
+    R2 -->|yes| R3["selectWithinBudget()<br/>core → query relevance → 1-hop graph<br/>≤ MEMORY_INJECT_MAX_CHARS (3000)"]
+    R2 -->|no| R3B["legacy loadMemory()"]
+    R3 --> R4["frameMemory()<br/>hard cap · fence-neutralize · DATA framing"]
+    R3B --> R4
+    R4 --> R5["&lt;project_memory&gt; … injected into system prompt"]
+  end
+
+  WR -->|atomic| STORE
+  WN -->|fallback| S3
+  STORE -.->|loadConcepts / loadMemory| READ
+```
+
+**移行(`jeo memory-migrate`、ワンショット・冪等).** レガシーの単一ドキュメント `MEMORY.md` をロスレスでバンドルへ変換します: `## 見出し → タイプ`、各箇条書き → タイプ別コンセプト、インデント行 → 本文; `index.md`/`log.md` を再構築し、元ファイルを `MEMORY.md.bak` にリネームします。バンドルにコンセプトができた後の再実行は no-op です。**ロールバック:** `JEO_MEMORY_LEGACY=1` はバンドルを無視し、同じ注入堅牢化を通して `MEMORY.md`/`.bak` を読みます(`JEO_NO_MEMORY=1` がすべてに優先)。
+
 ## ローカルモデル
 
 ```bash
@@ -158,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.
-- **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -119,6 +119,48 @@ jeo ultragoal
 
 비정상 종료한 훅의 출력은 모델이 읽는 도구 결과에 첨부되고(배치 내 중복 제거), 훅이 빨간 채로 `done`을 부르면 훅 이름과 함께 푸시백됩니다.
 
+## 메모리 흐름
+
+`jeo`는 `.jeo/memory/` 아래에 **로컬 우선·증류된 프로젝트 메모리**를 둡니다(원격 백엔드 없음, 네이티브 의존성 0). 지난 세션은 [OKF](docs/okf_mem/) 개념 번들로 증류되고, 다음 세션은 관련성 높은 예산 한도 내 일부만 시스템 프롬프트로 다시 주입합니다 — 지시가 아닌 DATA로 강화 처리됩니다. `JEO_NO_MEMORY=1`로 전체 비활성화.
+
+📐 **편집 가능한 다이어그램:** [`docs/diagrams/memory-flow.drawio`](docs/diagrams/memory-flow.drawio) ([draw.io](https://app.diagrams.net) / 데스크톱 앱에서 열기) — 쓰기/저장/읽기/마이그레이션 전체 스윔레인. 요약 보기:
+
+```mermaid
+flowchart LR
+  subgraph WRITE["WRITE — session-end distill (detached, best-effort)"]
+    direction TB
+    W1["session exit / ^C^C"] --> W2["spawnDetachedDistill()<br/>payload + detached child, returns instantly"]
+    W2 --> W3["distillSessionMemory()<br/>load bundle · transcriptTail · ONE LLM call (JSON)"]
+    W3 --> WD{"concepts JSON<br/>parsed?"}
+    WD -->|yes| WY["per concept: upsert by title,<br/>atomic write into facts/ commands/<br/>gotchas/ preferences/"]
+    WD -->|no| WN["plain text →<br/>legacy MEMORY.md"]
+    WY --> WR["rebuildIndex() index.md<br/>updateLog() log.md"]
+  end
+
+  subgraph STORE[".jeo/memory/ — OKF concept bundle"]
+    direction TB
+    S1["facts/ · commands/ · gotchas/ · preferences/<br/>(YAML frontmatter + body)"]
+    S2["index.md · log.md · cross-link graph (Sprint 04)"]
+    S3["MEMORY.md (legacy fallback)<br/>MEMORY.md.bak (rollback)"]
+  end
+
+  subgraph READ["READ — memoryPromptSection(cwd, query)"]
+    direction TB
+    R1["session start (query = task text)"] --> R2{"bundle has<br/>concepts?"}
+    R2 -->|yes| R3["selectWithinBudget()<br/>core → query relevance → 1-hop graph<br/>≤ MEMORY_INJECT_MAX_CHARS (3000)"]
+    R2 -->|no| R3B["legacy loadMemory()"]
+    R3 --> R4["frameMemory()<br/>hard cap · fence-neutralize · DATA framing"]
+    R3B --> R4
+    R4 --> R5["&lt;project_memory&gt; … injected into system prompt"]
+  end
+
+  WR -->|atomic| STORE
+  WN -->|fallback| S3
+  STORE -.->|loadConcepts / loadMemory| READ
+```
+
+**마이그레이션 (`jeo memory-migrate`, 1회성 · 멱등).** 레거시 단일 문서 `MEMORY.md`를 무손실로 번들로 변환합니다: `## 헤딩 → 타입`, 각 불릿 → 타입별 개념, 들여쓴 줄 → 본문; `index.md`/`log.md`를 재생성하고 원본은 `MEMORY.md.bak`으로 이름을 바꿉니다. 번들에 개념이 생긴 뒤 재실행은 no-op입니다. **롤백:** `JEO_MEMORY_LEGACY=1`은 번들을 무시하고 동일한 주입 강화 처리로 `MEMORY.md`/`.bak`를 읽습니다(`JEO_NO_MEMORY=1`이 모든 것에 우선).
+
 ## 로컬 모델
 
 ```bash
@@ -158,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.
-- **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -119,6 +119,48 @@ Enable hooks once globally (`"hooks": { "enabled": true }` in `~/.jeo/config.jso
 
 Non-zero hook output is appended to the tool result the model reads (deduped per batch); a still-red hook triggers a `done` pushback naming the hook.
 
+## Memory flow
+
+`jeo` keeps a **local-first, distilled project memory** under `.jeo/memory/` (no remote backend, zero native deps). Past sessions are distilled into an [OKF](docs/okf_mem/) concept bundle, and the next session injects only the relevant, budget-bounded slice back into the system prompt — hardened as DATA, never as instructions. Disable everything with `JEO_NO_MEMORY=1`.
+
+📐 **Editable diagram:** [`docs/diagrams/memory-flow.drawio`](docs/diagrams/memory-flow.drawio) (open in [draw.io](https://app.diagrams.net) / the desktop app) — full write/store/read/migration swimlanes. Quick view:
+
+```mermaid
+flowchart LR
+  subgraph WRITE["WRITE — session-end distill (detached, best-effort)"]
+    direction TB
+    W1["session exit / ^C^C"] --> W2["spawnDetachedDistill()<br/>payload + detached child, returns instantly"]
+    W2 --> W3["distillSessionMemory()<br/>load bundle · transcriptTail · ONE LLM call (JSON)"]
+    W3 --> WD{"concepts JSON<br/>parsed?"}
+    WD -->|yes| WY["per concept: upsert by title,<br/>atomic write into facts/ commands/<br/>gotchas/ preferences/"]
+    WD -->|no| WN["plain text →<br/>legacy MEMORY.md"]
+    WY --> WR["rebuildIndex() index.md<br/>updateLog() log.md"]
+  end
+
+  subgraph STORE[".jeo/memory/ — OKF concept bundle"]
+    direction TB
+    S1["facts/ · commands/ · gotchas/ · preferences/<br/>(YAML frontmatter + body)"]
+    S2["index.md · log.md · cross-link graph (Sprint 04)"]
+    S3["MEMORY.md (legacy fallback)<br/>MEMORY.md.bak (rollback)"]
+  end
+
+  subgraph READ["READ — memoryPromptSection(cwd, query)"]
+    direction TB
+    R1["session start (query = task text)"] --> R2{"bundle has<br/>concepts?"}
+    R2 -->|yes| R3["selectWithinBudget()<br/>core → query relevance → 1-hop graph<br/>≤ MEMORY_INJECT_MAX_CHARS (3000)"]
+    R2 -->|no| R3B["legacy loadMemory()"]
+    R3 --> R4["frameMemory()<br/>hard cap · fence-neutralize · DATA framing"]
+    R3B --> R4
+    R4 --> R5["&lt;project_memory&gt; … injected into system prompt"]
+  end
+
+  WR -->|atomic| STORE
+  WN -->|fallback| S3
+  STORE -.->|loadConcepts / loadMemory| READ
+```
+
+**Migration (`jeo memory-migrate`, one-shot · idempotent).** A legacy single-doc `MEMORY.md` is converted losslessly into the bundle: `## heading → type`, each bullet → a typed concept, indented lines → body; `index.md`/`log.md` are rebuilt and the original is renamed to `MEMORY.md.bak`. Re-running is a no-op once the bundle has concepts. **Rollback:** `JEO_MEMORY_LEGACY=1` ignores the bundle and reads `MEMORY.md`/`.bak` through the same injection-hardening (`JEO_NO_MEMORY=1` still wins over everything).
+
 ## Local models
 
 ```bash
@@ -158,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.
-- **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -119,6 +119,48 @@ jeo ultragoal
 
 非零退出钩子的输出会附加到模型读取的工具结果中(批内去重)；钩子未通过就调用 `done` 会收到带钩子名称的回推。
 
+## 内存流程
+
+`jeo` 在 `.jeo/memory/` 下保存 **本地优先、蒸馏后的项目内存**(无远程后端,零原生依赖)。过往会话被蒸馏为 [OKF](docs/okf_mem/) 概念包,下一次会话仅把相关的、受预算约束的切片重新注入系统提示 —— 作为 DATA 而非指令加固。用 `JEO_NO_MEMORY=1` 完全禁用。
+
+📐 **可编辑图示:** [`docs/diagrams/memory-flow.drawio`](docs/diagrams/memory-flow.drawio)(在 [draw.io](https://app.diagrams.net) / 桌面应用中打开)—— 写入/存储/读取/迁移完整泳道。概览:
+
+```mermaid
+flowchart LR
+  subgraph WRITE["WRITE — session-end distill (detached, best-effort)"]
+    direction TB
+    W1["session exit / ^C^C"] --> W2["spawnDetachedDistill()<br/>payload + detached child, returns instantly"]
+    W2 --> W3["distillSessionMemory()<br/>load bundle · transcriptTail · ONE LLM call (JSON)"]
+    W3 --> WD{"concepts JSON<br/>parsed?"}
+    WD -->|yes| WY["per concept: upsert by title,<br/>atomic write into facts/ commands/<br/>gotchas/ preferences/"]
+    WD -->|no| WN["plain text →<br/>legacy MEMORY.md"]
+    WY --> WR["rebuildIndex() index.md<br/>updateLog() log.md"]
+  end
+
+  subgraph STORE[".jeo/memory/ — OKF concept bundle"]
+    direction TB
+    S1["facts/ · commands/ · gotchas/ · preferences/<br/>(YAML frontmatter + body)"]
+    S2["index.md · log.md · cross-link graph (Sprint 04)"]
+    S3["MEMORY.md (legacy fallback)<br/>MEMORY.md.bak (rollback)"]
+  end
+
+  subgraph READ["READ — memoryPromptSection(cwd, query)"]
+    direction TB
+    R1["session start (query = task text)"] --> R2{"bundle has<br/>concepts?"}
+    R2 -->|yes| R3["selectWithinBudget()<br/>core → query relevance → 1-hop graph<br/>≤ MEMORY_INJECT_MAX_CHARS (3000)"]
+    R2 -->|no| R3B["legacy loadMemory()"]
+    R3 --> R4["frameMemory()<br/>hard cap · fence-neutralize · DATA framing"]
+    R3B --> R4
+    R4 --> R5["&lt;project_memory&gt; … injected into system prompt"]
+  end
+
+  WR -->|atomic| STORE
+  WN -->|fallback| S3
+  STORE -.->|loadConcepts / loadMemory| READ
+```
+
+**迁移(`jeo memory-migrate`,一次性 · 幂等).** 把旧版单文档 `MEMORY.md` 无损转换为概念包: `## 标题 → 类型`,每个项目符号 → 一个类型化概念,缩进行 → 正文; 重建 `index.md`/`log.md`,并把原文件重命名为 `MEMORY.md.bak`。一旦概念包中已有概念,再次运行即为 no-op。**回滚:** `JEO_MEMORY_LEGACY=1` 忽略概念包,通过相同的注入加固读取 `MEMORY.md`/`.bak`(`JEO_NO_MEMORY=1` 仍优先于一切)。
+
 ## 本地模型
 
 ```bash
@@ -158,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.
-- **[0.6.13]** (2026-06-16) — `team` engine: concrete uncommitted-work reporting and stricter empty-run handling.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.6.17",
+  "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;
 }