amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/workspace-local-intent.test.js

@@ -1,1999 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const crypto = require('crypto');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execFileSync } = require('child_process');
-
-const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-local-intent-'));
-process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
-process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
-process.env.AMALGM_COMPUTER_ID = 'machine-intent';
-process.env.AMALGM_DEVICE_ID = 'machine-intent';
-fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
-const OWNER = '11111111-1111-4111-8111-111111111111';
-fs.writeFileSync(
-  path.join(process.env.AMALGM_DIR, 'computer.json'),
-  JSON.stringify({ computer_id: 'machine-intent', user_id: OWNER }),
-);
-
-const { closeLocalDb, openLocalDb } = require('../state/db');
-const attachments = require('../state/attachments');
-const mutations = require('../state/mutations');
-const replicas = require('../state/replicas');
-const checkpoint = require('../workspace/checkpoint');
-const intent = require('../workspace/intent');
-const merge = require('../workspace/merge');
-const projectStream = require('../workspace/project-stream');
-const reducer = require('../workspace/reducer');
-const wall = require('../workspace/wall');
-
-test.after(() => {
-  closeLocalDb();
-  fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-
-function git(repo, ...args) {
-  return execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-}
-
-function createRepo(name) {
-  const repo = path.join(tempRoot, name);
-  fs.mkdirSync(repo, { recursive: true });
-  git(repo, 'init', '-q');
-  git(repo, 'config', 'user.email', 'intent@example.test');
-  git(repo, 'config', 'user.name', 'Intent Test');
-  fs.writeFileSync(path.join(repo, 'file.txt'), 'base\n');
-  git(repo, 'add', '.');
-  git(repo, 'commit', '-qm', 'base');
-  return repo;
-}
-
-function bundle(resourceId, oid, byte = 'a') {
-  const chunks = [{ sha256: byte.repeat(64), bytes: 1 }];
-  return {
-    kind: 'bundle',
-    contract: projectStream.BUNDLE_CONTRACT,
-    resourceId,
-    oid,
-    ref: `refs/amalgm/exports/${oid}`,
-    checksum: crypto.createHash('sha256').update(JSON.stringify(chunks)).digest('hex'),
-    bytes: 1,
-    chunks,
-  };
-}
-
-function cardFor(project, repo, replica = `replica-${project.resourceId.slice(-4)}`) {
-  const oid = git(repo, 'rev-parse', 'HEAD');
-  const branches = git(repo, 'for-each-ref', '--format=%(refname:short) %(objectname)', 'refs/heads')
-    .split('\n')
-    .filter(Boolean)
-    .map((line, index) => {
-      const [name, branchOid] = line.split(' ');
-      return { name, oid: branchOid, objects: bundle(project.resourceId, branchOid, String(index + 1)) };
-    });
-  const branch = git(repo, 'branch', '--show-current') || null;
-  return {
-    card: projectStream.CARD_CONTRACT,
-    machine: 'machine-intent',
-    replica,
-    path: fs.realpathSync(repo),
-    kind: 'primary',
-    health: 'healthy',
-    operation: 'none',
-    head: { branch, oid, detached: branch === null },
-    objects: bundle(project.resourceId, oid),
-    refs: branches,
-  };
-}
-
-async function checkpointFor(project, card) {
-  const captured = await require('../workspace/git').captureCheckpoint(card.path);
-  return {
-    checkpoint: checkpoint.CHECKPOINT_CONTRACT,
-    machine: 'machine-intent',
-    repoKey: project.repoKey,
-    branch: card.head.branch,
-    baseOid: card.head.oid,
-    from: { revision: null, indexDiff: '', worktreeDiff: '' },
-    to: checkpoint.checkpointValue(
-      'machine-intent',
-      project.repoKey,
-      card.head.oid,
-      captured.indexDiff,
-      captured.worktreeDiff,
-    ),
-  };
-}
-
-function reducerFile(repoKey) {
-  const digest = crypto.createHash('sha256').update(repoKey).digest('hex').slice(0, 24);
-  return path.join(process.env.AMALGM_DIR, 'state', 'repo-reducer', `${digest}.json`);
-}
-
-async function setVerifiedBaseline(project, card, through = 1) {
-  const observed = await reducer.observePhysicalRepo(card.path);
-  const tree = await merge.treeOf(card.path, card.head.oid);
-  const state = {
-    repoKey: project.repoKey,
-    verificationContract: 'verified-repo-state@1',
-    resourceId: project.resourceId,
-    path: card.path,
-    replica: card.replica,
-    branch: card.head.branch,
-    baseOid: card.head.oid,
-    targetCard: {
-      branch: card.head.branch,
-      oid: card.head.oid,
-      version: through,
-      mutationId: `mutation_baseline_${project.resourceId.slice(-4)}`,
-    },
-    appliedThrough: through,
-    branches: card.refs.map((branch) => ({
-      ...branch,
-      version: through,
-      mutationId: `mutation_baseline_${project.resourceId.slice(-4)}`,
-    })),
-    heldIndexTree: tree,
-    heldTree: tree,
-    observedPhysicalDigest: observed.digest,
-    materialized: true,
-  };
-  fs.mkdirSync(path.dirname(reducerFile(project.repoKey)), { recursive: true });
-  fs.writeFileSync(reducerFile(project.repoKey), `${JSON.stringify(state)}\n`);
-  return state;
-}
-
-function officialSnapshot(project, card, version = 1, mutationId = 'mutation_official_base_01') {
-  return projectStream._test.fold(
-    projectStream.emptySnapshot(project.resourceId),
-    {
-      kind: 'code.publish',
-      project: project.resourceId,
-      delta: {
-        kind: 'card.set',
-        card: projectStream.CARD_CONTRACT,
-        head: card.head,
-        objects: card.objects,
-        branches: card.refs,
-        checkpoint: {
-          checkpoint: checkpoint.CHECKPOINT_CONTRACT,
-          baseOid: card.head.oid,
-          branch: card.head.branch,
-          value: { revision: null, indexDiff: '', worktreeDiff: '' },
-        },
-      },
-    },
-    { machine: 'machine-peer', mutationId, version },
-  );
-}
-
-async function setup(name, resourceId) {
-  const repo = createRepo(name);
-  const project = wall.bindProject(resourceId, OWNER, repo);
-  const card = cardFor(project, repo);
-  const snapshot = officialSnapshot(project, card);
-  projectStream.writeSnapshot(project.file, snapshot);
-  replicas.registerReplica({
-    resourceId,
-    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`,
-    localPath: project.file,
-    contract: projectStream.STREAM_CONTRACT,
-    schemaVersion: 2,
-    authorityEpoch: 1,
-    appliedVersion: 1,
-    snapshotVersion: 1,
-    snapshotChecksum: crypto.createHash('sha256').update(JSON.stringify(snapshot)).digest('hex'),
-  });
-  await setVerifiedBaseline(project, card);
-  return { repo, project, card };
-}
-
-function planWithPeerCheckpoint(setupState, peerCapture, version = 2) {
-  const snapshot = projectStream.readSnapshot(
-    setupState.project.file,
-    setupState.project.resourceId,
-  );
-  const peerValue = checkpoint.checkpointValue(
-    'machine-peer',
-    setupState.project.repoKey,
-    setupState.card.head.oid,
-    peerCapture.indexDiff,
-    peerCapture.worktreeDiff,
-  );
-  return {
-    repoKey: setupState.project.repoKey,
-    card: {
-      ...snapshot.card,
-      repo: { remote: null, rootCommit: setupState.card.head.oid },
-      kind: 'primary',
-      health: 'healthy',
-      positionMachine: snapshot.card.machine,
-      positionMutationId: snapshot.card.mutationId,
-      positionVersion: snapshot.card.version,
-    },
-    branches: snapshot.card.branches.map((branch) => ({
-      ...branch,
-      machine: snapshot.card.machine,
-      mutationId: snapshot.card.mutationId,
-      version: snapshot.card.version,
-    })),
-    transitions: [{
-      checkpoint: checkpoint.CHECKPOINT_CONTRACT,
-      machine: 'machine-peer',
-      baseOid: setupState.card.head.oid,
-      branch: setupState.card.head.branch,
-      from: { revision: null, indexDiff: '', worktreeDiff: '' },
-      to: peerValue,
-      mutationId: `mutation_peer_checkpoint_${version}`,
-      version,
-    }],
-  };
-}
-
-test('a real local edit while behind has durable provenance and refreshes at equal dirty counts', async () => {
-  const setupState = await setup(
-    'behind-edit',
-    '018f0000-0000-7000-8000-00000000c001',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'local one\n');
-  let card = cardFor(setupState.project, setupState.repo);
-  let captured = await checkpointFor(setupState.project, card);
-  const first = await checkpoint.captureLocalIntent(setupState.project, card, captured);
-  assert.equal(first.state, 'captured');
-  assert.equal(first.intent.base.through, 1);
-
-  openLocalDb().prepare(
-    'UPDATE shared_resource_replicas SET applied_version = 2 WHERE resource_id = ?',
-  ).run(setupState.project.resourceId);
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'local two\n');
-  card = cardFor(setupState.project, setupState.repo);
-  captured = await checkpointFor(setupState.project, card);
-  const second = await checkpoint.captureLocalIntent(setupState.project, card, captured);
-  assert.equal(second.state, 'captured');
-  assert.equal(second.intent.base.through, 1);
-  assert.notEqual(second.intent.semanticDigest, first.intent.semanticDigest);
-});
-
-test('legacy intent state upgrades on write and unknown contracts fail loudly', async () => {
-  const setupState = await setup(
-    'intent-contract-upgrade',
-    '018f0000-0000-7000-8000-00000000c11b',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'legacy intent\n');
-  const card = cardFor(setupState.project, setupState.repo);
-  const captured = await checkpoint.captureLocalIntent(
-    setupState.project,
-    card,
-    await checkpointFor(setupState.project, card),
-  );
-  const file = intent.intentFile(setupState.project.resourceId);
-  const legacy = { ...captured.intent, contract: 'repo-local-intent@2' };
-  delete legacy.birthMutationId;
-  delete legacy.successor;
-  fs.writeFileSync(file, `${JSON.stringify(legacy)}\n`);
-  assert.equal(intent.readIntent(setupState.project).contract, 'repo-local-intent@2');
-  const upgraded = intent.reservePublication(setupState.project, legacy);
-  assert.equal(upgraded.contract, intent.INTENT_CONTRACT);
-  assert.match(upgraded.birthMutationId, /^[A-Za-z0-9_-]{16,160}$/);
-  assert.equal(upgraded.publication.mutationId, upgraded.birthMutationId);
-
-  const legacyReserved = {
-    ...upgraded,
-    contract: 'repo-local-intent@3',
-  };
-  delete legacyReserved.birthMutationId;
-  fs.writeFileSync(file, `${JSON.stringify(legacyReserved)}\n`);
-  const migratedReserved = intent.reservePublication(
-    setupState.project,
-    legacyReserved,
-  );
-  assert.equal(
-    migratedReserved.birthMutationId,
-    legacyReserved.publication.mutationId,
-    'an already-reserved legacy identity is its birth identity after upgrade',
-  );
-
-  const unknown = {
-    ...intent.readIntent(setupState.project),
-    contract: 'repo-local-intent@999',
-  };
-  fs.writeFileSync(file, `${JSON.stringify(unknown)}\n`);
-  assert.throws(
-    () => intent.readIntent(setupState.project),
-    /invalid or unsupported contract/,
-  );
-});
-
-test('materialization output and missing reducer provenance are silent', async () => {
-  const setupState = await setup(
-    'silent-output',
-    '018f0000-0000-7000-8000-00000000c002',
-  );
-  const clean = await checkpointFor(setupState.project, setupState.card);
-  assert.equal(
-    (await checkpoint.captureLocalIntent(setupState.project, setupState.card, clean)).state,
-    'silent',
-  );
-  fs.rmSync(reducerFile(setupState.project.repoKey), { force: true });
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'state without provenance\n');
-  const changedCard = cardFor(setupState.project, setupState.repo);
-  assert.deepEqual(
-    await checkpoint.captureLocalIntent(
-      setupState.project,
-      changedCard,
-      await checkpointFor(setupState.project, changedCard),
-    ),
-    { state: 'silent', reason: 'no-verified-baseline' },
-  );
-  assert.equal(intent.readIntent(setupState.project), null);
-});
-
-test('missing reducer provenance blocks apply without discarding durable intent', async () => {
-  const setupState = await setup(
-    'missing-intent-provenance',
-    '018f0000-0000-7000-8000-00000000c110',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'official later\n');
-  const peerCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  git(setupState.repo, 'reset', '--hard', 'HEAD');
-
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'owned local\n');
-  const localCard = cardFor(setupState.project, setupState.repo);
-  const captured = await checkpoint.captureLocalIntent(
-    setupState.project,
-    localCard,
-    await checkpointFor(setupState.project, localCard),
-  );
-  assert.equal(captured.state, 'captured');
-  fs.rmSync(reducerFile(setupState.project.repoKey), { force: true });
-
-  const outcome = await reducer.materializeRepo(
-    localCard,
-    planWithPeerCheckpoint(setupState, peerCapture),
-    2,
-  );
-  assert.deepEqual(outcome, {
-    state: 'waiting',
-    reason: 'local-intent-provenance-unverified',
-  });
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'owned local\n');
-  assert.equal(intent.readIntent(setupState.project)?.semanticDigest, captured.intent.semanticDigest);
-});
-
-test('peer-identical official bytes cannot retire an unacknowledged local mutation ID', async () => {
-  const setupState = await setup(
-    'peer-identical-intent',
-    '018f0000-0000-7000-8000-00000000c12f',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'same independent bytes\n');
-  const peerCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  const localCard = cardFor(setupState.project, setupState.repo);
-  const captured = await checkpoint.captureLocalIntent(
-    setupState.project,
-    localCard,
-    await checkpointFor(setupState.project, localCard),
-  );
-  assert.equal(captured.state, 'captured');
-  assert.equal(captured.intent.publication, null);
-
-  const peerPlan = planWithPeerCheckpoint(setupState, peerCapture);
-  const beforePeer = projectStream.readSnapshot(
-    setupState.project.file,
-    setupState.project.resourceId,
-  );
-  projectStream.writeSnapshot(
-    setupState.project.file,
-    projectStream._test.fold(
-      beforePeer,
-      {
-        kind: 'code.publish',
-        project: setupState.project.resourceId,
-        delta: {
-          kind: 'checkpoint.set',
-          checkpoint: checkpoint.CHECKPOINT_CONTRACT,
-          baseOid: setupState.card.head.oid,
-          branch: setupState.card.head.branch,
-          from: beforePeer.checkpoint.value,
-          to: peerPlan.transitions[0].to,
-        },
-      },
-      {
-        machine: 'machine-peer',
-        mutationId: peerPlan.transitions[0].mutationId,
-        version: 2,
-      },
-    ),
-  );
-  const outcome = await reducer.materializeRepo(
-    localCard,
-    peerPlan,
-    2,
-  );
-  assert.equal(outcome.state, 'in-sync', JSON.stringify(outcome));
-  const retained = intent.readIntent(setupState.project);
-  assert.equal(retained.semanticDigest, captured.intent.semanticDigest);
-  assert.equal(retained.birthMutationId, captured.intent.birthMutationId);
-  assert.equal(retained.base.through, 2, JSON.stringify(retained));
-  assert.equal(retained.publication, null);
-  assert.equal(
-    fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'),
-    'same independent bytes\n',
-  );
-  openLocalDb().prepare(
-    'UPDATE shared_resource_replicas SET applied_version = 2 WHERE resource_id = ?',
-  ).run(setupState.project.resourceId);
-  const currentCard = cardFor(setupState.project, setupState.repo);
-  const publication = wall._test.publishProject(setupState.project, [currentCard]);
-  assert.equal(publication.published, true, JSON.stringify(publication));
-  assert.equal(publication.mutationId, captured.intent.birthMutationId);
-  assert.equal(publication.delta, 'checkpoint.set');
-  const pending = mutations.listPendingCloudMutations(setupState.project.resourceId);
-  assert.equal(pending.length, 1);
-  assert.deepEqual(
-    pending[0].operation.delta.from,
-    pending[0].operation.delta.to,
-    'the state-neutral event exists only to number this durable local identity',
-  );
-});
-
-test('an exact official ack ends ownership and cannot re-enter from the unchanged disk', async () => {
-  const setupState = await setup(
-    'exact-ack',
-    '018f0000-0000-7000-8000-00000000c003',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'owned once\n');
-  const card = cardFor(setupState.project, setupState.repo);
-  const captured = await checkpointFor(setupState.project, card);
-  await checkpoint.captureLocalIntent(setupState.project, card, captured);
-  const publication = wall._test.publishProject(setupState.project, [card]);
-  assert.equal(publication.published, true);
-  assert.equal(
-    intent.readIntent(setupState.project).publication.mutationId,
-    publication.mutationId,
-    'the publication id is durable before delivery',
-  );
-  const claimed = mutations.claimCloudMutations().find((entry) => (
-    entry.mutation.mutationId === publication.mutationId
-  ));
-  assert.ok(claimed);
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    { version: 2, committedAt: '2026-07-27T00:00:00.000Z' },
-  );
-  assert.equal(intent.readOwnedIntent(setupState.project), null);
-  assert.deepEqual(
-    {
-      numberedVersion: intent.readIntent(setupState.project).publication.numberedVersion,
-      numberedAt: intent.readIntent(setupState.project).publication.numberedAt,
-      foldedAt: intent.readIntent(setupState.project).publication.foldedAt,
-    },
-    {
-      numberedVersion: 2,
-      numberedAt: '2026-07-27T00:00:00.000Z',
-      foldedAt: null,
-    },
-    'server numbering ends ownership without claiming an ordered fold or physical apply',
-  );
-  const before = intent.readIntent(setupState.project);
-  projectStream.applyCloudMutation({
-    version: 2,
-    committedAt: '2026-07-27T00:00:00.000Z',
-    envelope: claimed.envelope,
-  });
-  assert.equal(
-    intent.readIntent(setupState.project).publication.numberedVersion,
-    2,
-    'the official number remains durable after the ordered fold',
-  );
-  assert.equal(
-    typeof intent.readIntent(setupState.project).publication.foldedAt,
-    'string',
-    'the ordinary official tail records its fold separately from numbering',
-  );
-  openLocalDb().prepare(`
-    UPDATE mutation_journal
-    SET updated_at = '2026-07-26T00:00:00.000Z'
-    WHERE mutation_id = ?
-  `).run(publication.mutationId);
-  mutations.pruneMutationJournal({
-    cutoffIso: '2026-07-26T12:00:00.000Z',
-    batchSize: 100,
-  });
-  assert.equal(
-    mutations.getMutation(
-      `resource:${setupState.project.resourceId}`,
-      publication.mutationId,
-    ),
-    null,
-    'the folded publication may leave the generic journal',
-  );
-  assert.deepEqual(intent.officialAcknowledgement(
-    setupState.project,
-    intent.readIntent(setupState.project),
-  ), {
-    mutationId: publication.mutationId,
-    version: 2,
-  });
-  assert.equal(intent.readOwnedIntent(setupState.project), null);
-  const repeated = await checkpoint.captureLocalIntent(setupState.project, card, captured);
-  assert.deepEqual(repeated, { state: 'silent', reason: 'officially-acknowledged' });
-  assert.equal(intent.readIntent(setupState.project).semanticDigest, before.semanticDigest);
-
-  const plan = reducer.reduceWall(wall.readWall(setupState.project.repoKey))
-    .get(setupState.project.repoKey);
-  const applied = await reducer.materializeRepo(card, plan, 2);
-  assert.equal(applied.state, 'in-sync', JSON.stringify(applied));
-  assert.equal(
-    intent.readIntent(setupState.project),
-    null,
-    'only verified physical apply and cursor advance retire the folded intent',
-  );
-});
-
-test('a crash after verified apply cannot revive the folded intent over a later local write', async () => {
-  const setupState = await setup(
-    'folded-retirement-crash',
-    '018f0000-0000-7000-8000-00000000c111',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'official local write\n');
-  const card = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    card,
-    await checkpointFor(setupState.project, card),
-  );
-  const publication = wall._test.publishProject(setupState.project, [card]);
-  const claimed = mutations.claimCloudMutations().find((entry) => (
-    entry.mutation.mutationId === publication.mutationId
-  ));
-  assert.ok(claimed);
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    { version: 2, committedAt: '2026-07-27T02:00:00.000Z' },
-  );
-  projectStream.applyCloudMutation({
-    version: 2,
-    committedAt: '2026-07-27T02:00:00.000Z',
-    envelope: claimed.envelope,
-  });
-  const foldedDigest = intent.readIntent(setupState.project).semanticDigest;
-  const plan = reducer.reduceWall(wall.readWall(setupState.project.repoKey))
-    .get(setupState.project.repoKey);
-
-  const clearIntent = intent.clearIntent;
-  let crashed = false;
-  intent.clearIntent = (...args) => {
-    if (!crashed) {
-      crashed = true;
-      throw new Error('simulated process death before folded-intent cleanup');
-    }
-    return clearIntent(...args);
-  };
-  try {
-    await assert.rejects(
-      reducer.materializeRepo(card, plan, 2),
-      /simulated process death/,
-    );
-  } finally {
-    intent.clearIntent = clearIntent;
-  }
-
-  const applied = reducer.readRepoState(setupState.project.repoKey, setupState.project.resourceId);
-  assert.equal(applied.appliedThrough, 2);
-  assert.equal(applied.materialized, true);
-  assert.equal(intent.readIntent(setupState.project).semanticDigest, foldedDigest);
-
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'written after the crash\n');
-  const restarted = await reducer.materializeRepo(card, plan, 2);
-  assert.deepEqual(restarted, {
-    state: 'waiting',
-    reason: 'local-intent-capture-required',
-  });
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'written after the crash\n');
-  assert.equal(intent.readIntent(setupState.project), null);
-  assert.equal(
-    reducer.readRepoState(setupState.project.repoKey, setupState.project.resourceId).appliedThrough,
-    2,
-  );
-
-  const changedCard = cardFor(setupState.project, setupState.repo);
-  const successor = await checkpoint.captureLocalIntent(
-    setupState.project,
-    changedCard,
-    await checkpointFor(setupState.project, changedCard),
-  );
-  assert.equal(successor.state, 'captured');
-  assert.equal(successor.intent.base.through, 2);
-  assert.equal(successor.intent.publication, null);
-});
-
-test('a write made after numbering becomes one successor over the folded official state', async () => {
-  const setupState = await setup(
-    'numbered-successor',
-    '018f0000-0000-7000-8000-00000000c112',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'numbered predecessor\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  const predecessor = await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const publication = wall._test.publishProject(setupState.project, [predecessorCard]);
-  const claimed = mutations.claimCloudMutations().find((entry) => (
-    entry.mutation.mutationId === publication.mutationId
-  ));
-  assert.ok(claimed);
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    { version: 2, committedAt: '2026-07-27T03:00:00.000Z' },
-  );
-
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'successor written before fold\n');
-  const successorCard = cardFor(setupState.project, setupState.repo);
-  const premature = await checkpoint.captureLocalIntent(
-    setupState.project,
-    successorCard,
-    await checkpointFor(setupState.project, successorCard),
-  );
-  assert.equal(premature.state, 'captured');
-  assert.equal(premature.reason, 'successor-captured');
-  assert.equal(
-    intent.readIntent(setupState.project).publication.mutationId,
-    publication.mutationId,
-  );
-  assert.equal(intent.readIntent(setupState.project).semanticDigest, predecessor.intent.semanticDigest);
-  assert.equal(
-    intent.readSuccessor(setupState.project).predecessorSemanticDigest,
-    predecessor.intent.semanticDigest,
-  );
-  assert.equal(
-    intent.readSuccessor(setupState.project).local.physicalDigest,
-    (await reducer.observePhysicalRepo(setupState.repo)).digest,
-  );
-  const successorBirthMutationId = intent.readSuccessor(
-    setupState.project,
-  ).birthMutationId;
-
-  projectStream.applyCloudMutation({
-    version: 2,
-    committedAt: '2026-07-27T03:00:00.000Z',
-    envelope: claimed.envelope,
-  });
-  const plan = reducer.reduceWall(wall.readWall(setupState.project.repoKey))
-    .get(setupState.project.repoKey);
-  const applied = await reducer.materializeRepo(successorCard, plan, 2);
-  assert.equal(applied.state, 'in-sync', JSON.stringify(applied));
-  assert.equal(
-    fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'),
-    'successor written before fold\n',
-  );
-  assert.equal(
-    reducer.readRepoState(setupState.project.repoKey, setupState.project.resourceId).appliedThrough,
-    2,
-  );
-  const successor = intent.readOwnedIntent(setupState.project);
-  assert.equal(successor.base.through, 2);
-  assert.equal(successor.publication, null);
-  assert.notEqual(successor.semanticDigest, predecessor.intent.semanticDigest);
-  assert.equal(successor.birthMutationId, successorBirthMutationId);
-  assert.equal(successor.local.physicalDigest, (
-    await reducer.observePhysicalRepo(setupState.repo)
-  ).digest);
-});
-
-test('successor intent keeps only later local work while a newer remote file also applies', async () => {
-  const setupState = await setup(
-    'folded-successor-plus-remote',
-    '018f0000-0000-7000-8000-00000000c113',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'official predecessor\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const publication = wall._test.publishProject(setupState.project, [predecessorCard]);
-  const claimed = mutations.claimCloudMutations().find((entry) => (
-    entry.mutation.mutationId === publication.mutationId
-  ));
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    { version: 2, committedAt: '2026-07-27T04:00:00.000Z' },
-  );
-  projectStream.applyCloudMutation({
-    version: 2,
-    committedAt: '2026-07-27T04:00:00.000Z',
-    envelope: claimed.envelope,
-  });
-
-  fs.writeFileSync(path.join(setupState.repo, 'remote.txt'), 'newer remote\n');
-  const remoteCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  fs.rmSync(path.join(setupState.repo, 'remote.txt'));
-  fs.writeFileSync(path.join(setupState.repo, 'successor.txt'), 'later local\n');
-  const successorCard = cardFor(setupState.project, setupState.repo);
-  const capturedSuccessor = await checkpoint.captureLocalIntent(
-    setupState.project,
-    successorCard,
-    await checkpointFor(setupState.project, successorCard),
-  );
-  assert.equal(capturedSuccessor.state, 'captured');
-  assert.equal(capturedSuccessor.reason, 'successor-captured');
-
-  const plan = reducer.reduceWall(wall.readWall(setupState.project.repoKey))
-    .get(setupState.project.repoKey);
-  const predecessorOperation = plan.transitions.find((entry) => entry.version === 2);
-  plan.transitions.push({
-    checkpoint: checkpoint.CHECKPOINT_CONTRACT,
-    machine: 'machine-peer',
-    repoKey: setupState.project.repoKey,
-    branch: predecessorCard.head.branch,
-    baseOid: predecessorCard.head.oid,
-    from: predecessorOperation.to,
-    to: checkpoint.checkpointValue(
-      'machine-peer',
-      setupState.project.repoKey,
-      predecessorCard.head.oid,
-      remoteCapture.indexDiff,
-      remoteCapture.worktreeDiff,
-    ),
-    version: 3,
-    mutationId: 'mutation_remote_after_fold_03',
-  });
-
-  const applied = await reducer.materializeRepo(successorCard, plan, 3);
-  assert.equal(applied.state, 'in-sync', JSON.stringify(applied));
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'official predecessor\n');
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'remote.txt'), 'utf8'), 'newer remote\n');
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'successor.txt'), 'utf8'), 'later local\n');
-  const successor = intent.readOwnedIntent(setupState.project);
-  assert.equal(successor.base.through, 3);
-  assert.equal(successor.publication, null);
-  assert.equal(successor.local.physicalDigest, (
-    await reducer.observePhysicalRepo(setupState.repo)
-  ).digest);
-});
-
-test('restart recovers the apply WAL before replacing a folded predecessor with its successor', async () => {
-  const setupState = await setup(
-    'successor-capture-crash',
-    '018f0000-0000-7000-8000-00000000c114',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'folded predecessor\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const publication = wall._test.publishProject(setupState.project, [predecessorCard]);
-  const claimed = mutations.claimCloudMutations().find((entry) => (
-    entry.mutation.mutationId === publication.mutationId
-  ));
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    { version: 2, committedAt: '2026-07-27T05:00:00.000Z' },
-  );
-  projectStream.applyCloudMutation({
-    version: 2,
-    committedAt: '2026-07-27T05:00:00.000Z',
-    envelope: claimed.envelope,
-  });
-  const foldedDigest = intent.readIntent(setupState.project).semanticDigest;
-  fs.writeFileSync(path.join(setupState.repo, 'after.txt'), 'successor survives restart\n');
-  const successorCard = cardFor(setupState.project, setupState.repo);
-  const capturedSuccessor = await checkpoint.captureLocalIntent(
-    setupState.project,
-    successorCard,
-    await checkpointFor(setupState.project, successorCard),
-  );
-  assert.equal(capturedSuccessor.state, 'captured');
-  assert.equal(capturedSuccessor.reason, 'successor-captured');
-  const plan = reducer.reduceWall(wall.readWall(setupState.project.repoKey))
-    .get(setupState.project.repoKey);
-
-  const writeIntent = intent.writeIntent;
-  let crashed = false;
-  intent.writeIntent = (project, input) => {
-    if (!crashed && input.base?.through === 2) {
-      crashed = true;
-      throw new Error('simulated process death before successor capture');
-    }
-    return writeIntent(project, input);
-  };
-  try {
-    await assert.rejects(
-      reducer.materializeRepo(successorCard, plan, 2),
-      /simulated process death/,
-    );
-  } finally {
-    intent.writeIntent = writeIntent;
-  }
-
-  const interrupted = reducer.readRepoState(
-    setupState.project.repoKey,
-    setupState.project.resourceId,
-  );
-  assert.equal(interrupted.appliedThrough, 1);
-  assert.equal(interrupted.applying.through, 2);
-  assert.equal(interrupted.applying.predecessorIntentDigest, foldedDigest);
-  assert.equal(intent.readIntent(setupState.project).semanticDigest, foldedDigest);
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'after.txt'), 'utf8'), 'successor survives restart\n');
-
-  const recovered = await reducer.materializeRepo(successorCard, plan, 2);
-  assert.equal(recovered.state, 'in-sync', JSON.stringify(recovered));
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'after.txt'), 'utf8'), 'successor survives restart\n');
-  assert.equal(
-    reducer.readRepoState(setupState.project.repoKey, setupState.project.resourceId).appliedThrough,
-    2,
-  );
-  const successor = intent.readOwnedIntent(setupState.project);
-  assert.equal(successor.base.through, 2);
-  assert.equal(successor.publication, null);
-  assert.notEqual(successor.semanticDigest, foldedDigest);
-});
-
-test('a reserved publication stays immutable across restart and later local writes', async () => {
-  const setupState = await setup(
-    'reserved-publication',
-    '018f0000-0000-7000-8000-00000000c00c',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'reserved work\n');
-  const card = cardFor(setupState.project, setupState.repo);
-  const captured = await checkpoint.captureLocalIntent(
-    setupState.project,
-    card,
-    await checkpointFor(setupState.project, card),
-  );
-  const first = intent.reservePublication(setupState.project, captured.intent);
-  const second = intent.reservePublication(setupState.project, captured.intent);
-  assert.equal(first.publication.mutationId, captured.intent.birthMutationId);
-  assert.equal(second.publication.mutationId, first.publication.mutationId);
-  assert.equal(
-    mutations.getMutation(
-      `resource:${setupState.project.resourceId}`,
-      first.publication.mutationId,
-    ),
-    null,
-    'reserving the id does not pretend the outbox row already exists',
-  );
-
-  const published = wall._test.publishProject(setupState.project, [card]);
-  assert.equal(published.published, true);
-  assert.equal(published.mutationId, first.publication.mutationId);
-  const replay = wall._test.publishProject(setupState.project, [card]);
-  assert.equal(replay.published, false);
-  assert.equal(replay.reason, 'project-not-current');
-  assert.equal(
-    mutations.listPendingCloudMutations(setupState.project.resourceId)
-      .filter((row) => row.mutationId === first.publication.mutationId).length,
-    1,
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'written after reservation\n');
-  const changedCard = cardFor(setupState.project, setupState.repo);
-  const changed = await checkpoint.captureLocalIntent(
-    setupState.project,
-    changedCard,
-    await checkpointFor(setupState.project, changedCard),
-  );
-  assert.equal(changed.state, 'captured');
-  assert.equal(changed.reason, 'successor-captured');
-  assert.equal(
-    intent.readIntent(setupState.project).publication.mutationId,
-    first.publication.mutationId,
-  );
-  assert.equal(
-    intent.readIntent(setupState.project).semanticDigest,
-    first.semanticDigest,
-  );
-  assert.equal(
-    intent.readSuccessor(setupState.project).predecessorSemanticDigest,
-    first.semanticDigest,
-  );
-});
-
-test('a failed successor write leaves the predecessor immutable and the next capture repairs it', async () => {
-  const setupState = await setup(
-    'successor-write-crash',
-    '018f0000-0000-7000-8000-00000000c11a',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'frozen predecessor\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  const predecessor = await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const reserved = intent.reservePublication(setupState.project, predecessor.intent);
-
-  fs.writeFileSync(path.join(setupState.repo, 'later.txt'), 'durable on retry\n');
-  const successorCard = cardFor(setupState.project, setupState.repo);
-  const writeSuccessor = intent.writeSuccessor;
-  intent.writeSuccessor = () => {
-    throw new Error('simulated process death during successor write');
-  };
-  try {
-    await assert.rejects(
-      checkpoint.captureLocalIntent(
-        setupState.project,
-        successorCard,
-        await checkpointFor(setupState.project, successorCard),
-      ),
-      /simulated process death/,
-    );
-  } finally {
-    intent.writeSuccessor = writeSuccessor;
-  }
-
-  const afterCrash = intent.readIntent(setupState.project);
-  assert.equal(afterCrash.semanticDigest, predecessor.intent.semanticDigest);
-  assert.equal(afterCrash.publication.mutationId, reserved.publication.mutationId);
-  assert.equal(intent.readSuccessor(setupState.project), null);
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'later.txt'), 'utf8'), 'durable on retry\n');
-
-  const repaired = await checkpoint.captureLocalIntent(
-    setupState.project,
-    successorCard,
-    await checkpointFor(setupState.project, successorCard),
-  );
-  assert.equal(repaired.state, 'captured');
-  assert.equal(repaired.reason, 'successor-captured');
-  assert.equal(
-    intent.readSuccessor(setupState.project).local.physicalDigest,
-    (await reducer.observePhysicalRepo(setupState.repo)).digest,
-  );
-});
-
-test('later saves coalesce into one successor pinned to the frozen predecessor', async () => {
-  const setupState = await setup(
-    'successor-coalescing',
-    '018f0000-0000-7000-8000-00000000c116',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'A\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  const predecessor = await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const reserved = intent.reservePublication(setupState.project, predecessor.intent);
-  const successorDigests = [];
-
-  for (const value of ['B', 'C', 'D']) {
-    fs.writeFileSync(path.join(setupState.repo, 'later.txt'), `${value}\n`);
-    const card = cardFor(setupState.project, setupState.repo);
-    const captured = await checkpoint.captureLocalIntent(
-      setupState.project,
-      card,
-      await checkpointFor(setupState.project, card),
-    );
-    assert.equal(captured.state, 'captured');
-    assert.equal(captured.reason, 'successor-captured');
-    successorDigests.push(captured.successor.semanticDigest);
-    assert.equal(
-      captured.successor.predecessorSemanticDigest,
-      predecessor.intent.semanticDigest,
-    );
-    assert.equal(
-      captured.successor.base.physicalDigest,
-      predecessor.intent.local.physicalDigest,
-    );
-  }
-
-  assert.equal(new Set(successorDigests).size, 3);
-  assert.equal(intent.readIntent(setupState.project).semanticDigest, predecessor.intent.semanticDigest);
-  assert.equal(
-    intent.readIntent(setupState.project).publication.mutationId,
-    reserved.publication.mutationId,
-  );
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'later.txt'), 'utf8'), 'D\n');
-  assert.equal(
-    intent.readSuccessor(setupState.project).semanticDigest,
-    successorDigests.at(-1),
-  );
-});
-
-test('a crash while numbering A keeps its successor and repairs the lifecycle stamp on retry', async () => {
-  const setupState = await setup(
-    'numbering-with-successor-crash',
-    '018f0000-0000-7000-8000-00000000c117',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'A\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const publication = wall._test.publishProject(setupState.project, [predecessorCard]);
-  fs.writeFileSync(path.join(setupState.repo, 'later.txt'), 'B\n');
-  const successorCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    successorCard,
-    await checkpointFor(setupState.project, successorCard),
-  );
-  const successorDigest = intent.readSuccessor(setupState.project).semanticDigest;
-
-  const markPublicationNumbered = intent.markPublicationNumbered;
-  intent.markPublicationNumbered = () => {
-    throw new Error('simulated process death after durable cloud ack');
-  };
-  try {
-    assert.throws(
-      () => mutations.acknowledgeCloudMutation(
-        setupState.project.resourceId,
-        publication.mutationId,
-        { version: 2, committedAt: '2026-07-27T05:30:00.000Z' },
-      ),
-      /simulated process death/,
-    );
-  } finally {
-    intent.markPublicationNumbered = markPublicationNumbered;
-  }
-  assert.equal(intent.readIntent(setupState.project).publication.numberedVersion, null);
-  assert.equal(intent.readSuccessor(setupState.project).semanticDigest, successorDigest);
-
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    { version: 2, committedAt: '2026-07-27T05:30:00.000Z' },
-  );
-  assert.equal(intent.readIntent(setupState.project).publication.numberedVersion, 2);
-  assert.equal(intent.readSuccessor(setupState.project).semanticDigest, successorDigest);
-});
-
-test('a stale rejected A rebases together with its successor after the winning event applies', async () => {
-  const setupState = await setup(
-    'stale-predecessor-successor-rebase',
-    '018f0000-0000-7000-8000-00000000c118',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'peer.txt'), 'peer winner\n');
-  const peerCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  fs.rmSync(path.join(setupState.repo, 'peer.txt'));
-
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'A\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const publication = wall._test.publishProject(setupState.project, [predecessorCard]);
-  fs.writeFileSync(path.join(setupState.repo, 'later.txt'), 'B\n');
-  const successorCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    successorCard,
-    await checkpointFor(setupState.project, successorCard),
-  );
-  mutations.failCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    {
-      message: 'code_project_stale_base',
-      code: 'code_project_stale_base',
-      retryable: false,
-    },
-  );
-
-  const applied = await reducer.materializeRepo(
-    successorCard,
-    planWithPeerCheckpoint(setupState, peerCapture),
-    2,
-  );
-  assert.equal(applied.state, 'in-sync', JSON.stringify(applied));
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'peer.txt'), 'utf8'), 'peer winner\n');
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'A\n');
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'later.txt'), 'utf8'), 'B\n');
-
-  const rebasedCard = cardFor(setupState.project, setupState.repo);
-  const rebased = await checkpoint.captureLocalIntent(
-    setupState.project,
-    rebasedCard,
-    await checkpointFor(setupState.project, rebasedCard),
-  );
-  assert.equal(rebased.state, 'captured');
-  assert.equal(rebased.intent.base.through, 2);
-  assert.equal(rebased.intent.publication, null);
-  assert.equal(rebased.intent.successor, null);
-  assert.equal(
-    rebased.intent.local.physicalDigest,
-    (await reducer.observePhysicalRepo(setupState.repo)).digest,
-  );
-});
-
-test('a successor that cancels stale A disappears after the winning floor applies', async () => {
-  const setupState = await setup(
-    'stale-predecessor-cancelled',
-    '018f0000-0000-7000-8000-00000000c119',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'peer.txt'), 'peer winner\n');
-  const peerCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  fs.rmSync(path.join(setupState.repo, 'peer.txt'));
-
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'A\n');
-  const predecessorCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    predecessorCard,
-    await checkpointFor(setupState.project, predecessorCard),
-  );
-  const publication = wall._test.publishProject(setupState.project, [predecessorCard]);
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'base\n');
-  const cancelledCard = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    cancelledCard,
-    await checkpointFor(setupState.project, cancelledCard),
-  );
-  assert.ok(intent.readSuccessor(setupState.project));
-  mutations.failCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    {
-      message: 'code_project_stale_base',
-      code: 'code_project_stale_base',
-      retryable: false,
-    },
-  );
-
-  const applied = await reducer.materializeRepo(
-    cancelledCard,
-    planWithPeerCheckpoint(setupState, peerCapture),
-    2,
-  );
-  assert.equal(applied.state, 'in-sync', JSON.stringify(applied));
-  const currentCard = cardFor(setupState.project, setupState.repo);
-  const recaptured = await checkpoint.captureLocalIntent(
-    setupState.project,
-    currentCard,
-    await checkpointFor(setupState.project, currentCard),
-  );
-  assert.deepEqual(recaptured, { state: 'silent', reason: 'no-local-effect' });
-  assert.equal(intent.readIntent(setupState.project), null);
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'base\n');
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'peer.txt'), 'utf8'), 'peer winner\n');
-});
-
-test('the same bytes are new intent after the official base has advanced', async () => {
-  const setupState = await setup(
-    'intentional-revert',
-    '018f0000-0000-7000-8000-00000000c00d',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'state A\n');
-  let card = cardFor(setupState.project, setupState.repo);
-  const first = await checkpoint.captureLocalIntent(
-    setupState.project,
-    card,
-    await checkpointFor(setupState.project, card),
-  );
-  const publication = wall._test.publishProject(setupState.project, [card]);
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    publication.mutationId,
-    { version: 2, committedAt: '2026-07-27T01:00:00.000Z' },
-  );
-  assert.equal(first.intent.semanticDigest, intent.readIntent(setupState.project).semanticDigest);
-
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'state B\n');
-  card = cardFor(setupState.project, setupState.repo);
-  await setVerifiedBaseline(setupState.project, card, 3);
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'state A\n');
-  card = cardFor(setupState.project, setupState.repo);
-  const reverted = await checkpoint.captureLocalIntent(
-    setupState.project,
-    card,
-    await checkpointFor(setupState.project, card),
-  );
-  assert.equal(reverted.state, 'captured');
-  assert.equal(reverted.intent.base.through, 3);
-  assert.equal(reverted.intent.semanticDigest, first.intent.semanticDigest);
-  assert.equal(
-    reverted.intent.publication,
-    null,
-    'the old official number belongs to the earlier A, not this new A',
-  );
-});
-
-test('the losing first writer keeps one exact empty-tree intent while event one applies', async () => {
-  const repo = createRepo('base-zero-loser');
-  const localBranch = git(repo, 'branch', '--show-current');
-  git(repo, 'switch', '-qc', 'winner');
-  fs.writeFileSync(path.join(repo, 'winner.txt'), 'official winner\n');
-  git(repo, 'add', '.');
-  git(repo, 'commit', '-qm', 'winner');
-  const winnerOid = git(repo, 'rev-parse', 'HEAD');
-  git(repo, 'switch', '-q', localBranch);
-  const localOid = git(repo, 'rev-parse', 'HEAD');
-  const resourceId = '018f0000-0000-7000-8000-00000000c10e';
-  const project = wall.bindProject(resourceId, OWNER, repo);
-  projectStream.writeSnapshot(project.file, projectStream.emptySnapshot(resourceId));
-  replicas.registerReplica({
-    resourceId,
-    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`,
-    localPath: project.file,
-    contract: projectStream.STREAM_CONTRACT,
-    schemaVersion: 2,
-    authorityEpoch: 1,
-    appliedVersion: 0,
-    snapshotVersion: 0,
-  });
-  const localCard = cardFor(project, repo);
-  const captured = await checkpoint.captureLocalIntent(
-    project,
-    localCard,
-    await checkpointFor(project, localCard),
-  );
-  assert.equal(captured.state, 'captured');
-  assert.match(captured.intent.base.indexTree, /^[0-9a-f]{40,64}$/);
-  assert.equal(captured.intent.base.worktreeTree, captured.intent.base.indexTree);
-  assert.equal(captured.intent.base.card, null);
-
-  const winnerObjects = localCard.refs.find((branch) => branch.name === 'winner').objects;
-  const official = {
-    ...localCard,
-    head: { branch: localBranch, oid: winnerOid, detached: false },
-    objects: winnerObjects,
-    positionVersion: 1,
-    positionMutationId: 'mutation_first_winner_01',
-  };
-  const outcome = await reducer.materializeRepo(localCard, {
-    repoKey: project.repoKey,
-    card: official,
-    branches: [{
-      name: localBranch,
-      oid: winnerOid,
-      objects: winnerObjects,
-      version: 1,
-      mutationId: official.positionMutationId,
-    }],
-    transitions: [],
-  }, 1);
-  assert.equal(outcome.state, 'in-sync', JSON.stringify(outcome));
-  assert.equal(git(repo, 'rev-parse', 'HEAD'), localOid);
-  const retained = intent.readOwnedIntent(project);
-  assert.equal(retained?.base.through, 1);
-  assert.equal(
-    retained?.birthMutationId,
-    captured.intent.birthMutationId,
-    JSON.stringify({ captured: captured.intent, retained }),
-  );
-  assert.equal(reducer.readRepoState(project.repoKey, project.resourceId).appliedThrough, 1);
-});
-
-test('a base-zero intent with a non-empty fake baseline blocks instead of being discarded', async () => {
-  const repo = createRepo('base-zero-corrupt');
-  const resourceId = '018f0000-0000-7000-8000-00000000c10f';
-  const project = wall.bindProject(resourceId, OWNER, repo);
-  projectStream.writeSnapshot(project.file, projectStream.emptySnapshot(resourceId));
-  replicas.registerReplica({
-    resourceId,
-    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`,
-    localPath: project.file,
-    contract: projectStream.STREAM_CONTRACT,
-    schemaVersion: 2,
-    authorityEpoch: 1,
-    appliedVersion: 0,
-    snapshotVersion: 0,
-  });
-  const localCard = cardFor(project, repo);
-  const captured = await checkpoint.captureLocalIntent(
-    project,
-    localCard,
-    await checkpointFor(project, localCard),
-  );
-  const nonEmptyTree = await merge.treeOf(repo, localCard.head.oid);
-  intent.writeIntent(project, {
-    base: {
-      through: 0,
-      card: null,
-      indexTree: nonEmptyTree,
-      worktreeTree: nonEmptyTree,
-    },
-    local: captured.intent.local,
-    publication: null,
-  });
-  const official = {
-    ...localCard,
-    positionVersion: 1,
-    positionMutationId: 'mutation_initial_corrupt_01',
-  };
-  const outcome = await reducer.materializeRepo(localCard, {
-    repoKey: project.repoKey,
-    card: official,
-    branches: localCard.refs.map((branch) => ({
-      ...branch,
-      version: 1,
-      mutationId: official.positionMutationId,
-    })),
-    transitions: [],
-  }, 1);
-  assert.deepEqual(outcome, {
-    state: 'waiting',
-    reason: 'local-intent-provenance-unverified',
-  });
-  assert.equal(intent.readIntent(project)?.semanticDigest, captured.intent.semanticDigest);
-});
-
-test('inbound work arriving before the watcher captures local intent and applies underneath it', async () => {
-  const setupState = await setup(
-    'ordered-catch-up',
-    '018f0000-0000-7000-8000-00000000c00a',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'official peer\n');
-  const peerCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'base\n');
-  fs.writeFileSync(path.join(setupState.repo, 'local.txt'), 'pending local\n');
-  const localCard = cardFor(setupState.project, setupState.repo);
-  const synchronousCapture = await checkpoint.captureIntentForCard(
-    setupState.project,
-    localCard,
-  );
-  assert.equal(synchronousCapture.state, 'captured');
-
-  const plan = planWithPeerCheckpoint(setupState, peerCapture);
-  const outcome = await reducer.materializeRepo(localCard, plan, 2);
-  assert.equal(outcome.state, 'in-sync', JSON.stringify(outcome));
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'official peer\n');
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'local.txt'), 'utf8'), 'pending local\n');
-  const verified = reducer.readRepoState(
-    setupState.project.repoKey,
-    setupState.project.resourceId,
-  );
-  assert.equal(verified.appliedThrough, 2);
-  assert.equal(Object.hasOwn(verified, 'pendingCard'), false);
-  assert.equal(Object.hasOwn(verified, 'pendingRefs'), false);
-  assert.equal(Object.hasOwn(verified, 'pendingCheckpoint'), false);
-
-  const refreshedCard = cardFor(setupState.project, setupState.repo);
-  const refreshed = await checkpoint.captureLocalIntent(
-    setupState.project,
-    refreshedCard,
-    await checkpointFor(setupState.project, refreshedCard),
-  );
-  assert.equal(refreshed.state, 'captured');
-  assert.equal(refreshed.intent.base.through, 2);
-});
-
-test('one intent birth certificate cannot combine captures from two repo states', async () => {
-  const setupState = await setup(
-    'single-observation-capture',
-    '018f0000-0000-7000-8000-00000000c120',
-  );
-  const staleCard = setupState.card;
-  const staleCheckpoint = await checkpointFor(setupState.project, staleCard);
-
-  fs.writeFileSync(path.join(setupState.repo, 'committed-later.txt'), 'later commit\n');
-  git(setupState.repo, 'add', 'committed-later.txt');
-  git(setupState.repo, 'commit', '-qm', 'commit between captures');
-  const laterOid = git(setupState.repo, 'rev-parse', 'HEAD');
-  assert.notEqual(laterOid, staleCard.head.oid);
-
-  const mixed = await checkpoint.captureLocalIntent(
-    setupState.project,
-    staleCard,
-    staleCheckpoint,
-  );
-  assert.deepEqual(mixed, {
-    state: 'waiting',
-    reason: 'local-state-moving',
-  });
-  assert.equal(intent.readIntent(setupState.project), null);
-
-  const freshCard = cardFor(setupState.project, setupState.repo);
-  const freshCheckpoint = await checkpointFor(setupState.project, freshCard);
-  const captured = await checkpoint.captureLocalIntent(
-    setupState.project,
-    freshCard,
-    freshCheckpoint,
-  );
-  assert.equal(captured.state, 'captured');
-  assert.equal(captured.intent.local.card.head.oid, laterOid);
-  assert.equal(
-    captured.intent.local.physicalDigest,
-    (await reducer.observePhysicalRepo(setupState.repo)).digest,
-  );
-});
-
-test('one capture records card, checkpoint, trees, and digest from one observation', async () => {
-  const setupState = await setup(
-    'one-observation-fields',
-    '018f0000-0000-7000-8000-00000000c121',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'first local value\n');
-  const card = cardFor(setupState.project, setupState.repo);
-  const observe = reducer.observePhysicalRepo;
-  let firstObservation = null;
-  reducer.observePhysicalRepo = async (repo) => {
-    firstObservation = await observe(repo);
-    fs.writeFileSync(path.join(repo, 'file.txt'), 'second local value\n');
-    return firstObservation;
-  };
-  let captured;
-  try {
-    captured = await checkpoint.captureIntentForCard(setupState.project, card);
-  } finally {
-    reducer.observePhysicalRepo = observe;
-  }
-
-  assert.equal(captured.state, 'captured');
-  const held = intent.readIntent(setupState.project);
-  assert.equal(held.local.physicalDigest, firstObservation.digest);
-  assert.equal(held.local.indexTree, firstObservation.value.indexTree);
-  assert.equal(held.local.worktreeTree, firstObservation.value.worktreeTree);
-  assert.equal(
-    held.local.checkpoint.value.revision,
-    checkpoint.revisionOf(
-      firstObservation.captured.baseOid,
-      firstObservation.captured.indexDiff,
-      firstObservation.captured.worktreeDiff,
-    ),
-  );
-  assert.notEqual((await reducer.observePhysicalRepo(setupState.repo)).digest, held.local.physicalDigest);
-
-  const successor = await checkpoint.captureIntentForCard(
-    setupState.project,
-    cardFor(setupState.project, setupState.repo),
-  );
-  assert.equal(successor.state, 'captured');
-  assert.equal(
-    successor.intent.local.physicalDigest,
-    (await reducer.observePhysicalRepo(setupState.repo)).digest,
-  );
-});
-
-test('capture and materialization take one serialized repo-state turn', async () => {
-  const setupState = await setup(
-    'capture-materialization-epoch',
-    '018f0000-0000-7000-8000-00000000c122',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'local before pause\n');
-  const card = cardFor(setupState.project, setupState.repo);
-  const observe = reducer.observePhysicalRepo;
-  let releaseObservation;
-  let observationStarted;
-  const started = new Promise((resolve) => { observationStarted = resolve; });
-  const release = new Promise((resolve) => { releaseObservation = resolve; });
-  reducer.observePhysicalRepo = async (repo) => {
-    observationStarted();
-    await release;
-    return observe(repo);
-  };
-  let materializationEntered = false;
-  try {
-    const pendingCapture = checkpoint.captureIntentForCard(setupState.project, card);
-    await started;
-    const pendingMaterialization = reducer.withMaterialization(
-      setupState.project.repoKey,
-      async () => {
-        materializationEntered = true;
-      },
-    );
-    await new Promise((resolve) => { setImmediate(resolve); });
-    assert.equal(materializationEntered, false);
-    releaseObservation();
-    const capture = await pendingCapture;
-    assert.equal(capture.state, 'captured');
-    await pendingMaterialization;
-    assert.equal(materializationEntered, true);
-  } finally {
-    reducer.observePhysicalRepo = observe;
-    releaseObservation?.();
-  }
-
-  assert.ok(intent.readIntent(setupState.project));
-});
-
-test('two materializations of one repo never overlap', async () => {
-  const repoKey = 'code-folder:serialized-materializations';
-  let active = 0;
-  let maximum = 0;
-  let releaseFirst;
-  const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
-  const first = reducer.withMaterialization(repoKey, async () => {
-    active += 1;
-    maximum = Math.max(maximum, active);
-    await firstGate;
-    active -= 1;
-  });
-  const second = reducer.withMaterialization(repoKey, async () => {
-    active += 1;
-    maximum = Math.max(maximum, active);
-    active -= 1;
-  });
-  await new Promise((resolve) => { setImmediate(resolve); });
-  assert.equal(maximum, 1);
-  releaseFirst();
-  await Promise.all([first, second]);
-  assert.equal(maximum, 1);
-});
-
-test('different repos keep independent local-state turns', async () => {
-  let active = 0;
-  let maximum = 0;
-  let release;
-  const gate = new Promise((resolve) => { release = resolve; });
-  const enter = async () => {
-    active += 1;
-    maximum = Math.max(maximum, active);
-    await gate;
-    active -= 1;
-  };
-  const first = reducer.withMaterialization('code-folder:turn-a', enter);
-  const second = reducer.withMaterialization('code-folder:turn-b', enter);
-  await new Promise((resolve) => { setImmediate(resolve); });
-  assert.equal(maximum, 2);
-  release();
-  await Promise.all([first, second]);
-});
-
-test('an edit between capture and the apply lock stops apply, captures, then survives catch-up', async () => {
-  const setupState = await setup(
-    'apply-boundary-race',
-    '018f0000-0000-7000-8000-00000000c00b',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'official peer\n');
-  const peerCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'base\n');
-
-  assert.equal(
-    (await checkpoint.captureIntentForCard(setupState.project, setupState.card)).state,
-    'silent',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'local.txt'), 'written inside the gap\n');
-
-  const boundary = await reducer.withMaterialization(
-    setupState.project.repoKey,
-    () => reducer.verifyApplyBoundary(setupState.project, setupState.card, 2),
-  );
-  assert.deepEqual(boundary, {
-    state: 'waiting',
-    reason: 'local-intent-capture-required',
-  });
-  assert.equal(intent.readIntent(setupState.project), null);
-
-  const captured = await checkpoint.captureIntentForCard(
-    setupState.project,
-    setupState.card,
-  );
-  assert.equal(captured.state, 'captured');
-  const outcome = await reducer.materializeRepo(
-    setupState.card,
-    planWithPeerCheckpoint(setupState, peerCapture),
-    2,
-  );
-  assert.equal(outcome.state, 'in-sync', JSON.stringify(outcome));
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'official peer\n');
-  assert.equal(
-    fs.readFileSync(path.join(setupState.repo, 'local.txt'), 'utf8'),
-    'written inside the gap\n',
-  );
-});
-
-test('a save after the boundary check cannot be blessed by the later WAL observation', async () => {
-  const setupState = await setup(
-    'post-boundary-save',
-    '018f0000-0000-7000-8000-00000000c115',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'official peer\n');
-  const peerCapture = await require('../workspace/git').captureCheckpoint(setupState.repo);
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'base\n');
-  const plan = planWithPeerCheckpoint(setupState, peerCapture);
-
-  const boundary = await reducer.withMaterialization(
-    setupState.project.repoKey,
-    () => reducer.verifyApplyBoundary(setupState.project, setupState.card, 2),
-  );
-  assert.deepEqual(boundary, { state: 'ready' });
-  fs.writeFileSync(path.join(setupState.repo, 'local.txt'), 'saved after boundary\n');
-
-  const blocked = await reducer.materializeRepo(setupState.card, plan, 2);
-  assert.deepEqual(blocked, {
-    state: 'waiting',
-    reason: 'local-intent-capture-required',
-  });
-  const held = reducer.readRepoState(
-    setupState.project.repoKey,
-    setupState.project.resourceId,
-  );
-  assert.equal(held.appliedThrough, 1);
-  assert.equal(held.applying, undefined);
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'local.txt'), 'utf8'), 'saved after boundary\n');
-
-  const captured = await checkpoint.captureIntentForCard(
-    setupState.project,
-    setupState.card,
-  );
-  assert.equal(captured.state, 'captured');
-  const applied = await reducer.materializeRepo(setupState.card, plan, 2);
-  assert.equal(applied.state, 'in-sync', JSON.stringify(applied));
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'file.txt'), 'utf8'), 'official peer\n');
-  assert.equal(fs.readFileSync(path.join(setupState.repo, 'local.txt'), 'utf8'), 'saved after boundary\n');
-});
-
-test('only a provenance record can keep an old branch from yielding to the rail', () => {
-  const oidA = 'a'.repeat(40);
-  const oidB = 'b'.repeat(40);
-  const oidC = 'c'.repeat(40);
-  const plan = {
-    card: { head: { branch: 'main', oid: oidA } },
-    branches: [
-      { name: 'main', oid: oidA },
-      { name: 'feature', oid: oidB },
-    ],
-  };
-  const current = [
-    { name: 'main', oid: oidA },
-    { name: 'feature', oid: oidC },
-  ];
-  const owned = reducer.classifyBranchRefs(plan, current, {
-    base: { card: { branches: [{ name: 'main', oid: oidA }, { name: 'feature', oid: oidA }] } },
-    local: { card: { branches: current } },
-  });
-  assert.deepEqual(owned.changes, []);
-  assert.deepEqual(owned.pending, [{ name: 'feature', oid: oidC }]);
-
-  const acknowledged = reducer.classifyBranchRefs(plan, current, null);
-  assert.deepEqual(acknowledged.pending, []);
-  assert.deepEqual(acknowledged.changes, [{
-    branch: 'feature',
-    expectedOid: oidC,
-    oid: oidB,
-  }]);
-});
-
-test('a pending HEAD switch protects its attached branch but still advances official HEAD', () => {
-  const oidA = 'a'.repeat(40);
-  const oidB = 'b'.repeat(40);
-  const oidF = 'f'.repeat(40);
-  const classified = reducer.classifyBranchRefs({
-    card: { head: { branch: 'main', oid: oidB } },
-    branches: [{ name: 'main', oid: oidB }],
-  }, [
-    { name: 'main', oid: oidA },
-    { name: 'feature', oid: oidF },
-  ], {
-    base: {
-      card: {
-        head: { branch: 'main', oid: oidA },
-        branches: [{ name: 'main', oid: oidA }],
-      },
-    },
-    local: {
-      card: {
-        head: { branch: 'feature', oid: oidF },
-        branches: [
-          { name: 'main', oid: oidA },
-          { name: 'feature', oid: oidF },
-        ],
-      },
-    },
-  });
-  assert.deepEqual(classified.changes, [{
-    branch: 'main',
-    expectedOid: oidA,
-    oid: oidB,
-  }]);
-  assert.deepEqual(classified.pending, [{ name: 'feature', oid: oidF }]);
-  assert.deepEqual(Object.fromEntries(classified.expected), {
-    main: oidB,
-    feature: oidF,
-  });
-});
-
-test('switching to an existing branch owns the attached ref while official main advances', () => {
-  const oidA = 'a'.repeat(40);
-  const oidB = 'b'.repeat(40);
-  const oidF = 'f'.repeat(40);
-  const classified = reducer.classifyBranchRefs({
-    card: { head: { branch: 'main', oid: oidB } },
-    branches: [
-      { name: 'main', oid: oidB },
-      { name: 'feature', oid: null },
-    ],
-  }, [
-    { name: 'main', oid: oidA },
-    { name: 'feature', oid: oidF },
-  ], {
-    base: {
-      card: {
-        head: { branch: 'main', oid: oidA },
-        branches: [
-          { name: 'main', oid: oidA },
-          { name: 'feature', oid: oidF },
-        ],
-      },
-    },
-    local: {
-      card: {
-        head: { branch: 'feature', oid: oidF },
-        branches: [
-          { name: 'main', oid: oidA },
-          { name: 'feature', oid: oidF },
-        ],
-      },
-    },
-  });
-  assert.deepEqual(classified.changes, [{
-    branch: 'main',
-    expectedOid: oidA,
-    oid: oidB,
-  }]);
-  assert.deepEqual(classified.pending, [{ name: 'feature', oid: oidF }]);
-  assert.deepEqual(Object.fromEntries(classified.expected), {
-    main: oidB,
-    feature: oidF,
-  });
-});
-
-test('folder binding is an owner/resource/realpath bijection', () => {
-  const realParent = path.join(tempRoot, 'binding-real');
-  const aliasParent = path.join(tempRoot, 'binding-alias');
-  fs.mkdirSync(realParent);
-  fs.symlinkSync(realParent, aliasParent);
-  const real = path.join(realParent, 'repo');
-  const alias = path.join(aliasParent, 'repo');
-  fs.mkdirSync(real);
-  const resourceId = '018f0000-0000-7000-8000-00000000c004';
-  const first = wall.bindProject(resourceId, OWNER, alias);
-  assert.equal(first.path, fs.realpathSync(real));
-  assert.equal(wall.bindProject(resourceId, OWNER, real).path, first.path);
-  assert.throws(
-    () => wall.bindProject('018f0000-0000-7000-8000-00000000c005', OWNER, alias),
-    /already bound/,
-  );
-  assert.throws(
-    () => wall.bindProject(resourceId, OWNER, path.join(tempRoot, 'elsewhere')),
-    /already bound differently/,
-  );
-  assert.throws(
-    () => wall.bindProject('018f0000-0000-7000-8000-00000000c006', 'not-a-user', path.join(tempRoot, 'other')),
-    /ownerUserId/,
-  );
-});
-
-test('snapshot install ignores older state, accepts exact equality, and rejects unequal equality', async () => {
-  const setupState = await setup(
-    'snapshot-order',
-    '018f0000-0000-7000-8000-00000000c007',
-  );
-  const input = (snapshot) => {
-    const bytes = Buffer.from(JSON.stringify(snapshot));
-    return {
-      resourceId: setupState.project.resourceId,
-      contract: projectStream.STREAM_CONTRACT,
-      schemaVersion: 2,
-      authorityEpoch: 1,
-      headVersion: snapshot.version,
-      snapshotVersion: snapshot.version,
-      snapshotChecksum: crypto.createHash('sha256').update(bytes).digest('hex'),
-      snapshotBase64: bytes.toString('base64'),
-    };
-  };
-  const current = projectStream.readSnapshot(
-    setupState.project.file,
-    setupState.project.resourceId,
-  );
-  const older = projectStream.installSnapshot(
-    setupState.project.file,
-    input(projectStream.emptySnapshot(setupState.project.resourceId)),
-  );
-  assert.equal(older.ignored, true);
-  assert.equal(projectStream.installSnapshot(
-    setupState.project.file,
-    input(current),
-  ).duplicate, true);
-
-  const otherRepo = createRepo('snapshot-other');
-  fs.writeFileSync(path.join(otherRepo, 'other.txt'), 'other\n');
-  git(otherRepo, 'add', '.');
-  git(otherRepo, 'commit', '-qm', 'other');
-  const otherCard = cardFor(setupState.project, otherRepo, 'replica-other');
-  const unequal = officialSnapshot(
-    setupState.project,
-    otherCard,
-    1,
-    'mutation_official_other_01',
-  );
-  assert.throws(
-    () => projectStream.installSnapshot(setupState.project.file, input(unequal)),
-    (error) => error.code === 'code_project_snapshot_mismatch',
-  );
-
-  const newer = projectStream._test.fold(
-    current,
-    {
-      kind: 'code.publish',
-      project: setupState.project.resourceId,
-      delta: {
-        kind: 'checkpoint.set',
-        checkpoint: checkpoint.CHECKPOINT_CONTRACT,
-        baseOid: current.card.head.oid,
-        branch: current.card.head.branch,
-        from: current.checkpoint.value,
-        to: {
-          revision: checkpoint.revisionOf(current.card.head.oid, '', 'diff --git a/new b/new\n'),
-          indexDiff: '',
-          worktreeDiff: 'diff --git a/new b/new\n',
-        },
-      },
-    },
-    { machine: 'machine-peer', mutationId: 'mutation_snapshot_newer_01', version: 2 },
-  );
-  const beforeFuture = fs.readFileSync(setupState.project.file, 'utf8');
-  assert.throws(
-    () => projectStream.installSnapshot(
-      setupState.project.file,
-      { ...input(newer), headVersion: 1 },
-    ),
-    /cannot exceed headVersion/,
-  );
-  assert.equal(fs.readFileSync(setupState.project.file, 'utf8'), beforeFuture);
-  assert.equal(
-    projectStream.installSnapshot(setupState.project.file, input(newer)).replica.appliedVersion,
-    2,
-  );
-  assert.equal(
-    projectStream.readSnapshot(setupState.project.file, setupState.project.resourceId).version,
-    2,
-  );
-
-  openLocalDb().prepare(`
-    UPDATE shared_resource_replicas
-    SET applied_version = 1, snapshot_version = 1
-    WHERE resource_id = ?
-  `).run(setupState.project.resourceId);
-  const replay = projectStream.installSnapshot(
-    setupState.project.file,
-    input(newer),
-  );
-  assert.equal(replay.duplicate, true);
-  assert.equal(replay.replica.appliedVersion, 2);
-  assert.equal(replay.replica.snapshotVersion, 2);
-});
-
-test('an equal snapshot retry repairs numbered work through fold and physical apply', async () => {
-  const setupState = await setup(
-    'snapshot-fold-recovery',
-    '018f0000-0000-7000-8000-00000000c00e',
-  );
-  fs.writeFileSync(path.join(setupState.repo, 'file.txt'), 'numbered by snapshot\n');
-  const card = cardFor(setupState.project, setupState.repo);
-  await checkpoint.captureLocalIntent(
-    setupState.project,
-    card,
-    await checkpointFor(setupState.project, card),
-  );
-  const published = wall._test.publishProject(setupState.project, [card]);
-  const claimed = mutations.claimCloudMutations().find((entry) => (
-    entry.mutation.mutationId === published.mutationId
-  ));
-  mutations.acknowledgeCloudMutation(
-    setupState.project.resourceId,
-    published.mutationId,
-    { version: 2, committedAt: '2026-07-27T02:00:00.000Z' },
-  );
-  const next = projectStream._test.fold(
-    projectStream.readSnapshot(
-      setupState.project.file,
-      setupState.project.resourceId,
-    ),
-    claimed.envelope.operation,
-    {
-      machine: claimed.envelope.deviceId,
-      mutationId: claimed.envelope.mutationId,
-      version: 2,
-    },
-  );
-  const bytes = Buffer.from(JSON.stringify(next));
-  const snapshotInput = {
-    resourceId: setupState.project.resourceId,
-    contract: projectStream.STREAM_CONTRACT,
-    schemaVersion: 2,
-    authorityEpoch: 1,
-    headVersion: 2,
-    snapshotVersion: 2,
-    snapshotChecksum: crypto.createHash('sha256').update(bytes).digest('hex'),
-    snapshotBase64: bytes.toString('base64'),
-  };
-  projectStream.installSnapshot(setupState.project.file, snapshotInput);
-
-  const numbered = intent.readIntent(setupState.project);
-  intent.writeIntent(setupState.project, {
-    base: numbered.base,
-    local: numbered.local,
-    terminal: numbered.terminal,
-    publication: { ...numbered.publication, foldedAt: null },
-  });
-  openLocalDb().prepare(`
-    UPDATE mutation_journal
-    SET official_projected_at = NULL
-    WHERE mutation_id = ?
-  `).run(published.mutationId);
-
-  const retried = projectStream.installSnapshot(
-    setupState.project.file,
-    snapshotInput,
-  );
-  assert.equal(retried.duplicate, true);
-  assert.equal(
-    typeof intent.readIntent(setupState.project).publication.foldedAt,
-    'string',
-    'equal snapshot retry restores the durable folded-intent fact',
-  );
-  assert.equal(
-    typeof mutations.getMutation(
-      `resource:${setupState.project.resourceId}`,
-      published.mutationId,
-    ).officialProjectedAt,
-    'string',
-    'equal snapshot retry restores the generic official-fold fact',
-  );
-
-  const plan = reducer.reduceWall(wall.readWall(setupState.project.repoKey))
-    .get(setupState.project.repoKey);
-  const applied = await reducer.materializeRepo(card, plan, 2);
-  assert.equal(applied.state, 'in-sync', JSON.stringify(applied));
-  assert.equal(intent.readIntent(setupState.project), null);
-  assert.equal(
-    reducer.readRepoState(
-      setupState.project.repoKey,
-      setupState.project.resourceId,
-    ).appliedThrough,
-    2,
-  );
-});
-
-test('an unauthorized rejected attachment remains terminal', async () => {
-  const repo = path.join(tempRoot, 'terminal-attachment');
-  fs.mkdirSync(repo);
-  const resourceId = '018f0000-0000-7000-8000-00000000c008';
-  const project = wall.bindProject(
-    resourceId,
-    '22222222-2222-4222-8222-222222222222',
-    repo,
-  );
-  const request = attachments.enqueueAttachment({
-    attachmentId: 'att_terminal_code_project_01',
-    resourceId,
-    localPath: project.file,
-  }).attachment;
-  attachments.failAttachment(request.attachmentId, {
-    message: 'shared_resource_read_forbidden',
-    retryable: false,
-  });
-  await wall._test.ensureProject(project);
-  assert.equal(attachments.getAttachmentByResource(resourceId).state, 'rejected');
-});
-
-test('a gitlink is a typed local terminal and never enters the outbox', async () => {
-  const setupState = await setup(
-    'gitlink-terminal',
-    '018f0000-0000-7000-8000-00000000c009',
-  );
-  const oid = setupState.card.head.oid;
-  git(setupState.repo, 'update-index', '--add', '--cacheinfo', `160000,${oid},vendor`);
-  const card = cardFor(setupState.project, setupState.repo);
-  const captured = await checkpoint.captureLocalIntent(
-    setupState.project,
-    card,
-    await checkpointFor(setupState.project, card),
-  );
-  assert.equal(captured.state, 'rejected');
-  assert.equal(captured.intent.terminal.code, 'unsupported_gitlink');
-  const publication = wall._test.publishProject(setupState.project, [card]);
-  assert.equal(publication.published, false);
-  assert.equal(publication.terminalCode, 'unsupported_gitlink');
-  assert.equal(mutations.listPendingCloudMutations(setupState.project.resourceId).length, 0);
-});