amalgm 0.1.215 → 0.1.217

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.215",
+  "version": "0.1.217",
   "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

@@ -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

@@ -0,0 +1,312 @@
+'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-publication-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 = 'machine-a';
+process.env.AMALGM_DEVICE_ID = 'device-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 {
+  _test: checkpointTest,
+  CHECKPOINT_CONTRACT,
+  checkpointFile,
+  sameTransition,
+} = require('../workspace/checkpoint');
+const { parkedForState } = require('../workspace/reducer');
+const {
+  compactWallText,
+  hasLocalContribution,
+  publicationStatus,
+  stampCards,
+} = require('../workspace/wall');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+const rules = {
+  card: {
+    identity: 'branch-and-commit-content',
+    ownership: 'originator-publishes',
+    liveness: 'shared-wall-outbox',
+    gating: 'defines-winning-card',
+  },
+  branch: {
+    identity: 'ref-name-and-commit-content',
+    ownership: 'originator-publishes',
+    liveness: 'shared-wall-outbox',
+    gating: 'per-ref-rail-order',
+  },
+  checkpoint: {
+    identity: 'from-and-to-content',
+    ownership: 'originator-publishes',
+    liveness: 'shared-wall-outbox',
+    gating: 'winning-card-only',
+  },
+  parked: {
+    identity: 'commit-and-object-content',
+    ownership: 'holder-publishes-until-acknowledged',
+    liveness: 'shared-wall-outbox',
+    gating: 'inside-winning-card-checkpoint',
+  },
+  compaction: {
+    identity: 'derived-deletion',
+    ownership: 'any-machine-may-compact',
+    liveness: 'not-semantic-state',
+    gating: 'commutative-with-writers',
+  },
+};
+
+test('the publication model has one explicit rule for every value and property', () => {
+  assert.deepEqual(Object.keys(rules), ['card', 'branch', 'checkpoint', 'parked', 'compaction']);
+  for (const rule of Object.values(rules)) {
+    assert.deepEqual(Object.keys(rule), ['identity', 'ownership', 'liveness', 'gating']);
+    assert.equal(Object.values(rule).every(Boolean), true);
+  }
+  assert.deepEqual(
+    new Set(['card', 'branch', 'checkpoint', 'parked'].map((name) => rules[name].liveness)),
+    new Set(['shared-wall-outbox']),
+  );
+});
+
+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 = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine: 'machine-a',
+    repoKey: 'root:test',
+    branch: 'main',
+    baseOid: oid,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'work-a', indexDiff: '', worktreeDiff: 'patch-a' },
+    parked: [{
+      oid: 'b'.repeat(40),
+      ref: `refs/amalgm/parked/${'b'.repeat(40)}`,
+      objects: { kind: 'bundle', checksum: 'c'.repeat(64) },
+    }],
+  };
+  assert.equal(sameTransition(transition, {
+    ...transition,
+    mutationId: 'mut_server_metadata',
+    version: 41,
+    parked: transition.parked.map((entry) => ({ ...entry, version: 41 })),
+  }), true);
+  assert.equal(sameTransition(transition, {
+    ...transition,
+    to: { ...transition.to, revision: 'different-work' },
+  }), false);
+  assert.equal(sameTransition(transition, {
+    ...transition,
+    parked: transition.parked.map((entry) => ({
+      ...entry,
+      objects: { ...entry.objects, checksum: 'd'.repeat(64) },
+    })),
+  }), false);
+});
+
+test('receivers stay silent and only unacknowledged local parked work republishes', () => {
+  const head = 'a'.repeat(40);
+  const local = {
+    head: { branch: 'main', oid: head, detached: false },
+    refs: [{ name: 'main', oid: head }],
+  };
+  const transition = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine: 'machine-a',
+    repoKey: 'root:test',
+    branch: 'main',
+    baseOid: head,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'shared-work', indexDiff: '', worktreeDiff: 'patch' },
+    parked: [],
+  };
+  const plan = {
+    card: { head: { branch: 'main', oid: head, detached: false } },
+    branches: [{ name: 'main', oid: head }],
+    transitions: [{ ...transition, version: 9 }],
+  };
+  const baseline = {
+    branch: 'main',
+    baseOid: head,
+    branches: [{ name: 'main', oid: head }],
+  };
+  assert.equal(hasLocalContribution(local, plan, baseline, transition), false);
+
+  const localParked = { oid: 'b'.repeat(40), objects: { kind: 'bundle', checksum: 'local' } };
+  const unsentParked = { oid: 'c'.repeat(40), objects: { kind: 'bundle', checksum: 'unsent' } };
+  const peerParked = {
+    oid: 'd'.repeat(40),
+    objects: { kind: 'bundle', checksum: 'peer' },
+    version: 9,
+  };
+  assert.deepEqual(
+    checkpointTest.localParkedEntries(
+      { ...transition, parked: [localParked] },
+      { parked: [peerParked, unsentParked] },
+      local,
+    ),
+    [localParked, unsentParked],
+  );
+  assert.deepEqual(parkedForState([localParked], [], []), [localParked]);
+  assert.deepEqual(
+    parkedForState([localParked], [{ ...localParked, version: 10 }], []),
+    [{ ...localParked, version: 10 }],
+  );
+  assert.deepEqual(parkedForState([{ ...localParked, version: 10 }], [], []), []);
+});
+
+test('card, branch, checkpoint, and parked work ride one wall mutation', () => {
+  const repoKey = 'https://github.com/amalgm-inc/publication-invariant-test';
+  const head = 'a'.repeat(40);
+  const parkedOid = 'b'.repeat(40);
+  const checkpoint = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine: 'machine-a',
+    repoKey,
+    branch: 'main',
+    baseOid: head,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'work-a', indexDiff: '', worktreeDiff: 'patch-a' },
+    parked: [{
+      oid: parkedOid,
+      ref: `refs/amalgm/parked/${parkedOid}`,
+      objects: { kind: 'bundle', checksum: 'c'.repeat(64) },
+    }],
+  };
+  const file = checkpointFile('machine-a', repoKey);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(checkpoint)}\n`);
+
+  const mutationId = 'mut_one_shared_wall_outbox';
+  const stamped = stampCards([{
+    card: 'repo-card@2',
+    machine: 'machine-a',
+    replica: 'rpl_publication_test',
+    kind: 'primary',
+    repo: { remote: repoKey },
+    head: { branch: 'main', oid: head, detached: false },
+    refs: [
+      { name: 'main', oid: head },
+      { name: 'feature', oid: head },
+    ],
+    health: 'healthy',
+  }], [], null, null, mutationId, {
+    repoKey,
+    resourceId: 'shr_publication_invariant_test',
+  })[0];
+
+  assert.equal(stamped.positionMutationId, mutationId);
+  assert.equal(stamped.branches.every((ref) => ref.mutationId === mutationId), true);
+  assert.equal(stamped.checkpoints[0].mutationId, mutationId);
+  assert.equal(stamped.checkpoints[0].parked[0].oid, parkedOid);
+});
+
+test('two concurrent compacting publishers converge without losing either latest value', () => {
+  const Y = require('yjs');
+  const repoKey = 'root:compaction-collision';
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@3',
+    project: repoKey,
+    machine,
+    mutationId: `mut_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  const baseText = [
+    line('machine-a', 'old-a'),
+    line('machine-b', 'old-b'),
+    line('machine-a', 'current-a'),
+    line('machine-b', 'current-b'),
+    '',
+  ].join('\n');
+  const compacted = compactWallText(baseText, repoKey);
+  const removedBytes = baseText.length - compacted.length;
+  assert.ok(removedBytes > 0);
+
+  const base = new Y.Doc();
+  base.getText('content').insert(0, baseText);
+  const baseUpdate = Y.encodeStateAsUpdate(base);
+  const baseVector = Y.encodeStateVector(base);
+  const publisherUpdate = (machine, value) => {
+    const writer = new Y.Doc();
+    Y.applyUpdate(writer, baseUpdate);
+    const text = writer.getText('content');
+    text.delete(0, removedBytes);
+    text.insert(text.length, `${line(machine, value)}\n`);
+    return Y.encodeStateAsUpdate(writer, baseVector);
+  };
+  const updateA = publisherUpdate('machine-a', 'latest-a');
+  const updateB = publisherUpdate('machine-b', 'latest-b');
+  const replicas = [
+    [updateA, updateB],
+    [updateB, updateA],
+  ].map((order) => {
+    const replica = new Y.Doc();
+    Y.applyUpdate(replica, baseUpdate);
+    for (const update of order) Y.applyUpdate(replica, update);
+    return replica.getText('content').toString();
+  });
+
+  assert.equal(replicas[0], replicas[1]);
+  const latest = new Map();
+  for (const raw of replicas[0].trim().split('\n')) {
+    const entry = JSON.parse(raw);
+    latest.set(entry.machine, entry.cards[0].value);
+  }
+  assert.deepEqual(Object.fromEntries(latest), {
+    'machine-a': 'latest-a',
+    'machine-b': 'latest-b',
+  });
+});

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,
@@ -360,8 +364,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 +379,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');
 });
