amalgm 0.1.175 → 0.1.176

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

@@ -13,6 +13,14 @@ const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-repo-objects-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-objects-test';
+fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
+fs.writeFileSync(
+  path.join(process.env.AMALGM_DIR, 'computer.json'),
+  JSON.stringify({
+    computer_id: 'machine-objects-test',
+    user_id: '11111111-1111-4111-8111-111111111111',
+  }),
+);
 
 const { closeLocalDb } = require('../state/db');
 const { hasCommit, headOid } = require('../workspace/git');
@@ -69,7 +77,7 @@ test('an unpushed commit travels as card-owned chunks and imports without moving
       continue;
     }
     uploaded.set(upload.sha256, upload.dataBase64);
-    acknowledgeUpload(upload.sha256);
+    acknowledgeUpload(upload.resourceId, upload.sha256);
     const sourceState = await objectSourceFor(source, 'repo:test', unpushedOid);
     if (sourceState.kind === 'bundle') break;
   }
@@ -86,7 +94,7 @@ test('an unpushed commit travels as card-owned chunks and imports without moving
   while (true) {
     const download = claimDownload();
     if (!download) break;
-    receiveDownload(download.sha256, uploaded.get(download.sha256));
+    receiveDownload(download.resourceId, download.sha256, uploaded.get(download.sha256));
   }
   assert.equal((await importFromLocator(destination, locator)).state, 'imported');
   assert.equal(await hasCommit(destination, unpushedOid), true);
@@ -95,16 +103,16 @@ test('an unpushed commit travels as card-owned chunks and imports without moving
 
 test('a large checkpoint uses the same verified chunk lane', () => {
   const content = Buffer.alloc(1_300_000, 0x61);
-  assert.equal(publishPayload('large-checkpoint', content).kind, 'pending');
+  assert.equal(publishPayload('large-checkpoint', content, 'repo:test').kind, 'pending');
 
   const uploaded = new Map();
   while (true) {
     const upload = claimUpload();
     if (!upload) break;
     uploaded.set(upload.sha256, upload.dataBase64);
-    acknowledgeUpload(upload.sha256);
+    acknowledgeUpload(upload.resourceId, upload.sha256);
   }
-  const locator = publishPayload('large-checkpoint', content);
+  const locator = publishPayload('large-checkpoint', content, 'repo:test');
   assert.equal(locator.kind, 'chunks');
   assert.ok(locator.chunks.length >= 3);
 
@@ -116,7 +124,7 @@ test('a large checkpoint uses the same verified chunk lane', () => {
   while (true) {
     const download = claimDownload();
     if (!download) break;
-    receiveDownload(download.sha256, uploaded.get(download.sha256));
+    receiveDownload(download.resourceId, download.sha256, uploaded.get(download.sha256));
   }
   const received = readPayload(locator);
   assert.equal(received.state, 'ready');

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

@@ -0,0 +1,324 @@
+'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 { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-reducer-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-local';
+process.env.AMALGM_DEVICE_ID = 'device-local';
+fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
+fs.writeFileSync(
+  path.join(process.env.AMALGM_DIR, 'computer.json'),
+  JSON.stringify({ computer_id: 'machine-local', user_id: '11111111-1111-4111-8111-111111111111' }),
+);
+
+const { closeLocalDb } = require('../state/db');
+const { revisionOf } = require('../workspace/checkpoint');
+const { materializeRepo, readRepoState, reduceWall } = require('../workspace/reducer');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+async function git(cwd, ...args) {
+  const { stdout } = await execFileAsync(
+    'git',
+    ['-c', 'user.email=test@amalgm.test', '-c', 'user.name=Amalgm Test', '-c', 'commit.gpgsign=false', ...args],
+    { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' } },
+  );
+  return stdout;
+}
+
+async function makeRepo(name) {
+  const repo = path.join(tempRoot, name);
+  fs.mkdirSync(repo, { recursive: true });
+  await git(repo, 'init', '-b', 'main');
+  fs.writeFileSync(path.join(repo, 'a.txt'), 'a0\n');
+  fs.writeFileSync(path.join(repo, 'b.txt'), 'b0\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'base');
+  return { repo, oid: (await git(repo, 'rev-parse', 'HEAD')).trim() };
+}
+
+async function patchFor(repo, edits) {
+  for (const [name, content] of Object.entries(edits)) fs.writeFileSync(path.join(repo, name), content);
+  const diff = await git(repo, 'diff', 'HEAD', '--binary', '--full-index');
+  await git(repo, 'reset', '--hard', 'HEAD');
+  return diff;
+}
+
+function value(baseOid, diff) {
+  return {
+    revision: revisionOf(baseOid, diff, ''),
+    indexDiff: diff,
+    worktreeDiff: '',
+  };
+}
+
+function transition(machine, version, baseOid, from, to) {
+  return {
+    checkpoint: 'repo-checkpoint@4',
+    machine,
+    repoKey: 'root:test',
+    branch: 'main',
+    baseOid,
+    from: value(baseOid, from),
+    to: value(baseOid, to),
+    version,
+    mutationId: `mut_${machine}_${version}`.padEnd(16, 'x'),
+  };
+}
+
+function card(repo, oid, version) {
+  return {
+    card: 'repo-card@2',
+    path: repo,
+    replica: 'rpl_local',
+    machine: 'machine-local',
+    kind: 'primary',
+    health: 'healthy',
+    operation: 'none',
+    head: { branch: 'main', oid, detached: false },
+    repo: { rootCommit: 'test', remote: null },
+    objects: { kind: 'local' },
+    positionVersion: version,
+    positionMutationId: `mut_card_${version}`.padEnd(16, 'x'),
+  };
+}
+
+test('wall reduction chooses one rail winner and orders checkpoint transitions by rail', () => {
+  const oldCard = { ...card('/old', 'a'.repeat(40), 4), checkpointVersion: 9 };
+  oldCard.checkpoint = transition('machine-a', 9, oldCard.head.oid, '', 'a');
+  const newCard = { ...card('/new', 'b'.repeat(40), 7), checkpointVersion: 8 };
+  newCard.checkpoint = transition('machine-b', 8, newCard.head.oid, '', 'b');
+  const plans = reduceWall([
+    { machine: 'machine-a', cards: [oldCard] },
+    { machine: 'machine-b', cards: [newCard] },
+  ]);
+  const plan = plans.get('root:test');
+  assert.equal(plan.card.positionVersion, 7);
+  assert.deepEqual(plan.transitions.map((item) => item.version), [8]);
+});
+
+test('branch refs reduce per name; an absent stale list cannot delete another writer branch', () => {
+  const first = card('/a', 'a'.repeat(40), 5);
+  first.branches = [
+    { name: 'main', oid: first.head.oid, version: 5, mutationId: 'mut_main_00000001' },
+    { name: 'feature', oid: 'c'.repeat(40), version: 4, mutationId: 'mut_feature_0001' },
+  ];
+  const stale = card('/b', 'a'.repeat(40), 6);
+  stale.branches = [
+    { name: 'main', oid: stale.head.oid, version: 6, mutationId: 'mut_main_00000002' },
+  ];
+  let plan = reduceWall([
+    { machine: 'machine-a', cards: [first] },
+    { machine: 'machine-b', cards: [stale] },
+  ]).get('root:test');
+  assert.equal(plan.branches.find((ref) => ref.name === 'feature').oid, 'c'.repeat(40));
+
+  stale.branches.push({
+    name: 'feature',
+    oid: null,
+    version: 7,
+    mutationId: 'mut_feature_del01',
+  });
+  plan = reduceWall([
+    { machine: 'machine-a', cards: [first] },
+    { machine: 'machine-b', cards: [stale] },
+  ]).get('root:test');
+  assert.equal(plan.branches.find((ref) => ref.name === 'feature').oid, null);
+});
+
+test('a multi-user storm reduces identically regardless of network arrival order', () => {
+  const oid = 'a'.repeat(40);
+  const entries = Array.from({ length: 12 }, (_, index) => {
+    const machine = `machine-${index}`;
+    const observed = card(`/machine-${index}`, oid, index + 1);
+    observed.checkpoint = transition(machine, 100 + index, oid, '', `patch-${index}`);
+    observed.checkpointVersion = 100 + index;
+    observed.checkpointMutationId = `mut_checkpoint_${index}`.padEnd(16, 'x');
+    observed.branches = [
+      {
+        name: `feature-${index % 4}`,
+        oid: index >= 8 && index % 4 === 0 ? null : String(index % 10).repeat(40),
+        version: 200 + index,
+        mutationId: `mut_branch_${index}`.padEnd(16, 'x'),
+      },
+    ];
+    return { machine, cards: [observed] };
+  });
+  const normalized = (wallEntries) => {
+    const plan = reduceWall(wallEntries).get('root:test');
+    return {
+      card: [plan.card.positionVersion, plan.card.writer],
+      checkpoints: plan.transitions.map((item) => [item.version, item.machine]),
+      branches: plan.branches.map((ref) => [ref.name, ref.oid, ref.version]),
+    };
+  };
+  const expected = normalized(entries);
+  let seed = 0x5eed1234;
+  const random = () => {
+    seed ^= seed << 13;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5;
+    return (seed >>> 0) / 0x100000000;
+  };
+  for (let pass = 0; pass < 250; pass += 1) {
+    const shuffled = [...entries];
+    for (let index = shuffled.length - 1; index > 0; index -= 1) {
+      const other = Math.floor(random() * (index + 1));
+      [shuffled[index], shuffled[other]] = [shuffled[other], shuffled[index]];
+    }
+    assert.deepEqual(normalized(shuffled), expected);
+  }
+});
+
+test('one materializer converges to the reduced checkpoint and later removes a reverted edit', async () => {
+  const { repo, oid } = await makeRepo('materialize');
+  const patchA = await patchFor(repo, { 'a.txt': 'a1\n' });
+  const patchB = await patchFor(repo, { 'b.txt': 'b1\n' });
+  const localCard = card(repo, oid, 1);
+
+  const first = {
+    repoKey: 'root:test',
+    card: localCard,
+    transitions: [
+      transition('machine-a', 2, oid, '', patchA),
+      transition('machine-b', 3, oid, patchA, `${patchA}${patchB}`),
+    ],
+  };
+  const applied = await materializeRepo(localCard, first);
+  assert.equal(applied.state, 'in-sync');
+  assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), 'a1\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'b.txt'), 'utf8'), 'b1\n');
+
+  const combined = readRepoState('root:test').indexDiff;
+  const second = {
+    repoKey: 'root:test',
+    card: localCard,
+    transitions: [
+      transition('machine-b', 3, oid, patchA, combined),
+      transition('machine-a', 4, oid, combined, patchB),
+    ],
+  };
+  const reverted = await materializeRepo(localCard, second);
+  assert.equal(reverted.state, 'in-sync');
+  assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), 'a0\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'b.txt'), 'utf8'), 'b1\n');
+});
+
+test('a losing commit is parked, the winning card lands exactly, and losing work becomes uncommitted', async () => {
+  const { repo, oid: baseOid } = await makeRepo('simultaneous-commit');
+  fs.writeFileSync(path.join(repo, 'local-commit.txt'), 'losing commit work\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'local losing commit');
+  const losingOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  fs.writeFileSync(path.join(repo, 'local-dirty.txt'), 'also uncommitted\n');
+
+  await git(repo, 'switch', '--detach', baseOid);
+  fs.writeFileSync(path.join(repo, 'winner.txt'), 'winning commit work\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'remote winning commit');
+  const winningOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  await git(repo, 'switch', '-C', 'main', losingOid);
+
+  const localCard = card(repo, losingOid, 1);
+  const winningCard = {
+    ...localCard,
+    head: { branch: 'main', oid: winningOid, detached: false },
+    positionVersion: 2,
+    positionMutationId: 'mut_card_winner_0001',
+  };
+  const outcome = await materializeRepo(localCard, {
+    repoKey: 'root:test',
+    card: winningCard,
+    transitions: [],
+    parked: [],
+  });
+
+  assert.equal(outcome.state, 'in-sync');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), winningOid);
+  assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingOid}`)).trim(), losingOid);
+  assert.equal(fs.readFileSync(path.join(repo, 'winner.txt'), 'utf8'), 'winning commit work\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'local-commit.txt'), 'utf8'), 'losing commit work\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'local-dirty.txt'), 'utf8'), 'also uncommitted\n');
+  assert.equal((await git(repo, 'status', '--porcelain')).trim().length > 0, true);
+  assert.deepEqual(readRepoState('root:test').parked.map((entry) => entry.oid), [losingOid]);
+});
+
+test('checkpoint then commit folds through the same card movement and unrelated local work stays', async () => {
+  const { repo, oid: baseOid } = await makeRepo('checkpoint-commit-fold');
+  await git(repo, 'switch', '-c', 'target');
+  fs.writeFileSync(path.join(repo, 'shared.txt'), 'already checkpointed\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'commit checkpointed work');
+  const targetOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  await git(repo, 'switch', '-C', 'main', baseOid);
+
+  fs.writeFileSync(path.join(repo, 'shared.txt'), 'already checkpointed\n');
+  fs.writeFileSync(path.join(repo, 'local-only.txt'), 'keep me dirty\n');
+  const localCard = card(repo, baseOid, 1);
+  const outcome = await materializeRepo(localCard, {
+    repoKey: 'root:test',
+    card: {
+      ...localCard,
+      head: { branch: 'main', oid: targetOid, detached: false },
+      positionVersion: 2,
+      positionMutationId: 'mut_card_fold_00001',
+    },
+    transitions: [],
+    parked: [],
+    branches: [{ name: 'main', oid: targetOid, version: 2 }],
+  });
+
+  assert.equal(outcome.state, 'in-sync');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), targetOid);
+  assert.equal(fs.readFileSync(path.join(repo, 'shared.txt'), 'utf8'), 'already checkpointed\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'local-only.txt'), 'utf8'), 'keep me dirty\n');
+  assert.equal((await git(repo, 'status', '--porcelain')).trim(), '?? local-only.txt');
+});
+
+test('the materializer creates, moves, and deletes branch refs without checking them out', async () => {
+  const { repo, oid } = await makeRepo('branches');
+  await git(repo, 'switch', '-c', 'feature');
+  fs.writeFileSync(path.join(repo, 'feature.txt'), 'feature\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'feature');
+  const featureOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  await git(repo, 'switch', 'main');
+  await git(repo, 'branch', '-D', 'feature');
+
+  const localCard = card(repo, oid, 1);
+  const createdPlan = {
+    repoKey: 'root:test',
+    card: localCard,
+    transitions: [],
+    parked: [],
+    branches: [
+      { name: 'main', oid, version: 1 },
+      { name: 'feature', oid: featureOid, version: 2 },
+    ],
+  };
+  await materializeRepo(localCard, createdPlan);
+  assert.equal((await git(repo, 'rev-parse', 'refs/heads/feature')).trim(), featureOid);
+  assert.equal((await git(repo, 'branch', '--show-current')).trim(), 'main');
+
+  await materializeRepo(localCard, {
+    ...createdPlan,
+    branches: [
+      { name: 'main', oid, version: 1 },
+      { name: 'feature', oid: null, version: 3 },
+    ],
+  });
+  await assert.rejects(() => git(repo, 'rev-parse', 'refs/heads/feature'));
+  assert.equal((await git(repo, 'branch', '--show-current')).trim(), 'main');
+});

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

@@ -11,7 +11,8 @@ 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 { closeLocalDb, openLocalDb } = require('../state/db');
+const { isUuidV7 } = require('../workspace/tree/identity');
 const {
   listWorkspaces,
   removeWorkspace,
@@ -82,3 +83,37 @@ test('workspace registry does not auto-discover managed folders', () => {
   assert.equal(fs.existsSync(projectPath), true);
   assert.equal(listWorkspaces().some((item) => item.path === projectPath), false);
 });
+
+test('legacy workspace ids are replaced once and never retained as aliases', () => {
+  const projectPath = path.join(tempRoot, 'legacy-id-project');
+  fs.mkdirSync(projectPath, { recursive: true });
+
+  const workspace = upsertWorkspace({
+    id: 'legacy-workspace-id',
+    path: projectPath,
+    name: 'Legacy id project',
+    source: 'computer',
+  });
+
+  assert.equal(isUuidV7(workspace.id), true);
+  assert.notEqual(workspace.id, 'legacy-workspace-id');
+  assert.equal(
+    openLocalDb().prepare('SELECT count(*) AS count FROM workspace_id_aliases').get().count,
+    0,
+    'the historical alias table stays inert',
+  );
+  assert.throws(
+    () => renameWorkspace('legacy-workspace-id', 'Should not resolve'),
+    /Workspace not found/,
+  );
+  assert.equal(
+    upsertWorkspace({
+      id: 'another-legacy-id',
+      path: projectPath,
+      name: 'Same workspace',
+      source: 'computer',
+    }).id,
+    workspace.id,
+    'stable path lookup returns the one canonical workspace UUID',
+  );
+});

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

@@ -23,11 +23,23 @@ fs.writeFileSync(
 );
 
 const { closeLocalDb } = require('../state/db');
+const { acknowledgeCloudMutation } = 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 { publishWall, readWall, wallResourceId, wallStats } = require('../workspace/wall');
+const { repoKeyOfCard } = require('../workspace/checkpoint');
+const {
+  bindProject,
+  projectForRepo,
+  projectResourceId,
+  publishWall,
+  readWall,
+  wallStats,
+} = require('../workspace/wall');
+
+let repoKey;
+let project;
 
 test.after(() => {
   closeLocalDb();
@@ -42,25 +54,29 @@ async function run(cwd, ...args) {
   );
 }
 
-const wallFile = path.join(process.env.AMALGM_DIR, 'state', 'machine-cards-v4.jsonl');
-
-test('the wall resource id is derived from the account: stable per user, distinct across users, valid on the rail', () => {
+test('a project id is stable for one owner and repo, and distinct for another owner or repo', () => {
   const userA = '11111111-1111-4111-8111-111111111111';
   const userB = '22222222-2222-4222-8222-222222222222';
-  assert.equal(wallResourceId(userA), wallResourceId(userA));
-  assert.notEqual(wallResourceId(userA), wallResourceId(userB));
-  assert.match(wallResourceId(userA), /^shr_[A-Za-z0-9_-]{16,128}$/);
-  assert.equal(wallResourceId(null), null);
+  assert.equal(projectResourceId('repo-a', userA), projectResourceId('repo-a', userA));
+  assert.notEqual(projectResourceId('repo-a', userA), projectResourceId('repo-a', userB));
+  assert.notEqual(projectResourceId('repo-a', userA), projectResourceId('repo-b', userA));
+  assert.match(projectResourceId('repo-a', userA), /^shr_[A-Za-z0-9_-]{16,128}$/);
+  assert.equal(projectResourceId(null, userA), null);
 });
 
-test('publishing without a bound wall is a visible skip, never a write', () => {
-  const result = publishWall();
-  assert.equal(result.published, false);
-  assert.equal(result.reason, 'wall-not-bound');
-  assert.equal(fs.existsSync(wallFile), false);
+test('a collaborator binds the same repo to the owner project, not a parallel project', () => {
+  const shared = projectResourceId('repo-shared', '22222222-2222-4222-8222-222222222222');
+  const bound = bindProject(
+    'repo-shared',
+    shared,
+    '22222222-2222-4222-8222-222222222222',
+  );
+  assert.equal(bound.resourceId, shared);
+  assert.equal(projectForRepo('repo-shared').resourceId, shared);
+  assert.equal(projectForRepo('repo-shared').ownerUserId, '22222222-2222-4222-8222-222222222222');
 });
 
-test('a bound wall carries exactly one line per machine, replaced in place', async () => {
+test('a repo project carries exactly one line per machine, replaced in place', async () => {
   const repo = path.join(tempRoot, 'projects/app');
   fs.mkdirSync(repo, { recursive: true });
   await run(repo, 'init', '-b', 'main');
@@ -68,81 +84,98 @@ test('a bound wall carries exactly one line per machine, replaced in place', asy
   await run(repo, 'add', '.');
   await run(repo, 'commit', '-m', 'initial');
   upsertWorkspace({ path: path.join(tempRoot, 'projects'), name: 'Projects', source: 'computer' });
-  await refreshRepoCards();
+  const refreshed = await refreshRepoCards();
+  repoKey = repoKeyOfCard(refreshed.cards[0]);
+  project = projectForRepo(repoKey);
 
-  // Bind the wall the way a completed attachment would: an empty file with
-  // a registered replica for the account's derived resource id.
-  fs.mkdirSync(path.dirname(wallFile), { recursive: true });
-  fs.writeFileSync(wallFile, '');
-  const opened = openDoc(wallFile);
+  fs.mkdirSync(path.dirname(project.file), { recursive: true });
+  fs.writeFileSync(project.file, '');
+  const opened = openDoc(project.file);
   registerReplica({
-    resourceId: wallResourceId(),
+    resourceId: project.resourceId,
     localResource: opened.resource,
-    localPath: wallFile,
+    localPath: project.file,
     contract: 'text-yjs@1',
     schemaVersion: 1,
     authorityEpoch: 1,
   });
 
-  const first = publishWall();
+  const first = publishWall(repoKey);
   assert.equal(first.published, true);
-  const entries = readWall();
+  const entries = readWall(repoKey);
   assert.equal(entries.length, 1);
+  assert.equal(entries[0].wall, 'code-project@1');
+  assert.equal(entries[0].project, repoKey);
   assert.equal(entries[0].machine, 'machine-a');
   assert.equal(entries[0].cards.length, 1);
   assert.equal(entries[0].cards[0].head.branch, 'main');
+  assert.equal(entries[0].cards[0].positionMutationId, first.mutationId);
+  assert.equal(entries[0].cards[0].positionVersion, null);
 
-  // Same cards again: no new version, no doc write.
-  const again = publishWall();
+  acknowledgeCloudMutation(project.resourceId, first.mutationId, {
+    version: 1,
+    committedAt: '2026-07-23T00:00:00.000Z',
+  });
+  const sealed = publishWall(repoKey);
+  assert.equal(sealed.published, true);
+  const sealedCard = readWall(repoKey)[0].cards[0];
+  assert.equal(sealedCard.positionMutationId, first.mutationId);
+  assert.equal(sealedCard.positionVersion, 1);
+
+  const again = publishWall(repoKey);
   assert.equal(again.published, false);
   assert.equal(again.reason, 'unchanged');
 
-  // A real change replaces the line — never appends a second one.
   fs.writeFileSync(path.join(repo, 'new.txt'), 'x\n');
   await refreshRepoCards();
-  const republished = publishWall();
+  const republished = publishWall(repoKey);
   assert.equal(republished.published, true);
-  const after = readWall();
+  const after = readWall(repoKey);
   assert.equal(after.length, 1);
   assert.equal(after[0].cards[0].dirty.untracked, 1);
-  assert.equal(getDocText(wallFile).trim().split('\n').length, 1);
+  assert.equal(after[0].cards[0].positionMutationId, first.mutationId);
+  assert.equal(after[0].cards[0].positionVersion, 1);
+  assert.equal(getDocText(project.file).trim().split('\n').length, 1);
 });
 
-test('a peer machine\'s line is preserved byte-for-byte through this machine\'s publishes', async () => {
+test('a peer machine line is preserved byte-for-byte through local publishes', async () => {
   const peerLine = JSON.stringify({
-    wall: 'machine-cards@4',
+    wall: 'code-project@1',
+    project: repoKey,
     machine: 'machine-b',
     publishedAt: '2026-07-19T00:00:00.000Z',
     cards: [{ card: 'repo-card@2', machine: 'machine-b', replica: 'rpl_peer', path: '/work/app', head: { branch: 'preview' } }],
   });
-  // Land the peer's line the way fanout would: a doc edit from elsewhere.
-  writeDocText(wallFile, `${getDocText(wallFile)}${peerLine}\n`);
+  writeDocText(project.file, `${getDocText(project.file)}${peerLine}\n`);
 
   const repo = path.join(tempRoot, 'projects/app');
   fs.writeFileSync(path.join(repo, 'another.txt'), 'y\n');
   await refreshRepoCards();
-  const result = publishWall();
+  const result = publishWall(repoKey);
   assert.equal(result.published, true);
 
-  const lines = getDocText(wallFile).trim().split('\n');
+  const lines = getDocText(project.file).trim().split('\n');
   assert.equal(lines.length, 2);
-  assert.ok(lines.includes(peerLine), 'the peer line must survive untouched');
-  const entries = readWall();
-  assert.deepEqual(entries.map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
+  assert.ok(lines.includes(peerLine));
+  assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
 });
 
-test('a torn line is ignored by readers and healed by its owner, never fatal', () => {
-  writeDocText(wallFile, `${getDocText(wallFile)}{"wall":"machine-cards@4","machine":"machine-c","car\n`);
-  const entries = readWall();
-  assert.deepEqual(entries.map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
+test('a torn line is ignored by readers, never fatal', () => {
+  writeDocText(
+    project.file,
+    `${getDocText(project.file)}{"wall":"code-project@1","project":"${repoKey}","machine":"machine-c","car\n`,
+  );
+  assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
 });
 
-test('wall stats name the resource, the binding, and the publish counters', () => {
+test('project stats name every project resource, binding, and publish counter', () => {
   const stats = wallStats();
-  assert.equal(stats.resourceId, wallResourceId());
-  assert.equal(stats.contract, 'machine-cards@4');
-  assert.equal(stats.replica.appliedVersion >= 0, true);
-  assert.equal(stats.machines, 2);
+  const row = stats.projects.find((entry) => entry.repoKey === repoKey);
+  assert.equal(stats.contract, 'code-project@1');
+  assert.equal(row.resourceId, project.resourceId);
+  assert.equal(row.replica.appliedVersion >= 0, true);
+  assert.equal(row.machines, 2);
   assert.ok(stats.publishes >= 3);
   assert.ok(stats.publishSkips >= 1);
+  assert.ok(stats.paths.includes(project.file));
 });