Persist session commit keys with exclusive create

Write first-time commit keys with wx and reload on EEXIST. Wrap JSON.parse failures as Invalid commit signing key. Stop listIndexPaths from swallowing every error. Treat SessionStores as an interface. Drop the IMPLEMENTATION.md claim that exclusive-delta blob staging is in place.

Author: TheGreatAxios

docs/IMPLEMENTATION.md

@@ -403,9 +403,10 @@ segments (`turns-0001.jsonl`, ...) that seal at 256KB, so `git add` re-hashes on
 the small active segment instead of the whole growing file. Segment zero keeps the
 original filename, so a legacy monolithic `turns.jsonl` reads back as its own first
 segment. `load` and `readAt` concatenate every segment in order; a torn final line
-in the active segment (from a crash mid-write) is dropped on resume. Only tool-output
-blobs new since the last commit are staged, and stale segments deleted by a
-history rewrite (compaction) are removed from the tree on the next commit. The
+in the active segment (from a crash mid-write) is dropped on resume. The wrapper
+stages extra tool-output blobs it wrote since the last commit; vendor
+`base.commit()` also stages the whole `tool-output/` tree. Stale segments deleted
+by a history rewrite (compaction) are removed from the tree on the next commit. The
 per-commit git tree still grows one entry per spilled tool-output blob across the
 session; that tree re-write is inherent to git and left as residual cost.
 

src/session/assemble-runtime.test.ts

@@ -223,7 +223,7 @@ describe("assembleChatAgent", () => {
             expect(agentSessionIds).toEqual(["build-session"]);
             expect(agentStorages).toEqual([fakeStorage]);
             expect(agentAudits).toEqual([fakeStorage]);
-            expect(agentAudits[0]).toBe(agentStorages[0]);
+            expect(Object.is(agentAudits[0], agentStorages[0])).toBe(true);
             expect(agentCompactors).toEqual([builtCompactor]);
           },
         );

src/session/commit-signer.test.ts

@@ -0,0 +1,75 @@
+import { describe, test, expect } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { loadOrCreateCommitSigner } from "./commit-signer.js";
+
+const KEY_FILE = path.join("keys", "commit-ed25519.json");
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "commit-signer-"));
+}
+
+function keyPath(dir: string): string {
+  return path.join(dir, KEY_FILE);
+}
+
+function publicKeyInFile(dir: string): string {
+  const parsed = JSON.parse(fs.readFileSync(keyPath(dir), "utf8")) as { publicKey: string };
+  return parsed.publicKey;
+}
+
+describe("loadOrCreateCommitSigner", () => {
+  test("first call creates a signed-able signer and a 0600 key file", async () => {
+    const dir = tempDir();
+    const signer = await loadOrCreateCommitSigner(dir);
+    const signature = await signer("payload");
+    expect(typeof signature).toBe("string");
+    expect(signature.length).toBeGreaterThan(0);
+
+    const st = fs.statSync(keyPath(dir));
+    expect(st.mode & 0o777).toBe(0o600);
+  });
+
+  test("second call reloads the same key (same publicKey bytes in the file)", async () => {
+    const dir = tempDir();
+    await loadOrCreateCommitSigner(dir);
+    const firstPublic = publicKeyInFile(dir);
+    await loadOrCreateCommitSigner(dir);
+    expect(publicKeyInFile(dir)).toBe(firstPublic);
+  });
+
+  test("concurrent first-time create: both succeed, only one key file, both signers work", async () => {
+    const dir = tempDir();
+    const [a, b] = await Promise.all([
+      loadOrCreateCommitSigner(dir),
+      loadOrCreateCommitSigner(dir),
+    ]);
+    const sigA = await a("a");
+    const sigB = await b("b");
+    expect(typeof sigA).toBe("string");
+    expect(typeof sigB).toBe("string");
+    expect(sigA.length).toBeGreaterThan(0);
+    expect(sigB.length).toBeGreaterThan(0);
+    expect(fs.readdirSync(path.join(dir, "keys"))).toEqual(["commit-ed25519.json"]);
+  });
+
+  test("corrupt JSON throws Invalid commit signing key", async () => {
+    const dir = tempDir();
+    fs.mkdirSync(path.join(dir, "keys"));
+    fs.writeFileSync(keyPath(dir), "{not-json");
+    await expect(loadOrCreateCommitSigner(dir)).rejects.toThrow(
+      `Invalid commit signing key at ${keyPath(dir)}`,
+    );
+  });
+
+  test("invalid arktype shape throws Invalid commit signing key", async () => {
+    const dir = tempDir();
+    fs.mkdirSync(path.join(dir, "keys"));
+    fs.writeFileSync(keyPath(dir), JSON.stringify({ privateKey: 1 }));
+    await expect(loadOrCreateCommitSigner(dir)).rejects.toThrow(
+      `Invalid commit signing key at ${keyPath(dir)}`,
+    );
+  });
+});

