amalgm 0.1.216 → 0.1.218

package/package.json

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

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

@@ -180,7 +180,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-v7/);
+  assert.match(first, /repo-checkpoints-v8/);
 });
 
 test('a materialized peer card is immediately a valid checkpoint base', () => {
@@ -188,13 +188,37 @@ test('a materialized peer card is immediately a valid checkpoint base', () => {
   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', () => {
   const pending = {
     revision: 'a'.repeat(64),

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

@@ -28,7 +28,12 @@ const {
   sameTransition,
 } = require('../workspace/checkpoint');
 const { parkedForState } = require('../workspace/reducer');
-const { compactWallText, hasLocalContribution, stampCards } = require('../workspace/wall');
+const {
+  compactWallText,
+  hasLocalContribution,
+  publicationStatus,
+  stampCards,
+} = require('../workspace/wall');
 
 test.after(() => {
   closeLocalDb();
@@ -80,6 +85,43 @@ 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);
+  require('../state/replicas').registerReplica({
+    resourceId,
+    localResource: opened.resource,
+    localPath: file,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    authorityEpoch: 1,
+    appliedVersion: 12,
+  });
+
+  assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 11 }), {
+    receivedThrough: 12,
+    appliedThrough: 11,
+    pending: 0,
+    current: false,
+  });
+  assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 12 }), {
+    receivedThrough: 12,
+    appliedThrough: 12,
+    pending: 0,
+    current: true,
+  });
+  require('../state/docs').writeDocText(file, 'pending\n');
+  assert.deepEqual(publicationStatus(repoKey, { appliedThrough: 12 }), {
+    receivedThrough: 12,
+    appliedThrough: 12,
+    pending: 1,
+    current: false,
+  });
+});
+
 test('server rail numbers do not change checkpoint or parked identity', () => {
   const oid = 'a'.repeat(40);
   const transition = {
@@ -216,7 +258,7 @@ test('two concurrent compacting publishers converge without losing either latest
   const Y = require('yjs');
   const repoKey = 'root:compaction-collision';
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_${machine}_${value}`,

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

@@ -40,6 +40,10 @@ test('a materialized baseline can follow the rail without publishing an echo', (
     published: false,
     reason: 'shared-state-covered',
   }), true);
+  assert.equal(localCardMayMaterialize(null, {
+    published: false,
+    reason: 'project-not-current',
+  }), true);
   assert.equal(localCardMayMaterialize({ positionVersion: 7 }, null), true);
   assert.equal(localCardMayMaterialize(null, {
     published: true,
@@ -148,6 +152,56 @@ test('wall reduction chooses one rail winner and orders checkpoint transitions b
   ]);
 });
 
+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' });
+  const patchAB = await patchFor(repo, { 'a.txt': 'a1\n', 'b.txt': 'b1\n' });
+  const current = card(repo, oid, 1);
+  current.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, patchA),
+  };
+  current.checkpoints = [
+    transition('machine-a', 2, oid, '', patchA),
+    transition('machine-a', 5, oid, patchA, patchAB),
+  ];
+  const plan = reduceWall([{ machine: 'machine-a', cards: [current] }]).get('root:test');
+  assert.equal(plan.checkpointBase.through, 4);
+  assert.deepEqual(plan.transitions.map((entry) => entry.version), [5]);
+  const reduced = await reduceCheckpoint(current, plan);
+  assert.equal(reduced.state, 'ready');
+  assert.equal(reduced.checkpointRevision, revisionOf(oid, patchAB, ''));
+});
+
+test('different snapshots claiming the same rail position stop instead of choosing a winner', () => {
+  const oid = 'a'.repeat(40);
+  const first = card('/first', oid, 1);
+  first.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'patch-a'),
+  };
+  const second = card('/second', oid, 1);
+  second.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'patch-b'),
+  };
+  const plan = reduceWall([
+    { machine: 'machine-a', cards: [first] },
+    { machine: 'machine-b', cards: [second] },
+  ]).get('root:test');
+  assert.equal(plan.checkpointBase, null);
+  assert.equal(plan.checkpointBaseConflict, true);
+});
+
 test('a ready parked bundle never regresses to pending', () => {
   const oid = 'c'.repeat(40);
   const ready = card('/ready', 'a'.repeat(40), 1);
@@ -360,8 +414,9 @@ test('one materializer converges to the reduced checkpoint and later removes a r
       transition('machine-b', 3, oid, patchA, `${patchA}${patchB}`),
     ],
   };
-  const applied = await materializeRepo(localCard, first);
+  const applied = await materializeRepo(localCard, first, 3);
   assert.equal(applied.state, 'in-sync');
+  assert.equal(readRepoState('root:test').appliedThrough, 3);
   assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), 'a1\n');
   assert.equal(fs.readFileSync(path.join(repo, 'b.txt'), 'utf8'), 'b1\n');
 
@@ -374,8 +429,9 @@ test('one materializer converges to the reduced checkpoint and later removes a r
       transition('machine-a', 4, oid, combined, patchB),
     ],
   };
-  const reverted = await materializeRepo(localCard, second);
+  const reverted = await materializeRepo(localCard, second, 4);
   assert.equal(reverted.state, 'in-sync');
+  assert.equal(readRepoState('root:test').appliedThrough, 4);
   assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), 'a0\n');
   assert.equal(fs.readFileSync(path.join(repo, 'b.txt'), 'utf8'), 'b1\n');
 });

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

@@ -0,0 +1,128 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-rest-delete-test-'));
+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 = 'computer-test';
+
+const { closeLocalDb } = require('../state/db');
+const { listWorkspaces, upsertWorkspace } = require('../workspace/store');
+const { handleProjectDelete } = require('../workspace/rest');
+
+const WORKSPACES_ROOT = process.env.AMALGM_WORKSPACES_DIR;
+const TRASH_ROOT = path.join(process.env.AMALGM_DIR, 'trash', 'workspaces');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+function captureJson() {
+  const sent = {};
+  return {
+    sent,
+    sendJson: (status, body) => {
+      sent.status = status;
+      sent.body = body;
+    },
+  };
+}
+
+test('deleting a managed workspace trashes its folder instead of leaving a corpse', async () => {
+  const folder = path.join(WORKSPACES_ROOT, 'managed-project');
+  fs.mkdirSync(folder, { recursive: true });
+  fs.writeFileSync(path.join(folder, 'keep.md'), 'survives the trash move');
+
+  const workspace = upsertWorkspace({
+    path: folder,
+    name: 'managed-project',
+    source: 'managed',
+    managed: true,
+  }, { workspaceRoot: WORKSPACES_ROOT });
+
+  const { sent, sendJson } = captureJson();
+  await handleProjectDelete({ id: workspace.id }, sendJson);
+
+  assert.equal(sent.status, 200);
+  assert.equal(sent.body.success, true);
+  assert.ok(sent.body.trashedTo, 'delete reports where the folder went');
+  assert.ok(
+    sent.body.trashedTo.startsWith(TRASH_ROOT + path.sep),
+    `trashed into the trash root, got ${sent.body.trashedTo}`,
+  );
+  assert.equal(fs.existsSync(folder), false, 'the workspaces root is clean');
+  assert.equal(
+    fs.readFileSync(path.join(sent.body.trashedTo, 'keep.md'), 'utf8'),
+    'survives the trash move',
+    'contents survive the move',
+  );
+  assert.equal(
+    listWorkspaces().some((entry) => entry.id === workspace.id),
+    false,
+    'the registry row is gone',
+  );
+});
+
+test('deleting an unmanaged workspace never touches its folder', async () => {
+  const folder = path.join(tempRoot, 'my-own-checkout');
+  fs.mkdirSync(folder, { recursive: true });
+  fs.writeFileSync(path.join(folder, 'precious.md'), 'user data');
+
+  const workspace = upsertWorkspace({
+    path: folder,
+    name: 'my-own-checkout',
+    source: 'computer',
+  }, { workspaceRoot: WORKSPACES_ROOT });
+  assert.equal(workspace.managed, false);
+
+  const { sent, sendJson } = captureJson();
+  await handleProjectDelete({ id: workspace.id }, sendJson);
+
+  assert.equal(sent.status, 200);
+  assert.equal(sent.body.trashedTo, null);
+  assert.equal(fs.existsSync(path.join(folder, 'precious.md')), true, 'folder untouched');
+});
+
+test('a managed flag on a path outside the workspaces root still never moves it', async () => {
+  const folder = path.join(tempRoot, 'mislabeled-managed');
+  fs.mkdirSync(folder, { recursive: true });
+
+  const workspace = upsertWorkspace({
+    path: folder,
+    name: 'mislabeled-managed',
+    source: 'managed',
+    managed: true,
+  }, { workspaceRoot: WORKSPACES_ROOT });
+
+  const { sent, sendJson } = captureJson();
+  await handleProjectDelete({ id: workspace.id }, sendJson);
+
+  assert.equal(sent.status, 200);
+  assert.equal(sent.body.trashedTo, null, 'outside the root nothing moves');
+  assert.equal(fs.existsSync(folder), true);
+});
+
+test('deleting a managed workspace whose folder is already gone succeeds', async () => {
+  const folder = path.join(WORKSPACES_ROOT, 'already-gone');
+  fs.mkdirSync(folder, { recursive: true });
+  const workspace = upsertWorkspace({
+    path: folder,
+    name: 'already-gone',
+    source: 'managed',
+    managed: true,
+  }, { workspaceRoot: WORKSPACES_ROOT });
+  fs.rmSync(folder, { recursive: true, force: true });
+
+  const { sent, sendJson } = captureJson();
+  await handleProjectDelete({ id: workspace.id }, sendJson);
+
+  assert.equal(sent.status, 200);
+  assert.equal(sent.body.success, true);
+  assert.equal(sent.body.trashedTo, null);
+});

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

@@ -2,6 +2,7 @@
 
 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');
@@ -24,13 +25,17 @@ fs.writeFileSync(
 
 const { closeLocalDb } = require('../state/db');
 const { appendStateEvent } = require('../state/events');
-const { acknowledgeCloudMutation } = require('../state/mutations');
+const {
+  acknowledgeCloudMutation,
+  listPendingCloudMutations,
+} = require('../state/mutations');
 const { registerReplica } = require('../state/replicas');
 const { openDoc, getDocText, writeDocText } = require('../state/docs');
 const { upsertWorkspace } = require('../workspace/store');
 const { refreshRepoCards } = require('../workspace/cards');
 const { checkpointFile, repoKeyOfCard } = require('../workspace/checkpoint');
 const {
+  _test: wallTest,
   bindProject,
   compactWallText,
   hasLocalContribution,
@@ -48,6 +53,29 @@ const {
 
 let repoKey;
 let project;
+let nextCloudVersion = 1;
+
+function markReducerApplied(version) {
+  const digest = crypto.createHash('sha256').update(repoKey).digest('hex').slice(0, 24);
+  const file = path.join(process.env.AMALGM_DIR, 'state', 'repo-reducer', `${digest}.json`);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ repoKey, appliedThrough: version })}\n`);
+}
+
+function settleProject() {
+  const versions = [];
+  for (const mutation of listPendingCloudMutations(project.resourceId)) {
+    const version = nextCloudVersion;
+    nextCloudVersion += 1;
+    acknowledgeCloudMutation(project.resourceId, mutation.mutationId, {
+      version,
+      committedAt: `2026-07-23T00:00:${String(version).padStart(2, '0')}.000Z`,
+    });
+    versions.push(version);
+  }
+  if (versions.length > 0) markReducerApplied(versions.at(-1));
+  return versions;
+}
 
 test.after(() => {
   closeLocalDb();
@@ -121,7 +149,7 @@ test('only a value different from both the materialized baseline and the rail is
   };
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline), false);
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline, {
-    checkpoint: 'repo-checkpoint@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -191,7 +219,7 @@ test('only a value different from both the materialized baseline and the rail is
     },
   ), true);
   assert.equal(hasLocalContribution(local, plan, baseline, {
-    checkpoint: 'repo-checkpoint@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -301,7 +329,7 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(first.published, true);
   const entries = readWall(repoKey);
   assert.equal(entries.length, 1);
-  assert.equal(entries[0].wall, 'code-project@3');
+  assert.equal(entries[0].wall, 'code-project@4');
   assert.equal(entries[0].project, repoKey);
   assert.equal(entries[0].machine, 'machine-a');
   assert.equal(entries[0].cards.length, 1);
@@ -317,10 +345,7 @@ test('a repo project appends immutable machine records', async () => {
     false,
   );
 
-  acknowledgeCloudMutation(project.resourceId, first.mutationId, {
-    version: 1,
-    committedAt: '2026-07-23T00:00:00.000Z',
-  });
+  assert.deepEqual(settleProject(), [1]);
   const sealed = publishWall(repoKey);
   assert.equal(sealed.published, false);
   assert.equal(sealed.reason, 'shared-state-covered');
@@ -360,12 +385,12 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(getDocText(project.file).trim().split('\n').length, 1);
 });
 
-test('checkpoint transitions append until the next card and carry their official rail numbers', async () => {
+test('a checkpoint base replaces history already covered by the applied rail', async () => {
   const card = readWall(repoKey)[0].cards[0];
   const file = checkpointFile('machine-a', repoKey);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const firstCheckpoint = {
-    checkpoint: 'repo-checkpoint@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     repoKey,
     branch: card.head.branch,
@@ -381,10 +406,7 @@ test('checkpoint transitions append until the next card and carry their official
   assert.equal(readWall(repoKey)[0].cards[0].checkpoints.length, 1);
   assert.equal(readWall(repoKey)[0].cards[0].checkpoints[0].mutationId, first.mutationId);
 
-  acknowledgeCloudMutation(project.resourceId, first.mutationId, {
-    version: 2,
-    committedAt: '2026-07-23T00:00:02.000Z',
-  });
+  assert.deepEqual(settleProject(), [2]);
   assert.equal(readWall(repoKey)[0].cards[0].checkpoints[0].version, 2);
   assert.equal(publishWall(repoKey).published, false);
   const checkpointLines = getDocText(project.file).trim().split('\n');
@@ -392,6 +414,20 @@ test('checkpoint transitions append until the next card and carry their official
     JSON.parse(checkpointLines.at(-1)).cards[0].checkpoints[0].version ?? null,
     null,
   );
+  const reducerFile = path.join(
+    process.env.AMALGM_DIR,
+    'state',
+    'repo-reducer',
+    `${crypto.createHash('sha256').update(repoKey).digest('hex').slice(0, 24)}.json`,
+  );
+  fs.writeFileSync(reducerFile, `${JSON.stringify({
+    repoKey,
+    baseOid: card.head.oid,
+    branch: card.head.branch,
+    appliedThrough: 2,
+    indexDiff: '',
+    worktreeDiff: 'patch-a',
+  })}\n`);
 
   fs.writeFileSync(file, `${JSON.stringify({
     ...firstCheckpoint,
@@ -401,9 +437,24 @@ test('checkpoint transitions append until the next card and carry their official
   })}\n`);
   const second = publishWall(repoKey);
   assert.equal(second.published, true);
-  const history = readWall(repoKey)[0].cards[0].checkpoints;
-  assert.equal(history.length, 2);
-  assert.deepEqual(history.map((entry) => entry.mutationId), [first.mutationId, second.mutationId]);
+  const latestCard = readWall(repoKey)[0].cards[0];
+  assert.equal(latestCard.checkpointBase.through, 2);
+  assert.equal(latestCard.checkpoints.length, 1);
+  assert.deepEqual(latestCard.checkpoints.map((entry) => entry.mutationId), [second.mutationId]);
+  assert.deepEqual(settleProject(), [3]);
+});
+
+test('one failed project publisher cannot block the next repo', () => {
+  const selected = [{ repoKey: 'root:first' }, { repoKey: 'root:second' }];
+  const calls = [];
+  const results = wallTest.publishSelected(selected, [], (selectedProject) => {
+    calls.push(selectedProject.repoKey);
+    if (selectedProject.repoKey === 'root:first') throw new Error('too large');
+    return { published: true, repoKey: selectedProject.repoKey };
+  });
+  assert.deepEqual(calls, ['root:first', 'root:second']);
+  assert.equal(results[0].reason, 'publish-failed');
+  assert.equal(results[1].published, true);
 });
 
 test('side branches keep one rail operation while the checked-out card advances', async () => {
@@ -429,10 +480,7 @@ test('side branches keep one rail operation while the checked-out card advances'
   assert.equal(card.positionMutationId, before.positionMutationId);
   assert.equal(ref.mutationId, created.mutationId);
 
-  acknowledgeCloudMutation(project.resourceId, created.mutationId, {
-    version: 3,
-    committedAt: '2026-07-23T00:00:04.000Z',
-  });
+  assert.deepEqual(settleProject(), [4]);
   await run(repo, 'add', 'new.txt');
   await run(repo, 'commit', '-m', 'advance without moving side branch');
   await refreshRepoCards();
@@ -442,10 +490,7 @@ test('side branches keep one rail operation while the checked-out card advances'
   assert.equal(card.positionMutationId, advanced.mutationId);
   assert.equal(card.branches.find((entry) => entry.name === branch).mutationId, created.mutationId);
 
-  acknowledgeCloudMutation(project.resourceId, advanced.mutationId, {
-    version: 4,
-    committedAt: '2026-07-23T00:00:05.000Z',
-  });
+  assert.deepEqual(settleProject(), [5]);
   await run(repo, 'branch', '-D', branch);
   await refreshRepoCards();
   const deleted = publishWall(repoKey);
@@ -453,12 +498,13 @@ test('side branches keep one rail operation while the checked-out card advances'
   card = readWall(repoKey)[0].cards[0];
   assert.equal(card.branches.find((entry) => entry.name === branch).oid, null);
   assert.equal(card.branches.find((entry) => entry.name === branch).mutationId, deleted.mutationId);
+  assert.deepEqual(settleProject(), [6]);
 });
 
 test('peer records and earlier local history survive later publishes', async () => {
   const beforeLines = getDocText(project.file).trim().split('\n');
   const peerLine = JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine: 'machine-b',
     mutationId: 'mut_project_peer',
@@ -466,6 +512,7 @@ test('peer records and earlier local history survive later publishes', async ()
     cards: [{ card: 'repo-card@2', machine: 'machine-b', replica: 'rpl_peer', path: '/work/app', head: { branch: 'preview' } }],
   });
   writeDocText(project.file, `${getDocText(project.file)}${peerLine}\n`);
+  assert.deepEqual(settleProject(), [7]);
 
   const repo = path.join(tempRoot, 'projects/app');
   fs.writeFileSync(path.join(repo, 'another.txt'), 'y\n');
@@ -480,6 +527,7 @@ test('peer records and earlier local history survive later publishes', async ()
   for (const line of beforeLines) assert.ok(lines.includes(line));
   assert.ok(lines.includes(peerLine));
   assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
+  assert.deepEqual(settleProject(), [8]);
 });
 
 test('three concurrent append records stay whole under Yjs ordering', () => {
@@ -513,7 +561,7 @@ test('three concurrent append records stay whole under Yjs ordering', () => {
 
 test('wall compaction deletes only records superseded for every machine', () => {
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -522,7 +570,7 @@ test('wall compaction deletes only records superseded for every machine', () =>
   const oldA = line('machine-a', 'old-a');
   const oldB = line('machine-b', 'old-b');
   const latestA = line('machine-a', 'latest-a');
-  const torn = '{"wall":"code-project@3","machine":"torn"';
+  const torn = '{"wall":"code-project@4","machine":"torn"';
   const latestB = line('machine-b', 'latest-b');
   const current = `${oldA}\n${oldB}\n${latestA}\n${torn}\n${latestB}\n`;
   const compacted = compactWallText(current, repoKey);
@@ -534,13 +582,13 @@ test('wall compaction deletes only records superseded for every machine', () =>
 
 test('an unordered legacy record cannot pin wall compaction', () => {
   const unordered = JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine: '16.612Z',
     cards: [{ value: 'corrupted-legacy-record' }],
   });
   const ordered = (machine) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}`,
@@ -557,7 +605,7 @@ test('an unordered legacy record cannot pin wall compaction', () => {
 
 test('retired machine values stay represented without pinning obsolete active history', () => {
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -582,7 +630,7 @@ test('retired machine values stay represented without pinning obsolete active hi
 test('a concurrent deletion-only compaction and append commute in Yjs', () => {
   const Y = require('yjs');
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -635,14 +683,16 @@ test('a concurrent deletion-only compaction and append commute in Yjs', () => {
 test('a torn line is ignored by readers, never fatal', () => {
   writeDocText(
     project.file,
-    `${getDocText(project.file)}{"wall":"code-project@3","project":"${repoKey}","machine":"machine-c","car\n`,
+    `${getDocText(project.file)}{"wall":"code-project@4","project":"${repoKey}","machine":"machine-c","car\n`,
   );
+  settleProject();
   assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
 });
 
 test('publishing compacts an oversized history before appending the new record', async () => {
   const before = getDocText(project.file);
   writeDocText(project.file, `${'obsolete\n'.repeat(132_000)}${before}`);
+  settleProject();
   assert.ok(Buffer.byteLength(getDocText(project.file), 'utf8') > 1024 * 1024);
 
   const repo = path.join(tempRoot, 'projects/app');
@@ -655,12 +705,13 @@ test('publishing compacts an oversized history before appending the new record',
   assert.equal(result.published, true);
   assert.ok(Buffer.byteLength(getDocText(project.file), 'utf8') < 1024 * 1024);
   assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
+  settleProject();
 });
 
 test('project stats name every project resource, binding, and publish counter', () => {
   const stats = wallStats();
   const row = stats.projects.find((entry) => entry.repoKey === repoKey);
-  assert.equal(stats.contract, 'code-project@3');
+  assert.equal(stats.contract, 'code-project@4');
   assert.equal(row.resourceId, project.resourceId);
   assert.equal(row.replica.appliedVersion >= 0, true);
   assert.equal(row.machines, 2);

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

@@ -25,7 +25,7 @@ const { machineId } = require('./identity');
 const { listRepoCards } = require('./cards');
 const { captureCheckpoint } = require('./git');
 
-const CHECKPOINT_CONTRACT = 'repo-checkpoint@7';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@8';
 const MAX_INLINE_DIFF_BYTES = 512 * 1024;
 const PUBLISH_QUIET_MS = 25;
 const RECONCILE_INTERVAL_MS = 30_000;
@@ -54,7 +54,7 @@ function checkpointFile(machine, repoKey) {
     .update(`${CHECKPOINT_CONTRACT}|${machine}|${repoKey}`)
     .digest('hex')
     .slice(0, 24);
-  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v7', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v8', `${digest}.json`);
 }
 
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {
@@ -197,9 +197,10 @@ function readCheckpointValue(baseOid, value) {
   return { state: 'ready', indexDiff, worktreeDiff };
 }
 
-function checkpointBaseReady(card, reduced) {
+function checkpointBaseReady(card, reduced, publication) {
   return Boolean(
     reduced
+    && publication?.current
     && reduced.baseOid === card.head?.oid
     && reduced.branch === card.head?.branch
     && typeof reduced.indexDiff === 'string'
@@ -225,7 +226,8 @@ async function publishPass(replicaId = null) {
     }
     try {
       const reduced = require('./reducer').readRepoState(repoKey);
-      if (!checkpointBaseReady(card, reduced)) {
+      const wall = require('./wall');
+      if (!checkpointBaseReady(card, reduced, wall.publicationStatus(repoKey, reduced))) {
         run.waiting += 1;
         continue;
       }
@@ -243,6 +245,10 @@ async function publishPass(replicaId = null) {
         ...entry,
         objects: await require('./objects').bundleSourceFor(card.path, repoKey, entry.oid),
       })));
+      if (!wall.publicationStatus(repoKey, reduced).current) {
+        run.waiting += 1;
+        continue;
+      }
 
       // Exact equality means the working tree merely materialized the shared
       // checkpoint. Keep the writer's last transition because it remains part
@@ -410,6 +416,7 @@ module.exports = {
   MAX_INLINE_DIFF_BYTES,
   checkpointFile,
   checkpointStats,
+  checkpointValue,
   checkpointValueReady,
   parseCheckpoint,
   publishCheckpoints,

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

@@ -29,6 +29,7 @@ const {
 } = require('./git');
 const {
   CHECKPOINT_CONTRACT,
+  checkpointValueReady,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
@@ -108,7 +109,14 @@ function reduceWall(entries) {
       ) continue;
       let repo = repos.get(repoKey);
       if (!repo) {
-        repo = { repoKey, card: null, transitions: [], parked: [], branchMap: new Map() };
+        repo = {
+          repoKey,
+          card: null,
+          checkpointBases: [],
+          transitions: [],
+          parked: [],
+          branchMap: new Map(),
+        };
         repos.set(repoKey, repo);
       }
       if (!repo.card || card.positionVersion > repo.card.positionVersion) {
@@ -128,13 +136,39 @@ function reduceWall(entries) {
           repo.transitions.push(checkpoint);
         }
       }
+      const checkpointBase = card.checkpointBase;
+      if (
+        checkpointBase?.checkpoint === CHECKPOINT_CONTRACT
+        && Number.isInteger(checkpointBase.through)
+        && checkpointBase.through >= 0
+        && checkpointBase.baseOid === card.head?.oid
+        && checkpointBase.branch === card.head?.branch
+      ) {
+        repo.checkpointBases.push(checkpointBase);
+      }
     }
   }
   for (const repo of repos.values()) {
+    const matchingBases = repo.checkpointBases
+      .filter((entry) => (
+        entry.baseOid === repo.card.head?.oid
+        && entry.branch === repo.card.head?.branch
+      ))
+      .sort((left, right) => right.through - left.through);
+    const newestThrough = matchingBases[0]?.through ?? null;
+    const newestBases = matchingBases
+      .filter((entry) => entry.through === newestThrough)
+      .sort((left, right) => (
+        Number(checkpointValueReady(right.value)) - Number(checkpointValueReady(left.value))
+      ));
+    const baseRevisions = new Set(newestBases.map((entry) => entry.value?.revision ?? null));
+    repo.checkpointBaseConflict = baseRevisions.size > 1;
+    repo.checkpointBase = repo.checkpointBaseConflict ? null : newestBases[0] || null;
     repo.transitions = repo.transitions
       .filter((entry) => (
         entry.baseOid === repo.card.head?.oid
         && entry.branch === repo.card.head?.branch
+        && (!repo.checkpointBase || entry.version > repo.checkpointBase.through)
       ))
       .sort((left, right) => left.version - right.version);
     repo.parked = uniqueParked(repo.transitions.flatMap((checkpoint) => (
@@ -157,6 +191,7 @@ function reduceWall(entries) {
     }
     repo.branches = [...repo.branchMap.values()].sort((left, right) => left.name.localeCompare(right.name));
     delete repo.branchMap;
+    delete repo.checkpointBases;
   }
   return repos;
 }
@@ -433,6 +468,21 @@ async function reduceCheckpoint(localCard, plan) {
   let indexTree = baseTree;
   let worktreeTree = baseTree;
   const conflicts = [];
+  if (plan.checkpointBaseConflict) {
+    return { state: 'waiting', reason: 'checkpoint-base-disagrees' };
+  }
+  if (plan.checkpointBase) {
+    const snapshot = readCheckpointValue(baseOid, plan.checkpointBase.value);
+    if (snapshot.state !== 'ready') {
+      return { state: 'waiting', reason: `checkpoint-base-${snapshot.state}` };
+    }
+    indexTree = await merge.treeOfPatch(localCard.path, baseOid, snapshot.indexDiff);
+    worktreeTree = await merge.treeOfPatch(
+      localCard.path,
+      indexTree,
+      snapshot.worktreeDiff,
+    );
+  }
 
   for (const entry of plan.parked || []) {
     const commonOid = await mergeBase(localCard.path, baseOid, entry.oid);
@@ -520,7 +570,7 @@ function captureIsOnRail(plan, captured, localMachine = machineId()) {
   );
 }
 
-async function materializeRepo(localCardInput, plan) {
+async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   const refreshed = localCardInput;
   const cardResult = await moveToWinningCard(refreshed, plan.card);
   if (cardResult.state !== 'ready') return cardResult;
@@ -587,6 +637,7 @@ async function materializeRepo(localCardInput, plan) {
     baseOid: plan.card.head.oid,
     cardVersion: plan.card.positionVersion,
     cardMutationId: plan.card.positionMutationId,
+    appliedThrough,
     checkpointRevision: reduced.checkpointRevision,
     indexDiff: reduced.indexDiff,
     worktreeDiff: reduced.worktreeDiff,
@@ -634,7 +685,9 @@ async function advanceIndex(worktreeRoot, observedTree, targetTree) {
 }
 
 function localCardMayMaterialize(publishedCard, publication) {
-  return Boolean(publishedCard) || publication?.reason === 'shared-state-covered';
+  return Boolean(publishedCard)
+    || publication?.reason === 'shared-state-covered'
+    || publication?.reason === 'project-not-current';
 }
 
 function pathForRepo(localCard, project) {
@@ -691,7 +744,8 @@ async function runReducer() {
         service.counters.waiting += 1;
         continue;
       }
-      const currentPlan = reduceWall(wall.readWall()).get(repoKey);
+      const receivedThrough = wall.publicationStatus(repoKey).receivedThrough;
+      const currentPlan = reduceWall(wall.readWall(repoKey)).get(repoKey);
       if (!currentPlan?.card) {
         const outcome = { state: 'waiting', reason: 'official-card-settling', moved: false };
         service.repos.set(repoKey, {
@@ -705,7 +759,7 @@ async function runReducer() {
       }
       const outcome = await withMaterialization(
         repoKey,
-        () => materializeRepo(refreshed, currentPlan),
+        () => materializeRepo(refreshed, currentPlan, receivedThrough),
       );
       service.repos.set(repoKey, { repoKey, path: local.path, ...outcome, at: new Date().toISOString() });
       if (outcome.state === 'waiting') service.counters.waiting += 1;
@@ -762,11 +816,15 @@ function startWorkspaceReducer() {
   if (service.started) return;
   service.started = true;
   service.unsubscribe = subscribeStateEvents((event) => {
-    const wallPaths = require('./wall').wallStats().paths;
+    const wallState = require('./wall').wallStats();
+    const wallPaths = wallState.paths;
+    const acknowledged = event.resource === 'shared-mutations'
+      && wallState.projects.some((project) => project.resourceId === event.sharedResourceId);
     if (
       event.resource === 'repo-cards'
       || event.resource === 'repo-checkpoints'
       || wallPaths.includes(event.id)
+      || acknowledged
     ) scheduleReduce();
   });
   service.interval = setInterval(scheduleReduce, REDUCE_INTERVAL_MS);

package/runtime/scripts/amalgm-mcp/workspace/rest.js

@@ -250,6 +250,40 @@ async function handleProjectUpdate(body, sendJson) {
   }
 }
 
+// A removed managed workspace's folder moves here (same volume, instant
+// rename) — leaving it in the workspaces root grows a graveyard of corpses
+// that later same-name creates dodge with `-2`, `-3`… suffixes. Never a
+// hard delete: the user empties the trash, not the runtime.
+function workspaceTrashDir() {
+  return path.join(AMALGM_DIR, 'trash', 'workspaces');
+}
+
+async function trashManagedWorkspaceFolder(workspace) {
+  if (!workspace?.managed || !workspace.path) return null;
+
+  const workspaceRoot = getWorkspaceRoot();
+  let realTarget;
+  let realRoot;
+  try {
+    [realTarget, realRoot] = await Promise.all([
+      fs.promises.realpath(workspace.path),
+      fs.promises.realpath(workspaceRoot),
+    ]);
+  } catch {
+    return null; // Folder already gone — nothing to trash.
+  }
+  // Only folders strictly inside the workspaces root move; a registered
+  // path anywhere else is the user's own directory and is never touched.
+  if (realTarget === realRoot || !isWithin(realRoot, realTarget)) return null;
+
+  const trashRoot = workspaceTrashDir();
+  await fs.promises.mkdir(trashRoot, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const destination = path.join(trashRoot, `${path.basename(realTarget)}-${stamp}`);
+  await fs.promises.rename(realTarget, destination);
+  return destination;
+}
+
 async function handleProjectDelete(body, sendJson) {
   const identifier = body?.id || body?.path;
   if (!identifier || typeof identifier !== 'string') {
@@ -262,7 +296,15 @@ async function handleProjectDelete(body, sendJson) {
     if (workspace?.id) {
       require('../project-context/store').removeProjectContext(workspace.id, { source: 'workspace:delete' });
     }
-    sendJson(200, { success: true, workspace });
+    let trashedTo = null;
+    try {
+      trashedTo = await trashManagedWorkspaceFolder(workspace);
+    } catch (error) {
+      // The registry row is gone either way; a stuck folder is reported,
+      // not fatal.
+      console.warn('[workspace] failed to trash managed folder:', error?.message || error);
+    }
+    sendJson(200, { success: true, workspace, trashedTo });
   } catch (error) {
     sendJson(500, {
       error: error instanceof Error ? error.message : 'Failed to remove workspace',

package/runtime/scripts/amalgm-mcp/workspace/wall.js

@@ -17,9 +17,15 @@ const { AMALGM_DIR } = require('../config');
 const { subscribeStateEvents } = require('../state/events');
 const { machineId, userId } = require('./identity');
 const { listRepoCards } = require('./cards');
-const { readCheckpoint, repoKeyOfCard, sameTransition } = require('./checkpoint');
-
-const WALL_CONTRACT = 'code-project@3';
+const {
+  CHECKPOINT_CONTRACT,
+  checkpointValue,
+  readCheckpoint,
+  repoKeyOfCard,
+  sameTransition,
+} = require('./checkpoint');
+
+const WALL_CONTRACT = 'code-project@4';
 const PROJECT_DIR = path.join(AMALGM_DIR, 'state', 'code-projects');
 const REGISTRY_FILE = path.join(PROJECT_DIR, 'projects.json');
 const PUBLISH_QUIET_MS = 25;
@@ -128,6 +134,29 @@ function wallReplica(project) {
   return require('../state/replicas').getReplicaByResourceId(project.resourceId);
 }
 
+function publicationStatus(repoKey, reduced = undefined) {
+  const project = projectForRepo(repoKey);
+  const replica = project ? wallReplica(project) : null;
+  const receivedThrough = replica?.appliedVersion ?? null;
+  const baseline = reduced === undefined
+    ? require('./reducer').readRepoState(repoKey)
+    : reduced;
+  const appliedThrough = Number.isInteger(baseline?.appliedThrough)
+    ? baseline.appliedThrough
+    : receivedThrough === 0 && !baseline ? 0 : null;
+  const pending = project
+    ? require('../state/mutations').listPendingCloudMutations(project.resourceId).length
+    : 0;
+  return {
+    receivedThrough,
+    appliedThrough,
+    pending,
+    current: receivedThrough !== null
+      && appliedThrough === receivedThrough
+      && pending === 0,
+  };
+}
+
 function parseWallLine(line) {
   try {
     const entry = JSON.parse(line);
@@ -286,6 +315,46 @@ function hasObjectUpgrade(card, plan) {
   });
 }
 
+function checkpointBaseFor(card, baseline, project, shared = null) {
+  if (
+    !baseline
+    || baseline.baseOid !== card.head?.oid
+    || baseline.branch !== card.head?.branch
+    || !Number.isInteger(baseline.appliedThrough)
+    || baseline.appliedThrough < 0
+  ) return null;
+  const value = checkpointValue(
+    machineId(),
+    project.repoKey,
+    card.head.oid,
+    baseline.indexDiff || '',
+    baseline.worktreeDiff || '',
+  );
+  const reusableThrough = shared
+    && shared.baseOid === card.head.oid
+    && shared.branch === card.head.branch
+    && shared.value?.revision === value.revision
+    && Number.isInteger(shared.through)
+    && shared.through >= 0;
+  return {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: card.head.oid,
+    branch: card.head.branch,
+    through: reusableThrough ? shared.through : baseline.appliedThrough,
+    value,
+  };
+}
+
+function hasCheckpointBaseUpgrade(card, plan, baseline, project) {
+  const shared = plan?.card?.checkpointBase;
+  const candidate = checkpointBaseFor(card, baseline, project, shared);
+  return Boolean(shared && candidate) && (
+    candidate.through === shared.through
+    && candidate.value?.revision === shared.value?.revision
+    && JSON.stringify(candidate.value) !== JSON.stringify(shared.value)
+  );
+}
+
 function validVersion(value) {
   return Number.isInteger(value) && value > 0;
 }
@@ -420,6 +489,12 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
       && checkpoint.branch === card.head?.branch
       ? checkpoint
       : null;
+    const checkpointBase = checkpointBaseFor(
+      card,
+      baseline,
+      project,
+      sharedPlan?.card?.checkpointBase,
+    );
     const sameBase = previous?.head?.oid === card.head?.oid
       && previous?.head?.branch === card.head?.branch;
     const history = sameBase && Array.isArray(previous?.checkpoints)
@@ -430,7 +505,10 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
           entry.mutationId,
           entry.version,
         ),
-      }))
+      })).filter((entry) => (
+        validVersion(entry.version)
+        && (!checkpointBase || entry.version > checkpointBase.through)
+      ))
       : [];
     const last = history.at(-1);
     const checkpoints = currentCheckpoint
@@ -450,6 +528,7 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
         mutationId,
         project.resourceId,
       ),
+      ...(checkpointBase ? { checkpointBase } : {}),
       ...(checkpoints.length ? { checkpoints } : {}),
     };
   });
@@ -526,7 +605,8 @@ function publishProject(project, rawCards) {
     const checkpoint = readCheckpoint(machineId(), project.repoKey);
     const previousCard = previousCards.find((entry) => entry.replica === card.replica);
     return hasLocalContribution(card, sharedPlan, baseline, checkpoint, previousCard)
-      || hasObjectUpgrade(card, sharedPlan);
+      || hasObjectUpgrade(card, sharedPlan)
+      || hasCheckpointBaseUpgrade(card, sharedPlan, baseline, project);
   });
   if (!removed && !contributes) {
     service.counters.publishSkips += 1;
@@ -555,6 +635,16 @@ function publishProject(project, rawCards) {
     service.counters.publishSkips += 1;
     return { published: false, reason: 'unchanged', repoKey: project.repoKey };
   }
+  const status = publicationStatus(project.repoKey, baseline);
+  if (!status.current) {
+    service.counters.publishSkips += 1;
+    return {
+      published: false,
+      reason: 'project-not-current',
+      repoKey: project.repoKey,
+      ...status,
+    };
+  }
 
   const separator = current && !current.endsWith('\n') ? '\n' : '';
   if (Buffer.byteLength(`${current}${separator}${mine}\n`, 'utf8') > COMPACT_AT_BYTES) {
@@ -585,16 +675,33 @@ function publishProject(project, rawCards) {
   };
 }
 
+function publishSelected(selected, allCards, publisher = publishProject) {
+  return selected.map((project) => {
+    try {
+      return publisher(
+        project,
+        allCards.filter((card) => (
+          repoKeyOfCard(card) === project.repoKey
+          && isCommittedCard(card)
+        )),
+      );
+    } catch (error) {
+      service.counters.publishFailures += 1;
+      console.warn(`[CodeProject] ${project.repoKey} publish failed:`, error.message);
+      return {
+        published: false,
+        reason: 'publish-failed',
+        repoKey: project.repoKey,
+        error: error.message,
+      };
+    }
+  });
+}
+
 function publishWall(repoKey = null) {
   const allCards = listRepoCards();
   const selected = repoKey ? [projectForRepo(repoKey)].filter(Boolean) : projects();
-  const results = selected.map((project) => publishProject(
-    project,
-    allCards.filter((card) => (
-      repoKeyOfCard(card) === project.repoKey
-      && isCommittedCard(card)
-    )),
-  ));
+  const results = publishSelected(selected, allCards);
   if (repoKey) return results[0] || { published: false, reason: 'project-missing', repoKey };
   return {
     published: results.some((result) => result.published),
@@ -755,6 +862,7 @@ function wallStats() {
 }
 
 module.exports = {
+  _test: { publishSelected },
   WALL_CONTRACT,
   bindProject,
   compactWallText,
@@ -763,6 +871,7 @@ module.exports = {
   projectFile,
   projectForRepo,
   projectResourceId,
+  publicationStatus,
   publishedCardFor,
   publishWall,
   readWall,