amalgm 0.1.245 → 0.1.246

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

@@ -6,186 +6,789 @@ const crypto = require('crypto');
 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-wall-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 = 'machine-a';
+process.env.AMALGM_DEVICE_ID = 'device-machine-a';
+
 fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
 fs.writeFileSync(
   path.join(process.env.AMALGM_DIR, 'computer.json'),
-  JSON.stringify({
-    computer_id: 'machine-a',
-    user_id: '11111111-1111-4111-8111-111111111111',
-  }),
+  JSON.stringify({ computer_id: 'machine-a', user_id: '11111111-1111-4111-8111-111111111111' }),
 );
 
 const { closeLocalDb } = require('../state/db');
-const mutations = require('../state/mutations');
-const replicas = require('../state/replicas');
-const checkpoint = require('../workspace/checkpoint');
-const intent = require('../workspace/intent');
-const projectStream = require('../workspace/project-stream');
-const wall = require('../workspace/wall');
-
-const PROJECT = '018f0000-0000-7000-8000-00000000babe';
-const HEAD = 'a'.repeat(40);
-const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
-const REPO_KEY = `code-folder:${PROJECT}`;
+const { appendStateEvent } = require('../state/events');
+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,
+  isCommittedCard,
+  projectForRepo,
+  projectResourceId,
+  publishedCardFor,
+  publishWall,
+  readWall,
+  startWallService,
+  stampCards,
+  stopWallService,
+  wallStats,
+} = require('../workspace/wall');
+
+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();
   fs.rmSync(tempRoot, { recursive: true, force: true });
 });
 
-function bundle(oid = HEAD, byte = 'b') {
-  const chunks = [{ sha256: byte.repeat(64), bytes: 1 }];
-  return {
-    kind: 'bundle',
-    contract: projectStream.BUNDLE_CONTRACT,
-    resourceId: PROJECT,
-    oid,
-    ref: `refs/amalgm/exports/${oid}`,
-    checksum: crypto.createHash('sha256').update(Buffer.from(JSON.stringify(chunks))).digest('hex'),
-    bytes: 1,
-    chunks,
-  };
+async function run(cwd, ...args) {
+  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' } },
+  );
 }
 
