amalgm 0.1.219 → 0.1.221

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.219",
+  "version": "0.1.221",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

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

@@ -176,6 +176,46 @@ test('a checkpoint base replaces covered history and keeps only newer mutations'
   assert.equal(reduced.checkpointRevision, revisionOf(oid, patchAB, ''));
 });
 
+test('an unfinished checkpoint base cannot replace the last complete base', () => {
+  const oid = 'a'.repeat(40);
+  const complete = card('/complete', oid, 1);
+  complete.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'complete-patch'),
+  };
+  complete.checkpoints = [
+    transition('machine-a', 5, oid, 'complete-patch', 'later-patch'),
+  ];
+
+  const unfinished = card('/unfinished', oid, 1);
+  unfinished.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 6,
+    value: {
+      revision: 'b'.repeat(64),
+      payload: {
+        kind: 'pending',
+        contract: 'opaque-chunks@1',
+        checksum: 'c'.repeat(64),
+      },
+    },
+  };
+
+  const plan = reduceWall([
+    { machine: 'machine-a', cards: [complete] },
+    { machine: 'machine-b', cards: [unfinished] },
+  ]).get('root:test');
+
+  assert.equal(plan.checkpointBase.through, 4);
+  assert.equal(plan.checkpointBaseConflict, false);
+  assert.deepEqual(plan.transitions.map((entry) => entry.version), [5]);
+});
+
 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);
@@ -863,6 +903,37 @@ test('the materializer creates, moves, and deletes branch refs without checking
   assert.equal((await git(repo, 'branch', '--show-current')).trim(), 'main');
 });
 
+test('an unpublished local branch delete is not restored while catching up', async () => {
+  const { repo, oid } = await makeRepo('pending-branch-delete');
+  await git(repo, 'switch', '-c', 'feature');
+  fs.writeFileSync(path.join(repo, 'feature.txt'), 'feature\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'feature');
+  const featureOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  await git(repo, 'switch', 'main');
+  await git(repo, 'branch', '-D', 'feature');
+
+  const localCard = card(repo, oid, 1);
+  const plan = {
+    repoKey: 'root:pending-branch-delete',
+    card: localCard,
+    transitions: [],
+    parked: [],
+    branches: [
+      { name: 'main', oid, version: 1 },
+      { name: 'feature', oid: featureOid, version: 2 },
+    ],
+  };
+  await materializeRepo(localCard, plan);
+  assert.equal((await git(repo, 'rev-parse', 'refs/heads/feature')).trim(), featureOid);
+
+  await git(repo, 'branch', '-D', 'feature');
+  await materializeRepo(localCard, plan);
+
+  await assert.rejects(() => git(repo, 'rev-parse', 'refs/heads/feature'));
+  assert.equal((await git(repo, 'branch', '--show-current')).trim(), 'main');
+});
+
 test('a card branch switch follows branch and OID together and leaves the old branch unchanged', async () => {
   const { repo, oid: mainOid } = await makeRepo('card-branch-switch');
   await git(repo, 'checkout', '-b', 'feature');

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

@@ -453,6 +453,20 @@ test('a checkpoint base replaces history already covered by the applied rail', a
   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);
+});
+
 test('one failed project publisher cannot block the next repo', () => {
   const selected = [{ repoKey: 'root:first' }, { repoKey: 'root:second' }];
   const calls = [];

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

@@ -153,6 +153,7 @@ function reduceWall(entries) {
       .filter((entry) => (
         entry.baseOid === repo.card.head?.oid
         && entry.branch === repo.card.head?.branch
+        && checkpointValueReady(entry.value)
       ))
       .sort((left, right) => right.through - left.through);
     const newestThrough = matchingBases[0]?.through ?? null;
@@ -426,9 +427,11 @@ async function materializeParked(localCard, entries) {
   return waiting;
 }
 
-async function materializeBranches(localCard, plan) {
+async function materializeBranches(localCard, plan, heldBranches = []) {
   const current = new Map((await localBranches(localCard.path)).map((ref) => [ref.name, ref.oid]));
+  const held = new Map(heldBranches.map((ref) => [ref.name, ref.oid]));
   const waiting = [];
+  const pending = [];
   let moved = false;
   for (const ref of plan.branches || []) {
     if (ref.name === plan.card.head?.branch) {
@@ -437,6 +440,12 @@ async function materializeBranches(localCard, plan) {
       }
       continue;
     }
+    const currentOid = current.get(ref.name) || null;
+    const heldOid = held.get(ref.name) || null;
+    if (currentOid !== heldOid && currentOid !== ref.oid) {
+      pending.push({ name: ref.name, oid: currentOid });
+      continue;
+    }
     if (ref.oid === null) {
       if (current.has(ref.name)) {
         await transition.deleteBranchRef(localCard.path, ref.name);
@@ -467,7 +476,7 @@ async function materializeBranches(localCard, plan) {
       moved = true;
     }
   }
-  return { moved, waiting };
+  return { moved, waiting, pending };
 }
 
 async function reduceCheckpoint(localCard, plan) {
@@ -598,7 +607,7 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   if (requiredParkedWaiting.length > 0) {
     return { state: 'waiting', reason: `parked-${requiredParkedWaiting[0].state}` };
   }
-  const branchResult = await materializeBranches(localCard, plan);
+  const branchResult = await materializeBranches(localCard, plan, previous?.branches);
   const reduced = await reduceCheckpoint(localCard, plan);
   if (reduced.state !== 'ready') return reduced;
 
@@ -701,6 +710,7 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
     worktreeDiff: stateWorktreeDiff,
     checkpointVersions: plan.transitions.map((entry) => entry.version),
     branches: plan.branches || [],
+    pendingRefs: branchResult.pending,
     heldTree: applied.heldTree,
     heldIndexTree: targetIndex,
     parked,

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

@@ -20,6 +20,7 @@ const { listRepoCards } = require('./cards');
 const {
   CHECKPOINT_CONTRACT,
   checkpointValue,
+  checkpointValueReady,
   readCheckpoint,
   repoKeyOfCard,
   sameTransition,
@@ -331,6 +332,7 @@ function checkpointBaseFor(card, baseline, project, shared = null) {
     baseline.indexDiff || '',
     baseline.worktreeDiff || '',
   );
+  if (!checkpointValueReady(value)) return null;
   const reusableThrough = shared
     && shared.baseOid === card.head.oid
     && shared.branch === card.head.branch