amalgm 0.1.216 → 0.1.217

package/package.json

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

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

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');
 });

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

@@ -520,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;
@@ -587,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,
@@ -634,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) {
@@ -691,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, {
@@ -705,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;
@@ -762,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/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,