amalgm 0.1.239 → 0.1.241

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 } = require('child_process');
+const { execFile, spawn } = require('child_process');
 const { promisify } = require('util');
 
 const execFileAsync = promisify(execFile);
@@ -29,7 +29,7 @@ const {
   captureWorktreeDiff,
 } = require('../workspace/git');
 const merge = require('../workspace/merge');
-const { applyPatch } = require('../workspace/transition');
+const { advanceIndex } = require('../workspace/reducer');
 const {
   _test,
   CHECKPOINT_CONTRACT,
@@ -80,6 +80,58 @@ test('a checkpoint read across two different HEADs is discarded', () => {
   });
 });
 
+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',
@@ -114,7 +166,7 @@ async function makeRepoPair() {
   return { author, receiver };
 }
 
-test('a dirty worktree round-trips through capture and apply, gitignore filtering included', async () => {
+test('a dirty worktree round-trips through checkpoint trees, gitignore filtering included', async () => {
   const { author, receiver } = await makeRepoPair();
 
   // Every dirty shape at once: tracked edit, staged edit, deletion, new
@@ -129,13 +181,32 @@ test('a dirty worktree round-trips through capture and apply, gitignore filterin
   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 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);
+  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',
+  );
 
   assert.equal(
     fs.readFileSync(path.join(receiver, 'README.md'), 'utf8'),
@@ -156,8 +227,20 @@ test('a dirty worktree round-trips through capture and apply, gitignore filterin
   assert.equal(fs.existsSync(path.join(receiver, 'LICENSE')), false, 'deletions travel');
   assert.equal(fs.existsSync(path.join(receiver, 'node_modules')), false);
 
-  // And the reverse of the same patch restores the receiver to clean.
-  await applyPatch(receiver, patchFile, { reverse: true });
+  // 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',
+  );
   const after = await captureWorktreeDiff(receiver);
   assert.equal(after.diff, '');
 });
@@ -171,6 +254,215 @@ 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');
@@ -196,10 +488,11 @@ 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.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'));
+  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));
 
   const indexTree = await merge.treeOfPatch(author, captured.baseOid, captured.indexDiff);
   const worktreeTree = await merge.treeOfPatch(author, indexTree, captured.worktreeDiff);
@@ -207,6 +500,23 @@ 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);
@@ -223,43 +533,7 @@ 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-v9/);
-});
-
-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);
+  assert.match(first, /repo-checkpoints-v11/);
 });
 
 test('an uploading checkpoint payload is not published as a transition', () => {
@@ -267,7 +541,7 @@ test('an uploading checkpoint payload is not published as a transition', () => {
     revision: 'a'.repeat(64),
     payload: {
       kind: 'pending',
-      contract: 'opaque-chunks@1',
+      contract: 'opaque-chunks@2',
       checksum: 'b'.repeat(64),
     },
   };
@@ -277,7 +551,12 @@ test('an uploading checkpoint payload is not published as a transition', () => {
 });
 
 test('a small edit after a large file reuses the large file payload', () => {
-  const repoKey = 'https://example.test/granular-checkpoint.git';
+  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',
@@ -329,139 +608,3 @@ test('a small edit after a large file reuses the large file payload', () => {
   assert.equal(decoded.state, 'ready');
   assert.equal(decoded.worktreeDiff, `${largePatch}${smallPatch}`);
 });
-
-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({
-    machine: 'machine-a',
-    repoKey: 'root:test',
-    branch: 'main',
-    baseOid: 'd'.repeat(40),
-    sharedValue,
-    parked,
-    capturedAt: '2026-07-24T00:00:00.000Z',
-  });
-
-  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('shared content clears the local pending checkpoint instead of publishing an acknowledgement', () => {
-  const sharedValue = { revision: 'shared', indexDiff: '', worktreeDiff: 'shared-patch' };
-  assert.equal(_test.checkpointForSharedState({
-    machine: 'machine-a',
-    repoKey: 'root:test',
-    branch: 'main',
-    baseOid: 'a'.repeat(40),
-    sharedValue,
-    parked: [],
-  }), null);
-});
-
-test('an acknowledged checkpoint remains a silent receipt until newer state replaces it', () => {
-  const oid = 'a'.repeat(40);
-  const checkpoint = {
-    baseOid: oid,
-    branch: 'main',
-    to: { revision: 'local-revision' },
-  };
-  const card = { head: { oid, branch: 'main' } };
-
-  assert.equal(
-    _test.checkpointWasAcknowledged(checkpoint, card, 'local-revision', 51),
-    true,
-  );
-  assert.equal(
-    _test.checkpointWasAcknowledged(checkpoint, card, 'newer-revision', 51),
-    false,
-  );
-  assert.equal(
-    _test.checkpointWasAcknowledged(checkpoint, card, 'local-revision', null),
-    false,
-  );
-});
-
-test('unpublished parked work uses a no-op checkpoint over the current shared value', () => {
-  const sharedValue = { revision: 'shared', indexDiff: '', worktreeDiff: 'shared-patch' };
-  const parked = [{ oid: 'b'.repeat(40), objects: { kind: 'bundle' } }];
-  const checkpoint = _test.checkpointForSharedState({
-    machine: 'machine-a',
-    repoKey: 'root:test',
-    branch: 'main',
-    baseOid: 'a'.repeat(40),
-    sharedValue,
-    parked,
-  });
-
-  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,
-    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),
-    [pendingOid],
-  );
-  assert.deepEqual(
-    _test.localParkedEntries(existing, reduced, {
-      head: { branch: 'main', oid: 'e'.repeat(40) },
-    }).map((entry) => entry.oid),
-    [pendingOid],
-  );
-});
-
-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,
-    }],
-  };
-
-  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);
-});

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

@@ -0,0 +1,24 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const test = require('node:test');
+const durable = require('../workspace/durable');
+
+test('durable state replacement leaves one complete value and no temporary file', () => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-durable-'));
+  const file = path.join(directory, 'state.json');
+  try {
+    durable.writeJson(file, { version: 1, value: 'old' });
+    durable.writeJson(file, { version: 2, value: 'new' });
+    assert.deepEqual(JSON.parse(fs.readFileSync(file, 'utf8')), {
+      version: 2,
+      value: 'new',
+    });
+    assert.deepEqual(fs.readdirSync(directory), ['state.json']);
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+});