amalgm 0.1.220 → 0.1.234

package/runtime/scripts/amalgm-mcp/tests/workspace-publication-invariants.test.js

@@ -29,11 +29,12 @@ const {
 } = require('../workspace/checkpoint');
 const { parkedForState } = require('../workspace/reducer');
 const {
-  compactWallText,
+  _test: wallTest,
   hasLocalContribution,
   publicationStatus,
   stampCards,
 } = require('../workspace/wall');
+const projectStream = require('../workspace/project-stream');
 
 test.after(() => {
   closeLocalDb();
@@ -65,16 +66,16 @@ const rules = {
     liveness: 'shared-wall-outbox',
     gating: 'inside-winning-card-checkpoint',
   },
-  compaction: {
-    identity: 'derived-deletion',
-    ownership: 'any-machine-may-compact',
-    liveness: 'not-semantic-state',
-    gating: 'commutative-with-writers',
+  snapshot: {
+    identity: 'state-through-official-version',
+    ownership: 'authority-derived',
+    liveness: 'hydrates-then-replays-tail',
+    gating: 'never-a-new-event',
   },
 };
 
 test('the publication model has one explicit rule for every value and property', () => {
-  assert.deepEqual(Object.keys(rules), ['card', 'branch', 'checkpoint', 'parked', 'compaction']);
+  assert.deepEqual(Object.keys(rules), ['card', 'branch', 'checkpoint', 'parked', 'snapshot']);
   for (const rule of Object.values(rules)) {
     assert.deepEqual(Object.keys(rule), ['identity', 'ownership', 'liveness', 'gating']);
     assert.equal(Object.values(rule).every(Boolean), true);
@@ -87,15 +88,15 @@ test('the publication model has one explicit rule for every value and property',
 
 test('publication requires one current applied rail position and no unresolved send', () => {
   const repoKey = 'root:currentness';
-  const resourceId = require('../workspace/wall').projectResourceId(repoKey);
-  const file = path.join(tempRoot, 'currentness.jsonl');
-  fs.writeFileSync(file, '');
-  const opened = require('../state/docs').openDoc(file);
+  const project = require('../workspace/wall').projectForRepo(repoKey);
+  const resourceId = project.resourceId;
+  const file = project.file;
+  projectStream.writeSnapshot(file, projectStream._test.emptySnapshot(repoKey));
   require('../state/replicas').registerReplica({
     resourceId,
-    localResource: opened.resource,
+    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`,
     localPath: file,
-    contract: 'text-yjs@1',
+    contract: projectStream.STREAM_CONTRACT,
     schemaVersion: 1,
     authorityEpoch: 1,
     appliedVersion: 12,
@@ -113,7 +114,14 @@ test('publication requires one current applied rail position and no unresolved s
     pending: 0,
     current: true,
   });
-  require('../state/docs').writeDocText(file, 'pending\n');
+  projectStream.publish(project, {
+    wall: 'code-project@6',
+    project: repoKey,
+    machine: 'machine-a',
+    mutationId: 'mut_currentness_pending_01',
+    publishedAt: '2026-07-26T00:00:00.000Z',
+    cards: [],
+  });
   assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 12 }), {
     receivedThrough: 12,
     appliedThrough: 12,
@@ -195,10 +203,10 @@ test('receivers stay silent and only unacknowledged local parked work republishe
   assert.deepEqual(
     checkpointTest.localParkedEntries(
       { ...transition, parked: [localParked] },
-      { parked: [peerParked, unsentParked] },
+      { parked: [{ ...localParked, version: 10 }, peerParked, unsentParked] },
       local,
     ),
-    [localParked, unsentParked],
+    [unsentParked],
   );
   assert.deepEqual(parkedForState([localParked], [], []), [localParked]);
   assert.deepEqual(
@@ -254,59 +262,89 @@ test('card, branch, checkpoint, and parked work ride one wall mutation', () => {
   assert.equal(stamped.checkpoints[0].parked[0].oid, parkedOid);
 });
 
-test('two concurrent compacting publishers converge without losing either latest value', () => {
-  const Y = require('yjs');
-  const repoKey = 'root:compaction-collision';
-  const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@4',
-    project: repoKey,
-    machine,
-    mutationId: `mut_${machine}_${value}`,
-    cards: [{ value }],
-  });
-  const baseText = [
-    line('machine-a', 'old-a'),
-    line('machine-b', 'old-b'),
-    line('machine-a', 'current-a'),
-    line('machine-b', 'current-b'),
-    '',
-  ].join('\n');
-  const compacted = compactWallText(baseText, repoKey);
-  const removedBytes = baseText.length - compacted.length;
-  assert.ok(removedBytes > 0);
+test('a new card waits for its bundle instead of publishing transport metadata twice', () => {
+  const oldOid = 'a'.repeat(40);
+  const newOid = 'b'.repeat(40);
+  const plan = {
+    card: { head: { branch: 'main', oid: oldOid, detached: false } },
+    branches: [{ name: 'main', oid: oldOid }],
+  };
+  const pending = {
+    head: { branch: 'main', oid: newOid, detached: false },
+    objects: { kind: 'pending' },
+    refs: [{ name: 'main', oid: newOid, objects: { kind: 'pending' } }],
+  };
+  const ready = {
+    ...pending,
+    objects: { kind: 'bundle' },
+    refs: pending.refs.map((ref) => ({ ...ref, objects: { kind: 'bundle' } })),
+  };
 
-  const base = new Y.Doc();
-  base.getText('content').insert(0, baseText);
-  const baseUpdate = Y.encodeStateAsUpdate(base);
-  const baseVector = Y.encodeStateVector(base);
-  const publisherUpdate = (machine, value) => {
-    const writer = new Y.Doc();
-    Y.applyUpdate(writer, baseUpdate);
-    const text = writer.getText('content');
-    text.delete(0, removedBytes);
-    text.insert(text.length, `${line(machine, value)}\n`);
-    return Y.encodeStateAsUpdate(writer, baseVector);
+  assert.equal(wallTest.hasPendingContributionObjects(pending, plan), true);
+  assert.equal(wallTest.hasPendingContributionObjects(ready, plan), false);
+});
+
+test('an unnumbered branch waits for its bundle before sharing the card', () => {
+  const oid = 'b'.repeat(40);
+  const card = {
+    head: { branch: 'main', oid: 'a'.repeat(40) },
+    refs: [{ name: 'topic', oid, objects: { kind: 'pending' } }],
   };
-  const updateA = publisherUpdate('machine-a', 'latest-a');
-  const updateB = publisherUpdate('machine-b', 'latest-b');
-  const replicas = [
-    [updateA, updateB],
-    [updateB, updateA],
-  ].map((order) => {
-    const replica = new Y.Doc();
-    Y.applyUpdate(replica, baseUpdate);
-    for (const update of order) Y.applyUpdate(replica, update);
-    return replica.getText('content').toString();
-  });
+  const plan = {
+    card: { head: { branch: 'main', oid: 'a'.repeat(40) } },
+    branches: [{ name: 'topic', oid, version: null }],
+  };
+  assert.equal(wallTest.hasPendingContributionObjects(card, plan), true);
+  plan.branches[0].version = 50;
+  assert.equal(wallTest.hasPendingContributionObjects(card, plan), false);
+});
 
-  assert.equal(replicas[0], replicas[1]);
-  const latest = new Map();
-  for (const raw of replicas[0].trim().split('\n')) {
-    const entry = JSON.parse(raw);
-    latest.set(entry.machine, entry.cards[0].value);
-  }
-  assert.deepEqual(Object.fromEntries(latest), {
-    'machine-a': 'latest-a',
-    'machine-b': 'latest-b',
+test('transport metadata without a real card, branch, or checkpoint change is silent', () => {
+  const previousMutation = 'mut_previous_content';
+  const metadataOnly = [{
+    positionMutationId: previousMutation,
+    branches: [{ name: 'main', mutationId: previousMutation }],
+    checkpoints: [{ mutationId: previousMutation }],
+  }];
+  assert.equal(wallTest.cardsUseMutation(metadataOnly, 'mut_new_transport_metadata'), false);
+  assert.equal(wallTest.cardsUseMutation([{
+    ...metadataOnly[0],
+    checkpoints: [{ mutationId: 'mut_real_checkpoint' }],
+  }], 'mut_real_checkpoint'), true);
+});
+
+test('a snapshot is exactly one latest numbered record per machine', () => {
+  const project = 'root:snapshot';
+  const snapshot = projectStream._test.emptySnapshot(project);
+  const record = (machine, mutationId, value) => ({
+    wall: 'code-project@6',
+    project,
+    machine,
+    mutationId,
+    publishedAt: '2026-07-26T00:00:00.000Z',
+    cards: [{ value }],
   });
+  const afterA = projectStream._test.applyRecord(
+    snapshot,
+    record('machine-a', 'mut_snapshot_machine_a1', 'old-a'),
+    1,
+  );
+  const afterB = projectStream._test.applyRecord(
+    afterA,
+    record('machine-b', 'mut_snapshot_machine_b1', 'current-b'),
+    2,
+  );
+  const compacted = projectStream._test.applyRecord(
+    afterB,
+    record('machine-a', 'mut_snapshot_machine_a2', 'current-a'),
+    3,
+  );
+  assert.equal(compacted.version, 3);
+  assert.deepEqual(
+    compacted.records.map((entry) => [entry.machine, entry.version, entry.cards[0].value]),
+    [
+      ['machine-a', 3, 'current-a'],
+      ['machine-b', 2, 'current-b'],
+    ],
+  );
 });

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

@@ -152,6 +152,50 @@ test('wall reduction chooses one rail winner and orders checkpoint transitions b
   ]);
 });
 
+test('copies of one numbered card reduce to the copy with ready objects', () => {
+  const oid = 'a'.repeat(40);
+  const mutationId = 'mut_same_card_01';
+  const pending = card('/pending', oid, 7);
+  pending.replica = 'rpl_pending';
+  pending.positionMutationId = mutationId;
+  pending.objects = { kind: 'pending' };
+  pending.branches = [{
+    name: 'feature',
+    oid,
+    mutationId,
+    version: 7,
+    objects: { kind: 'pending' },
+  }];
+
+  const ready = card('/ready', oid, 7);
+  ready.replica = 'rpl_ready';
+  ready.positionMutationId = mutationId;
+  ready.objects = { kind: 'bundle', checksum: 'b'.repeat(64) };
+  ready.branches = [{
+    name: 'feature',
+    oid,
+    mutationId,
+    version: 7,
+    objects: { kind: 'bundle', checksum: 'b'.repeat(64) },
+  }];
+
+  for (const entries of [
+    [
+      { machine: 'machine-pending', cards: [pending] },
+      { machine: 'machine-ready', cards: [ready] },
+    ],
+    [
+      { machine: 'machine-ready', cards: [ready] },
+      { machine: 'machine-pending', cards: [pending] },
+    ],
+  ]) {
+    const plan = reduceWall(entries).get('root:test');
+    assert.equal(plan.card.positionVersion, 7);
+    assert.equal(plan.card.objects.kind, 'bundle');
+    assert.equal(plan.branches.find((ref) => ref.name === 'feature').objects.kind, 'bundle');
+  }
+});
+
 test('a checkpoint base replaces covered history and keeps only newer mutations', async () => {
   const { repo, oid } = await makeRepo('checkpoint-base');
   const patchA = await patchFor(repo, { 'a.txt': 'a1\n' });
@@ -511,8 +555,8 @@ test('a mode-only checkpoint makes the peer working file executable', async () =
   assert.equal(await git(repo, 'diff', '--cached', '--binary', '--full-index'), '');
 });
 
-test('once local work is on the rail, a checkpoint conflict materializes exactly without echoing', async () => {
-  const { repo, oid } = await makeRepo('materialize-conflict');
+test('once local work is on the rail, a later checkpoint replaces it exactly without echoing', async () => {
+  const { repo, oid } = await makeRepo('materialize-later-wins');
   const localPatch = await patchFor(repo, { 'a.txt': 'local answer\n' });
   const remotePatch = await patchFor(repo, { 'a.txt': 'remote answer\n' });
   const localTransition = transition('machine-local', 2, oid, '', localPatch);
@@ -534,16 +578,44 @@ test('once local work is on the rail, a checkpoint conflict materializes exactly
   }), true);
 
   const outcome = await materializeRepo(plan.card, plan);
-  assert.equal(outcome.state, 'conflict');
+  assert.equal(outcome.state, 'in-sync');
   const first = fs.readFileSync(path.join(repo, 'a.txt'), 'utf8');
-  assert.match(first, /local answer/);
-  assert.match(first, /remote answer/);
-  assert.match(first, /<<<<<<< current/);
+  assert.equal(first, 'remote answer\n');
 
   await materializeRepo(plan.card, plan);
   assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), first);
 });
 
+test('a snapshot cannot hide that local work was already numbered', async () => {
+  const { repo, oid } = await makeRepo('materialize-snapshot-ack');
+  const localPatch = await patchFor(repo, { 'a.txt': 'local answer\n' });
+  const remotePatch = await patchFor(repo, { 'a.txt': 'remote answer\n' });
+  const localTransition = transition('machine-local', 2, oid, '', localPatch);
+  const plan = {
+    repoKey: 'root:test',
+    card: card(repo, oid, 1),
+    checkpointBase: {
+      through: 2,
+      baseOid: oid,
+      branch: 'main',
+      value: localTransition.to,
+    },
+    transitions: [transition('machine-remote', 3, oid, localPatch, remotePatch)],
+  };
+  const captured = {
+    baseOid: oid,
+    indexDiff: localPatch,
+    worktreeDiff: '',
+  };
+
+  assert.equal(captureIsOnRail(plan, captured, 'machine-local'), false);
+  assert.equal(captureIsOnRail(plan, captured, 'machine-local', {
+    ...localTransition,
+    mutationId: 'mut_local_numbered',
+    version: 2,
+  }), true);
+});
+
 test('a writer publishing again cannot erase its earlier uncommitted work', async () => {
   const { repo, oid } = await makeRepo('checkpoint-history');
   const patchA = await patchFor(repo, { 'a.txt': 'a1\n' });
@@ -578,13 +650,12 @@ test('a writer publishing again cannot erase its earlier uncommitted work', asyn
   assert.equal(fs.readFileSync(path.join(repo, 'c.txt'), 'utf8'), 'c1\n');
 });
 
-test('a losing commit is parked, the winning card lands exactly, and losing work becomes uncommitted', async () => {
+test('a losing commit is archived, the winning card lands exactly, and later dirty work stays', async () => {
   const { repo, oid: baseOid } = await makeRepo('simultaneous-commit');
   fs.writeFileSync(path.join(repo, 'local-commit.txt'), 'losing commit work\n');
   await git(repo, 'add', '.');
   await git(repo, 'commit', '-m', 'local losing commit');
   const losingOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
-  fs.writeFileSync(path.join(repo, 'local-dirty.txt'), 'also uncommitted\n');
 
   await git(repo, 'switch', '--detach', baseOid);
   fs.writeFileSync(path.join(repo, 'winner.txt'), 'winning commit work\n');
@@ -592,6 +663,7 @@ test('a losing commit is parked, the winning card lands exactly, and losing work
   await git(repo, 'commit', '-m', 'remote winning commit');
   const winningOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
   await git(repo, 'switch', '-C', 'main', losingOid);
+  fs.writeFileSync(path.join(repo, 'local-dirty.txt'), 'also uncommitted\n');
 
   const localCard = card(repo, losingOid, 1);
   const winningCard = {
@@ -611,7 +683,7 @@ test('a losing commit is parked, the winning card lands exactly, and losing work
   assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), winningOid);
   assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingOid}`)).trim(), losingOid);
   assert.equal(fs.readFileSync(path.join(repo, 'winner.txt'), 'utf8'), 'winning commit work\n');
-  assert.equal(fs.readFileSync(path.join(repo, 'local-commit.txt'), 'utf8'), 'losing commit work\n');
+  assert.equal(fs.existsSync(path.join(repo, 'local-commit.txt')), false);
   assert.equal(fs.readFileSync(path.join(repo, 'local-dirty.txt'), 'utf8'), 'also uncommitted\n');
   assert.equal((await git(repo, 'status', '--porcelain')).trim().length > 0, true);
   assert.deepEqual(readRepoState('root:test').parked.map((entry) => entry.oid), [losingOid]);
@@ -626,26 +698,28 @@ test('a losing commit is parked, the winning card lands exactly, and losing work
     transitions: [],
     parked: sharedParked,
   });
+  assert.equal(fs.existsSync(path.join(repo, 'local-commit.txt')), false);
+  assert.equal(fs.readFileSync(path.join(repo, 'local-dirty.txt'), 'utf8'), 'also uncommitted\n');
 
   await git(repo, 'add', '.');
-  await git(repo, 'commit', '-m', 'fold parked work');
-  const foldedOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
-  const foldedCard = card(repo, foldedOid, 3);
-  const folded = await materializeRepo(foldedCard, {
+  await git(repo, 'commit', '-m', 'commit later dirty work');
+  const nextOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  const nextCard = card(repo, nextOid, 3);
+  const advanced = await materializeRepo(nextCard, {
     repoKey: 'root:test',
-    card: foldedCard,
+    card: nextCard,
     transitions: [],
     parked: [],
   });
 
-  assert.equal(folded.state, 'in-sync');
+  assert.equal(advanced.state, 'in-sync');
   assert.deepEqual(readRepoState('root:test').parked, []);
   await assert.rejects(
     git(repo, 'rev-parse', '--verify', `refs/amalgm/parked/${losingOid}`),
   );
 });
 
-test('rail-parked peer commits become one staged checkpoint on every machine', async () => {
+test('rail-parked peer commits are archived without changing the winning card tree', async () => {
   const { repo, oid: baseOid } = await makeRepo('peer-parked-commits');
 
   await git(repo, 'switch', '-c', 'winner');
@@ -680,13 +754,61 @@ test('rail-parked peer commits become one staged checkpoint on every machine', a
 
   assert.equal(outcome.state, 'in-sync');
   assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), winningOid);
+  assert.equal((await git(repo, 'diff', '--cached', '--name-only')).trim(), '');
+  assert.equal((await git(repo, 'diff', '--name-only')).trim(), '');
+  assert.equal(fs.existsSync(path.join(repo, 'loser-a.txt')), false);
+  assert.equal(fs.existsSync(path.join(repo, 'loser-b.txt')), false);
+  assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingAOid}`)).trim(), losingAOid);
+  assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingBOid}`)).trim(), losingBOid);
+});
+
+test('a local losing commit stays pending while a peer parked bundle is missing', async () => {
+  const { repo, oid: baseOid } = await makeRepo('parked-while-peer-bundle-waits');
+
+  await git(repo, 'switch', '-c', 'winner');
+  fs.writeFileSync(path.join(repo, 'winner.txt'), 'winning card\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'winning card');
+  const winningOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  await git(repo, 'switch', '-C', 'main', baseOid);
+  fs.writeFileSync(path.join(repo, 'local-loser.txt'), 'local losing commit\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'local losing commit');
+  const losingOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  const localCard = card(repo, losingOid, 1);
+  const winningCard = {
+    ...localCard,
+    head: { branch: 'main', oid: winningOid, detached: false },
+    positionVersion: 2,
+    positionMutationId: 'mut_card_winner_waiting',
+  };
+  const peerOid = 'f'.repeat(40);
+  const plan = {
+    repoKey: 'root:test',
+    card: winningCard,
+    transitions: [],
+    parked: [{ oid: peerOid, version: 3 }],
+  };
+
+  const first = await materializeRepo(localCard, plan, 3);
+  assert.equal(first.state, 'waiting');
+  assert.equal(first.reason, 'parked-objects-missing');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), winningOid);
+  assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingOid}`)).trim(), losingOid);
   assert.deepEqual(
-    (await git(repo, 'diff', '--cached', '--name-only')).trim().split('\n'),
-    ['loser-a.txt', 'loser-b.txt'],
+    readRepoState('root:test').parked.map((entry) => entry.oid).sort(),
+    [losingOid, peerOid].sort(),
+  );
+
+  const second = await materializeRepo(card(repo, winningOid, 2), plan, 3);
+  assert.equal(second.state, 'waiting');
+  assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingOid}`)).trim(), losingOid);
+  assert.deepEqual(
+    readRepoState('root:test').parked.map((entry) => entry.oid).sort(),
+    [losingOid, peerOid].sort(),
   );
-  assert.equal((await git(repo, 'diff', '--name-only')).trim(), '');
-  assert.equal(fs.readFileSync(path.join(repo, 'loser-a.txt'), 'utf8'), 'first losing commit\n');
-  assert.equal(fs.readFileSync(path.join(repo, 'loser-b.txt'), 'utf8'), 'second losing commit\n');
 });
 
 test('a local commit made after the verified card snapshot is never parked or overwritten', async () => {
@@ -800,7 +922,7 @@ test('an index advance preserves unrelated work staged by another writer', async
   assert.deepEqual(staged.trim().split('\n').sort(), ['a.txt', 'b.txt']);
 });
 
-test('a new card folds checkpoint work already on the rail instead of replaying it as local work', async () => {
+test('a new card includes checkpoint work already on the rail instead of replaying it as local work', async () => {
   const { repo, oid: baseOid } = await makeRepo('card-folds-shared-checkpoint');
   const sharedPatch = await patchFor(repo, { 'a.txt': 'shared checkpoint\n' });
 
@@ -835,7 +957,7 @@ test('a new card folds checkpoint work already on the rail instead of replaying
   assert.equal((await git(repo, 'status', '--porcelain')).trim(), '');
 });
 
-test('checkpoint then commit folds through the same card movement and unrelated local work stays', async () => {
+test('checkpoint then commit advances through the same card movement and unrelated local work stays', async () => {
   const { repo, oid: baseOid } = await makeRepo('checkpoint-commit-fold');
   await git(repo, 'switch', '-c', 'target');
   fs.writeFileSync(path.join(repo, 'shared.txt'), 'already checkpointed\n');
@@ -903,6 +1025,75 @@ test('the materializer creates, moves, and deletes branch refs without checking
   assert.equal((await git(repo, 'branch', '--show-current')).trim(), 'main');
 });
 
+test('a branch event is not applied until its commit is available', async () => {
+  const { repo, oid } = await makeRepo('branch-event-waits');
+  const peer = path.join(tempRoot, 'branch-event-waits-peer');
+  await git(tempRoot, 'clone', '--quiet', repo, peer);
+  await git(peer, 'switch', '-c', 'feature');
+  fs.writeFileSync(path.join(peer, 'feature.txt'), 'feature\n');
+  await git(peer, 'add', '.');
+  await git(peer, 'commit', '-m', 'feature');
+  const featureOid = (await git(peer, 'rev-parse', 'HEAD')).trim();
+
+  const repoKey = 'root:branch-event-waits';
+  const localCard = card(repo, oid, 1);
+  const plan = {
+    repoKey,
+    card: localCard,
+    transitions: [],
+    parked: [],
+    branches: [
+      { name: 'main', oid, version: 1 },
+      { name: 'feature', oid: featureOid, version: 2 },
+    ],
+  };
+
+  const waiting = await materializeRepo(localCard, plan, 2);
+  assert.deepEqual(waiting, {
+    state: 'waiting',
+    reason: 'branch-objects-missing',
+  });
+  assert.equal(readRepoState(repoKey), null);
+  await assert.rejects(() => git(repo, 'rev-parse', 'refs/heads/feature'));
+
+  await git(repo, 'fetch', '--quiet', peer, 'feature:refs/amalgm-test/feature');
+  const applied = await materializeRepo(localCard, plan, 2);
+  assert.equal(applied.state, 'in-sync');
+  assert.equal((await git(repo, 'rev-parse', 'refs/heads/feature')).trim(), featureOid);
+  assert.equal(readRepoState(repoKey).appliedThrough, 2);
+});
+
+test('an unpublished local branch delete is not restored while catching up', async () => {
+  const { repo, oid } = await makeRepo('pending-branch-delete');
+  await git(repo, 'switch', '-c', 'feature');
+  fs.writeFileSync(path.join(repo, 'feature.txt'), 'feature\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'feature');
+  const featureOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  await git(repo, 'switch', 'main');
+  await git(repo, 'branch', '-D', 'feature');
+
+  const localCard = card(repo, oid, 1);
+  const plan = {
+    repoKey: 'root:pending-branch-delete',
+    card: localCard,
+    transitions: [],
+    parked: [],
+    branches: [
+      { name: 'main', oid, version: 1 },
+      { name: 'feature', oid: featureOid, version: 2 },
+    ],
+  };
+  await materializeRepo(localCard, plan);
+  assert.equal((await git(repo, 'rev-parse', 'refs/heads/feature')).trim(), featureOid);
+
+  await git(repo, 'branch', '-D', 'feature');
+  await materializeRepo(localCard, plan);
+
+  await assert.rejects(() => git(repo, 'rev-parse', 'refs/heads/feature'));
+  assert.equal((await git(repo, 'branch', '--show-current')).trim(), 'main');
+});
+
 test('a card branch switch follows branch and OID together and leaves the old branch unchanged', async () => {
   const { repo, oid: mainOid } = await makeRepo('card-branch-switch');
   await git(repo, 'checkout', '-b', 'feature');