src/session/commit-signer.ts

@@ -35,7 +35,16 @@ async function loadPersistedKeyPair(
     if (cause instanceof Error && "code" in cause && cause.code === "ENOENT") return null;
     throw cause;
   }
-  const parsed = PersistedKeyPair(JSON.parse(raw) as unknown);
+  let parsedJson: unknown;
+  try {
+    parsedJson = JSON.parse(raw);
+  } catch (cause) {
+    if (cause instanceof SyntaxError) {
+      throw new Error(`Invalid commit signing key at ${filePath}`, { cause });
+    }
+    throw cause;
+  }
+  const parsed = PersistedKeyPair(parsedJson);
   if (parsed instanceof type.errors) {
     throw new Error(`Invalid commit signing key at ${filePath}: ${parsed.summary}`);
   }
@@ -52,16 +61,27 @@ export async function loadOrCreateCommitSigner(dir: string): Promise<CommitSigne
   if (keyPair === null) {
     const generated = await generateKeyPair();
     await fs.promises.mkdir(keyDir, { recursive: true });
-    await fs.promises.writeFile(
-      filePath,
-      JSON.stringify({
-        privateKey: Buffer.from(generated.privateKey).toString("base64"),
-        publicKey: Buffer.from(generated.publicKey).toString("base64"),
-      }),
-      { encoding: "utf8", mode: 0o600 },
-    );
-    log.debug?.("wrote session commit signing key");
-    keyPair = generated;
+    try {
+      await fs.promises.writeFile(
+        filePath,
+        JSON.stringify({
+          privateKey: Buffer.from(generated.privateKey).toString("base64"),
+          publicKey: Buffer.from(generated.publicKey).toString("base64"),
+        }),
+        { encoding: "utf8", mode: 0o600, flag: "wx" },
+      );
+      log.debug?.("wrote session commit signing key");
+      keyPair = generated;
+    } catch (cause) {
+      if (cause instanceof Error && "code" in cause && cause.code === "EEXIST") {
+        keyPair = await loadPersistedKeyPair(filePath);
+        if (keyPair === null) {
+          throw new Error(`Commit signing key missing after EEXIST at ${filePath}`);
+        }
+      } else {
+        throw cause;
+      }
+    }
   }
   return (payload) => createSSHSignature(payload, keyPair.privateKey, keyPair.publicKey);
 }

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

@@ -539,7 +539,7 @@ describe("createSessionStores", () => {
   test("exposes the same object as ContextStore and AuditStore", async () => {
     const dir = tempDir();
     const { storage, audit } = await createSessionStores(dir);
-    expect(storage).toBe(audit);
+    expect(Object.is(storage, audit)).toBe(true);
     expect(typeof audit.commitAudit).toBe("function");
     expect(typeof audit.commitErrors).toBe("function");
     expect(typeof audit.loadAudit).toBe("function");

src/session/optimized-context-store.ts

@@ -307,11 +307,7 @@ export async function loadRecentTurns(dir: string, minTurns: number): Promise<Co
 }
 
 async function listIndexPaths(dir: string): Promise<Set<string>> {
-  try {
-    return new Set(await git.listFiles({ fs, dir }));
-  } catch {
-    return new Set();
-  }
+  return new Set(await git.listFiles({ fs, dir }));
 }
 
 async function extraSegmentNamesAtCommit(dir: string, hash: string): Promise<string[]> {
@@ -383,10 +379,10 @@ function extraCommitPaths(paths: readonly string[]): string[] {
   return paths.filter((filepath) => !VENDOR_COMMIT_ROOT_FILES.has(filepath));
 }
 
-export type SessionStores = {
+export interface SessionStores {
   storage: ContextStore;
   audit: AuditStore;
-};
+}
 
 /**
  * Local wrapper around the Interchange git store that avoids O(session length)