amalgm 0.1.221 → 0.1.234

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.221",
+  "version": "0.1.234",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/state/attachments.js

@@ -129,7 +129,13 @@ function acknowledgeAttachment(attachmentIdInput, payload, options = {}) {
 
   const installed = payload?.contract === 'workspace-tree@1'
     ? require('../workspace/tree-store').installCloudTreeSnapshot(attachment.localPath, payload, { database })
-    : require('./docs').installCloudDocSnapshot(attachment.localPath, payload);
+    : payload?.contract === 'code-project-stream@1'
+      ? require('../workspace/project-stream').installSnapshot(
+        attachment.localPath,
+        payload,
+        { database },
+      )
+      : require('./docs').installCloudDocSnapshot(attachment.localPath, payload);
   const now = new Date().toISOString();
   cachedStatement(database, `
     UPDATE shared_resource_attachments

package/runtime/scripts/amalgm-mcp/state/shared-rest.js

@@ -118,9 +118,35 @@ async function handleWorkspaceContentDiscover(body, sendJson) {
 
 async function handlePromotionStart(body, sendJson) {
   try {
+    const codeProject = body?.contract === 'code-project-stream@1';
     const requestedResourceId = typeof body?.resourceId === 'string' && body.resourceId.trim()
       ? body.resourceId.trim()
       : null;
+    if (codeProject) {
+      if (!requestedResourceId) {
+        const error = new Error('code project promotion requires a resourceId');
+        error.statusCode = 409;
+        throw error;
+      }
+      const projectStream = require('../workspace/project-stream');
+      const localPath = require('path').resolve(body?.path || '');
+      const snapshot = projectStream.readSnapshot(localPath, body?.project);
+      const bytes = Buffer.from(`${JSON.stringify(snapshot)}\n`, 'utf8');
+      const result = require('./promotions').enqueuePromotion({
+        promotionId: body?.promotionId || `prm_${crypto.randomBytes(16).toString('base64url')}`,
+        resourceId: requestedResourceId,
+        localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${requestedResourceId}`,
+        localPath,
+        contract: projectStream.STREAM_CONTRACT,
+        schemaVersion: 1,
+        snapshotBase64: bytes.toString('base64'),
+        contentBytes: bytes.length,
+        name: body?.name,
+        mediaType: 'application/vnd.amalgm.code-project+json',
+      });
+      sendJson(result.duplicate ? 200 : 202, result);
+      return;
+    }
     const requestedNodeId = requestedResourceId
       && require('../workspace/tree/identity').isUuid(requestedResourceId)
       ? requestedResourceId.toLowerCase()