@@ -544,7 +550,9 @@ test('a losing commit is parked, the winning card lands exactly, and losing work
 
   assert.equal(folded.state, 'in-sync');
   assert.deepEqual(readRepoState('root:test').parked, []);
-  assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingOid}`)).trim(), losingOid);
+  await assert.rejects(
+    git(repo, 'rev-parse', '--verify', `refs/amalgm/parked/${losingOid}`),
+  );
 });
 
 test('rail-parked peer commits become one staged checkpoint on every machine', async () => {

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,7 +25,10 @@ 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');
@@ -48,6 +52,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();
@@ -317,10 +344,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');
@@ -381,10 +405,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');
@@ -404,6 +425,7 @@ test('checkpoint transitions append until the next card and carry their official
   const history = readWall(repoKey)[0].cards[0].checkpoints;
   assert.equal(history.length, 2);
   assert.deepEqual(history.map((entry) => entry.mutationId), [first.mutationId, second.mutationId]);
+  assert.deepEqual(settleProject(), [3]);
 });
 
 test('side branches keep one rail operation while the checked-out card advances', async () => {
@@ -429,10 +451,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 +461,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,6 +469,7 @@ 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 () => {
@@ -466,6 +483,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 +498,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', () => {
@@ -637,12 +656,14 @@ test('a torn line is ignored by readers, never fatal', () => {
     project.file,
     `${getDocText(project.file)}{"wall":"code-project@3","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,6 +676,7 @@ 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', () => {

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

@@ -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

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

@@ -360,7 +360,8 @@ async function moveToWinningCard(localCard, targetCard) {
 
 async function materializeParked(localCard, entries) {
   const waiting = [];
-  for (const entry of uniqueParked(entries)) {
+  const active = uniqueParked(entries);
+  for (const entry of active) {
     if (!(await hasCommit(localCard.path, entry.oid))) {
       if (entry.objects?.kind === 'bundle') {
         const imported = await require('./objects').importFromLocator(localCard.path, entry.objects);
@@ -375,6 +376,10 @@ async function materializeParked(localCard, entries) {
     }
     await transition.parkCommit(localCard.path, entry.oid);
   }
+  await transition.pruneParkedCommits(
+    localCard.path,
+    new Set(active.map((entry) => entry.oid)),
+  );
   return waiting;
 }
 
@@ -515,7 +520,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;
@@ -582,6 +587,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,
@@ -629,7 +635,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) {
@@ -686,7 +694,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, {
@@ -700,7 +709,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;
@@ -757,11 +766,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/transition.js

@@ -236,6 +236,20 @@ function parkCommit(worktreeRoot, oid) {
   ]).then(() => ref);
 }
 
+/** Delete internal parked refs that are no longer part of shared checkpoint state. */
+async function pruneParkedCommits(worktreeRoot, keepOids) {
+  const output = await run('list-parked-commits', worktreeRoot, [
+    '-C', worktreeRoot, 'for-each-ref', '--format=%(refname)', 'refs/amalgm/parked',
+  ], { journalResult: false });
+  const prefix = 'refs/amalgm/parked/';
+  for (const ref of output.trim().split('\n').filter(Boolean)) {
+    if (!ref.startsWith(prefix) || keepOids.has(ref.slice(prefix.length))) continue;
+    await run('remove-parked-commit', worktreeRoot, [
+      '-C', worktreeRoot, 'update-ref', '-d', ref,
+    ]);
+  }
+}
+
 function setBranchRef(worktreeRoot, branch, oid) {
   return run('set-branch-ref', worktreeRoot, [
     '-C', worktreeRoot, 'update-ref', `refs/heads/${branch}`, oid,
@@ -380,6 +394,7 @@ module.exports = {
   initializeRepo,
   moveToCard,
   parkCommit,
+  pruneParkedCommits,
   restoreInitialFiles,
   setBranchRef,
   setIndexTree,

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

@@ -128,6 +128,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);
@@ -555,6 +578,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) {
@@ -763,6 +796,7 @@ module.exports = {
   projectFile,
   projectForRepo,
   projectResourceId,
+  publicationStatus,
   publishedCardFor,
   publishWall,
   readWall,