amalgm 0.1.238 → 0.1.240

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

@@ -6,688 +6,186 @@ 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 = 'device-machine-a';
-
+process.env.AMALGM_DEVICE_ID = '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 { appendStateEvent } = require('../state/events');
-const {
-  acknowledgeCloudMutation,
-  listPendingCloudMutations,
-  pruneMutationJournal,
-} = require('../state/mutations');
-const { registerReplica } = require('../state/replicas');
-const { listWorkspaces, upsertWorkspace } = require('../workspace/store');
-const { refreshRepoCards } = require('../workspace/cards');
-const { checkpointFile, repoKeyOfCard } = require('../workspace/checkpoint');
+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 {
-  _test: wallTest,
-  bindProject,
-  hasLocalContribution,
-  isCommittedCard,
-  projectForRepo,
-  projectResourceId,
-  publishedCardFor,
-  publishWall,
-  readWall,
-  startWallService,
-  stampCards,
-  stopWallService,
-  wallStats,
-} = require('../workspace/wall');
+const wall = 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,
-    resourceId: project.resourceId,
-    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;
-}
+const PROJECT = '018f0000-0000-7000-8000-00000000babe';
+const HEAD = 'a'.repeat(40);
+const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+const REPO_KEY = `code-folder:${PROJECT}`;
 
 test.after(() => {
   closeLocalDb();
   fs.rmSync(tempRoot, { recursive: true, force: true });
 });
 
-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' } },
-  );
-}
-
-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('transport metadata alone does not make a new code record', () => {
-  const base = {
-    wall: 'code-project@6',
-    project: 'root:ordered',
-    machine: 'machine-a',
-    mutationId: 'mut_older_transport',
-    version: 10,
-    publishedAt: '2026-07-26T00:00:00.000Z',
-    cards: [{ marker: 'same-content' }],
-  };
-  assert.equal(wallTest.samePublishedRecord(base, {
-    ...base,
-    mutationId: 'mut_newer_transport',
-    version: 11,
-    publishedAt: '2026-07-26T00:01:00.000Z',
-  }), 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 }],
+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,
   };
+}
 
