amalgm 0.1.212 → 0.1.214

package/package.json

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

@@ -507,6 +507,21 @@ test('a losing commit is parked, the winning card lands exactly, and losing work
   assert.equal(fs.readFileSync(path.join(repo, 'local-dirty.txt'), 'utf8'), 'also uncommitted\n');
   assert.equal((await git(repo, 'status', '--porcelain')).trim().length > 0, true);
   assert.deepEqual(readRepoState('root:test').parked.map((entry) => entry.oid), [losingOid]);
+
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'fold parked work');
+  const foldedOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  const foldedCard = card(repo, foldedOid, 3);
+  const folded = await materializeRepo(foldedCard, {
+    repoKey: 'root:test',
+    card: foldedCard,
+    transitions: [],
+    parked: [],
+  });
+
+  assert.equal(folded.state, 'in-sync');
+  assert.deepEqual(readRepoState('root:test').parked, []);
+  assert.equal((await git(repo, 'rev-parse', `refs/amalgm/parked/${losingOid}`)).trim(), losingOid);
 });
 
 test('rail-parked peer commits become one staged checkpoint on every machine', async () => {

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

@@ -120,6 +120,15 @@ 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, remoteAdvance, baseline, {
+    checkpoint: 'repo-checkpoint@7',
+    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 },

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

@@ -513,7 +513,6 @@ async function materializeRepo(localCardInput, plan) {
     : refreshed;
   const previous = readRepoState(plan.repoKey);
   const parked = uniqueParked([
-    ...(previous?.parked || []),
     ...(plan.parked || []),
     ...(cardResult.parked || []),
   ]);

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]));
 }
@@ -271,14 +260,15 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
   }
 
   if (
-    checkpoint
+    onRail
+    && checkpoint
     && checkpoint.baseOid === card.head?.oid
     && checkpoint.branch === card.head?.branch
   ) {
     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 +434,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;