jeo-code 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -6,6 +6,18 @@ 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.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._
+
+### Changed
+- **Project-context guidance files are cached by `mtimeMs:size` signature instead of re-read every spawn.** `readContextFile` (in `src/agent/context-files.ts`) now keeps a 256-entry LRU of raw file text keyed by a stat signature. The cheap `fs.stat` still runs every call, so an edit (new mtime/size) or deletion is caught immediately; truncation is reapplied per call from the raw text, so a differing budget never pollutes the cache. `loadProjectContext` runs once per subagent spawn (team/ralph/autopilot), so this removes the bulk of repeated AGENTS.md/guidance reads.
+- **OKF memory concepts are parse-cached per file under the same stat-signature scheme.** `loadConcepts` (in `src/agent/memory.ts`) walks `.jeo/memory/` and parses every concept file; the new 256-entry cache skips the read+parse for unchanged files. The directory walk and per-file `stat` still run (new files appear, deleted files drop out), and every write path (`migrateLegacyMemory`, both `distillSessionMemory` branches) calls `invalidateConceptCache()` so a freshly written concept is never served stale.
+- **Native tool schemas are derived once per turn, not rebuilt every step.** `runAgentLoop` (in `src/agent/engine.ts`) hoists `nativeToolSchemasFor(...)` out of the step loop since the active toolset is constant for the whole turn, eliminating a per-step list rebuild/reallocation.
+- **Autopilot keeps the running `best` score in memory across iterations.** `cmdLoop` (in `src/autopilot.ts`) seeds `best` from `currentBest(s)` once and folds each kept step forward via the new exported `foldBest(goal, best, score)` helper, instead of re-reading and re-parsing the entire append-only log on every step. `foldBest` mirrors `currentBest`'s reduction exactly (NaN never becomes best; `min`/`max`/last-value semantics by goal) so the in-memory value can never diverge from a fresh log re-scan.
+
+### Verified
+- `bun run typecheck` clean; the touched suites pass — `test/context-files.test.ts`, `test/memory-distill-okf.test.ts`, and `test/autopilot-engine.test.ts` (43 pass / 0 fail) exercise cache hits, post-edit/post-delete invalidation, and `foldBest`/`currentBest` parity.
+
 ## [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._
 

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.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.
 - **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
-- **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 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.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.
 - **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
-- **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 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.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.
 - **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
-- **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 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.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.
 - **[0.7.2]** (2026-06-22) — Workflow honesty + prompt-input testability: `ultragoal` acceptance criteria can now carry a trailing `{verify: <command>}` directive that makes a criterion **individually** provable (real PASS/FAIL instead of a blanket UNVERIFIED on a green suite), with a SUCCESS / PARTIAL / SUITE_GREEN / FAILED status taxonomy; the boxed prompt's full stdin→readline keystroke rewriter is extracted into a pure, PTY-free function so the "↓ cuts the lower text" fix and the rest of the wiring are unit-tested directly. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
 - **[0.7.1]** (2026-06-22) — TUI polish + provider breadth: the live forge-card border and forge mark now flow in the **active theme's** own neon palette instead of a fixed brand gradient, the boxed prompt's Up/Down keys no longer wipe a multi-line draft at its top/bottom edge, the Tencent Cloud MaaS catalog gains the live-verified DeepSeek/MiniMax/GLM model families (with catalog backfill for providers that expose no models-list endpoint), and the `jeo --tmux` smoke check drops a false-positive launcher-log grep. Verified leak-free (`mem-probe`, 2000 turns, exit 0) with a fresh `jeo --tmux` boot battery (6/6).
-- **[0.7.0]** (2026-06-22) — Adds an opt-in, fail-closed **computer-use** capability (a `computer` tool + `jeo computer` CLI for screenshot/click/type/keypress/scroll/drag/wait/batch), hardens the spec-first workflow against silent post-consensus plan edits and PID-reuse lock starvation, makes OAuth refresh degrade cleanly when the refresh token is dead, and teaches tool-arg JSON repair to tolerate unescaped control characters. Verified leak-free (`mem-probe`, 2000 turns, −447 bytes/turn slope) with a fresh `jeo --tmux` boot battery (6/6).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/context-files.ts

