Use the operator git identity for session checkpoints

Cycle commits shell out to system git with a synthetic harness author, so operator commit-author hooks reject every tool cycle. Using global user.name and user.email when both are set makes those hooks see a real identity.

Author: TheGreatAxios

docs/IMPLEMENTATION.md

@@ -358,6 +358,10 @@ Session runtime state lives under the global projects tree (not in the repo):
 
 `createOptimizedContextStore` (`src/session/optimized-context-store.ts`) wraps the
 Interchange git store to keep per-checkpoint cost independent of session length.
+Checkpoint commits go through system git and use the operator's global
+`user.name` / `user.email` when both are set, so commit-author hooks see a real
+identity; otherwise they fall back to Interchange's harness author
+(`interchange-harness`, `harness@interchange.local`).
 The append-only snapshots (`turns.jsonl`, `prompt.jsonl`) are written as rolling
 segments (`turns-0001.jsonl`, ...) that seal at 256KB, so `git add` re-hashes only
 the small active segment instead of the whole growing file. Segment zero keeps the

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

@@ -3,7 +3,11 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import type { ConversationTurn } from "@intx/types/runtime";
-import { createOptimizedContextStore, loadRecentTurns } from "./optimized-context-store.js";
+import {
+  createOptimizedContextStore,
+  loadRecentTurns,
+  resolveCheckpointAuthor,
+} from "./optimized-context-store.js";
 import { segmentFileName, listSegmentFiles } from "./incremental-jsonl.js";
 
 const TURNS_FILE = "turns.jsonl";
@@ -12,6 +16,39 @@ function tempDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), "opt-store-"));
 }
 
+function isolatedGitEnv(gitconfig: string): NodeJS.ProcessEnv {
+  const dir = tempDir();
+  const config = path.join(dir, "gitconfig");
+  fs.writeFileSync(config, gitconfig);
+  return {
+    ...process.env,
+    GIT_CONFIG_GLOBAL: config,
+    GIT_CONFIG_SYSTEM: "/dev/null",
+    GIT_CONFIG_NOSYSTEM: "1",
+    HOME: dir,
+  };
+}
+
+async function headAuthor(dir: string): Promise<{ name: string; email: string }> {
+  const proc = Bun.spawn(["git", "-C", dir, "log", "-1", "--format=%an%n%ae"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`git log failed: ${stderr.trim() || stdout.trim()}`);
+  }
+  const [name, email] = stdout.trimEnd().split("\n");
+  if (name === undefined || email === undefined) {
+    throw new Error(`unexpected git log author output: ${JSON.stringify(stdout)}`);
+  }
+  return { name, email };
+}
+
 function turn(text: string): ConversationTurn {
   return { role: "user", content: [{ type: "text", text }], timestamp: 1 };
 }
@@ -472,4 +509,52 @@ describe("createOptimizedContextStore checkpoint", () => {
     const atHead = await store.readAt(head.hash);
     expect(atHead).toHaveLength(total);
   }, 20_000);
+
+  test("records the operator identity on the cycle commit", async () => {
+    const dir = tempDir();
+    const store = await createOptimizedContextStore(dir, {
+      author: { name: "Sawyer", email: "sawyer@dirtroad.dev" },
+    });
+    await store.writeMetadata({
+      pendingOperations: [],
+      tokenUsage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, thinking: 0 },
+    });
+    await store.commit({ message: "checkpoint: tool-execution" });
+
+    expect(await headAuthor(dir)).toEqual({
+      name: "Sawyer",
+      email: "sawyer@dirtroad.dev",
+    });
+  });
+});
+
+describe("resolveCheckpointAuthor", () => {
+  test("uses global user.name and user.email when both are set", async () => {
+    const env = isolatedGitEnv(`[user]\n\tname = Sawyer\n\temail = sawyer@dirtroad.dev\n`);
+    await expect(resolveCheckpointAuthor(env)).resolves.toEqual({
+      name: "Sawyer",
+      email: "sawyer@dirtroad.dev",
+    });
+  });
+
+  test("falls back to the harness identity when global config is missing", async () => {
+    const env = isolatedGitEnv("");
+    await expect(resolveCheckpointAuthor(env)).resolves.toEqual({
+      name: "interchange-harness",
+      email: "harness@interchange.local",
+    });
+  });
+
+  test("falls back when only one of name or email is set", async () => {
+    const nameOnly = isolatedGitEnv(`[user]\n\tname = Sawyer\n`);
+    const emailOnly = isolatedGitEnv(`[user]\n\temail = sawyer@dirtroad.dev\n`);
+    await expect(resolveCheckpointAuthor(nameOnly)).resolves.toEqual({
+      name: "interchange-harness",
+      email: "harness@interchange.local",
+    });
+    await expect(resolveCheckpointAuthor(emailOnly)).resolves.toEqual({
+      name: "interchange-harness",
+      email: "harness@interchange.local",
+    });
+  });
 });