-  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@9',
-    machine: 'machine-a',
-    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@9',
-    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',
+function localCard() {
+  return {
+    card: projectStream.CARD_CONTRACT,
     machine: 'machine-a',
-    replica: 'rpl_baseline',
+    replica: 'replica-a',
+    path: path.join(tempRoot, 'repo'),
+    repo: { remote: null, rootCommit: 'explicit-binding' },
     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);
-  assert.equal(listWorkspaces().find((workspace) => workspace.path === localPath)?.source, 'computer');
-});
-
-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);
-
-  projectStream.writeSnapshot(project.file, projectStream._test.emptySnapshot(repoKey));
-  registerReplica({
-    resourceId: project.resourceId,
-    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${project.resourceId}`,
-    localPath: project.file,
-    contract: projectStream.STREAM_CONTRACT,
-    schemaVersion: 1,
-    authorityEpoch: 1,
-  });
+}
 
-  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@6');
-  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,
+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/,
   );
-
-  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 sealedSnapshot = projectStream.readSnapshot(project.file, repoKey);
-  assert.equal(sealedSnapshot.records.length, 1);
-  assert.equal(sealedSnapshot.records[0].version, 1);
-  assert.equal(sealedSnapshot.records[0].cards[0].positionVersion ?? null, 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).positionVersion,
-    1,
-    'transport readiness does not turn an accepted card into new Git work',
+  const bound = wall.bindProject(
+    PROJECT,
+    '11111111-1111-4111-8111-111111111111',
+    localCard().path,
   );
-
-  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(projectStream.readSnapshot(project.file, repoKey).records.length, 1);
+  assert.equal(bound.resourceId, PROJECT);
+  assert.equal(wall.projectForRepo(REPO_KEY).resourceId, PROJECT);
+  assert.equal(wall.projectForRepo('root:identical-unregistered-clone'), null);
 });
 
-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@9',
-    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',
+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') }],
   };
-  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 checkpointSnapshot = projectStream.readSnapshot(project.file, repoKey);
-  assert.equal(checkpointSnapshot.records[0].version, 2);
-  assert.equal(
-    checkpointSnapshot.records[0].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,
-    resourceId: project.resourceId,
-    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('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);
+  assert.equal(wall._test.sameCardState(first, second), true);
+  assert.equal(wall._test.sameCardState(first, {
+    ...second,
+    refs: [{ ...second.refs[0], oid: 'e'.repeat(40) }],
+  }), false);
 });
 
-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 };
+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,
   });
-  assert.deepEqual(calls, ['root:first', 'root:second']);
-  assert.equal(results[0].reason, 'publish-failed');
-  assert.equal(results[1].published, true);
-});
-
-test('side branches keep one rail operation while the checked-out card advances', async () => {
-  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 = fs.readFileSync(project.file, 'utf8');
-  const blocked = await require('../workspace/reducer').withMaterialization(
-    repoKey,
-    async () => publishWall(repoKey),
-  );
-  assert.equal(blocked.published, false);
-  assert.equal(blocked.reason, 'repo-materializing');
-  assert.equal(fs.readFileSync(project.file, 'utf8'), 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('an inbound numbered record and a later local publish keep one record per machine', async () => {
-  const peerMutationId = 'mut_project_peer_0001';
-  projectStream.applyCloudMutation({
-    version: 7,
-    committedAt: '2026-07-26T12:00:07.000Z',
-    envelope: {
-      resourceId: project.resourceId,
-      authorityEpoch: 1,
-      mutationId: peerMutationId,
-      deviceId: 'machine-b',
-      baseVersion: 6,
-      contract: projectStream.STREAM_CONTRACT,
-      schemaVersion: 1,
-      operationKind: 'code.publish',
-      operation: {
-        kind: 'code.publish',
-        record: {
-          wall: 'code-project@6',
-          project: repoKey,
-          machine: 'machine-b',
-          mutationId: peerMutationId,
-          publishedAt: '2026-07-26T12:00:07.000Z',
-          cards: [],
-        },
+  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',
     },
   });
-  nextCloudVersion = 8;
-  markReducerApplied(7);
-  assert.deepEqual(
-    readWall(repoKey).map((entry) => [entry.machine, entry.version]),
-    [['machine-a', 6], ['machine-b', 7]],
-  );
 
-  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);
+  const result = wall._test.publishProject(project, [card]);
   assert.equal(result.published, true);
-  assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
-  assert.deepEqual(settleProject(), [8]);
-  assert.equal(projectStream.readSnapshot(project.file, repoKey).records.length, 2);
-});
-
-test('official code order survives mutation-journal pruning', () => {
-  const recordBeforePrune = readWall(repoKey).find((entry) => entry.machine === 'machine-a');
-  assert.equal(recordBeforePrune.version, 8);
-  assert.equal(recordBeforePrune.cards[0].positionVersion, 8);
-
-  const pruned = pruneMutationJournal({
-    cutoffIso: '2100-01-01T00:00:00.000Z',
-    batchSize: 10_000,
-  });
-  assert.ok(pruned.deleted >= 8);
-  assert.equal(
-    require('../state/mutations').getMutation(
-      `resource:${project.resourceId}`,
-      recordBeforePrune.mutationId,
-    ),
-    null,
-  );
-
-  const durable = readWall(repoKey).find((entry) => entry.machine === 'machine-a');
-  assert.equal(durable.version, 8);
-  assert.equal(durable.cards[0].positionVersion, 8);
-  assert.equal(
-    require('../workspace/wall').mutationVersion(
-      project.resourceId,
-      durable.mutationId,
-      repoKey,
-    ),
-    8,
-  );
-  assert.equal(
-    require('../workspace/reducer').reduceWall(readWall(repoKey)).get(repoKey).card.positionVersion,
-    8,
+  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');
+  assert.deepEqual(
+    Object.keys(pending[0].operation.delta).sort(),
+    ['branches', 'card', 'checkpoint', 'head', 'kind', 'objects'].sort(),
   );
 });
 
-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@6');
-  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('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 },
   );
+  projectStream.writeSnapshot(project.file, snapshot);
+  const covered = wall._test.sameCardState(localCard(), snapshot.card);
+  assert.equal(covered, true);
 });
 
-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('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('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;
-  }
+  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 };
+  });
+  assert.equal(results[0].published, false);
+  assert.equal(results[1].published, true);
 });