@@ -26,12 +26,36 @@ const GUIDANCE_CONTEXT_CHARS = TOTAL_CONTEXT_CHARS - BASE_CONTEXT_CHARS;
 const MAX_AGENT_GUIDANCE_FILES = 20;
 const AGENT_GUIDANCE_EXTENSIONS = new Set([".md", ".json", ".jsonc", ".yaml", ".yml", ".toml"]);
 
+// Per-file RAW content cache: absolute path → mtimeMs:size signature + raw text.
+// loadProjectContext runs once per subagent spawn (team/ralph/autopilot); this skips
+// re-reading every unchanged AGENTS.md / guidance file. The cheap fs.stat still runs
+// each call, so an edit (new mtime/size) or deletion is caught immediately. Truncation
+// is applied per call from the raw text, so a differing budget never pollutes the cache.
+const fileContentCache = new Map<string, { sig: string; content: string }>();
+const FILE_CONTENT_CACHE_CAP = 256;
+
 async function readContextFile(filePath: string, displayPath: string, remainingChars: number): Promise<ProjectContextFile | null> {
   if (remainingChars <= 0) return null;
   try {
     const stat = await fs.stat(filePath);
     if (!stat.isFile() || stat.size <= 0) return null;
-    const content = await fs.readFile(filePath, "utf-8");
+    const sig = `${stat.mtimeMs}:${stat.size}`;
+    let content: string;
+    const cached = fileContentCache.get(filePath);
+    if (cached && cached.sig === sig) {
+      // LRU refresh so a hot file is evicted last.
+      fileContentCache.delete(filePath);
+      fileContentCache.set(filePath, cached);
+      content = cached.content;
+    } else {
+      content = await fs.readFile(filePath, "utf-8");
+      // Evict the oldest entry (Map preserves insertion order) once at capacity.
+      if (fileContentCache.size >= FILE_CONTENT_CACHE_CAP) {
+        const oldest = fileContentCache.keys().next().value;
+        if (oldest !== undefined) fileContentCache.delete(oldest);
+      }
+      fileContentCache.set(filePath, { sig, content });
+    }
     if (content.length <= 0) return null;
     const cap = Math.min(PER_CONTEXT_FILE_CHARS, remainingChars);
     const finalContent = content.length > cap ? content.slice(0, cap) + "\n…(truncated)" : content;
@@ -83,6 +107,7 @@ const EXPLICIT_GUIDANCE_FILES = [".agents/oma-config.yaml", ".agents/oma-config.
 const workspaceScanCache = new Map<string, WorkspaceScan>();
 const WORKSPACE_SCAN_CACHE_CAP = 32;
 
+
 function segsEqual(a: readonly string[], b: readonly string[]): boolean {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
@@ -188,8 +213,12 @@ async function getWorkspaceScan(cwd: string): Promise<WorkspaceScan> {
 export function invalidateWorkspaceScan(cwd?: string): void {
   if (cwd === undefined) {
     workspaceScanCache.clear();
+    fileContentCache.clear();
     return;
   }
+  // Per-cwd: drop just the downward scan. The per-file content cache is mtime/size
+  // self-invalidating, so it needs no per-cwd eviction (a path's stale entry is
+  // replaced on the next read once its mtime/size changes).
   workspaceScanCache.delete(path.resolve(cwd));
 }
 
@@ -216,6 +245,10 @@ export async function discoverAgentGuidanceFiles(cwd = process.cwd()): Promise<A
 }
 
 
+// No assembled-result cache: the parent walk + downward scan (cached by workspaceScanCache)
+// are cheap, and readContextFile skips re-reading unchanged file CONTENTS via its mtime/size
+// cache. This keeps the result disk-truthful — a guidance/AGENTS.md edit is reflected on the
+// next spawn — while still avoiding the dominant per-spawn cost (re-reading every file).
 export async function loadProjectContext(cwd = process.cwd()): Promise<ProjectContextFile[]> {
   const result: ProjectContextFile[] = [];
   let baseChars = 0;

package/src/agent/engine.ts

@@ -450,6 +450,9 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   // model's text as the final answer instead of burning the whole step budget.
   const MAX_PARSE_BOUNCES = GUARD_LIMITS.MAX_PARSE_BOUNCES;
   let parseFailures = 0;
+  // The active toolset is constant for the whole turn, so derive the native tool
+  // schemas ONCE instead of rebuilding/reallocating the list on every step.
+  const turnToolSchemas = nativeToolSchemasFor(Object.keys(tools));
   while (true) {
     if (turnBudgetMs > 0 && Date.now() - turnStartedAt > turnBudgetMs) {
       stopKind = "time";
@@ -536,7 +539,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
               // use these and re-serialize the structured call to canonical JSON; the
               // antigravity/ollama fallback ignores them. Only on the main step — never
               // the prose wrap-up call below.
-              tools: nativeToolSchemasFor(Object.keys(tools)),
+              tools: turnToolSchemas,
               model: opts.model,
               maxTokens: opts.maxTokens,
               reasoningEffort: opts.reasoningEffort,

package/src/agent/memory.ts

@@ -176,6 +176,7 @@ export async function migrateLegacyMemory(cwd: string): Promise<MigrationResult>
   // Preserve the legacy doc as a rollback backup, off the active read path.
   const backupPath = `${memoryFilePath(cwd)}.bak`;
   await fs.rename(memoryFilePath(cwd), backupPath).catch(() => {});
+  invalidateConceptCache();
   return { migrated: true, conceptCount: written.length, backupPath };
 }
 
@@ -205,6 +206,25 @@ export interface Concept {
   relPath: string;
 }
 
+/** Per-file parse cache keyed by absolute path → (mtimeMs+size signature, parsed
+ *  Concept or null for a frontmatter-less/unparseable file). loadConcepts walks
+ *  `.jeo/memory/` and read+parses every concept file; team/ralph/autopilot call
+ *  memoryPromptSection (→ loadConcepts) once per subagent spawn, re-paying that
+ *  read+parse each time. The cheap directory walk + per-file stat still run (so new
+ *  files appear and deleted files drop out immediately — disk is the source of
+ *  truth), but an UNCHANGED file (same mtime+size) skips the read+parse. A changed
+ *  file's signature differs, so edits are picked up without explicit invalidation. */
+interface ParsedConceptEntry { sig: string; concept: Concept | null }
+const parsedConceptCache = new Map<string, ParsedConceptEntry>();
+const PARSED_CONCEPT_CACHE_CAP = 512;
+
+/** Drop the per-file concept parse cache so the next loadConcepts re-reads disk.
+ *  The cache is already mtime/size self-invalidating; this is a hard reset for
+ *  tests and callers that mutate files without changing their stat signature. */
+export function invalidateConceptCache(): void {
+  parsedConceptCache.clear();
+}
+
 /** Read every concept document in the bundle into structured `Concept`s. Reserved
  *  files (index.md/log.md) and raw/ payloads are skipped; unparseable or
  *  frontmatter-less files are ignored (lenient consumption). */
@@ -226,15 +246,38 @@ async function loadConceptsFromBundle(bundleDir: string): Promise<Concept[]> {
   for (const file of files) {
     const relPath = path.relative(bundleDir, file).replace(/\\/g, "/");
     if (isReservedFile(relPath)) continue;
+
+    // Skip the read+parse when the file is byte-for-byte unchanged since we last
+    // saw it (same mtime+size). A missing stat falls through to a fresh read.
+    let sig: string | null = null;
+    try {
+      const st = await fs.stat(file);
+      sig = `${st.mtimeMs}:${st.size}`;
+    } catch {
+      continue;
+    }
+    const cached = parsedConceptCache.get(file);
+    if (cached && cached.sig === sig) {
+      // LRU refresh so a hot file is evicted last.
+      parsedConceptCache.delete(file);
+      parsedConceptCache.set(file, cached);
+      if (cached.concept) concepts.push(cached.concept);
+      continue;
+    }
+
     let parsed;
     try {
       parsed = parseConcept(await fs.readFile(file, "utf-8"));
     } catch {
+      cacheParsedConcept(file, sig, null);
+      continue;
+    }
+    if (!parsed.hasFrontmatter) {
+      cacheParsedConcept(file, sig, null);
       continue;
     }
-    if (!parsed.hasFrontmatter) continue;
     const fm = parsed.frontmatter;
-    concepts.push({
+    const concept: Concept = {
       type: (fm.type as string) || "RepoFact",
       title: (fm.title as string) || path.basename(file, ".md"),
       description: (fm.description as string) || "",
@@ -242,11 +285,24 @@ async function loadConceptsFromBundle(bundleDir: string): Promise<Concept[]> {
       tags: Array.isArray(fm.tags) ? fm.tags.filter((t): t is string => typeof t === "string") : [],
       confidence: typeof fm.confidence === "string" ? fm.confidence : "high",
       relPath,
-    });
+    };
+    cacheParsedConcept(file, sig, concept);
+    concepts.push(concept);
   }
   return concepts;
 }
 
+/** Store a per-file parse result under its stat signature, evicting the oldest
+ *  entry once at capacity (Map preserves insertion order → FIFO/LRU). */
+function cacheParsedConcept(file: string, sig: string, concept: Concept | null): void {
+  parsedConceptCache.delete(file);
+  if (parsedConceptCache.size >= PARSED_CONCEPT_CACHE_CAP) {
+    const oldest = parsedConceptCache.keys().next().value;
+    if (oldest !== undefined) parsedConceptCache.delete(oldest);
+  }
+  parsedConceptCache.set(file, { sig, concept });
+}
+
 /** Tokenize a free-text query into distinct lowercased keywords (len ≥ 3). */
 function tokenize(query?: string): string[] {
   if (!query) return [];
@@ -735,6 +791,7 @@ export async function distillSessionMemory(
         await fs.rename(memoryFilePath(cwd), `${memoryFilePath(cwd)}.bak`).catch(() => {});
       }
       await cleanupStalePendingFiles(bundleDir);
+      invalidateConceptCache();
       return { updated: true };
     } else {
       // JSON extraction failed (text-only models often wrap or drop the JSON).
@@ -754,6 +811,7 @@ export async function distillSessionMemory(
       const tmp = `${file}.tmp-${process.pid}`;
       await fs.writeFile(tmp, doc + "\n", "utf-8");
       await fs.rename(tmp, file);
+      invalidateConceptCache();
       return { updated: true };
     }
   } catch (err: any) {

package/src/autopilot.ts

@@ -142,6 +142,17 @@ function isImprovement(goal: Goal, score: number, best: number | undefined): boo
   return true; // gate handled via passed, not score
 }
 
+/** Fold one KEPT step's score into the running best, mirroring currentBest's
+ *  reduction so an in-memory best (loop hot path) never diverges from a fresh
+ *  log re-scan. NaN scores never become the best; gate tracks the last value. */
+export function foldBest(goal: Goal, best: number | undefined, score: number): number | undefined {
+  if (Number.isNaN(score)) return best;
+  if (best === undefined) return score;
+  if (goal === "min") return Math.min(best, score);
+  if (goal === "max") return Math.max(best, score);
+  return score;
+}
+
 /**
  * Single source of truth for the ratchet keep/revert decision. Shared by step,
  * loop, and status so they can never diverge.
@@ -246,6 +257,10 @@ function cmdLoop(flags: Record<string, string>): void {
   }
 
   let sinceImprove = 0;
+  // Keep `best` in memory across iterations instead of re-reading and re-parsing
+  // the whole append-only log on every step (currentBest scans LOG each call).
+  // Folded forward on each kept step to match a fresh currentBest() exactly.
+  let best = currentBest(s);
   for (let i = 1; i <= max; i++) {
     // mutate: runner makes exactly one change
     let runnerOk = true;
@@ -260,7 +275,6 @@ function cmdLoop(flags: Record<string, string>): void {
       return;
     }
 
-    const best = currentBest(s);
     const { score, passed, output } = runEval(s);
     const decision = decideStep(s.goal, score, passed, best);
 
@@ -274,6 +288,7 @@ function cmdLoop(flags: Record<string, string>): void {
     appendLog({ type: "step", iteration: i, change: `loop#${i}`, score, passed, decision, prevBest: best ?? null, output });
     // A keep is forward progress (min/max: provably an improvement; gate: a pass).
     // Anything else extends the no-progress streak toward convergence.
+    if (decision === "keep") best = foldBest(s.goal, best, score);
     sinceImprove = decision === "keep" ? 0 : sinceImprove + 1;
     console.log(`jeo autopilot: loop ${i}/${max} ${decision.toUpperCase()} score=${fmt(score)} (sinceImprove=${sinceImprove})`);
 

package/src/cli.ts

@@ -35,8 +35,5 @@ try {
   const code = await dispatch(process.argv.slice(2), { appName: APP_NAME, version: VERSION });
   if (code !== 0) process.exit(code);
 } catch (err) {
-  // Service-readiness: never surface a raw stack trace to users; clean error + non-zero exit.
-  restoreTerminalState();
-  process.stderr.write(`error: ${(err as Error)?.message ?? String(err)}\n`);
-  process.exit(1);
+  fatal(err);
 }