amalgm 0.1.217 → 0.1.219

package/package.json

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

@@ -180,7 +180,7 @@ test('checkpoint captures are local cache; their operations travel on the one wa
   assert.equal(first, checkpointFile('m1', 'https://github.com/a/b'));
   assert.notEqual(first, checkpointFile('m2', 'https://github.com/a/b'));
   assert.notEqual(first, checkpointFile('m1', 'https://github.com/a/c'));
-  assert.match(first, /repo-checkpoints-v7/);
+  assert.match(first, /repo-checkpoints-v8/);
 });
 
 test('a materialized peer card is immediately a valid checkpoint base', () => {

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

@@ -258,7 +258,7 @@ test('two concurrent compacting publishers converge without losing either latest
   const Y = require('yjs');
   const repoKey = 'root:compaction-collision';
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_${machine}_${value}`,

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

@@ -152,6 +152,56 @@ test('wall reduction chooses one rail winner and orders checkpoint transitions b
   ]);
 });
 
+test('a checkpoint base replaces covered history and keeps only newer mutations', async () => {
+  const { repo, oid } = await makeRepo('checkpoint-base');
+  const patchA = await patchFor(repo, { 'a.txt': 'a1\n' });
+  const patchAB = await patchFor(repo, { 'a.txt': 'a1\n', 'b.txt': 'b1\n' });
+  const current = card(repo, oid, 1);
+  current.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, patchA),
+  };
+  current.checkpoints = [
+    transition('machine-a', 2, oid, '', patchA),
+    transition('machine-a', 5, oid, patchA, patchAB),
+  ];
+  const plan = reduceWall([{ machine: 'machine-a', cards: [current] }]).get('root:test');
+  assert.equal(plan.checkpointBase.through, 4);
+  assert.deepEqual(plan.transitions.map((entry) => entry.version), [5]);
+  const reduced = await reduceCheckpoint(current, plan);
+  assert.equal(reduced.state, 'ready');
+  assert.equal(reduced.checkpointRevision, revisionOf(oid, patchAB, ''));
+});
+
+test('different snapshots claiming the same rail position stop instead of choosing a winner', () => {
+  const oid = 'a'.repeat(40);
+  const first = card('/first', oid, 1);
+  first.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'patch-a'),
+  };
+  const second = card('/second', oid, 1);
+  second.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'patch-b'),
+  };
+  const plan = reduceWall([
+    { machine: 'machine-a', cards: [first] },
+    { machine: 'machine-b', cards: [second] },
+  ]).get('root:test');
+  assert.equal(plan.checkpointBase, null);
+  assert.equal(plan.checkpointBaseConflict, true);
+});
+
 test('a ready parked bundle never regresses to pending', () => {
   const oid = 'c'.repeat(40);
   const ready = card('/ready', 'a'.repeat(40), 1);
@@ -635,6 +685,51 @@ test('a local commit made after the verified card snapshot is never parked or ov
   );
 });
 
+test('a pending descendant commit catches up without becoming a losing commit', async () => {
+  const { repo, oid: baseOid } = await makeRepo('pending-descendant-card');
+  const firstPatch = await patchFor(repo, { 'a.txt': 'before commit\n' });
+  const secondPatch = await patchFor(repo, {
+    'a.txt': 'before commit\n',
+    'b.txt': 'after commit\n',
+  });
+  const winningCard = card(repo, baseOid, 1);
+  const before = {
+    repoKey: 'root:test',
+    card: winningCard,
+    transitions: [transition('machine-peer', 2, baseOid, '', firstPatch)],
+    parked: [],
+  };
+
+  await materializeRepo(winningCard, before, 2);
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'local pending card');
+  const pendingOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  const pendingCard = card(repo, pendingOid, null);
+  const caughtUp = await materializeRepo(pendingCard, {
+    ...before,
+    transitions: [
+      ...before.transitions,
+      transition('machine-peer', 3, baseOid, firstPatch, secondPatch),
+    ],
+  }, 3);
+
+  assert.equal(caughtUp.state, 'in-sync');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), pendingOid);
+  assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), 'before commit\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'b.txt'), 'utf8'), 'after commit\n');
+  const staged = (await git(repo, 'diff', '--cached', '--name-only')).trim();
+  const status = (await git(repo, 'status', '--short')).trim();
+  assert.equal(staged, 'b.txt', status);
+  await assert.rejects(
+    git(repo, 'rev-parse', `refs/amalgm/parked/${pendingOid}`),
+  );
+  const state = readRepoState('root:test');
+  assert.equal(state.baseOid, pendingOid);
+  assert.equal(state.appliedThrough, 3);
+  assert.equal(state.cardVersion, null);
+});
+
 test('an empty index advance cannot overwrite a commit that just finished', async () => {
   const { repo } = await makeRepo('index-commit-race');
   const observedIndex = (await git(repo, 'write-tree')).trim();

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

@@ -35,6 +35,7 @@ const { upsertWorkspace } = require('../workspace/store');
 const { refreshRepoCards } = require('../workspace/cards');
 const { checkpointFile, repoKeyOfCard } = require('../workspace/checkpoint');
 const {
+  _test: wallTest,
   bindProject,
   compactWallText,
   hasLocalContribution,
@@ -147,8 +148,17 @@ test('only a value different from both the materialized baseline and the rail is
     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@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -218,7 +228,7 @@ test('only a value different from both the materialized baseline and the rail is
     },
   ), true);
   assert.equal(hasLocalContribution(local, plan, baseline, {
-    checkpoint: 'repo-checkpoint@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -328,7 +338,7 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(first.published, true);
   const entries = readWall(repoKey);
   assert.equal(entries.length, 1);
-  assert.equal(entries[0].wall, 'code-project@3');
+  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);
@@ -384,12 +394,12 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(getDocText(project.file).trim().split('\n').length, 1);
 });
 
-test('checkpoint transitions append until the next card and carry their official rail numbers', async () => {
+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@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     repoKey,
     branch: card.head.branch,
@@ -413,6 +423,20 @@ test('checkpoint transitions append until the next card and carry their official
     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,
@@ -422,12 +446,26 @@ test('checkpoint transitions append until the next card and carry their official
   })}\n`);
   const second = publishWall(repoKey);
   assert.equal(second.published, true);
-  const history = readWall(repoKey)[0].cards[0].checkpoints;
-  assert.equal(history.length, 2);
-  assert.deepEqual(history.map((entry) => entry.mutationId), [first.mutationId, second.mutationId]);
+  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('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);
+});
+
 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];
