amalgm 0.1.175 → 0.1.176

package/runtime/scripts/amalgm-mcp/workspace/card.js

@@ -15,6 +15,7 @@ const {
   classifyDirectory,
   headAndDirty,
   headOid,
+  localBranches,
   listWorktrees,
   operationState,
   originUrl,
@@ -63,10 +64,11 @@ async function observeWorktree(classified) {
   const worktreeRoot = classified.toplevel;
   const gitDir = await fs.promises.realpath(classified.gitDir);
   const replica = replicaForGitDir(gitDir);
-  const [{ head, dirty }, operation, remote] = await Promise.all([
+  const [{ head, dirty }, operation, remote, branches] = await Promise.all([
     headAndDirty(worktreeRoot),
     operationState(worktreeRoot),
     originUrl(worktreeRoot),
+    localBranches(worktreeRoot),
   ]);
   let anchor = replica.rootCommit;
   if (!anchor && head.oid) {
@@ -78,12 +80,19 @@ async function observeWorktree(classified) {
   const objects = head.oid && repoIdentity
     ? await require('./objects').objectSourceFor(worktreeRoot, repoIdentity, head.oid)
     : null;
+  const refs = await Promise.all(branches.map(async (branch) => ({
+    ...branch,
+    objects: repoIdentity
+      ? await require('./objects').objectSourceFor(worktreeRoot, repoIdentity, branch.oid)
+      : null,
+  })));
   return {
     card: CARD_CONTRACT,
     machine: machineId(),
     replica: replica.replicaId,
     path: worktreeRoot,
     gitDir,
+    commonGitDir: classified.commonDir,
     repo: {
       remote: repoIdentity,
       rootCommit: anchor,
@@ -91,6 +100,7 @@ async function observeWorktree(classified) {
     objects,
     kind: cardKind(classified),
     head,
+    refs,
     dirty,
     operation,
     observedAt: new Date().toISOString(),

package/runtime/scripts/amalgm-mcp/workspace/cards.js

@@ -52,24 +52,6 @@ function rowToCard(row) {
   };
 }
 
-/**
- * positionAt is the card's committed-state clock. Working-tree changes
- * update the card without pretending that branch/commit moved.
- */
-function withPositionAt(card, row) {
-  if (!row) return { ...card, positionAt: card.observedAt };
-  const previous = JSON.parse(row.card_json);
-  const samePosition = previous.head?.branch === card.head?.branch
-    && previous.head?.oid === card.head?.oid
-    && Boolean(previous.head?.detached) === Boolean(card.head?.detached);
-  return {
-    ...card,
-    positionAt: samePosition
-      ? previous.positionAt || previous.observedAt || card.observedAt
-      : card.observedAt,
-  };
-}
-
 function listRepoCards() {
   return openLocalDb()
     .prepare('SELECT * FROM repo_cards ORDER BY path')
@@ -261,7 +243,7 @@ async function runRefresh() {
 
     for (const { card: observedCard, root } of built) {
       const row = readRow.get(observedCard.replica);
-      const card = withPositionAt(observedCard, row);
+      const card = observedCard;
       const fingerprint = cardFingerprint(card);
       if (row && row.fingerprint === fingerprint && row.health === 'healthy') {
         // Which registration covers a checkout can change with no git
@@ -341,7 +323,7 @@ async function refreshRepoCard(replicaId) {
 
   const observedCard = await buildRepoCard(row.path);
   if (observedCard.replica !== replicaId) return refreshRepoCards();
-  const card = withPositionAt(observedCard, row);
+  const card = observedCard;
   const fingerprint = cardFingerprint(card);
   if (row.fingerprint === fingerprint && row.health === 'healthy') {
     service.lastRefresh = {
@@ -442,7 +424,13 @@ function watchGitDir(card) {
   const ring = () => ringDoorbell(card.replica);
   // The git dir itself carries HEAD, index, and operation markers; logs/
   // carries the reflog, which moves on every commit, checkout, and reset.
-  for (const dir of [card.gitDir, path.join(card.gitDir, 'logs')]) {
+  const common = card.commonGitDir || card.gitDir;
+  for (const dir of [
+    card.gitDir,
+    path.join(card.gitDir, 'logs'),
+    path.join(common, 'refs', 'heads'),
+    path.join(common, 'logs', 'refs', 'heads'),
+  ]) {
     try {
       const watcher = fs.watch(dir, ring);
       watcher.on('error', () => watcher.close());

package/runtime/scripts/amalgm-mcp/workspace/checkpoint.js

@@ -1,36 +1,31 @@
 'use strict';
 
 /**
- * Repo checkpoints: each machine's uncommitted work as one recoverable
- * fact on the rail.
+ * The checkpoint publisher.
  *
- * The two-value repo sync model: the card carries B — where the repo
- * stands (commit, branch, dirty counts) — and the checkpoint carries D —
- * the exact uncommitted content as one patch against B. A checkpoint
- * lives in a document only this machine ever writes: one derived-id
- * resource per (machine, repository identity), so machines never share a
- * writer and the doc rail's merge question never arises. Ignored files
- * never travel by construction — git does not list them.
+ * One checkpoint operation says only this:
  *
- * Checkpoints are captured only from settled repos (no operation in
- * flight) and only for primary checkouts with a transportable repo
- * identity. A clean repo publishes { revision: null } — "nothing dirty"
- * is a fact peers act on, not an absence. Large dirty states use the same
- * chunk lane as unpushed commits instead of changing the model.
+ *   shared checkpoint I read  →  working tree I now have
+ *
+ * Both sides are exact patches against the card commit. The repo reducer
+ * applies these transitions in server rail order. A remote edit that was
+ * merely materialized is therefore not republished as new work, while a
+ * real local edit or revert is one new transition.
+ *
+ * Checkpoint files below are local capture cache only. Their operations ride
+ * inside the machine wall, so the entire repo has one ordered stream.
  */
 
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const { AMALGM_DIR } = require('../config');
-const { subscribeStateEvents } = require('../state/events');
-const { machineId, userId } = require('./identity');
+const { appendStateEvent, subscribeStateEvents } = require('../state/events');
+const { machineId } = require('./identity');
 const { listRepoCards } = require('./cards');
-const { captureWorktreeDiff } = require('./git');
-const { ensureDocBound } = require('./binding');
-const { listPairStates } = require('./ledger');
+const { captureCheckpoint } = require('./git');
 
-const CHECKPOINT_CONTRACT = 'repo-checkpoint@3';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@4';
 const MAX_INLINE_DIFF_BYTES = 512 * 1024;
 const PUBLISH_QUIET_MS = 25;
 const RECONCILE_INTERVAL_MS = 30_000;
@@ -40,7 +35,7 @@ const service = {
   publishTimer: null,
   reconcileTimer: null,
   unsubscribe: null,
-  counters: { published: 0, skips: 0, unbound: 0, failures: 0 },
+  counters: { published: 0, skips: 0, waiting: 0, failures: 0 },
   lastRun: null,
 };
 
@@ -48,141 +43,217 @@ let publishing = null;
 let publishAllRequested = false;
 const publishReplicasRequested = new Set();
 
-function sha256(text) {
-  return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
-}
-
 /** The transportable identity of a card's repository, or null. */
 function repoKeyOfCard(card) {
   if (card?.repo?.remote) return card.repo.remote;
   return card?.repo?.rootCommit ? `root:${card.repo.rootCommit}` : null;
 }
 
-/** One resource per (machine, repo) per account — same id on every machine. */
-function checkpointResourceId(machine, repoKey, forUserId = userId()) {
-  if (!forUserId || !machine || !repoKey) return null;
-  const digest = crypto.createHash('sha256')
-    .update(`amalgm-repo-checkpoint@3|${forUserId}|${machine}|${repoKey}`)
-    .digest('base64url');
-  return `shr_rc3${digest.slice(0, 40)}`;
-}
-
-/** The local file backing a checkpoint doc — own or an attached peer's. */
 function checkpointFile(machine, repoKey) {
   const digest = crypto.createHash('sha256')
     .update(`${CHECKPOINT_CONTRACT}|${machine}|${repoKey}`)
     .digest('hex')
     .slice(0, 24);
-  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v4', `${digest}.json`);
 }
 
-/** The content identity of a dirty state: same base, same patch → same revision. */
-function revisionOf(baseOid, diff) {
-  return crypto.createHash('sha256').update(`${baseOid}\n${diff}`, 'utf8').digest('hex');
+function revisionOf(baseOid, indexDiff, worktreeDiff = '') {
+  return indexDiff === '' && worktreeDiff === ''
+    ? null
+    : crypto.createHash('sha256')
+      .update(`${baseOid}\nindex\n${indexDiff}\nworktree\n${worktreeDiff}`, 'utf8')
+      .digest('hex');
 }
 
 function parseCheckpoint(text) {
   try {
     const entry = JSON.parse(text);
-    if (entry?.checkpoint !== CHECKPOINT_CONTRACT || !entry.machine || !entry.repoKey) return null;
+    if (
+      entry?.checkpoint !== CHECKPOINT_CONTRACT
+      || !entry.machine
+      || !entry.repoKey
+      || !entry.from
+      || !entry.to
+    ) return null;
     return entry;
   } catch {
     return null;
   }
 }
 
-/** A machine's published checkpoint for a repo, as this machine sees it. */
 function readCheckpoint(machine, repoKey) {
-  const file = checkpointFile(machine, repoKey);
-  if (!fs.existsSync(file)) return null;
-  return parseCheckpoint(require('../state/docs').getDocText(file));
+  try {
+    return parseCheckpoint(fs.readFileSync(checkpointFile(machine, repoKey), 'utf8'));
+  } catch {
+    return null;
+  }
 }
 
-/**
- * Whose work this machine's tree already holds for a repo, from the
- * reconciliation ledger. Stamped onto outgoing checkpoints so "this diff
- * incorporates peer X's revision R" is an explicit fact on the wire —
- * a receiver can tell its own echoed work from new content.
- */
-function incorporatesFor(repoKey) {
-  const map = {};
-  for (const state of listPairStates()) {
-    if (state.repoKey === repoKey && state.holdsContent && state.peerRevision) {
-      map[state.peerMachine] = state.peerRevision;
-    }
-  }
-  return Object.keys(map).length ? map : undefined;
+function valueIdentity(value) {
+  return JSON.stringify({
+    revision: value?.revision ?? null,
+    payload: value?.payload ?? null,
+  });
 }
 
-async function buildEnvelope(card, machine, repoKey) {
-  if (!card.head.oid) return null;
-  const base = {
-    checkpoint: CHECKPOINT_CONTRACT,
-    machine,
-    repoKey,
-    branch: card.head.branch,
-    baseOid: card.head.oid,
-    capturedAt: new Date().toISOString(),
-  };
-  const dirtyTotal = card.dirty.staged + card.dirty.unstaged + card.dirty.untracked + card.dirty.conflicted;
-  if (dirtyTotal === 0) return { ...base, revision: null, diff: '' };
+function sameTransition(left, right) {
+  return left
+    && left.baseOid === right.baseOid
+    && left.branch === right.branch
+    && valueIdentity(left.from) === valueIdentity(right.from)
+    && valueIdentity(left.to) === valueIdentity(right.to)
+    && JSON.stringify(left.parked || []) === JSON.stringify(right.parked || []);
+}
 
-  const captured = await captureWorktreeDiff(card.path);
-  if (captured.diff === null) return { ...base, revision: null, diff: '', skipped: captured.reason };
-  // The repo may have moved between the card and this capture; the next
-  // doorbell pass re-cards and re-captures a coherent pair.
-  if (captured.baseOid !== card.head.oid) return null;
-  const incorporates = incorporatesFor(repoKey);
-  const revision = revisionOf(captured.baseOid, captured.diff);
-  const payload = captured.bytes > MAX_INLINE_DIFF_BYTES
-    ? require('./objects').publishPayload(
-      `${machine}\n${repoKey}\n${revision}`,
-      Buffer.from(captured.diff),
-    )
-    : null;
+function checkpointValue(machine, repoKey, baseOid, indexDiff, worktreeDiff) {
+  const revision = revisionOf(baseOid, indexDiff, worktreeDiff);
+  const bytes = Buffer.from(JSON.stringify({ indexDiff, worktreeDiff }), 'utf8');
+  if (bytes.length <= MAX_INLINE_DIFF_BYTES) return { revision, indexDiff, worktreeDiff };
   return {
-    ...base,
-    baseOid: captured.baseOid,
     revision,
-    diff: payload ? '' : captured.diff,
-    ...(payload ? { payload } : {}),
-    ...(incorporates ? { incorporates } : {}),
+    payload: require('./objects').publishPayload(
+      `${CHECKPOINT_CONTRACT}\n${machine}\n${repoKey}\n${baseOid}\n${revision || 'clean'}`,
+      bytes,
+      repoKey,
+    ),
   };
 }
 
+function readCheckpointValue(baseOid, value) {
+  let indexDiff = typeof value?.indexDiff === 'string' ? value.indexDiff : '';
+  let worktreeDiff = typeof value?.worktreeDiff === 'string' ? value.worktreeDiff : '';
+  if (value?.payload) {
+    const payload = require('./objects').readPayload(value.payload);
+    if (payload.state !== 'ready') {
+      return { state: payload.state, indexDiff: null, worktreeDiff: null };
+    }
+    try {
+      const parsed = JSON.parse(payload.bytes.toString('utf8'));
+      indexDiff = parsed.indexDiff;
+      worktreeDiff = parsed.worktreeDiff;
+    } catch {
+      return { state: 'payload-invalid', indexDiff: null, worktreeDiff: null };
+    }
+  }
+  if (
+    typeof indexDiff !== 'string'
+    || typeof worktreeDiff !== 'string'
+    || revisionOf(baseOid, indexDiff, worktreeDiff) !== (value?.revision ?? null)
+  ) {
+    return { state: 'revision-mismatch', indexDiff: null, worktreeDiff: null };
+  }
+  return { state: 'ready', indexDiff, worktreeDiff };
+}
+
+function ownPublishedCard(card) {
+  const own = require('./wall').readWall().find((entry) => entry.machine === machineId());
+  const published = own?.cards?.find((candidate) => candidate.replica === card.replica);
+  if (
+    !published
+    || !Number.isInteger(published.positionVersion)
+    || published.positionVersion < 1
+    || published.head?.branch !== card.head?.branch
+    || published.head?.oid !== card.head?.oid
+    || Boolean(published.head?.detached) !== Boolean(card.head?.detached)
+  ) return null;
+  return published;
+}
+
 async function publishPass(replicaId = null) {
   const machine = machineId();
-  const run = { published: 0, skips: 0, unbound: 0, failures: 0 };
+  const run = { published: 0, skips: 0, waiting: 0, failures: 0 };
   for (const card of listRepoCards()) {
     if (replicaId && card.replica !== replicaId) continue;
     if (card.health !== 'healthy' || card.kind !== 'primary' || card.operation !== 'none') continue;
     const repoKey = repoKeyOfCard(card);
-    const resourceId = checkpointResourceId(machine, repoKey);
-    if (!resourceId) continue;
+    if (!repoKey || !card.head?.oid) continue;
     try {
+      const publishedCard = ownPublishedCard(card);
+      const reduced = require('./reducer').readRepoState(repoKey);
+      if (
+        !publishedCard
+        || !reduced
+        || reduced.baseOid !== card.head.oid
+        || reduced.branch !== card.head.branch
+        || typeof reduced.indexDiff !== 'string'
+        || typeof reduced.worktreeDiff !== 'string'
+      ) {
+        run.waiting += 1;
+        continue;
+      }
+
+      const captured = await captureCheckpoint(card.path);
+      if (captured.indexDiff === null || captured.baseOid !== card.head.oid) {
+        run.waiting += 1;
+        continue;
+      }
+      const sharedRevision = revisionOf(card.head.oid, reduced.indexDiff, reduced.worktreeDiff);
+      const localRevision = revisionOf(card.head.oid, captured.indexDiff, captured.worktreeDiff);
       const file = checkpointFile(machine, repoKey);
-      const binding = await ensureDocBound({ resourceId, filePath: file, create: true });
-      if (!binding.bound) {
-        run.unbound += 1;
+      const existing = readCheckpoint(machine, repoKey);
+      const parked = await Promise.all((reduced.parked || []).map(async (entry) => ({
+        ...entry,
+        objects: await require('./objects').bundleSourceFor(card.path, repoKey, entry.oid),
+      })));
+
+      // Exact equality means the working tree merely materialized the shared
+      // checkpoint. Keep the writer's last transition because it remains part
+      // of the reducer input, but do not invent an echo operation.
+      if (sharedRevision === localRevision) {
+        const refreshed = existing ? { ...existing, parked } : null;
+        if (refreshed && !sameTransition(existing, refreshed)) {
+          fs.writeFileSync(file, `${JSON.stringify(refreshed)}\n`);
+          appendStateEvent({
+            resource: 'repo-checkpoints',
+            op: 'update',
+            id: card.replica,
+            value: refreshed,
+            source: 'repo-checkpoint:parked-objects',
+          });
+          run.published += 1;
+          continue;
+        }
+        run.skips += 1;
         continue;
       }
-      const envelope = await buildEnvelope(card, machine, repoKey);
-      if (!envelope) continue;
-      const docs = require('../state/docs');
-      const current = docs.getDocText(file);
-      const existing = parseCheckpoint(current);
-      const unchanged = existing
-        && existing.baseOid === envelope.baseOid
-        && existing.revision === envelope.revision
-        && (existing.skipped || null) === (envelope.skipped || null)
-        && JSON.stringify(existing.payload ?? null) === JSON.stringify(envelope.payload ?? null)
-        && JSON.stringify(existing.incorporates ?? null) === JSON.stringify(envelope.incorporates ?? null);
-      if (unchanged) {
+
+      const envelope = {
+        checkpoint: CHECKPOINT_CONTRACT,
+        machine,
+        repoKey,
+        branch: card.head.branch,
+        baseOid: card.head.oid,
+        cardVersion: publishedCard.positionVersion,
+        from: checkpointValue(
+          machine,
+          repoKey,
+          card.head.oid,
+          reduced.indexDiff,
+          reduced.worktreeDiff,
+        ),
+        to: checkpointValue(
+          machine,
+          repoKey,
+          card.head.oid,
+          captured.indexDiff,
+          captured.worktreeDiff,
+        ),
+        parked,
+        capturedAt: new Date().toISOString(),
+      };
+      if (sameTransition(existing, envelope)) {
         run.skips += 1;
         continue;
       }
-      envelope.publishedAt = new Date().toISOString();
-      docs.writeDocText(file, `${JSON.stringify(envelope)}\n`, { baseHash: sha256(current) });
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, `${JSON.stringify(envelope)}\n`);
+      appendStateEvent({
+        resource: 'repo-checkpoints',
+        op: existing ? 'update' : 'insert',
+        id: card.replica,
+        value: envelope,
+        source: 'repo-checkpoint:capture',
+      });
       run.published += 1;
     } catch (error) {
       run.failures += 1;
@@ -191,34 +262,28 @@ async function publishPass(replicaId = null) {
   }
   service.counters.published += run.published;
   service.counters.skips += run.skips;
-  service.counters.unbound += run.unbound;
+  service.counters.waiting += run.waiting;
   service.counters.failures += run.failures;
   service.lastRun = { ...run, at: new Date().toISOString() };
   return run;
 }
 
-/**
- * Publish this machine's checkpoint docs. Calls are one serialized queue:
- * a worktree can change again while Git is being captured, but two
- * whole-checkpoint replacements must never race each other.
- */
 function publishCheckpoints(replicaId = null) {
   if (replicaId) publishReplicasRequested.add(replicaId);
   else publishAllRequested = true;
   if (publishing) return publishing;
-
   publishing = (async () => {
-    let lastRun = { published: 0, skips: 0, unbound: 0, failures: 0 };
+    let lastRun = { published: 0, skips: 0, waiting: 0, failures: 0 };
     while (publishAllRequested || publishReplicasRequested.size > 0) {
       if (publishAllRequested) {
         publishAllRequested = false;
         publishReplicasRequested.clear();
         lastRun = await publishPass();
-        continue;
+      } else {
+        const replicas = [...publishReplicasRequested];
+        publishReplicasRequested.clear();
+        for (const requested of replicas) lastRun = await publishPass(requested);
       }
-      const replicas = [...publishReplicasRequested];
-      publishReplicasRequested.clear();
-      for (const requested of replicas) lastRun = await publishPass(requested);
     }
     return lastRun;
   })().finally(() => {
@@ -240,7 +305,7 @@ function startCheckpointService() {
   if (service.started) return;
   service.started = true;
   service.unsubscribe = subscribeStateEvents((event) => {
-    if (event.resource === 'repo-cards') schedulePublish();
+    if (event.resource === 'repo-cards' || event.resource === 'workspace-reducer') schedulePublish();
   });
   service.reconcileTimer = setInterval(schedulePublish, RECONCILE_INTERVAL_MS);
   service.reconcileTimer.unref?.();
@@ -271,11 +336,11 @@ module.exports = {
   CHECKPOINT_CONTRACT,
   MAX_INLINE_DIFF_BYTES,
   checkpointFile,
-  checkpointResourceId,
   checkpointStats,
   parseCheckpoint,
   publishCheckpoints,
   readCheckpoint,
+  readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
   startCheckpointService,

package/runtime/scripts/amalgm-mcp/workspace/git.js

@@ -158,6 +158,18 @@ async function listWorktrees(worktreeRoot) {
   return worktrees.filter((worktree) => !worktree.bare);
 }
 
+/** Every local branch ref, sorted by name. */
+async function localBranches(worktreeRoot) {
+  const { stdout } = await git(
+    ['-C', worktreeRoot, 'for-each-ref', '--format=%(refname:strip=2)%00%(objectname)', 'refs/heads/'],
+    worktreeRoot,
+  );
+  return stdout.trim().split('\n').filter(Boolean).map((line) => {
+    const [name, oid] = line.split('\0');
+    return { name, oid };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+}
+
 /**
  * HEAD position and working-tree cleanliness in one `git status
  * --porcelain=v2 -z --branch` call.
@@ -278,6 +290,16 @@ async function isAncestor(worktreeRoot, ancestorOid, descendantOid) {
   return result.exitCode === 0;
 }
 
+/** The shared ancestor of two commits, or null for unrelated histories. */
+async function mergeBase(worktreeRoot, leftOid, rightOid) {
+  const result = await git(
+    ['-C', worktreeRoot, 'merge-base', leftOid, rightOid],
+    worktreeRoot,
+    { okCodes: [0, 1, 128] },
+  );
+  return result.exitCode === 0 ? result.stdout.trim() || null : null;
+}
+
 /** Is this commit already obtainable from an origin remote-tracking ref? */
 async function originContains(worktreeRoot, oid) {
   const { stdout } = await git(
@@ -331,15 +353,64 @@ async function captureWorktreeDiff(worktreeRoot, { maxBytes = Infinity } = {}) {
   return { baseOid, diff: parts.join(''), bytes };
 }
 
+/**
+ * Git's exact two-layer uncommitted state:
+ *   HEAD → index, then index → working tree.
+ *
+ * Untracked, non-ignored files belong to the working-tree layer. Keeping
+ * these deltas separate preserves what the user deliberately staged.
+ */
+async function captureCheckpoint(worktreeRoot, { maxBytes = Infinity } = {}) {
+  const baseOid = await headOid(worktreeRoot);
+  if (!baseOid) return { baseOid: null, indexDiff: null, worktreeDiff: null, reason: 'unborn' };
+
+  const staged = await git(
+    ['-C', worktreeRoot, ...PATCH_ARGS, 'diff', '--cached', 'HEAD', '--binary', '--full-index'],
+    worktreeRoot,
+  );
+  const unstaged = await git(
+    ['-C', worktreeRoot, ...PATCH_ARGS, 'diff', '--binary', '--full-index'],
+    worktreeRoot,
+  );
+  const worktreeParts = [unstaged.stdout];
+  let bytes = Buffer.byteLength(staged.stdout) + Buffer.byteLength(unstaged.stdout);
+  const untracked = await git(
+    ['-C', worktreeRoot, 'ls-files', '--others', '--exclude-standard', '-z'],
+    worktreeRoot,
+  );
+  for (const file of untracked.stdout.split('\0').filter(Boolean).sort()) {
+    if (bytes > maxBytes) break;
+    const creation = await git(
+      ['-C', worktreeRoot, ...PATCH_ARGS, 'diff', '--no-index', '--binary', '--full-index', '--', '/dev/null', file],
+      worktreeRoot,
+      { okCodes: [0, 1] },
+    );
+    worktreeParts.push(creation.stdout);
+    bytes += Buffer.byteLength(creation.stdout);
+  }
+  if (bytes > maxBytes) {
+    return { baseOid, indexDiff: null, worktreeDiff: null, reason: 'too-large', bytes };
+  }
+  return {
+    baseOid,
+    indexDiff: staged.stdout,
+    worktreeDiff: worktreeParts.join(''),
+    bytes,
+  };
+}
+
 module.exports = {
   GitError,
+  captureCheckpoint,
   captureWorktreeDiff,
   classifyDirectory,
   hasCommit,
   headAndDirty,
   headOid,
   isAncestor,
+  localBranches,
   listWorktrees,
+  mergeBase,
   operationState,
   originContains,
   originUrl,