amalgm 0.1.210 → 0.1.212

package/package.json

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

@@ -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/tests/workspace-wall.test.js

@@ -685,3 +685,27 @@ test('a restarted wall publishes once even when the project is already attached'
       > 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;
+  }
+});

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

@@ -714,7 +714,10 @@ function startWallService() {
       schedulePublish();
     }
   });
-  service.ensureInterval = setInterval(() => ensureProjects().catch(() => {}), ENSURE_INTERVAL_MS);
+  service.ensureInterval = setInterval(() => {
+    ensureProjects().catch(() => {});
+    schedulePublish();
+  }, ENSURE_INTERVAL_MS);
   service.ensureInterval.unref?.();
   ensureProjects().catch(() => {});
   schedulePublish();