amalgm 0.1.211 → 0.1.213

package/package.json

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

@@ -33,6 +33,7 @@ const {
   checkpointValueReady,
   readCheckpointValue,
   revisionOf,
+  sameTransition,
 } = require('../workspace/checkpoint');
 
 test.after(() => {
@@ -241,3 +242,31 @@ test('a clean losing commit travels as parked metadata on a no-op checkpoint', (
   assert.deepEqual(checkpoint.to, sharedValue);
   assert.deepEqual(checkpoint.parked, parked);
 });
+
+test('a server rail number does not turn the same parked checkpoint into new work', () => {
+  const value = { revision: null, indexDiff: '', worktreeDiff: '' };
+  const checkpoint = {
+    branch: 'main',
+    baseOid: 'a'.repeat(40),
+    from: value,
+    to: value,
+    parked: [{
+      oid: 'b'.repeat(40),
+      ref: `refs/amalgm/parked/${'b'.repeat(40)}`,
+      objects: { kind: 'bundle', checksum: 'c'.repeat(64) },
+      version: 12,
+    }],
+  };
+
+  assert.equal(sameTransition(checkpoint, {
+    ...checkpoint,
+    parked: checkpoint.parked.map((entry) => ({ ...entry, version: 37 })),
+  }), true);
+  assert.equal(sameTransition(checkpoint, {
+    ...checkpoint,
+    parked: checkpoint.parked.map((entry) => ({
+      ...entry,
+      objects: { ...entry.objects, checksum: 'd'.repeat(64) },
+    })),
+  }), false);
+});

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

@@ -129,14 +129,22 @@ test('wall reduction chooses one rail winner and orders checkpoint transitions b
   const oldCard = card('/old', 'a'.repeat(40), 4);
   oldCard.checkpoints = [transition('machine-a', 9, oldCard.head.oid, '', 'a')];
   const newCard = card('/new', 'b'.repeat(40), 7);
-  newCard.checkpoints = [transition('machine-b', 8, newCard.head.oid, '', 'b')];
+  const later = transition('machine-b', 11, newCard.head.oid, 'b', 'c');
+  later.parked = [{ oid: 'd'.repeat(40) }];
+  const earlier = transition('machine-b', 8, newCard.head.oid, '', 'b');
+  earlier.parked = [{ oid: 'c'.repeat(40) }];
+  newCard.checkpoints = [later, earlier];
   const plans = reduceWall([
     { machine: 'machine-a', cards: [oldCard] },
     { machine: 'machine-b', cards: [newCard] },
   ]);
   const plan = plans.get('root:test');
   assert.equal(plan.card.positionVersion, 7);
-  assert.deepEqual(plan.transitions.map((item) => item.version), [8]);
+  assert.deepEqual(plan.transitions.map((item) => item.version), [8, 11]);
+  assert.deepEqual(plan.parked.map((item) => [item.oid, item.version]), [
+    ['c'.repeat(40), 8],
+    ['d'.repeat(40), 11],
+  ]);
 });
 
 test('a ready parked bundle never regresses to pending', () => {
@@ -501,6 +509,50 @@ test('a losing commit is parked, the winning card lands exactly, and losing work
   assert.deepEqual(readRepoState('root:test').parked.map((entry) => entry.oid), [losingOid]);
 });
 
+test('rail-parked peer commits become one staged checkpoint on every machine', async () => {
+  const { repo, oid: baseOid } = await makeRepo('peer-parked-commits');
+
+  await git(repo, 'switch', '-c', 'winner');
+  fs.writeFileSync(path.join(repo, 'winner.txt'), 'winning card\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'winning card');
+  const winningOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  await git(repo, 'switch', '-C', 'loser-a', baseOid);
+  fs.writeFileSync(path.join(repo, 'loser-a.txt'), 'first losing commit\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'first losing commit');
+  const losingAOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  await git(repo, 'switch', '-C', 'loser-b', baseOid);
+  fs.writeFileSync(path.join(repo, 'loser-b.txt'), 'second losing commit\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'second losing commit');
+  const losingBOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  await git(repo, 'switch', '-C', 'main', winningOid);
+  const winningCard = card(repo, winningOid, 4);
+  const outcome = await materializeRepo(winningCard, {
+    repoKey: 'root:test',
+    card: winningCard,
+    transitions: [],
+    parked: [
+      { oid: losingAOid, version: 2 },
+      { oid: losingBOid, version: 3 },
+    ],
+  });
+
+  assert.equal(outcome.state, 'in-sync');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), winningOid);
+  assert.deepEqual(
+    (await git(repo, 'diff', '--cached', '--name-only')).trim().split('\n'),
+    ['loser-a.txt', 'loser-b.txt'],
+  );
+  assert.equal((await git(repo, 'diff', '--name-only')).trim(), '');
+  assert.equal(fs.readFileSync(path.join(repo, 'loser-a.txt'), 'utf8'), 'first losing commit\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'loser-b.txt'), 'utf8'), 'second losing commit\n');
+});
+
 test('a local commit made after the verified card snapshot is never parked or overwritten', async () => {
   const { repo, oid: baseOid } = await makeRepo('card-snapshot-race');
   const verifiedCard = card(repo, baseOid, 1);

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

@@ -96,13 +96,21 @@ function valueIdentity(value) {
   });
 }
 
+function parkedIdentity(parked) {
+  return JSON.stringify((parked || []).map((entry) => {
+    const stable = { ...entry };
+    delete stable.version;
+    return stable;
+  }));
+}
+
 function sameTransition(left, right) {
   return left
     && left.baseOid === right.baseOid
     && left.branch === right.branch
     && valueIdentity(left.from) === valueIdentity(right.from)
     && valueIdentity(left.to) === valueIdentity(right.to)
-    && JSON.stringify(left.parked || []) === JSON.stringify(right.parked || []);
+    && parkedIdentity(left.parked) === parkedIdentity(right.parked);
 }
 
 function checkpointValue(machine, repoKey, baseOid, indexDiff, worktreeDiff) {
@@ -397,6 +405,7 @@ module.exports = {
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
+  sameTransition,
   startCheckpointService,
   stopCheckpointService,
 };

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

@@ -126,7 +126,6 @@ function reduceWall(entries) {
           && checkpoint.machine === wallEntry.machine
         ) {
           repo.transitions.push(checkpoint);
-          repo.parked.push(...(checkpoint.parked || []));
         }
       }
     }
@@ -138,7 +137,12 @@ function reduceWall(entries) {
         && entry.branch === repo.card.head?.branch
       ))
       .sort((left, right) => left.version - right.version);
-    repo.parked = uniqueParked(repo.parked);
+    repo.parked = uniqueParked(repo.transitions.flatMap((checkpoint) => (
+      (checkpoint.parked || []).map((entry) => ({
+        ...entry,
+        version: checkpoint.version,
+      }))
+    )));
     if (repo.card.head?.branch) {
       const held = repo.branchMap.get(repo.card.head.branch);
       if (!held || repo.card.positionVersion > held.version) {
@@ -159,15 +163,17 @@ function reduceWall(entries) {
 
 function uniqueParked(entries) {
   const byOid = new Map();
+  const order = [];
   for (const entry of entries || []) {
     if (typeof entry?.oid === 'string' && /^[0-9a-f]{40,64}$/.test(entry.oid)) {
       const held = byOid.get(entry.oid);
+      if (!held) order.push(entry.oid);
       if (!held || held.objects?.kind !== 'bundle' || entry.objects?.kind === 'bundle') {
         byOid.set(entry.oid, entry);
       }
     }
   }
-  return [...byOid.values()].sort((left, right) => left.oid.localeCompare(right.oid));
+  return order.map((oid) => byOid.get(oid));
 }
 
 async function obtainCardObjects(localCard, targetCard) {
@@ -411,6 +417,32 @@ async function reduceCheckpoint(localCard, plan) {
   let worktreeTree = baseTree;
   const conflicts = [];
 
+  for (const entry of plan.parked || []) {
+    const commonOid = await mergeBase(localCard.path, baseOid, entry.oid);
+    if (!commonOid) return { state: 'waiting', reason: `parked-unrelated-${entry.oid}` };
+    const commonTree = await merge.treeOf(localCard.path, commonOid);
+    const parkedTree = await merge.treeOf(localCard.path, entry.oid);
+    const label = `parked-${entry.version || entry.oid.slice(0, 12)}`;
+    const reducedIndex = await merge.reduceTree(
+      localCard.path,
+      indexTree,
+      commonTree,
+      parkedTree,
+      { label },
+    );
+    indexTree = reducedIndex.tree;
+    conflicts.push(...reducedIndex.conflicts.map((item) => ({ ...item, layer: 'index' })));
+    const reducedWorktree = await merge.reduceTree(
+      localCard.path,
+      worktreeTree,
+      commonTree,
+      parkedTree,
+      { label },
+    );
+    worktreeTree = reducedWorktree.tree;
+    conflicts.push(...reducedWorktree.conflicts.map((item) => ({ ...item, layer: 'worktree' })));
+  }
+
   for (const operation of plan.transitions) {
     const from = readCheckpointValue(baseOid, operation.from);
     const to = readCheckpointValue(baseOid, operation.to);
@@ -486,6 +518,11 @@ async function materializeRepo(localCardInput, plan) {
     ...(cardResult.parked || []),
   ]);
   const parkedWaiting = await materializeParked(localCard, parked);
+  const planParked = new Set((plan.parked || []).map((entry) => entry.oid));
+  const requiredParkedWaiting = parkedWaiting.filter((entry) => planParked.has(entry.oid));
+  if (requiredParkedWaiting.length > 0) {
+    return { state: 'waiting', reason: `parked-${requiredParkedWaiting[0].state}` };
+  }
   const branchResult = await materializeBranches(localCard, plan);
   const reduced = await reduceCheckpoint(localCard, plan);
   if (reduced.state !== 'ready') return reduced;

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

@@ -17,7 +17,7 @@ const { AMALGM_DIR } = require('../config');
 const { subscribeStateEvents } = require('../state/events');
 const { machineId, userId } = require('./identity');
 const { listRepoCards } = require('./cards');
-const { readCheckpoint, repoKeyOfCard } = require('./checkpoint');
+const { readCheckpoint, repoKeyOfCard, sameTransition } = require('./checkpoint');
 
 const WALL_CONTRACT = 'code-project@3';
 const PROJECT_DIR = path.join(AMALGM_DIR, 'state', 'code-projects');
@@ -209,17 +209,6 @@ function samePosition(left, right) {
     && Boolean(left?.head?.detached) === Boolean(right?.head?.detached);
 }
 
-function checkpointIdentity(checkpoint) {
-  if (!checkpoint) return null;
-  return JSON.stringify({
-    baseOid: checkpoint.baseOid,
-    branch: checkpoint.branch,
-    from: checkpoint.from,
-    to: checkpoint.to,
-    parked: checkpoint.parked || [],
-  });
-}
-
 function oidMap(refs) {
   return new Map((refs || []).map((ref) => [ref.name, ref.oid ?? null]));
 }
@@ -278,7 +267,7 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
     const latest = [...(plan.transitions || [])]
       .reverse()
       .find((entry) => entry.machine === checkpoint.machine);
-    if (checkpointIdentity(latest) !== checkpointIdentity(checkpoint)) return true;
+    if (!sameTransition(latest, checkpoint)) return true;
   }
   return false;
 }
@@ -444,7 +433,7 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
       : [];
     const last = history.at(-1);
     const checkpoints = currentCheckpoint
-      ? (checkpointIdentity(last) === checkpointIdentity(currentCheckpoint)
+      ? (sameTransition(last, currentCheckpoint)
         ? history
         : [...history, { ...currentCheckpoint, mutationId }])
       : history;