@@ -475,7 +513,7 @@ test('side branches keep one rail operation while the checked-out card advances'
 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@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine: 'machine-b',
     mutationId: 'mut_project_peer',
@@ -532,7 +570,7 @@ test('three concurrent append records stay whole under Yjs ordering', () => {
 
 test('wall compaction deletes only records superseded for every machine', () => {
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -541,7 +579,7 @@ test('wall compaction deletes only records superseded for every machine', () =>
   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@3","machine":"torn"';
+  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);
@@ -553,13 +591,13 @@ test('wall compaction deletes only records superseded for every machine', () =>
 
 test('an unordered legacy record cannot pin wall compaction', () => {
   const unordered = JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine: '16.612Z',
     cards: [{ value: 'corrupted-legacy-record' }],
   });
   const ordered = (machine) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}`,
@@ -576,7 +614,7 @@ test('an unordered legacy record cannot pin wall compaction', () => {
 
 test('retired machine values stay represented without pinning obsolete active history', () => {
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -601,7 +639,7 @@ test('retired machine values stay represented without pinning obsolete active hi
 test('a concurrent deletion-only compaction and append commute in Yjs', () => {
   const Y = require('yjs');
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -654,7 +692,7 @@ test('a concurrent deletion-only compaction and append commute in Yjs', () => {
 test('a torn line is ignored by readers, never fatal', () => {
   writeDocText(
     project.file,
-    `${getDocText(project.file)}{"wall":"code-project@3","project":"${repoKey}","machine":"machine-c","car\n`,
+    `${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']);
@@ -682,7 +720,7 @@ test('publishing compacts an oversized history before appending the new record',
 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@3');
+  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);

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

@@ -25,7 +25,7 @@ const { machineId } = require('./identity');
 const { listRepoCards } = require('./cards');
 const { captureCheckpoint } = require('./git');
 
-const CHECKPOINT_CONTRACT = 'repo-checkpoint@7';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@8';
 const MAX_INLINE_DIFF_BYTES = 512 * 1024;
 const PUBLISH_QUIET_MS = 25;
 const RECONCILE_INTERVAL_MS = 30_000;
@@ -54,7 +54,7 @@ function checkpointFile(machine, repoKey) {
     .update(`${CHECKPOINT_CONTRACT}|${machine}|${repoKey}`)
     .digest('hex')
     .slice(0, 24);
-  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v7', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v8', `${digest}.json`);
 }
 
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {
@@ -416,6 +416,7 @@ module.exports = {
   MAX_INLINE_DIFF_BYTES,
   checkpointFile,
   checkpointStats,
+  checkpointValue,
   checkpointValueReady,
   parseCheckpoint,
   publishCheckpoints,

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

@@ -29,6 +29,7 @@ const {
 } = require('./git');
 const {
   CHECKPOINT_CONTRACT,
+  checkpointValueReady,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
@@ -108,7 +109,14 @@ function reduceWall(entries) {
       ) continue;
       let repo = repos.get(repoKey);
       if (!repo) {
-        repo = { repoKey, card: null, transitions: [], parked: [], branchMap: new Map() };
+        repo = {
+          repoKey,
+          card: null,
+          checkpointBases: [],
+          transitions: [],
+          parked: [],
+          branchMap: new Map(),
+        };
         repos.set(repoKey, repo);
       }
       if (!repo.card || card.positionVersion > repo.card.positionVersion) {
@@ -128,13 +136,39 @@ function reduceWall(entries) {
           repo.transitions.push(checkpoint);
         }
       }
+      const checkpointBase = card.checkpointBase;
+      if (
+        checkpointBase?.checkpoint === CHECKPOINT_CONTRACT
+        && Number.isInteger(checkpointBase.through)
+        && checkpointBase.through >= 0
+        && checkpointBase.baseOid === card.head?.oid
+        && checkpointBase.branch === card.head?.branch
+      ) {
+        repo.checkpointBases.push(checkpointBase);
+      }
     }
   }
   for (const repo of repos.values()) {
+    const matchingBases = repo.checkpointBases
+      .filter((entry) => (
+        entry.baseOid === repo.card.head?.oid
+        && entry.branch === repo.card.head?.branch
+      ))
+      .sort((left, right) => right.through - left.through);
+    const newestThrough = matchingBases[0]?.through ?? null;
+    const newestBases = matchingBases
+      .filter((entry) => entry.through === newestThrough)
+      .sort((left, right) => (
+        Number(checkpointValueReady(right.value)) - Number(checkpointValueReady(left.value))
+      ));
+    const baseRevisions = new Set(newestBases.map((entry) => entry.value?.revision ?? null));
+    repo.checkpointBaseConflict = baseRevisions.size > 1;
+    repo.checkpointBase = repo.checkpointBaseConflict ? null : newestBases[0] || null;
     repo.transitions = repo.transitions
       .filter((entry) => (
         entry.baseOid === repo.card.head?.oid
         && entry.branch === repo.card.head?.branch
+        && (!repo.checkpointBase || entry.version > repo.checkpointBase.through)
       ))
       .sort((left, right) => left.version - right.version);
     repo.parked = uniqueParked(repo.transitions.flatMap((checkpoint) => (
@@ -157,6 +191,7 @@ function reduceWall(entries) {
     }
     repo.branches = [...repo.branchMap.values()].sort((left, right) => left.name.localeCompare(right.name));
     delete repo.branchMap;
+    delete repo.checkpointBases;
   }
   return repos;
 }
@@ -253,6 +288,14 @@ async function moveToWinningCard(localCard, targetCard) {
     && current.head.branch === targetCard.head?.branch
   ) return { state: 'ready', moved: false };
 
+  const pendingCard = current.head.oid
+    && targetCard.head?.oid
+    && current.head.branch === targetCard.head?.branch
+    && await isAncestor(localCard.path, targetCard.head.oid, current.head.oid);
+  if (pendingCard) {
+    return { state: 'ready', moved: false, pendingCard: true, conflicts: [] };
+  }
+
   const objects = await obtainCardObjects(localCard, targetCard);
   if (objects.state !== 'ready') return { state: 'waiting', reason: objects.state };
 
@@ -433,6 +476,21 @@ async function reduceCheckpoint(localCard, plan) {
   let indexTree = baseTree;
   let worktreeTree = baseTree;
   const conflicts = [];
+  if (plan.checkpointBaseConflict) {
+    return { state: 'waiting', reason: 'checkpoint-base-disagrees' };
+  }
+  if (plan.checkpointBase) {
+    const snapshot = readCheckpointValue(baseOid, plan.checkpointBase.value);
+    if (snapshot.state !== 'ready') {
+      return { state: 'waiting', reason: `checkpoint-base-${snapshot.state}` };
+    }
+    indexTree = await merge.treeOfPatch(localCard.path, baseOid, snapshot.indexDiff);
+    worktreeTree = await merge.treeOfPatch(
+      localCard.path,
+      indexTree,
+      snapshot.worktreeDiff,
+    );
+  }
 
   for (const entry of plan.parked || []) {
     const commonOid = await mergeBase(localCard.path, baseOid, entry.oid);
@@ -544,38 +602,87 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   const reduced = await reduceCheckpoint(localCard, plan);
   if (reduced.state !== 'ready') return reduced;
 
-  const baseTree = await merge.treeOf(localCard.path, plan.card.head.oid);
-  const captured = await captureCheckpoint(localCard.path);
-  const represented = captureIsOnRail(plan, captured);
-  const capturedIndex = represented
-    ? await merge.treeOfPatch(localCard.path, plan.card.head.oid, captured.indexDiff)
-    : null;
-  const capturedWorktree = represented
-    ? await merge.treeOfPatch(localCard.path, capturedIndex, captured.worktreeDiff)
-    : null;
-  const heldWorktree = capturedWorktree || (
+  const sharedBaseTree = await merge.treeOf(localCard.path, plan.card.head.oid);
+  const previousHeldWorktree = (
     previous?.baseOid === plan.card.head.oid
       && previous.heldTree
       && await merge.hasTree(localCard.path, previous.heldTree)
       ? previous.heldTree
-      : baseTree
+      : sharedBaseTree
   );
-  const heldIndex = capturedIndex || (
+  const previousHeldIndex = (
     previous?.baseOid === plan.card.head.oid
       && previous.heldIndexTree
       && await merge.hasTree(localCard.path, previous.heldIndexTree)
       ? previous.heldIndexTree
-      : baseTree
+      : sharedBaseTree
   );
+  let stateBaseOid = plan.card.head.oid;
+  let stateBranch = plan.card.head.branch;
+  let stateCardVersion = plan.card.positionVersion;
+  let stateCardMutationId = plan.card.positionMutationId;
+  let stateIndexDiff = reduced.indexDiff;
+  let stateWorktreeDiff = reduced.worktreeDiff;
+  let heldWorktree;
+  let heldIndex;
+  let targetWorktree;
+  let targetIndex;
+  const pendingConflicts = [];
+
+  if (cardResult.pendingCard) {
+    const pendingBaseTree = await merge.treeOf(localCard.path, localCard.head.oid);
+    const rebasedIndex = await merge.reduceTree(
+      localCard.path,
+      pendingBaseTree,
+      previousHeldIndex,
+      reduced.indexTree,
+      { label: `pending-card-index-${appliedThrough ?? 'local'}` },
+    );
+    const rebasedWorktree = await merge.reduceTree(
+      localCard.path,
+      pendingBaseTree,
+      previousHeldWorktree,
+      reduced.worktreeTree,
+      { label: `pending-card-worktree-${appliedThrough ?? 'local'}` },
+    );
+    heldIndex = pendingBaseTree;
+    heldWorktree = pendingBaseTree;
+    targetIndex = rebasedIndex.tree;
+    targetWorktree = rebasedWorktree.tree;
+    stateBaseOid = localCard.head.oid;
+    stateBranch = localCard.head.branch;
+    stateCardVersion = null;
+    stateCardMutationId = null;
+    stateIndexDiff = await merge.diffOfTree(localCard.path, stateBaseOid, targetIndex);
+    stateWorktreeDiff = await merge.diffOfTree(localCard.path, targetIndex, targetWorktree);
+    pendingConflicts.push(
+      ...rebasedIndex.conflicts.map((item) => ({ ...item, layer: 'pending-card-index' })),
+      ...rebasedWorktree.conflicts.map((item) => ({ ...item, layer: 'pending-card-worktree' })),
+    );
+  } else {
+    const captured = await captureCheckpoint(localCard.path);
+    const represented = captureIsOnRail(plan, captured);
+    const capturedIndex = represented
+      ? await merge.treeOfPatch(localCard.path, plan.card.head.oid, captured.indexDiff)
+      : null;
+    const capturedWorktree = represented
+      ? await merge.treeOfPatch(localCard.path, capturedIndex, captured.worktreeDiff)
+      : null;
+    heldWorktree = capturedWorktree || previousHeldWorktree;
+    heldIndex = capturedIndex || previousHeldIndex;
+    targetWorktree = reduced.worktreeTree;
+    targetIndex = reduced.indexTree;
+  }
+
   const currentIndex = await merge.indexTree(localCard.path);
   const reducedLocalIndex = await merge.reduceTree(
     localCard.path,
     currentIndex,
     heldIndex,
-    reduced.indexTree,
+    targetIndex,
     { label: `index-${reduced.checkpointRevision || 'clean'}` },
   );
-  const applied = await merge.advance(localCard.path, heldWorktree, reduced.worktreeTree, {
+  const applied = await merge.advance(localCard.path, heldWorktree, targetWorktree, {
     label: `checkpoint-${reduced.checkpointRevision || 'clean'}`,
   });
   const indexResult = await advanceIndex(localCard.path, currentIndex, reducedLocalIndex.tree);
@@ -583,28 +690,30 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   const state = writeRepoState(plan.repoKey, {
     path: localCard.path,
     replica: localCard.replica,
-    branch: plan.card.head.branch,
-    baseOid: plan.card.head.oid,
-    cardVersion: plan.card.positionVersion,
-    cardMutationId: plan.card.positionMutationId,
+    branch: stateBranch,
+    baseOid: stateBaseOid,
+    cardVersion: stateCardVersion,
+    cardMutationId: stateCardMutationId,
+    pendingCard: Boolean(cardResult.pendingCard),
     appliedThrough,
-    checkpointRevision: reduced.checkpointRevision,
-    indexDiff: reduced.indexDiff,
-    worktreeDiff: reduced.worktreeDiff,
+    checkpointRevision: revisionOf(stateBaseOid, stateIndexDiff, stateWorktreeDiff),
+    indexDiff: stateIndexDiff,
+    worktreeDiff: stateWorktreeDiff,
     checkpointVersions: plan.transitions.map((entry) => entry.version),
     branches: plan.branches || [],
     heldTree: applied.heldTree,
-    heldIndexTree: reduced.indexTree,
+    heldIndexTree: targetIndex,
     parked,
     parkedWaiting: [...parkedWaiting, ...branchResult.waiting],
     conflicts: [
       ...(cardResult.conflicts || []),
       ...reduced.conflicts,
+      ...pendingConflicts,
       ...reducedLocalIndex.conflicts.map((item) => ({ ...item, layer: 'index-materialize' })),
       ...applied.conflicts,
     ],
-    materialized: applied.heldTree === reduced.worktreeTree
-      && reducedLocalIndex.tree === reduced.indexTree,
+    materialized: applied.heldTree === targetWorktree
+      && reducedLocalIndex.tree === targetIndex,
   });
   appendStateEvent({
     resource: 'workspace-reducer',

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

@@ -17,9 +17,15 @@ const { AMALGM_DIR } = require('../config');
 const { subscribeStateEvents } = require('../state/events');
 const { machineId, userId } = require('./identity');
 const { listRepoCards } = require('./cards');
-const { readCheckpoint, repoKeyOfCard, sameTransition } = require('./checkpoint');
-
-const WALL_CONTRACT = 'code-project@3';
+const {
+  CHECKPOINT_CONTRACT,
+  checkpointValue,
+  readCheckpoint,
+  repoKeyOfCard,
+  sameTransition,
+} = require('./checkpoint');
+
+const WALL_CONTRACT = 'code-project@4';
 const PROJECT_DIR = path.join(AMALGM_DIR, 'state', 'code-projects');
 const REGISTRY_FILE = path.join(PROJECT_DIR, 'projects.json');
 const PUBLISH_QUIET_MS = 25;
@@ -246,7 +252,8 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
   const onRail = samePosition(card, plan.card);
   const atBaseline = baseline
     && card.head?.branch === baseline.branch
-    && card.head?.oid === baseline.baseOid;
+    && card.head?.oid === baseline.baseOid
+    && !baseline.pendingCard;
   const alreadyPublished = validVersion(previousCard?.positionVersion)
     && samePosition(card, previousCard);
   const reversesPublishedSharedPosition = previousCard
@@ -309,6 +316,46 @@ function hasObjectUpgrade(card, plan) {
   });
 }
 
+function checkpointBaseFor(card, baseline, project, shared = null) {
+  if (
+    !baseline
+    || baseline.baseOid !== card.head?.oid
+    || baseline.branch !== card.head?.branch
+    || !Number.isInteger(baseline.appliedThrough)
+    || baseline.appliedThrough < 0
+  ) return null;
+  const value = checkpointValue(
+    machineId(),
+    project.repoKey,
+    card.head.oid,
+    baseline.indexDiff || '',
+    baseline.worktreeDiff || '',
+  );
+  const reusableThrough = shared
+    && shared.baseOid === card.head.oid
+    && shared.branch === card.head.branch
+    && shared.value?.revision === value.revision
+    && Number.isInteger(shared.through)
+    && shared.through >= 0;
+  return {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: card.head.oid,
+    branch: card.head.branch,
+    through: reusableThrough ? shared.through : baseline.appliedThrough,
+    value,
+  };
+}
+
+function hasCheckpointBaseUpgrade(card, plan, baseline, project) {
+  const shared = plan?.card?.checkpointBase;
+  const candidate = checkpointBaseFor(card, baseline, project, shared);
+  return Boolean(shared && candidate) && (
+    candidate.through === shared.through
+    && candidate.value?.revision === shared.value?.revision
+    && JSON.stringify(candidate.value) !== JSON.stringify(shared.value)
+  );
+}
+
 function validVersion(value) {
   return Number.isInteger(value) && value > 0;
 }
@@ -443,6 +490,12 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
       && checkpoint.branch === card.head?.branch
       ? checkpoint
       : null;
+    const checkpointBase = checkpointBaseFor(
+      card,
+      baseline,
+      project,
+      sharedPlan?.card?.checkpointBase,
+    );
     const sameBase = previous?.head?.oid === card.head?.oid
       && previous?.head?.branch === card.head?.branch;
     const history = sameBase && Array.isArray(previous?.checkpoints)
@@ -453,7 +506,10 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
           entry.mutationId,
           entry.version,
         ),
-      }))
+      })).filter((entry) => (
+        validVersion(entry.version)
+        && (!checkpointBase || entry.version > checkpointBase.through)
+      ))
       : [];
     const last = history.at(-1);
     const checkpoints = currentCheckpoint
@@ -473,6 +529,7 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
         mutationId,
         project.resourceId,
       ),
+      ...(checkpointBase ? { checkpointBase } : {}),
       ...(checkpoints.length ? { checkpoints } : {}),
     };
   });
@@ -549,7 +606,8 @@ function publishProject(project, rawCards) {
     const checkpoint = readCheckpoint(machineId(), project.repoKey);
     const previousCard = previousCards.find((entry) => entry.replica === card.replica);
     return hasLocalContribution(card, sharedPlan, baseline, checkpoint, previousCard)
-      || hasObjectUpgrade(card, sharedPlan);
+      || hasObjectUpgrade(card, sharedPlan)
+      || hasCheckpointBaseUpgrade(card, sharedPlan, baseline, project);
   });
   if (!removed && !contributes) {
     service.counters.publishSkips += 1;
@@ -618,16 +676,33 @@ function publishProject(project, rawCards) {
   };
 }
 
+function publishSelected(selected, allCards, publisher = publishProject) {
+  return selected.map((project) => {
+    try {
+      return publisher(
+        project,
+        allCards.filter((card) => (
+          repoKeyOfCard(card) === project.repoKey
+          && isCommittedCard(card)
+        )),
+      );
+    } catch (error) {
+      service.counters.publishFailures += 1;
+      console.warn(`[CodeProject] ${project.repoKey} publish failed:`, error.message);
+      return {
+        published: false,
+        reason: 'publish-failed',
+        repoKey: project.repoKey,
+        error: error.message,
+      };
+    }
+  });
+}
+
 function publishWall(repoKey = null) {
   const allCards = listRepoCards();
   const selected = repoKey ? [projectForRepo(repoKey)].filter(Boolean) : projects();
-  const results = selected.map((project) => publishProject(
-    project,
-    allCards.filter((card) => (
-      repoKeyOfCard(card) === project.repoKey
-      && isCommittedCard(card)
-    )),
-  ));
+  const results = publishSelected(selected, allCards);
   if (repoKey) return results[0] || { published: false, reason: 'project-missing', repoKey };
   return {
     published: results.some((result) => result.published),
@@ -788,6 +863,7 @@ function wallStats() {
 }
 
 module.exports = {
+  _test: { publishSelected },
   WALL_CONTRACT,
   bindProject,
   compactWallText,