src/session/optimized-context-store.ts

@@ -29,7 +29,16 @@ const TOOL_OUTPUT_DIR = "tool-output";
 
 const log = getLogger([LOG_NAMESPACE_ROOT, "session", "context-store"]);
 
-const AUTHOR = {
+export type CheckpointAuthor = {
+  name: string;
+  email: string;
+};
+
+// Cycle commits shell out to system git, so operator commit-author hooks see
+// this identity. Prefer their global git user when both name and email are
+// set; otherwise keep Interchange's harness fallback so machines without a
+// git identity still checkpoint.
+const HARNESS_AUTHOR: CheckpointAuthor = {
   name: "interchange-harness",
   email: "harness@interchange.local",
 };
@@ -299,16 +308,20 @@ export async function loadRecentTurns(dir: string, minTurns: number): Promise<Co
   return turns;
 }
 
-async function runGit(dir: string, args: string[]): Promise<string> {
+async function runGit(dir: string, args: string[], author?: CheckpointAuthor): Promise<string> {
   const proc = Bun.spawn(["git", "-C", dir, ...args], {
     stdout: "pipe",
     stderr: "pipe",
     env: {
       ...process.env,
-      GIT_AUTHOR_NAME: AUTHOR.name,
-      GIT_AUTHOR_EMAIL: AUTHOR.email,
-      GIT_COMMITTER_NAME: AUTHOR.name,
-      GIT_COMMITTER_EMAIL: AUTHOR.email,
+      ...(author === undefined
+        ? {}
+        : {
+            GIT_AUTHOR_NAME: author.name,
+            GIT_AUTHOR_EMAIL: author.email,
+            GIT_COMMITTER_NAME: author.name,
+            GIT_COMMITTER_EMAIL: author.email,
+          }),
     },
   });
   const [exitCode, stdout, stderr] = await Promise.all([
@@ -322,6 +335,34 @@ async function runGit(dir: string, args: string[]): Promise<string> {
   return stdout.trimEnd();
 }
 
+async function gitConfigGlobal(key: string, env: NodeJS.ProcessEnv): Promise<string | null> {
+  const proc = Bun.spawn(["git", "config", "--global", "--get", key], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  });
+  const [exitCode, stdout] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
+  if (exitCode !== 0) return null;
+  const value = stdout.trim();
+  return value.length > 0 ? value : null;
+}
+
+/**
+ * Author for Corbits cycle commits. Uses the operator's global git identity
+ * when both `user.name` and `user.email` are set; otherwise the Interchange
+ * harness identity.
+ */
+export async function resolveCheckpointAuthor(
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<CheckpointAuthor> {
+  const [name, email] = await Promise.all([
+    gitConfigGlobal("user.name", env),
+    gitConfigGlobal("user.email", env),
+  ]);
+  if (name === null || email === null) return HARNESS_AUTHOR;
+  return { name, email };
+}
+
 /**
  * Names of the tail turn segments (`turns-0001.jsonl`, ...) present in a commit
  * tree, in segment order. The base store reads the zeroth segment itself; these
@@ -395,7 +436,11 @@ async function reconcileSegmentStaging(
  * segment files so `git add` re-hashes only the small active segment, and only
  * spilled tool-output blobs that are new since the last commit are staged.
  */
-export async function createOptimizedContextStore(dir: string): Promise<ContextStore> {
+export async function createOptimizedContextStore(
+  dir: string,
+  opts?: { author?: CheckpointAuthor },
+): Promise<ContextStore> {
+  const author = opts?.author ?? (await resolveCheckpointAuthor());
   const base = await createIsogitStore(dir);
   const pendingBlobFilepaths = new Set<string>();
   const pendingSegmentPaths = new Set<string>();
@@ -550,12 +595,11 @@ export async function createOptimizedContextStore(dir: string): Promise<ContextS
       if (remove.length > 0) {
         await runGit(dir, ["rm", "--cached", "--ignore-unmatch", "--", ...remove]);
       }
-      await runGit(dir, [
-        "commit",
-        "-m",
-        options.message,
-        `--author=${AUTHOR.name} <${AUTHOR.email}>`,
-      ]);
+      await runGit(
+        dir,
+        ["commit", "-m", options.message, `--author=${author.name} <${author.email}>`],
+        author,
+      );
       pendingBlobFilepaths.clear();
       pendingSegmentPaths.clear();
       return describeHead(dir, options.message);