-function localCard() {
-  return {
-    card: projectStream.CARD_CONTRACT,
+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(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('no commit means no shared card', () => {
+  assert.equal(isCommittedCard({ head: { branch: 'main', oid: null } }), false);
+  assert.equal(isCommittedCard({ head: { branch: 'main', oid: 'a'.repeat(40) } }), true);
+});
+
+test('only a value different from both the materialized baseline and the rail is new work', () => {
+  const oidA = 'a'.repeat(40);
+  const oidB = 'b'.repeat(40);
+  const oidC = 'c'.repeat(40);
+  const local = {
+    head: { branch: 'main', oid: oidA, detached: false },
+    refs: [{ name: 'main', oid: oidA }],
+  };
+  const plan = {
+    card: { head: { branch: 'main', oid: oidA, detached: false } },
+    branches: [
+      { name: 'main', oid: oidA },
+      { name: 'feature', oid: oidB },
+    ],
+    transitions: [],
+  };
+  const baseline = {
+    branch: 'main',
+    baseOid: oidA,
+    branches: [{ name: 'main', oid: oidA }],
+  };
+
+  assert.equal(hasLocalContribution(local, plan, baseline), false);
+  assert.equal(hasLocalContribution({
+    ...local,
+    refs: [...local.refs, { name: 'feature', oid: oidB }],
+  }, plan, baseline), false);
+  assert.equal(hasLocalContribution({
+    ...local,
+    head: { branch: 'main', oid: oidC, detached: false },
+    refs: [{ name: 'main', oid: oidC }],
+  }, plan, baseline), true);
+  assert.equal(hasLocalContribution(local, plan, {
+    ...baseline,
+    branches: [...baseline.branches, { name: 'feature', oid: oidB }],
+  }), true);
+
+  const remoteAdvance = {
+    ...plan,
+    card: { head: { branch: 'main', oid: oidC, detached: false } },
+    branches: [{ name: 'main', oid: oidC }],
+  };
+  assert.equal(hasLocalContribution(local, remoteAdvance, baseline), false);
+  assert.equal(hasLocalContribution({
+    ...local,
+    head: { branch: 'main', oid: oidB, detached: false },
+    refs: [{ name: 'main', oid: oidB }],
+  }, remoteAdvance, {
+    ...baseline,
+    baseOid: oidB,
+    pendingCard: true,
+  }), true);
+  assert.equal(hasLocalContribution(local, remoteAdvance, baseline, {
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
-    replica: 'replica-a',
-    path: path.join(tempRoot, 'repo'),
-    repo: { remote: null, rootCommit: 'explicit-binding' },
+    branch: 'main',
+    baseOid: oidA,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'old-work', indexDiff: '', worktreeDiff: 'patch' },
+    parked: [],
+  }), false);
+  assert.equal(hasLocalContribution(
+    {
+      head: { branch: 'main', oid: oidB, detached: false },
+      refs: [{ name: 'main', oid: oidB }],
+    },
+    remoteAdvance,
+    {
+      branch: 'main',
+      baseOid: oidB,
+      branches: [{ name: 'main', oid: oidB }],
+    },
+    null,
+    {
+      head: { branch: 'main', oid: oidA, detached: false },
+      branches: [{ name: 'main', oid: oidA }],
+    },
+  ), false);
+  assert.equal(hasLocalContribution(
+    {
+      head: { branch: 'main', oid: oidB, detached: false },
+      refs: [{ name: 'main', oid: oidB }],
+    },
+    remoteAdvance,
+    baseline,
+    null,
+    {
+      positionVersion: 10,
+      head: { branch: 'main', oid: oidB, detached: false },
+      branches: [{ name: 'main', oid: oidB, version: 10 }],
+    },
+  ), false);
+  assert.equal(hasLocalContribution(
+    {
+      head: { branch: 'main', oid: oidB, detached: false },
+      refs: [{ name: 'main', oid: oidB }],
+    },
+    remoteAdvance,
+    baseline,
+    null,
+    {
+      positionVersion: null,
+      head: { branch: 'main', oid: oidB, detached: false },
+      branches: [{ name: 'main', oid: oidB, version: null }],
+    },
+  ), true);
+  assert.equal(hasLocalContribution(
+    local,
+    plan,
+    {
+      ...baseline,
+      branches: [...baseline.branches, { name: 'feature', oid: null }],
+    },
+    null,
+    {
+      head: { branch: 'main', oid: oidA, detached: false },
+      branches: [
+        { name: 'main', oid: oidA, version: 10 },
+        { name: 'feature', oid: oidB, version: 10 },
+      ],
+    },
+  ), true);
+  assert.equal(hasLocalContribution(local, plan, baseline, {
+    checkpoint: 'repo-checkpoint@8',
+    machine: 'machine-a',
+    branch: 'main',
+    baseOid: oidA,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'local-work', indexDiff: '', worktreeDiff: 'patch' },
+    parked: [],
+  }), true);
+});
+
+test('checkpoint work on the materialized baseline keeps the baseline card and branch numbers', () => {
+  const baselineOid = 'a'.repeat(40);
+  const railOid = 'b'.repeat(40);
+  const card = {
+    card: 'repo-card@2',
+    machine: 'machine-a',
+    replica: 'rpl_baseline',
     kind: 'primary',
+    head: { branch: 'main', oid: baselineOid, detached: false },
+    refs: [{ name: 'main', oid: baselineOid }],
     health: 'healthy',
-    operation: 'none',
-    head: { branch: 'main', oid: HEAD, detached: false },
-    objects: bundle(),
-    refs: [{ name: 'main', oid: HEAD, objects: bundle() }],
-    dirty: { staged: 0, unstaged: 0, untracked: 0, conflicted: 0, submodulesChanged: 0 },
   };
-}
+  const stamped = stampCards(
+    [card],
+    [{
+      ...card,
+      head: { branch: 'old', oid: 'c'.repeat(40), detached: false },
+      positionMutationId: 'mut_stale_card_01',
+      positionVersion: 8,
+      branches: [],
+    }],
+    {
+      card: {
+        ...card,
+        head: { branch: 'main', oid: railOid, detached: false },
+        positionMutationId: 'mut_winning_card1',
+        positionVersion: 12,
+      },
+      branches: [{
+        name: 'main',
+        oid: railOid,
+        mutationId: 'mut_winning_ref01',
+        version: 12,
+      }],
+    },
+    {
+      branch: 'main',
+      baseOid: baselineOid,
+      cardMutationId: 'mut_baseline_card',
+      cardVersion: 9,
+      branches: [{
+        name: 'main',
+        oid: baselineOid,
+        mutationId: 'mut_baseline_ref1',
+        version: 9,
+      }],
+    },
+    'mut_checkpoint_only',
+    { repoKey: 'root:baseline-stamp', resourceId: 'shr_baseline_stamp_test' },
+  )[0];
+
+  assert.equal(stamped.positionMutationId, 'mut_baseline_card');
+  assert.equal(stamped.positionVersion, 9);
+  assert.equal(stamped.branches[0].mutationId, 'mut_baseline_ref1');
+  assert.equal(stamped.branches[0].version, 9);
+});
+
+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 localPath = path.join(tempRoot, 'projects/shared');
+  const bound = bindProject(
+    'repo-shared',
+    shared,
+    '22222222-2222-4222-8222-222222222222',
+    localPath,
+  );
+  assert.equal(bound.resourceId, shared);
+  assert.equal(projectForRepo('repo-shared').resourceId, shared);
+  assert.equal(projectForRepo('repo-shared').ownerUserId, '22222222-2222-4222-8222-222222222222');
+  assert.equal(projectForRepo('repo-shared').path, localPath);
+});
+
+test('a repo project appends immutable machine records', async () => {
+  const repo = path.join(tempRoot, 'projects/app');
+  fs.mkdirSync(repo, { recursive: true });
+  await run(repo, 'init', '-b', 'main');
+  fs.writeFileSync(path.join(repo, 'README.md'), '# app\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'initial');
+  upsertWorkspace({ path: path.join(tempRoot, 'projects'), name: 'Projects', source: 'computer' });
+  const refreshed = await refreshRepoCards();
+  repoKey = repoKeyOfCard(refreshed.cards[0]);
+  project = projectForRepo(repoKey);
+
+  fs.mkdirSync(path.dirname(project.file), { recursive: true });
+  fs.writeFileSync(project.file, '');
+  const opened = openDoc(project.file);
+  registerReplica({
+    resourceId: project.resourceId,
+    localResource: opened.resource,
+    localPath: project.file,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    authorityEpoch: 1,
+  });
 
-test('only an explicit folder UUID creates a code project', () => {
-  assert.equal(wall.projectForRepo(REPO_KEY), null);
-  assert.throws(
-    () => wall.bindProject('shr_legacy_or_derived_identity', null, localCard().path),
-    /folder UUID/,
+  const first = publishWall(repoKey);
+  assert.equal(first.published, true);
+  const entries = readWall(repoKey);
+  assert.equal(entries.length, 1);
+  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);
+  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);
+  assert.equal(publishedCardFor(refreshed.cards[0]), null);
+  const awaitingNumber = publishWall(repoKey);
+  assert.equal(awaitingNumber.published, false);
+  assert.equal(awaitingNumber.reason, 'unchanged');
+  assert.equal(
+    require('../workspace/reducer').localCardMayMaterialize(null, awaitingNumber),
+    false,
   );
-  const bound = wall.bindProject(
-    PROJECT,
-    '11111111-1111-4111-8111-111111111111',
-    localCard().path,
+
+  assert.deepEqual(settleProject(), [1]);
+  const sealed = publishWall(repoKey);
+  assert.equal(sealed.published, false);
+  assert.equal(sealed.reason, 'shared-state-covered');
+  const sealedCard = readWall(repoKey)[0].cards[0];
+  assert.equal(sealedCard.positionMutationId, first.mutationId);
+  assert.equal(sealedCard.positionVersion, 1);
+  const sealedLines = getDocText(project.file).trim().split('\n');
+  assert.equal(sealedLines.length, 1);
+  assert.equal(
+    JSON.parse(sealedLines.at(-1)).cards[0].positionVersion,
+    null,
   );
-  assert.equal(bound.resourceId, PROJECT);
-  assert.equal(wall.projectForRepo(REPO_KEY).resourceId, PROJECT);
-  assert.equal(wall.projectForRepo('root:identical-unregistered-clone'), null);
+  assert.equal(publishedCardFor(refreshed.cards[0]).positionVersion, 1);
+  const readyObjects = {
+    ...refreshed.cards[0],
+    objects: { kind: 'bundle' },
+    refs: refreshed.cards[0].refs.map((ref) => ({
+      ...ref,
+      objects: { kind: 'bundle' },
+    })),
+  };
+  assert.equal(publishedCardFor(readyObjects), null);
+
+  const again = publishWall(repoKey);
+  assert.equal(again.published, false);
+  assert.equal(again.reason, 'shared-state-covered');
+
+  fs.writeFileSync(path.join(repo, 'new.txt'), 'x\n');
+  await refreshRepoCards();
+  const republished = publishWall(repoKey);
+  assert.equal(republished.published, false);
+  const after = readWall(repoKey);
+  assert.equal(after.length, 1);
+  assert.equal(Object.hasOwn(after[0].cards[0], 'dirty'), false);
+  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('card identity is Git state, not bundle transport metadata', () => {
-  const first = localCard();
-  const second = {
-    ...first,
-    objects: bundle(HEAD, 'c'),
-    refs: [{ ...first.refs[0], objects: bundle(HEAD, 'd') }],
+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@8',
+    machine: 'machine-a',
+    repoKey,
+    branch: card.head.branch,
+    baseOid: card.head.oid,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'revision-a', indexDiff: '', worktreeDiff: 'patch-a' },
+    parked: [],
+    capturedAt: '2026-07-23T00:00:01.000Z',
   };
-  assert.equal(wall._test.sameCardState(first, second), true);
-  assert.equal(wall._test.sameCardState(first, {
-    ...second,
-    refs: [{ ...second.refs[0], oid: 'e'.repeat(40) }],
-  }), false);
+  fs.writeFileSync(file, `${JSON.stringify(firstCheckpoint)}\n`);
+  const first = publishWall(repoKey);
+  assert.equal(first.published, true);
+  assert.equal(readWall(repoKey)[0].cards[0].checkpoints.length, 1);
+  assert.equal(readWall(repoKey)[0].cards[0].checkpoints[0].mutationId, first.mutationId);
+
+  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');
+  assert.equal(
+    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,
+    from: firstCheckpoint.to,
+    to: { revision: 'revision-b', indexDiff: '', worktreeDiff: 'patch-b' },
+    capturedAt: '2026-07-23T00:00:03.000Z',
+  })}\n`);
+  const second = publishWall(repoKey);
+  assert.equal(second.published, true);
+  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('a physical card publishes only after an explicit local intent capture', () => {
-  const project = wall.projectForRepo(REPO_KEY);
-  projectStream.writeSnapshot(project.file, projectStream.emptySnapshot(PROJECT));
-  replicas.registerReplica({
-    resourceId: PROJECT,
-    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${PROJECT}`,
-    localPath: project.file,
-    contract: projectStream.STREAM_CONTRACT,
-    schemaVersion: 2,
-    authorityEpoch: 1,
-    appliedVersion: 0,
-    snapshotVersion: 0,
+test('an uploading checkpoint base is not announced as complete', () => {
+  const card = readWall(repoKey)[0].cards[0];
+  const [stamped] = stampCards([card], [], { card, branches: [], transitions: [] }, {
+    repoKey,
+    baseOid: card.head.oid,
+    branch: card.head.branch,
+    appliedThrough: 3,
+    indexDiff: 'x'.repeat(600 * 1024),
+    worktreeDiff: '',
+  }, 'mut_project_pending_base', project);
+
+  assert.equal(stamped.checkpointBase, undefined);
+});
+
+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);
+});
 
-  const card = localCard();
-  const withoutIntent = wall._test.publishProject(project, [card]);
-  assert.equal(withoutIntent.published, false);
-  assert.equal(withoutIntent.reason, 'shared-state-covered');
-  assert.equal(mutations.listPendingCloudMutations(PROJECT).length, 0);
-
-  intent.writeIntent(project, {
-    base: {
-      through: 0,
-      card: null,
-      indexTree: EMPTY_TREE,
-      worktreeTree: EMPTY_TREE,
-    },
-    local: {
-      card: {
-        head: card.head,
-        objects: card.objects,
-        branches: card.refs,
-      },
-      checkpoint: {
-        checkpoint: checkpoint.CHECKPOINT_CONTRACT,
-        baseOid: card.head.oid,
-        branch: card.head.branch,
-        value: { revision: null, indexDiff: '', worktreeDiff: '' },
-      },
-      indexTree: HEAD,
-      worktreeTree: HEAD,
-      physicalDigest: 'captured-physical-state',
-    },
+test('side branches keep one rail operation while the checked-out card advances', async () => {
+  const repo = path.join(tempRoot, 'projects/app');
+  const before = readWall(repoKey)[0].cards[0];
+  const branch = 'storm/persistent-ref';
+
+  await run(repo, 'branch', branch);
+  await refreshRepoCards();
+  const beforeMaterialization = getDocText(project.file);
+  const blocked = await require('../workspace/reducer').withMaterialization(
+    repoKey,
+    async () => publishWall(repoKey),
+  );
+  assert.equal(blocked.published, false);
+  assert.equal(blocked.reason, 'repo-materializing');
+  assert.equal(getDocText(project.file), beforeMaterialization);
+
+  const created = publishWall(repoKey);
+  assert.equal(created.published, true);
+  let card = readWall(repoKey)[0].cards[0];
+  const ref = card.branches.find((entry) => entry.name === branch);
+  assert.equal(card.positionMutationId, before.positionMutationId);
+  assert.equal(ref.mutationId, created.mutationId);
+
+  assert.deepEqual(settleProject(), [4]);
+  await run(repo, 'add', 'new.txt');
+  await run(repo, 'commit', '-m', 'advance without moving side branch');
+  await refreshRepoCards();
+  const advanced = publishWall(repoKey);
+  assert.equal(advanced.published, true);
+  card = readWall(repoKey)[0].cards[0];
+  assert.equal(card.positionMutationId, advanced.mutationId);
+  assert.equal(card.branches.find((entry) => entry.name === branch).mutationId, created.mutationId);
+
+  assert.deepEqual(settleProject(), [5]);
+  await run(repo, 'branch', '-D', branch);
+  await refreshRepoCards();
+  const deleted = publishWall(repoKey);
+  assert.equal(deleted.published, true);
+  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@4',
+    project: repoKey,
+    machine: 'machine-b',
+    mutationId: 'mut_project_peer',
+    publishedAt: '2026-07-19T00:00:00.000Z',
+    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 result = wall._test.publishProject(project, [card]);
+  const repo = path.join(tempRoot, 'projects/app');
+  fs.writeFileSync(path.join(repo, 'another.txt'), 'y\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'advance card');
+  await refreshRepoCards();
+  const result = publishWall(repoKey);
   assert.equal(result.published, true);
-  assert.equal(result.delta, 'card.set');
-  assert.equal(projectStream.readSnapshot(project.file, PROJECT).version, 0);
-  const pending = mutations.listPendingCloudMutations(PROJECT);
-  assert.equal(pending.length, 1);
-  assert.equal(pending[0].operation.delta.kind, 'card.set');
+
+  const lines = getDocText(project.file).trim().split('\n');
+  assert.equal(lines.length, beforeLines.length + 2);
+  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', () => {
+  const Y = require('yjs');
+  const base = new Y.Doc();
+  base.getText('content').insert(0, '{"machine":"existing"}\n');
+  const baseUpdate = Y.encodeStateAsUpdate(base);
+  const updates = ['machine-a', 'machine-b', 'machine-c'].map((machine) => {
+    const writer = new Y.Doc();
+    Y.applyUpdate(writer, baseUpdate);
+    let update = null;
+    writer.on('update', (value) => {
+      update = value;
+    });
+    const text = writer.getText('content');
+    text.insert(text.length, `${JSON.stringify({ machine })}\n`);
+    return update;
+  });
+  const replicas = [updates, [...updates].reverse()].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]);
   assert.deepEqual(
-    Object.keys(pending[0].operation.delta).sort(),
-    ['branches', 'card', 'checkpoint', 'head', 'kind', 'objects'].sort(),
+    replicas[0].trim().split('\n').map((line) => JSON.parse(line).machine).sort(),
+    ['existing', 'machine-a', 'machine-b', 'machine-c'],
   );
 });
 
-test('catch-up coverage creates no second outbox event', () => {
-  const project = wall.projectForRepo(REPO_KEY);
-  const snapshot = projectStream._test.fold(
-    projectStream.emptySnapshot(PROJECT),
-    mutations.listPendingCloudMutations(PROJECT)[0].operation,
-    { machine: 'machine-a', mutationId: 'mut_official_card_0001', version: 1 },
+test('wall compaction deletes only records superseded for every machine', () => {
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@4',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  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@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);
+
+  assert.equal(compacted, `${latestA}\n${torn}\n${latestB}\n`);
+  assert.equal(compacted.includes(oldA), false);
+  assert.equal(compacted.includes(oldB), false);
+});
+
+test('an unordered legacy record cannot pin wall compaction', () => {
+  const unordered = JSON.stringify({
+    wall: 'code-project@4',
+    project: repoKey,
+    machine: '16.612Z',
+    cards: [{ value: 'corrupted-legacy-record' }],
+  });
+  const ordered = (machine) => JSON.stringify({
+    wall: 'code-project@4',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}`,
+    cards: [{ value: machine }],
+  });
+  const latestA = ordered('machine-a');
+  const latestB = ordered('machine-b');
+
+  assert.equal(
+    compactWallText(`${unordered}\n${latestA}\n${latestB}\n`, repoKey),
+    `${latestA}\n${latestB}\n`,
   );
-  projectStream.writeSnapshot(project.file, snapshot);
-  const covered = wall._test.sameCardState(localCard(), snapshot.card);
-  assert.equal(covered, true);
 });
 
-test('one failed project publisher cannot block another project', () => {
-  const first = wall.projectForRepo(REPO_KEY);
-  const second = wall.bindProject(
-    '018f0000-0000-7000-8000-00000000baaf',
-    '11111111-1111-4111-8111-111111111111',
-    path.join(tempRoot, 'repo-second'),
+test('retired machine values stay represented without pinning obsolete active history', () => {
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@4',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  const retiredA = line('retired-a', 'latest-retired-a');
+  const retiredB = line('retired-b', 'latest-retired-b');
+  const oldA = line('machine-a', 'old-a');
+  const oldB = line('machine-b', 'old-b');
+  const latestA = line('machine-a', 'latest-a');
+  const latestB = line('machine-b', 'latest-b');
+
+  assert.equal(
+    compactWallText(
+      `${retiredA}\n${retiredB}\n${oldA}\n${oldB}\n${latestA}\n${latestB}\n`,
+      repoKey,
+    ),
+    `${retiredA}\n${retiredB}\n${latestA}\n${latestB}\n`,
   );
-  const cards = [first, second].map((project, index) => ({
-    ...localCard(),
-    path: project.path,
-    replica: `replica-${index}`,
-  }));
-  const results = wall._test.publishSelected([first, second], cards, (project) => {
-    if (project.resourceId === first.resourceId) throw new Error('too large');
-    return { published: true, repoKey: project.repoKey };
+});
+
+test('a concurrent deletion-only compaction and append commute in Yjs', () => {
+  const Y = require('yjs');
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@4',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}_${value}`,
+    cards: [{ value }],
   });
-  assert.equal(results[0].published, false);
-  assert.equal(results[1].published, true);
+  const oldA = line('machine-a', 'old-a');
+  const oldB = line('machine-b', 'old-b');
+  const latestA = line('machine-a', 'latest-a');
+  const latestB = line('machine-b', 'latest-b');
+  const baseText = `${oldA}\n${oldB}\n${latestA}\n${latestB}\n`;
+  const compacted = compactWallText(baseText, repoKey);
+  const base = new Y.Doc();
+  base.getText('content').insert(0, baseText);
+  const baseUpdate = Y.encodeStateAsUpdate(base);
+
+  const writerUpdate = (change) => {
+    const writer = new Y.Doc();
+    Y.applyUpdate(writer, baseUpdate);
+    let update = null;
+    writer.on('update', (value) => {
+      update = value;
+    });
+    change(writer.getText('content'));
+    return update;
+  };
+  const compactUpdate = writerUpdate((text) => {
+    text.delete(0, baseText.length - compacted.length);
+  });
+  const appendLine = `${line('machine-c', 'latest-c')}\n`;
+  const appendUpdate = writerUpdate((text) => {
+    text.insert(text.length, appendLine);
+  });
+
+  const replicas = [
+    [compactUpdate, appendUpdate],
+    [appendUpdate, compactUpdate],
+  ].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]);
+  assert.deepEqual(
+    replicas[0].trim().split('\n').map((entry) => JSON.parse(entry).cards[0].value),
+    ['latest-a', 'latest-b', 'latest-c'],
+  );
+});
+
+test('a torn line is ignored by readers, never fatal', () => {
+  writeDocText(
+    project.file,
+    `${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');
+  fs.writeFileSync(path.join(repo, 'after-compaction.txt'), 'bounded\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'publish after compaction');
+  await refreshRepoCards();
+  const result = publishWall(repoKey);
+
+  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@4');
+  assert.equal(row.resourceId, project.resourceId);
+  assert.equal(row.replica.appliedVersion >= 0, true);
+  assert.equal(row.machines, 2);
+  assert.ok(stats.publishes >= 2);
+  assert.ok(stats.publishSkips >= 1);
+  assert.ok(stats.paths.includes(project.file));
+});
+
+test('ready repo objects wake the card publisher', async () => {
+  startWallService();
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const before = wallStats();
+  appendStateEvent({ resource: 'repo-objects', op: 'update', id: 'ready-bundle' });
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  stopWallService();
+  const after = wallStats();
+  assert.ok(
+    after.publishes + after.publishSkips
+      > before.publishes + before.publishSkips,
+  );
+});
+
+test('a restarted wall publishes once even when the project is already attached', async () => {
+  const before = wallStats();
+  startWallService();
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  stopWallService();
+  const after = wallStats();
+  assert.ok(
+    after.publishes + after.publishSkips
+      > before.publishes + before.publishSkips,
+  );
+});
+
+test('the periodic project check retries an unsent wall', async () => {
+  const originalSetInterval = global.setInterval;
+  let periodicCheck = null;
+  global.setInterval = (callback) => {
+    periodicCheck = callback;
+    return { unref() {} };
+  };
+  try {
+    startWallService();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const before = wallStats();
+    periodicCheck();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const after = wallStats();
+    assert.ok(
+      after.publishes + after.publishSkips
+        > before.publishes + before.publishSkips,
+    );
+  } finally {
+    stopWallService();
+    global.setInterval = originalSetInterval;
+  }
 });