amalgm 0.1.181 → 0.1.183

package/package.json

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

@@ -164,7 +164,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-v5/);
+  assert.match(first, /repo-checkpoints-v6/);
 });
 
 test('an uploading checkpoint payload is not published as a transition', () => {

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

@@ -21,7 +21,7 @@ fs.writeFileSync(
 );
 
 const { closeLocalDb } = require('../state/db');
-const { revisionOf } = require('../workspace/checkpoint');
+const { CHECKPOINT_CONTRACT, revisionOf } = require('../workspace/checkpoint');
 const {
   captureIsOnRail,
   hydrateRepo,
@@ -73,7 +73,7 @@ function value(baseOid, diff) {
 
 function transition(machine, version, baseOid, from, to) {
   return {
-    checkpoint: 'repo-checkpoint@5',
+    checkpoint: CHECKPOINT_CONTRACT,
     machine,
     repoKey: 'root:test',
     branch: 'main',
@@ -130,6 +130,18 @@ test('a stale lower rail card cannot roll back a newer branch and commit', () =>
   assert.equal(plan.card.positionVersion, 12);
 });
 
+test('checkpoint reduction reads only the current rail contract', () => {
+  const current = card('/current-contract', 'a'.repeat(40), 1);
+  const stale = transition('machine-local', 2, current.head.oid, '', 'stale');
+  stale.checkpoint = 'repo-checkpoint@5';
+  current.checkpoints = [
+    stale,
+    transition('machine-local', 3, current.head.oid, '', 'current'),
+  ];
+  const plan = reduceWall([{ machine: 'machine-local', cards: [current] }]).get('root:test');
+  assert.deepEqual(plan.transitions.map((item) => item.version), [3]);
+});
+
 test('an old pending payload does not block the later complete checkpoint transition', async () => {
   const { repo, oid } = await makeRepo('pending-payload');
   const diff = await patchFor(repo, { 'a.txt': 'a1\n' });
@@ -403,6 +415,41 @@ 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('a new card folds checkpoint work already on the rail instead of replaying it as local work', async () => {
+  const { repo, oid: baseOid } = await makeRepo('card-folds-shared-checkpoint');
+  const sharedPatch = await patchFor(repo, { 'a.txt': 'shared checkpoint\n' });
+
+  await git(repo, 'switch', '-c', 'target');
+  fs.writeFileSync(path.join(repo, 'a.txt'), 'shared checkpoint\n');
+  await git(repo, 'add', 'a.txt');
+  await git(repo, 'commit', '-m', 'commit shared checkpoint');
+  const targetOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  await git(repo, 'switch', 'main');
+
+  const oldCard = card(repo, baseOid, 1);
+  await materializeRepo(oldCard, {
+    repoKey: 'root:test',
+    card: oldCard,
+    transitions: [transition('machine-remote', 2, baseOid, '', sharedPatch)],
+  });
+  assert.notEqual((await git(repo, 'status', '--porcelain')).trim(), '');
+
+  const outcome = await materializeRepo(oldCard, {
+    repoKey: 'root:test',
+    card: {
+      ...oldCard,
+      head: { branch: 'main', oid: targetOid, detached: false },
+      positionVersion: 3,
+      positionMutationId: 'mut_card_shared_fold',
+    },
+    transitions: [],
+    parked: [],
+  });
+  assert.equal(outcome.state, 'in-sync');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), targetOid);
+  assert.equal((await git(repo, 'status', '--porcelain')).trim(), '');
+});
+
 test('checkpoint then commit folds through the same card movement and unrelated local work stays', async () => {
   const { repo, oid: baseOid } = await makeRepo('checkpoint-commit-fold');
   await git(repo, 'switch', '-c', 'target');

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

@@ -155,7 +155,7 @@ test('checkpoint transitions append until the next card and carry their official
   const file = checkpointFile('machine-a', repoKey);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const firstCheckpoint = {
-    checkpoint: 'repo-checkpoint@5',
+    checkpoint: 'repo-checkpoint@6',
     machine: 'machine-a',
     repoKey,
     branch: card.head.branch,

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@5';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@6';
 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-v5', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v6', `${digest}.json`);
 }
 
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {

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

@@ -28,6 +28,7 @@ const {
   operationState,
 } = require('./git');
 const {
+  CHECKPOINT_CONTRACT,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
@@ -106,7 +107,8 @@ function reduceWall(entries) {
       }
       for (const checkpoint of card.checkpoints || []) {
         if (
-          validVersion(checkpoint.version)
+          checkpoint.checkpoint === CHECKPOINT_CONTRACT
+          && validVersion(checkpoint.version)
           && checkpoint.machine === wallEntry.machine
         ) {
           repo.transitions.push(checkpoint);
@@ -228,6 +230,15 @@ async function moveToWinningCard(localCard, targetCard) {
     return { state: 'waiting', reason: 'local-state-moving' };
   }
   const repoKey = repoKeyOfCard(localCard);
+  const reducedState = readRepoState(repoKey);
+  const capturedOnRail = reducedState?.baseOid === current.head.oid
+    && reducedState.checkpointRevision === revisionOf(
+      current.head.oid,
+      captured.indexDiff,
+      captured.worktreeDiff,
+    );
+  const movingIndexDiff = capturedOnRail ? '' : captured.indexDiff;
+  const movingWorktreeDiff = capturedOnRail ? '' : captured.worktreeDiff;
   const parked = [];
   if (!forward && current.head.oid !== targetCard.head.oid) {
     const parkedRef = await transition.parkCommit(localCard.path, current.head.oid);
@@ -255,7 +266,7 @@ async function moveToWinningCard(localCard, targetCard) {
       oldTree,
       { label: `parked-${current.head.oid.slice(0, 12)}` },
     );
-  const oldIndexTree = await merge.treeOfPatch(localCard.path, current.head.oid, captured.indexDiff);
+  const oldIndexTree = await merge.treeOfPatch(localCard.path, current.head.oid, movingIndexDiff);
   const staged = await merge.reduceTree(
     localCard.path,
     committed.tree,
@@ -263,7 +274,7 @@ async function moveToWinningCard(localCard, targetCard) {
     oldIndexTree,
     { label: `staged-${current.head.oid.slice(0, 12)}` },
   );
-  const oldWorktree = await merge.treeOfPatch(localCard.path, oldIndexTree, captured.worktreeDiff);
+  const oldWorktree = await merge.treeOfPatch(localCard.path, oldIndexTree, movingWorktreeDiff);
   const working = await merge.reduceTree(
     localCard.path,
     staged.tree,