Merge pull request #1527 from corbitsdev/cl-10797-session-store-access-probes-regressed-67x-between-b5a452f6

fix(session): stop per-turn access probes on the base log

Author: TheGreatAxios

src/session/optimized-context-store.test.ts

@@ -2242,3 +2242,59 @@ describe("createOptimizedContextStore metadata ownership (CL-10667)", () => {
     expect((await resumed.load()).tokenUsage).toEqual(USAGE_TWO);
   });
 });
+
+describe("createOptimizedContextStore base-log access probes", () => {
+  test("a missing base loads as empty history", async () => {
+    const dir = tempDir();
+    const store = await createOptimizedContextStore(dir);
+    const loaded = await store.load();
+    expect(loaded.turns).toEqual([]);
+    expect(loaded.pendingOperations).toEqual([]);
+  });
+
+  test("access calls stay flat across turn counts", async () => {
+    const lowTurns = 3;
+    const highTurns = 9;
+    const low = await accessCallsForTurnCycles(lowTurns);
+    const high = await accessCallsForTurnCycles(highTurns);
+    const slope = (high - low) / (highTurns - lowTurns);
+    // A per-turn existence probe is slope 1. The directory listing already
+    // knows whether turns.jsonl is there, so extra turns must not add access.
+    expect(slope).toBe(0);
+  });
+});
+
+/**
+ * Counts `fs.promises.access` the way `scripts/context-store-perf.ts`
+ * `installCounters` does, for one fresh store's load/write/commit cycles.
+ */
+async function accessCallsForTurnCycles(turnCount: number): Promise<number> {
+  const target = fs.promises as unknown as Record<
+    string,
+    (...args: unknown[]) => unknown
+  >;
+  const original = target.access;
+  if (typeof original !== "function") {
+    throw new Error("fs.promises.access missing");
+  }
+  let access = 0;
+  target.access = function counted(this: unknown, ...args: unknown[]) {
+    access += 1;
+    return original.apply(this, args);
+  };
+  try {
+    const dir = tempDir();
+    const store = await createOptimizedContextStore(dir);
+    const history: ConversationTurn[] = [];
+    for (let index = 0; index < turnCount; index++) {
+      history.push(turn(`turn ${index}`));
+      await store.load();
+      await store.writePrompt(history);
+      await store.writeTurns(history);
+      await store.commit({ message: `checkpoint ${index}` });
+    }
+    return access;
+  } finally {
+    target.access = original;
+  }
+}

src/session/optimized-context-store.ts

@@ -517,11 +517,28 @@ interface ParsedLogSegment {
 /**
  * Resilient parse of `turns.jsonl` alone (extras merged by the caller), so a
  * torn or poisoned base cannot block the healing write.
+ *
+ * `baseListed` is the directory listing `turnSegmentStats` already paid for.
+ * A missing base is empty history (the same answer `pathExists` gave). A
+ * listed base is read directly: `access` only repeated that listing, and a
+ * changed base fingerprint was doing it once per appended turn. ENOENT
+ * between the listing and the read is still empty history, not a throw.
  */
-async function readBaseLogFromDisk(dir: string): Promise<ParsedLogSegment> {
+async function readBaseLogFromDisk(
+  dir: string,
+  baseListed: boolean,
+): Promise<ParsedLogSegment> {
+  if (!baseListed) return { turns: [], approvals: [] };
   const basePath = path.join(dir, TURNS_FILE);
-  if (!(await pathExists(basePath))) return { turns: [], approvals: [] };
-  const text = await fs.promises.readFile(basePath, "utf-8");
+  let text: string;
+  try {
+    text = await fs.promises.readFile(basePath, "utf-8");
+  } catch (cause) {
+    if (cause instanceof Error && "code" in cause && cause.code === "ENOENT") {
+      return { turns: [], approvals: [] };
+    }
+    throw cause;
+  }
   const approvals: PendingOperation[] = [];
   const turns = parseSegmentTurns(text, true, TURNS_FILE, true, approvals);
   return { turns, approvals };
@@ -1618,11 +1635,14 @@ export async function createSessionStores(
     // Otherwise parse turns.jsonl here rather than through the isogit base's
     // load(): that also validates metadata.json against the vendor shape,
     // which this store no longer writes (tokenUsage lives on the sidecar).
-    // Metadata is read separately by readSessionMetadata.
+    // Metadata is read separately by readSessionMetadata. The segment list
+    // already says whether the base file is present, so the parse does not
+    // probe it again.
+    const baseListed = segments.at(0)?.name === TURNS_FILE;
     const baseLog =
       reused >= 1 && turnsCache !== null
         ? turnsCache.base
-        : await readBaseLogFromDisk(dir);
+        : await readBaseLogFromDisk(dir, baseListed);
     const parsedExtras: ParsedLogSegment[] = [];
     for (let index = 1; index < segments.length; index++) {
       const cached =