amalgm 0.1.245 → 0.1.246

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

@@ -5,7 +5,7 @@ const assert = require('node:assert/strict');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { execFile, spawn } = require('child_process');
+const { execFile } = require('child_process');
 const { promisify } = require('util');
 
 const execFileAsync = promisify(execFile);
@@ -23,27 +23,18 @@ fs.writeFileSync(
 );
 
 const { closeLocalDb } = require('../state/db');
-const {
-  _test: gitTest,
-  captureCheckpoint,
-  captureWorktreeDiff,
-} = require('../workspace/git');
+const { captureCheckpoint, captureWorktreeDiff } = require('../workspace/git');
 const merge = require('../workspace/merge');
-const { advanceIndex } = require('../workspace/reducer');
+const { applyPatch } = require('../workspace/transition');
 const {
   _test,
   CHECKPOINT_CONTRACT,
   checkpointFile,
-  checkpointValue,
   checkpointValueReady,
   readCheckpointValue,
   revisionOf,
   sameTransition,
 } = require('../workspace/checkpoint');
-const {
-  acknowledgeUpload,
-  claimUpload,
-} = require('../workspace/objects');
 
 test.after(() => {
   closeLocalDb();
@@ -63,75 +54,6 @@ test('checkpoint publication waits until the reducer finishes writing both repo
   assert.equal(_test.checkpointMayPublish(repoKey), true);
 });
 
-test('a checkpoint read across two different HEADs is discarded', () => {
-  assert.deepEqual(gitTest.checkpointCaptureResult({
-    baseOid: 'old-head',
-    observedOid: 'new-head',
-    indexDiff: '',
-    worktreeDiff: '',
-    bytes: 0,
-    maxBytes: Infinity,
-  }), {
-    baseOid: 'old-head',
-    indexDiff: null,
-    worktreeDiff: null,
-    reason: 'head-moved',
-    bytes: 0,
-  });
-});
-
-test('a checkpoint read across two different index or worktree states is discarded', () => {
-  const clean = {
-    baseOid: 'a'.repeat(40),
-    indexDiff: '',
-    worktreeDiff: '',
-    bytes: 0,
-  };
-  const staged = {
-    ...clean,
-    indexDiff: 'staged bytes',
-    bytes: 12,
-  };
-  assert.deepEqual(gitTest.stableCheckpointCapture(clean, staged), {
-    baseOid: 'a'.repeat(40),
-    indexDiff: null,
-    worktreeDiff: null,
-    reason: 'observation-moved',
-    bytes: 12,
-  });
-  assert.deepEqual(gitTest.stableCheckpointCapture(staged, staged), staged);
-});
-
-test('checkpoint capture requires two consecutive equal observations within its bound', async () => {
-  const clean = {
-    baseOid: 'a'.repeat(40),
-    indexDiff: '',
-    worktreeDiff: '',
-    bytes: 0,
-  };
-  const staged = {
-    ...clean,
-    indexDiff: 'staged bytes',
-    bytes: 12,
-  };
-  const settling = [clean, staged, staged];
-  assert.deepEqual(
-    await gitTest.captureStableCheckpoint(() => Promise.resolve(settling.shift()), 3),
-    staged,
-  );
-  const alternating = [clean, staged, clean, staged];
-  assert.deepEqual(
-    await gitTest.captureStableCheckpoint(() => Promise.resolve(alternating.shift()), 4),
-    {
-      baseOid: 'a'.repeat(40),
-      indexDiff: null,
-      worktreeDiff: null,
-      reason: 'observation-moved',
-      bytes: 12,
-    },
-  );
-});
-
 async function run(cwd, ...args) {
   await execFileAsync(
     'git',
@@ -166,7 +88,7 @@ async function makeRepoPair() {
   return { author, receiver };
 }
 
-test('a dirty worktree round-trips through checkpoint trees, gitignore filtering included', async () => {
+test('a dirty worktree round-trips through capture and apply, gitignore filtering included', async () => {
   const { author, receiver } = await makeRepoPair();
 
   // Every dirty shape at once: tracked edit, staged edit, deletion, new
@@ -181,32 +103,13 @@ test('a dirty worktree round-trips through checkpoint trees, gitignore filtering
   fs.mkdirSync(path.join(author, 'node_modules', 'junk'), { recursive: true });
   fs.writeFileSync(path.join(author, 'node_modules', 'junk', 'x.js'), 'never travels\n');
 
-  const captured = await captureCheckpoint(author);
-  assert.ok(captured.worktreeDiff.length > 0);
-  assert.ok(
-    !captured.worktreeDiff.includes('node_modules'),
-    'ignored files must never enter a checkpoint',
-  );
-  const baseTree = await merge.treeOf(receiver, captured.baseOid);
-  const indexTree = await merge.treeOfPatch(receiver, captured.baseOid, captured.indexDiff);
-  const worktreeTree = await merge.treeOfPatch(
-    receiver,
-    indexTree,
-    captured.worktreeDiff,
-  );
-  await merge.advance(receiver, baseTree, worktreeTree, { label: 'checkpoint-test-forward' });
-  const forwardIndexOperation = '1'.repeat(64);
-  await advanceIndex(
-    receiver,
-    await merge.indexTree(receiver),
-    indexTree,
-    forwardIndexOperation,
-  );
-  require('../workspace/transition').releaseGitMetadataReceipts(
-    receiver,
-    forwardIndexOperation,
-    'index',
-  );
+  const captured = await captureWorktreeDiff(author);
+  assert.ok(captured.diff.length > 0);
+  assert.ok(!captured.diff.includes('node_modules'), 'ignored files must never enter a checkpoint');
+
+  const patchFile = path.join(tempRoot, 'roundtrip.patch');
+  fs.writeFileSync(patchFile, captured.diff);
+  await applyPatch(receiver, patchFile);
 
   assert.equal(
     fs.readFileSync(path.join(receiver, 'README.md'), 'utf8'),
@@ -227,20 +130,8 @@ test('a dirty worktree round-trips through checkpoint trees, gitignore filtering
   assert.equal(fs.existsSync(path.join(receiver, 'LICENSE')), false, 'deletions travel');
   assert.equal(fs.existsSync(path.join(receiver, 'node_modules')), false);
 
-  // The same two primitives can advance back to the clean shared state.
-  await merge.advance(receiver, worktreeTree, baseTree, { label: 'checkpoint-test-reverse' });
-  const reverseIndexOperation = '2'.repeat(64);
-  await advanceIndex(
-    receiver,
-    await merge.indexTree(receiver),
-    baseTree,
-    reverseIndexOperation,
-  );
-  require('../workspace/transition').releaseGitMetadataReceipts(
-    receiver,
-    reverseIndexOperation,
-    'index',
-  );
+  // And the reverse of the same patch restores the receiver to clean.
+  await applyPatch(receiver, patchFile, { reverse: true });
   const after = await captureWorktreeDiff(receiver);
   assert.equal(after.diff, '');
 });
@@ -254,232 +145,6 @@ test('capture is stable: two reads of an untouched tree produce the same revisio
   assert.equal(revisionOf(first.baseOid, first.diff), revisionOf(second.baseOid, second.diff));
 });
 
-test('index ABA cannot produce a checkpoint that never physically existed', async () => {
-  const author = path.join(tempRoot, 'index-aba-author');
-  fs.mkdirSync(author);
-  await run(author, 'init');
-  fs.writeFileSync(path.join(author, 'file.txt'), 'floor\n');
-  await run(author, 'add', 'file.txt');
-  await run(author, 'commit', '-m', 'floor');
-  fs.writeFileSync(path.join(author, 'file.txt'), 'local\n');
-
-  const mover = spawn('/bin/sh', ['-c', `
-    index=0
-    while [ "$index" -lt 500 ]; do
-      git reset -q HEAD -- file.txt
-      git add file.txt
-      index=$((index + 1))
-    done
-  `], {
-    cwd: author,
-    env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' },
-    stdio: ['ignore', 'ignore', 'pipe'],
-  });
-  let moved = 0;
-  try {
-    for (let attempt = 0; attempt < 8; attempt += 1) {
-      const captured = await captureCheckpoint(author);
-      if (captured.reason === 'observation-moved') {
-        moved += 1;
-        continue;
-      }
-      assert.ok(
-        captured.indexDiff.length > 0 || captured.worktreeDiff.length > 0,
-        'capture returned an impossible clean index + clean worktree mixture',
-      );
-    }
-  } finally {
-    mover.kill('SIGTERM');
-    await new Promise((resolve) => {
-      if (mover.exitCode !== null) resolve();
-      else mover.once('exit', resolve);
-    });
-  }
-  assert.ok(moved > 0, 'the test did not overlap an index movement');
-});
-
-test('directory membership ABA cannot hide an untracked file from capture', async () => {
-  const author = path.join(tempRoot, 'membership-aba-author');
-  fs.mkdirSync(author);
-  await run(author, 'init', '-b', 'main');
-  fs.writeFileSync(path.join(author, 'tracked.txt'), 'floor\n');
-  await run(author, 'add', 'tracked.txt');
-  await run(author, 'commit', '-m', 'floor');
-
-  const source = String.raw`
-    const childProcess = require('child_process');
-    const fs = require('fs');
-    const path = require('path');
-    const { promisify } = require('util');
-    const originalExecFile = childProcess.execFile;
-    const late = path.join(process.env.TEST_REPO, 'late.txt');
-    let otherCalls = 0;
-    const wrappedExecFile = function(file, args, options, callback) {
-      const isUntracked = file === 'git'
-        && Array.isArray(args)
-        && args.includes('ls-files')
-        && args.includes('--others');
-      if (!isUntracked) return originalExecFile(file, args, options, callback);
-      otherCalls += 1;
-      fs.rmSync(late, { force: true });
-      return originalExecFile(file, args, options, (error, stdout, stderr) => {
-        fs.writeFileSync(late, 'late bytes\n');
-        callback(error, stdout, stderr);
-      });
-    };
-    wrappedExecFile[promisify.custom] = (file, args, options) => new Promise(
-      (resolve, reject) => wrappedExecFile(file, args, options, (error, stdout, stderr) => {
-        if (error) {
-          error.stdout = stdout;
-          error.stderr = stderr;
-          reject(error);
-        } else {
-          resolve({ stdout, stderr });
-        }
-      }),
-    );
-    childProcess.execFile = wrappedExecFile;
-    const { captureCheckpoint } = require(process.env.GIT_MODULE);
-    captureCheckpoint(process.env.TEST_REPO).then((captured) => {
-      process.stdout.write(JSON.stringify({
-        captured,
-        otherCalls,
-        finalLateExists: fs.existsSync(late),
-      }));
-    }).catch((error) => {
-      process.stderr.write(error.stack || String(error));
-      process.exitCode = 1;
-    });
-  `;
-  const { stdout } = await execFileAsync(process.execPath, ['-e', source], {
-    env: {
-      ...process.env,
-      TEST_REPO: author,
-      GIT_MODULE: require.resolve('../workspace/git'),
-    },
-    timeout: 30_000,
-    maxBuffer: 8 * 1024 * 1024,
-  });
-  const result = JSON.parse(stdout);
-  assert.equal(result.finalLateExists, true);
-  assert.ok(result.otherCalls >= 4);
-  assert.equal(result.captured.reason, 'observation-moved');
-  assert.equal(result.captured.indexDiff, null);
-  assert.equal(result.captured.worktreeDiff, null);
-});
-
-test('same-inode directory rename ABA cannot hide its untracked children', async () => {
-  const author = path.join(tempRoot, 'directory-rename-aba-author');
-  fs.mkdirSync(author);
-  await run(author, 'init', '-b', 'main');
-  fs.writeFileSync(path.join(author, 'tracked.txt'), 'floor\n');
-  await run(author, 'add', 'tracked.txt');
-  await run(author, 'commit', '-m', 'floor');
-  fs.mkdirSync(path.join(author, 'local'));
-  fs.writeFileSync(path.join(author, 'local', 'local.txt'), 'local bytes\n');
-
-  const source = String.raw`
-    const childProcess = require('child_process');
-    const fs = require('fs');
-    const path = require('path');
-    const { promisify } = require('util');
-    const originalExecFile = childProcess.execFile;
-    const held = path.join(process.env.TEST_REPO, 'local');
-    const outside = path.join(path.dirname(process.env.TEST_REPO), 'held-local');
-    const originalIno = fs.statSync(held).ino;
-    let intercepted = 0;
-    const wrappedExecFile = function(file, args, options, callback) {
-      const isUntracked = file === 'git'
-        && Array.isArray(args)
-        && args.includes('ls-files')
-        && args.includes('--others')
-        && !args.includes('--ignored');
-      if (!isUntracked) return originalExecFile(file, args, options, callback);
-      intercepted += 1;
-      fs.renameSync(held, outside);
-      return originalExecFile(file, args, options, (error, stdout, stderr) => {
-        fs.renameSync(outside, held);
-        callback(error, stdout, stderr);
-      });
-    };
-    wrappedExecFile[promisify.custom] = (file, args, options) => new Promise(
-      (resolve, reject) => wrappedExecFile(file, args, options, (error, stdout, stderr) => {
-        if (error) {
-          error.stdout = stdout;
-          error.stderr = stderr;
-          reject(error);
-        } else {
-          resolve({ stdout, stderr });
-        }
-      }),
-    );
-    childProcess.execFile = wrappedExecFile;
-    const { captureCheckpoint } = require(process.env.GIT_MODULE);
-    captureCheckpoint(process.env.TEST_REPO).then((captured) => {
-      process.stdout.write(JSON.stringify({
-        captured,
-        intercepted,
-        finalExists: fs.existsSync(path.join(held, 'local.txt')),
-        sameInode: fs.statSync(held).ino === originalIno,
-      }));
-    }).catch((error) => {
-      process.stderr.write(error.stack || String(error));
-      process.exitCode = 1;
-    });
-  `;
-  const { stdout } = await execFileAsync(process.execPath, ['-e', source], {
-    env: {
-      ...process.env,
-      TEST_REPO: author,
-      GIT_MODULE: require.resolve('../workspace/git'),
-    },
-    timeout: 30_000,
-    maxBuffer: 8 * 1024 * 1024,
-  });
-  const result = JSON.parse(stdout);
-  assert.ok(result.intercepted >= 2);
-  assert.equal(result.finalExists, true);
-  assert.equal(result.sameInode, true);
-  assert.equal(result.captured.reason, 'observation-moved');
-});
-
-test('an untracked nested repository is rejected instead of certified clean', async () => {
-  const author = path.join(tempRoot, 'nested-repository-author');
-  fs.mkdirSync(author);
-  await run(author, 'init', '-b', 'main');
-  fs.writeFileSync(path.join(author, 'tracked.txt'), 'floor\n');
-  await run(author, 'add', 'tracked.txt');
-  await run(author, 'commit', '-m', 'floor');
-  const nested = path.join(author, 'nested');
-  fs.mkdirSync(nested);
-  await run(nested, 'init', '-b', 'main');
-  fs.writeFileSync(path.join(nested, 'local.txt'), 'nested local bytes\n');
-  await run(nested, 'add', 'local.txt');
-  await run(nested, 'commit', '-m', 'nested');
-
-  const captured = await captureCheckpoint(author);
-  assert.equal(captured.reason, 'unsupported-nested-repository');
-  assert.equal(captured.indexDiff, null);
-  assert.equal(captured.worktreeDiff, null);
-});
-
-test('checkpoint identity ignores Git file-patch order', async () => {
-  const { author } = await makeRepoPair();
-  fs.appendFileSync(path.join(author, 'README.md'), 'tracked edit\n');
-  fs.writeFileSync(path.join(author, 'A-new-file.txt'), 'untracked edit\n');
-
-  const captured = await captureCheckpoint(author);
-  const indexTree = await merge.treeOfPatch(author, captured.baseOid, captured.indexDiff);
-  const worktreeTree = await merge.treeOfPatch(author, indexTree, captured.worktreeDiff);
-  const normalized = await merge.diffOfTree(author, indexTree, worktreeTree);
-
-  assert.notEqual(captured.worktreeDiff, normalized);
-  assert.equal(
-    revisionOf(captured.baseOid, captured.indexDiff, captured.worktreeDiff),
-    revisionOf(captured.baseOid, captured.indexDiff, normalized),
-  );
-});
-
 test('one checkpoint preserves the staged and unstaged layers separately', async () => {
   const { author } = await makeRepoPair();
   fs.writeFileSync(path.join(author, 'src', 'index.js'), 'console.log(2);\n');
@@ -488,11 +153,10 @@ test('one checkpoint preserves the staged and unstaged layers separately', async
   fs.appendFileSync(path.join(author, 'README.md'), 'unstaged\n');
 
   const captured = await captureCheckpoint(author);
-  assert.equal(captured.reason, undefined, JSON.stringify(captured));
-  assert.ok(captured.indexDiff.includes('console.log(2)'), JSON.stringify(captured));
-  assert.ok(!captured.indexDiff.includes('console.log(3)'), JSON.stringify(captured));
-  assert.ok(captured.worktreeDiff.includes('console.log(3)'), JSON.stringify(captured));
-  assert.ok(captured.worktreeDiff.includes('unstaged'), JSON.stringify(captured));
+  assert.ok(captured.indexDiff.includes('console.log(2)'));
+  assert.ok(!captured.indexDiff.includes('console.log(3)'));
+  assert.ok(captured.worktreeDiff.includes('console.log(3)'));
+  assert.ok(captured.worktreeDiff.includes('unstaged'));
 
   const indexTree = await merge.treeOfPatch(author, captured.baseOid, captured.indexDiff);
   const worktreeTree = await merge.treeOfPatch(author, indexTree, captured.worktreeDiff);
@@ -500,23 +164,6 @@ test('one checkpoint preserves the staged and unstaged layers separately', async
   assert.equal(await runOutput(author, 'show', `${worktreeTree}:src/index.js`), 'console.log(3);\n');
 });
 
-test('same-size same-time saves cannot make Git mix staged identity with working bytes', async () => {
-  const { author } = await makeRepoPair();
-  await run(author, 'config', 'core.trustctime', 'false');
-  const file = path.join(author, 'src', 'index.js');
-  fs.writeFileSync(file, 'console.log(2);\n');
-  await run(author, 'add', 'src/index.js');
-  const stagedTime = fs.statSync(file);
-  fs.writeFileSync(file, 'console.log(3);\n');
-  fs.utimesSync(file, stagedTime.atime, stagedTime.mtime);
-
-  const captured = await captureCheckpoint(author);
-  assert.equal(captured.reason, undefined, JSON.stringify(captured));
-  assert.ok(captured.indexDiff.includes('console.log(2)'), JSON.stringify(captured));
-  assert.ok(!captured.indexDiff.includes('console.log(3)'), JSON.stringify(captured));
-  assert.ok(captured.worktreeDiff.includes('console.log(3)'), JSON.stringify(captured));
-});
-
 test('a clean tree captures as an empty patch, and oversized state is a named refusal', async () => {
   const { author } = await makeRepoPair();
   const clean = await captureWorktreeDiff(author);
@@ -533,7 +180,43 @@ test('checkpoint captures are local cache; their operations travel on the one wa
   assert.equal(first, checkpointFile('m1', 'https://github.com/a/b'));
   assert.notEqual(first, checkpointFile('m2', 'https://github.com/a/b'));
   assert.notEqual(first, checkpointFile('m1', 'https://github.com/a/c'));
-  assert.match(first, /repo-checkpoints-v11/);
+  assert.match(first, /repo-checkpoints-v8/);
+});
+
+test('a materialized peer card is immediately a valid checkpoint base', () => {
+  const oid = 'a'.repeat(40);
+  assert.equal(_test.checkpointBaseReady({
+    head: { branch: 'main', oid },
+  }, {
+    appliedThrough: 12,
+    branch: 'main',
+    baseOid: oid,
+    indexDiff: '',
+    worktreeDiff: '',
+  }, {
+    receivedThrough: 12,
+    appliedThrough: 12,
+    pending: 0,
+    current: true,
+  }), true);
+});
+
+test('checkpoint publication waits when the reducer is behind the rail', () => {
+  const oid = 'a'.repeat(40);
+  const card = { head: { branch: 'main', oid } };
+  const reduced = {
+    appliedThrough: 11,
+    branch: 'main',
+    baseOid: oid,
+    indexDiff: '',
+    worktreeDiff: '',
+  };
+  assert.equal(_test.checkpointBaseReady(card, reduced, {
+    receivedThrough: 12,
+    appliedThrough: 11,
+    pending: 0,
+    current: false,
+  }), false);
 });
 
 test('an uploading checkpoint payload is not published as a transition', () => {
@@ -541,7 +224,7 @@ test('an uploading checkpoint payload is not published as a transition', () => {
     revision: 'a'.repeat(64),
     payload: {
       kind: 'pending',
-      contract: 'opaque-chunks@2',
+      contract: 'opaque-chunks@1',
       checksum: 'b'.repeat(64),
     },
   };
@@ -550,61 +233,95 @@ test('an uploading checkpoint payload is not published as a transition', () => {
   assert.equal(checkpointValueReady({ revision: null, indexDiff: '', worktreeDiff: '' }), true);
 });
 
-test('a small edit after a large file reuses the large file payload', () => {
-  const project = require('../workspace/wall').bindProject(
-    '018f0000-0000-7000-8000-000000000010',
-    '11111111-1111-4111-8111-111111111111',
-    path.join(tempRoot, 'granular-checkpoint'),
-  );
-  const repoKey = project.repoKey;
-  const baseOid = 'c'.repeat(40);
-  const largePatch = [
-    'diff --git a/blob.bin b/blob.bin',
-    'new file mode 100644',
-    '--- /dev/null',
-    '+++ b/blob.bin',
-    `+${'x'.repeat(700_000)}`,
-    '',
-  ].join('\n');
-  const smallPatch = [
-    'diff --git a/z.txt b/z.txt',
-    'new file mode 100644',
-    '--- /dev/null',
-    '+++ b/z.txt',
-    '+small edit',
-    '',
-  ].join('\n');
+test('a clean losing commit travels as parked metadata on a no-op checkpoint', () => {
+  const sharedValue = { revision: null, indexDiff: '', worktreeDiff: '' };
+  const parked = [{
+    oid: 'a'.repeat(40),
+    ref: `refs/amalgm/parked/${'a'.repeat(40)}`,
+    objects: { kind: 'bundle', checksum: 'b'.repeat(64) },
+  }];
+  const checkpoint = _test.checkpointForSharedState({
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine: 'machine-a',
+    repoKey: 'root:test',
+    branch: 'old',
+    baseOid: 'c'.repeat(40),
+    from: sharedValue,
+    to: sharedValue,
+    parked: [],
+  }, {
+    machine: 'machine-a',
+    repoKey: 'root:test',
+    branch: 'main',
+    baseOid: 'd'.repeat(40),
+    sharedValue,
+    parked,
+    capturedAt: '2026-07-24T00:00:00.000Z',
+  });
 
-  assert.equal(
-    checkpointValue('machine-a', repoKey, baseOid, '', largePatch).sections.worktree[0].payload.kind,
-    'pending',
-  );
-  for (;;) {
-    const upload = claimUpload();
-    if (!upload) break;
-    acknowledgeUpload(upload.resourceId, upload.sha256);
-  }
-
-  const first = checkpointValue('machine-a', repoKey, baseOid, '', largePatch);
-  assert.equal(checkpointValueReady(first), true);
-  assert.equal(first.sections.worktree[0].payload.kind, 'chunks');
-
-  const second = checkpointValue(
-    'machine-a',
-    repoKey,
+  assert.equal(checkpoint.checkpoint, CHECKPOINT_CONTRACT);
+  assert.equal(checkpoint.baseOid, 'd'.repeat(40));
+  assert.equal(checkpoint.branch, 'main');
+  assert.deepEqual(checkpoint.from, sharedValue);
+  assert.deepEqual(checkpoint.to, sharedValue);
+  assert.deepEqual(checkpoint.parked, parked);
+});
+
+test('only this machine keeps announcing its parked commits', () => {
+  const baseOid = 'a'.repeat(40);
+  const localOid = 'b'.repeat(40);
+  const peerOid = 'c'.repeat(40);
+  const pendingOid = 'd'.repeat(40);
+  const existing = {
+    branch: 'main',
     baseOid,
-    '',
-    `${largePatch}${smallPatch}`,
+    parked: [{ oid: localOid, objects: { kind: 'pending' } }],
+  };
+  const reduced = {
+    parked: [
+      { oid: localOid, version: 10, objects: { kind: 'pending' } },
+      { oid: peerOid, version: 11, objects: { kind: 'bundle' } },
+      { oid: pendingOid, objects: { kind: 'pending' } },
+    ],
+  };
+  const card = { head: { branch: 'main', oid: baseOid } };
+
+  assert.deepEqual(
+    _test.localParkedEntries(existing, reduced, card).map((entry) => entry.oid),
+    [localOid, pendingOid],
   );
-  assert.equal(
-    checkpointValueReady(second),
-    true,
-    'the unchanged large file must not be uploaded again',
+  assert.deepEqual(
+    _test.localParkedEntries(existing, reduced, {
+      head: { branch: 'main', oid: 'e'.repeat(40) },
+    }).map((entry) => entry.oid),
+    [pendingOid],
   );
-  assert.equal(second.sections.worktree[0].payload.checksum, first.sections.worktree[0].payload.checksum);
-  assert.equal(claimUpload(), null);
+});
+
+test('a server rail number does not turn the same parked checkpoint into new work', () => {
+  const value = { revision: null, indexDiff: '', worktreeDiff: '' };
+  const checkpoint = {
+    branch: 'main',
+    baseOid: 'a'.repeat(40),
+    from: value,
+    to: value,
+    parked: [{
+      oid: 'b'.repeat(40),
+      ref: `refs/amalgm/parked/${'b'.repeat(40)}`,
+      objects: { kind: 'bundle', checksum: 'c'.repeat(64) },
+      version: 12,
+    }],
+  };
 
-  const decoded = readCheckpointValue(baseOid, second);
-  assert.equal(decoded.state, 'ready');
-  assert.equal(decoded.worktreeDiff, `${largePatch}${smallPatch}`);
+  assert.equal(sameTransition(checkpoint, {
+    ...checkpoint,
+    parked: checkpoint.parked.map((entry) => ({ ...entry, version: 37 })),
+  }), true);
+  assert.equal(sameTransition(checkpoint, {
+    ...checkpoint,
+    parked: checkpoint.parked.map((entry) => ({
+      ...entry,
+      objects: { ...entry.objects, checksum: 'd'.repeat(64) },
+    })),
+  }), false);
 });