@@ -214,13 +240,22 @@ async function handlePromotionFail(body, sendJson) {
 async function handleAttachmentStart(body, sendJson) {
   try {
     const tree = body?.contract === 'workspace-tree@1';
-    const localPath = tree ? require('path').resolve(body?.path || '') : require('./docs').openDoc(body?.path).path;
+    const codeProject = body?.contract === 'code-project-stream@1';
+    const localPath = tree || codeProject
+      ? require('path').resolve(body?.path || '')
+      : require('./docs').openDoc(body?.path).path;
     if (tree) {
       const stats = fs.statSync(localPath);
       if (!stats.isDirectory() || fs.readdirSync(localPath).length > 0) {
         sendJson(409, { error: 'cloud workspace attachment requires an empty folder' });
         return;
       }
+    } else if (codeProject) {
+      const contents = fs.existsSync(localPath) ? fs.readFileSync(localPath, 'utf8').trim() : '';
+      if (contents) {
+        sendJson(409, { error: 'code project attachment requires an empty local projection' });
+        return;
+      }
     } else if (require('./docs').getDocText(localPath).length > 0) {
       sendJson(409, { error: 'cloud attachment requires an empty local text file' });
       return;
@@ -331,7 +366,9 @@ async function handleMutationIngest(body, sendJson) {
       ? require('../browser/cookie-jar').applyCloudCookieMutation(body)
       : contract === 'workspace-tree@1'
         ? require('../workspace/tree-store').applyCloudTreeMutation(body)
-        : require('./docs').applyCloudDocMutation(body);
+        : contract === 'code-project-stream@1'
+          ? require('../workspace/project-stream').applyCloudMutation(body)
+          : require('./docs').applyCloudDocMutation(body);
     sendJson(200, result);
   } catch (error) {
     sendHandlerError(error, sendJson);

package/runtime/scripts/amalgm-mcp/tests/code-project-stream.test.js

@@ -0,0 +1,180 @@
+'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 tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-code-project-stream-'));
+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-a';
+process.env.AMALGM_DEVICE_ID = 'machine-a';
+fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
+fs.writeFileSync(
+  path.join(process.env.AMALGM_DIR, 'computer.json'),
+  JSON.stringify({
+    computer_id: 'machine-a',
+    user_id: '11111111-1111-4111-8111-111111111111',
+  }),
+);
+
+const { closeLocalDb } = require('../state/db');
+const attachments = require('../state/attachments');
+const promotions = require('../state/promotions');
+const shared = require('../state/shared-rest');
+const projectStream = require('../workspace/project-stream');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+function call(handler, body) {
+  return new Promise((resolve, reject) => {
+    handler(body, (status, payload) => {
+      if (status >= 400) reject(Object.assign(new Error(payload?.error), { status, payload }));
+      else resolve({ status, payload });
+    });
+  });
+}
+
+function record(project, machine, mutationId, marker) {
+  return {
+    wall: projectStream.WALL_CONTRACT,
+    project,
+    machine,
+    mutationId,
+    publishedAt: '2026-07-26T12:00:00.000Z',
+    cards: [{ marker }],
+  };
+}
+
+function encodedSnapshot(snapshot) {
+  const bytes = Buffer.from(`${JSON.stringify(snapshot)}\n`, 'utf8');
+  return {
+    snapshotBase64: bytes.toString('base64'),
+    snapshotChecksum: crypto.createHash('sha256').update(bytes).digest('hex'),
+  };
+}
+
+test('a code project promotes as a compact snapshot, not as a text document', async () => {
+  const project = 'root:promotion';
+  const resourceId = 'shr_code_project_promotion_0001';
+  const file = path.join(tempRoot, 'promotion.json');
+  projectStream.writeSnapshot(file, projectStream._test.emptySnapshot(project));
+
+  const started = await call(shared.handlePromotionStart, {
+    resourceId,
+    path: file,
+    project,
+    contract: projectStream.STREAM_CONTRACT,
+  });
+  assert.equal(started.status, 202);
+  assert.equal(started.payload.promotion.contract, projectStream.STREAM_CONTRACT);
+  assert.equal(started.payload.promotion.localResource, `${projectStream.LOCAL_RESOURCE_PREFIX}${resourceId}`);
+
+  const promotion = promotions.getPromotion(started.payload.promotion.promotionId);
+  promotions.acknowledgePromotion(promotion.promotionId, {
+    resourceId,
+    authorityEpoch: 1,
+    headVersion: 0,
+    snapshotVersion: 0,
+    snapshotChecksum: promotion.snapshotChecksum,
+    snapshotKey: 'shared/code-project/promotion.bin',
+  });
+  const replica = require('../state/replicas').getReplicaByResourceId(resourceId);
+  assert.equal(replica.contract, projectStream.STREAM_CONTRACT);
+  assert.equal(replica.localPath, file);
+});
+
+test('empty attachment hydrates through N, then applies only event N+1', async () => {
+  const project = 'root:hydrate';
+  const resourceId = 'shr_code_project_attachment_0001';
+  const file = path.join(tempRoot, 'attachment.json');
+  const started = await call(shared.handleAttachmentStart, {
+    resourceId,
+    path: file,
+    contract: projectStream.STREAM_CONTRACT,
+  });
+  assert.equal(started.status, 202);
+
+  const mutationA = 'mut_code_project_snapshot_a';
+  const snapshot = {
+    schemaVersion: 1,
+    project,
+    version: 2,
+    records: [{ ...record(project, 'machine-a', mutationA, 'snapshot'), version: 2 }],
+  };
+  const encoded = encodedSnapshot(snapshot);
+  await call(shared.handleAttachmentAck, {
+    attachmentId: started.payload.attachment.attachmentId,
+    resourceId,
+    authorityEpoch: 1,
+    headVersion: 2,
+    snapshotVersion: 2,
+    contract: projectStream.STREAM_CONTRACT,
+    schemaVersion: 1,
+    ...encoded,
+  });
+
+  assert.equal(attachments.getAttachmentByResource(resourceId).state, 'attached');
+  assert.deepEqual(projectStream.readSnapshot(file, project), snapshot);
+
+  const mutationB = 'mut_code_project_cloud_b';
+  await call(shared.handleMutationIngest, {
+    version: 3,
+    committedAt: '2026-07-26T12:00:03.000Z',
+    envelope: {
+      resourceId,
+      authorityEpoch: 1,
+      mutationId: mutationB,
+      deviceId: 'machine-b',
+      baseVersion: 2,
+      contract: projectStream.STREAM_CONTRACT,
+      schemaVersion: 1,
+      operationKind: 'code.publish',
+      operation: {
+        kind: 'code.publish',
+        record: record(project, 'machine-b', mutationB, 'event-3'),
+      },
+    },
+  });
+  assert.deepEqual(
+    projectStream.readSnapshot(file, project).records.map((entry) => [
+      entry.machine,
+      entry.version,
+      entry.cards[0].marker,
+    ]),
+    [
+      ['machine-a', 2, 'snapshot'],
+      ['machine-b', 3, 'event-3'],
+    ],
+  );
+
+  const beforeGap = fs.readFileSync(file, 'utf8');
+  await assert.rejects(
+    call(shared.handleMutationIngest, {
+      version: 5,
+      committedAt: '2026-07-26T12:00:05.000Z',
+      envelope: {
+        resourceId,
+        authorityEpoch: 1,
+        mutationId: 'mut_code_project_gap_005',
+        deviceId: 'machine-c',
+        baseVersion: 4,
+        contract: projectStream.STREAM_CONTRACT,
+        schemaVersion: 1,
+        operationKind: 'code.publish',
+        operation: {
+          kind: 'code.publish',
+          record: record(project, 'machine-c', 'mut_code_project_gap_005', 'gap'),
+        },
+      },
+    }),
+    /expected 4, received 5/,
+  );
+  assert.equal(fs.readFileSync(file, 'utf8'), beforeGap);
+});

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

@@ -16,6 +16,7 @@ process.env.AMALGM_COMPUTER_ID = 'computer-test';
 
 const { closeLocalDb, openLocalDb } = require('../state/db');
 const {
+  _test: cardTest,
   buildRepoCard,
   cardFingerprint,
   discoverWorktrees,
@@ -399,3 +400,49 @@ test('the fingerprint holds across observations and moves on any real change', a
   const third = await buildRepoCard(dir);
   assert.notEqual(cardFingerprint(second), cardFingerprint(third));
 });
+
+test('unchanged commits reuse their card object source and one new oid is resolved once', async () => {
+  const dir = await makeRepo('object-source-cache');
+  await run(dir, 'branch', 'side');
+  const local = await buildRepoCard(dir);
+  await run(dir, 'remote', 'add', 'origin', 'https://github.com/amalgm/object-source-cache.git');
+  const previous = {
+    ...local,
+    repo: { ...local.repo, remote: 'https://github.com/amalgm/object-source-cache' },
+    objects: { kind: 'remote' },
+    refs: local.refs.map((ref) => ({ ...ref, objects: { kind: 'remote' } })),
+  };
+  const objects = require('../workspace/objects');
+  const original = objects.objectSourceFor;
+  let calls = 0;
+  objects.objectSourceFor = async () => {
+    calls += 1;
+    return { kind: 'pending' };
+  };
+  try {
+    const unchanged = await buildRepoCard(dir, previous);
+    assert.equal(calls, 0);
+    assert.equal(unchanged.objects.kind, 'remote');
+    assert.ok(unchanged.refs.every((ref) => ref.objects.kind === 'remote'));
+
+    write(dir, 'next.txt', 'next\n');
+    await run(dir, 'add', '.');
+    await run(dir, 'commit', '-m', 'next');
+    const changed = await buildRepoCard(dir, unchanged);
+    assert.equal(calls, 1, 'HEAD and its branch share one content-addressed lookup');
+    assert.equal(changed.objects.kind, 'pending');
+    assert.equal(changed.refs.find((ref) => ref.name === 'main').objects.kind, 'pending');
+    assert.equal(changed.refs.find((ref) => ref.name === 'side').objects.kind, 'remote');
+  } finally {
+    objects.objectSourceFor = original;
+  }
+});
+
+test('only complete object sources are reusable', () => {
+  assert.deepEqual(
+    cardTest.reusableObjectSource('a', 'a', { kind: 'bundle', checksum: 'ready' }),
+    { kind: 'bundle', checksum: 'ready' },
+  );
+  assert.equal(cardTest.reusableObjectSource('a', 'b', { kind: 'remote' }), null);
+  assert.equal(cardTest.reusableObjectSource('a', 'a', { kind: 'pending' }), null);
+});

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

@@ -57,51 +57,44 @@ test('rail-ordered checkpoint transitions combine and a later revert removes onl
   const treeA = await merge.treeOfPatch(repo, oid, patchA);
   const treeB = await merge.treeOfPatch(repo, oid, patchB);
 
-  const afterA = await merge.reduceTree(repo, clean, clean, treeA, { label: '1' });
-  const afterB = await merge.reduceTree(repo, afterA.tree, clean, treeB, { label: '2' });
+  const afterA = await merge.reduceTree(repo, clean, clean, treeA);
+  const afterB = await merge.reduceTree(repo, afterA.tree, clean, treeB);
   assert.equal(await treeText(repo, afterB.tree, 'a.txt'), 'a1\n');
   assert.equal(await treeText(repo, afterB.tree, 'b.txt'), 'b1\n');
-  assert.deepEqual(afterB.conflicts, []);
 
   // A's next operation says "from A+B to B": the reducer can remove A even
   // though B's latest checkpoint already incorporated A.
-  const reverted = await merge.reduceTree(repo, afterB.tree, afterB.tree, treeB, { label: '3' });
+  const reverted = await merge.reduceTree(repo, afterB.tree, afterB.tree, treeB);
   assert.equal(await treeText(repo, reverted.tree, 'a.txt'), 'a0\n');
   assert.equal(await treeText(repo, reverted.tree, 'b.txt'), 'b1\n');
 });
 
-test('an overlapping transition produces deterministic conflict bytes', async () => {
-  const { repo, oid, tree: clean } = await makeRepo('conflict');
+test('a later overlapping transition supplies the exact final bytes', async () => {
+  const { repo, oid, tree: clean } = await makeRepo('later-wins');
   const leftPatch = await patchFor(repo, { 'same.txt': 'left\nline 2\n' });
   const rightPatch = await patchFor(repo, { 'same.txt': 'right\nline 2\n' });
   const left = await merge.treeOfPatch(repo, oid, leftPatch);
   const right = await merge.treeOfPatch(repo, oid, rightPatch);
 
-  const current = await merge.reduceTree(repo, clean, clean, left, { label: '10' });
-  const first = await merge.reduceTree(repo, current.tree, clean, right, { label: '11' });
-  const second = await merge.reduceTree(repo, current.tree, clean, right, { label: '11' });
+  const current = await merge.reduceTree(repo, clean, clean, left);
+  const first = await merge.reduceTree(repo, current.tree, clean, right);
+  const second = await merge.reduceTree(repo, current.tree, clean, right);
 
   assert.equal(first.tree, second.tree);
-  assert.deepEqual(first.conflicts, second.conflicts);
-  assert.equal(first.conflicts[0].kind, 'content-overlap');
-  const content = await treeText(repo, first.tree, 'same.txt');
-  assert.match(content, /<<<<<<< current/);
-  assert.match(content, /left/);
-  assert.match(content, /right/);
+  assert.equal(await treeText(repo, first.tree, 'same.txt'), 'right\nline 2\n');
 });
 
 test('an echoed transition that is already present reduces to a no-op', async () => {
   const { repo, oid, tree: clean } = await makeRepo('echo');
   const patch = await patchFor(repo, { 'a.txt': 'shared\n' });
   const shared = await merge.treeOfPatch(repo, oid, patch);
-  const current = await merge.reduceTree(repo, clean, clean, shared, { label: '20' });
-  const echoed = await merge.reduceTree(repo, current.tree, clean, shared, { label: '21' });
+  const current = await merge.reduceTree(repo, clean, clean, shared);
+  const echoed = await merge.reduceTree(repo, current.tree, clean, shared);
   assert.equal(echoed.tree, current.tree);
-  assert.deepEqual(echoed.conflicts, []);
 });
 
-test('a deletion never removes a file another writer edited', async () => {
-  const { repo, oid, tree: clean } = await makeRepo('delete-vs-edit');
+test('a later deletion removes a file changed by an earlier writer', async () => {
+  const { repo, oid, tree: clean } = await makeRepo('later-delete');
   const localPatch = await patchFor(repo, { 'a.txt': 'precious local edit\n' });
   const localTree = await merge.treeOfPatch(repo, oid, localPatch);
   fs.rmSync(path.join(repo, 'a.txt'));
@@ -109,8 +102,19 @@ test('a deletion never removes a file another writer edited', async () => {
   await git(repo, 'reset', '--hard', 'HEAD');
   const deletedTree = await merge.treeOfPatch(repo, oid, deletePatch);
 
-  const current = await merge.reduceTree(repo, clean, clean, localTree, { label: '30' });
-  const outcome = await merge.reduceTree(repo, current.tree, clean, deletedTree, { label: '31' });
-  assert.equal(outcome.conflicts[0].kind, 'delete-vs-change');
-  assert.equal(await treeText(repo, outcome.tree, 'a.txt'), 'precious local edit\n');
+  const current = await merge.reduceTree(repo, clean, clean, localTree);
+  const outcome = await merge.reduceTree(repo, current.tree, clean, deletedTree);
+  await assert.rejects(treeText(repo, outcome.tree, 'a.txt'));
+});
+
+test('an earlier inbound event advances underneath a pending local write', async () => {
+  const { repo, oid, tree: clean } = await makeRepo('pending-local');
+  const inboundPatch = await patchFor(repo, { 'same.txt': 'inbound\n' });
+  const inbound = await merge.treeOfPatch(repo, oid, inboundPatch);
+
+  fs.writeFileSync(path.join(repo, 'same.txt'), 'pending local\n');
+  const outcome = await merge.advance(repo, clean, inbound);
+
+  assert.equal(fs.readFileSync(path.join(repo, 'same.txt'), 'utf8'), 'pending local\n');
+  assert.equal(await treeText(repo, outcome.heldTree, 'same.txt'), 'inbound\n');
 });

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

@@ -23,18 +23,27 @@ fs.writeFileSync(
 );
 
 const { closeLocalDb } = require('../state/db');
-const { captureCheckpoint, captureWorktreeDiff } = require('../workspace/git');
+const {
+  _test: gitTest,
+  captureCheckpoint,
+  captureWorktreeDiff,
+} = require('../workspace/git');
 const merge = require('../workspace/merge');
 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();
@@ -54,6 +63,23 @@ 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,
+  });
+});
+
 async function run(cwd, ...args) {
   await execFileAsync(
     'git',
@@ -145,6 +171,23 @@ 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('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');
@@ -180,7 +223,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-v8/);
+  assert.match(first, /repo-checkpoints-v9/);
 });
 
 test('a materialized peer card is immediately a valid checkpoint base', () => {
@@ -233,6 +276,60 @@ 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 repoKey = 'https://example.test/granular-checkpoint.git';
+  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');
+
+  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,
+    baseOid,
+    '',
+    `${largePatch}${smallPatch}`,
+  );
+  assert.equal(
+    checkpointValueReady(second),
+    true,
+    'the unchanged large file must not be uploaded again',
+  );
+  assert.equal(second.sections.worktree[0].payload.checksum, first.sections.worktree[0].payload.checksum);
+  assert.equal(claimUpload(), null);
+
+  const decoded = readCheckpointValue(baseOid, second);
+  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 = [{
@@ -241,15 +338,6 @@ test('a clean losing commit travels as parked metadata on a no-op checkpoint', (
     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',
@@ -267,6 +355,58 @@ test('a clean losing commit travels as parked metadata on a no-op checkpoint', (
   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);
@@ -288,7 +428,7 @@ test('only this machine keeps announcing its parked commits', () => {
 
   assert.deepEqual(
     _test.localParkedEntries(existing, reduced, card).map((entry) => entry.oid),
-    [localOid, pendingOid],
+    [pendingOid],
   );
   assert.deepEqual(
     _test.localParkedEntries(existing, reduced, {

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

@@ -129,4 +129,10 @@ test('a large checkpoint uses the same verified chunk lane', () => {
   const received = readPayload(locator);
   assert.equal(received.state, 'ready');
   assert.deepEqual(received.bytes, content);
+  assert.equal(
+    publishPayload('same-content-after-download', content, 'repo:test').kind,
+    'chunks',
+    'verified downloaded content is immediately reusable by a later checkpoint',
+  );
+  assert.equal(claimUpload(), null);
 });