amalgm 0.1.185 → 0.1.187

package/package.json

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

@@ -27,6 +27,8 @@ const { captureCheckpoint, captureWorktreeDiff } = require('../workspace/git');
 const merge = require('../workspace/merge');
 const { applyPatch } = require('../workspace/transition');
 const {
+  _test,
+  CHECKPOINT_CONTRACT,
   checkpointFile,
   checkpointValueReady,
   readCheckpointValue,
@@ -180,3 +182,37 @@ test('an uploading checkpoint payload is not published as a transition', () => {
   assert.equal(readCheckpointValue('c'.repeat(40), pending).state, 'payload-pending');
   assert.equal(checkpointValueReady({ revision: null, indexDiff: '', worktreeDiff: '' }), true);
 });
+
+test('a clean losing commit travels as parked metadata on a no-op checkpoint', () => {
+  const sharedValue = { revision: null, indexDiff: '', worktreeDiff: '' };
+  const parked = [{
+    oid: 'a'.repeat(40),
+    ref: `refs/amalgm/parked/${'a'.repeat(40)}`,
+    objects: { kind: 'bundle', checksum: 'b'.repeat(64) },
+  }];
+  const checkpoint = _test.checkpointForSharedState({
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine: 'machine-a',
+    repoKey: 'root:test',
+    branch: 'old',
+    baseOid: 'c'.repeat(40),
+    from: sharedValue,
+    to: sharedValue,
+    parked: [],
+  }, {
+    machine: 'machine-a',
+    repoKey: 'root:test',
+    branch: 'main',
+    baseOid: 'd'.repeat(40),
+    sharedValue,
+    parked,
+    capturedAt: '2026-07-24T00:00:00.000Z',
+  });
+
+  assert.equal(checkpoint.checkpoint, CHECKPOINT_CONTRACT);
+  assert.equal(checkpoint.baseOid, 'd'.repeat(40));
+  assert.equal(checkpoint.branch, 'main');
+  assert.deepEqual(checkpoint.from, sharedValue);
+  assert.deepEqual(checkpoint.to, sharedValue);
+  assert.deepEqual(checkpoint.parked, parked);
+});

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

@@ -116,6 +116,34 @@ test('wall reduction chooses one rail winner and orders checkpoint transitions b
   assert.deepEqual(plan.transitions.map((item) => item.version), [8]);
 });
 
+test('a ready parked bundle never regresses to pending', () => {
+  const oid = 'c'.repeat(40);
+  const ready = card('/ready', 'a'.repeat(40), 1);
+  const readyCheckpoint = transition('machine-ready', 2, ready.head.oid, '', '');
+  readyCheckpoint.parked = [{
+    oid,
+    ref: `refs/amalgm/parked/${oid}`,
+    objects: { kind: 'bundle', checksum: 'd'.repeat(64) },
+  }];
+  ready.checkpoints = [readyCheckpoint];
+
+  const pending = card('/pending', ready.head.oid, 3);
+  const pendingCheckpoint = transition('machine-pending', 4, pending.head.oid, '', '');
+  pendingCheckpoint.parked = [{
+    oid,
+    ref: `refs/amalgm/parked/${oid}`,
+    objects: { kind: 'pending' },
+  }];
+  pending.checkpoints = [pendingCheckpoint];
+
+  const plan = reduceWall([
+    { machine: 'machine-ready', cards: [ready] },
+    { machine: 'machine-pending', cards: [pending] },
+  ]).get('root:test');
+  assert.equal(plan.parked.length, 1);
+  assert.equal(plan.parked[0].objects.kind, 'bundle');
+});
+
 test('a stale lower rail card cannot roll back a newer branch and commit', () => {
   const newer = card('/newer', 'b'.repeat(40), 12);
   newer.head.branch = 'feature';
@@ -450,6 +478,42 @@ 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 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);
+
+  await git(repo, 'switch', '--detach', baseOid);
+  fs.writeFileSync(path.join(repo, 'winner.txt'), 'winning commit work\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'remote winning commit');
+  const winningOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+  await git(repo, 'switch', '-C', 'main', baseOid);
+
+  fs.writeFileSync(path.join(repo, 'late-local.txt'), 'created after verification\n');
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'late local commit');
+  const lateLocalOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  const outcome = await materializeRepo(verifiedCard, {
+    repoKey: 'root:test',
+    card: {
+      ...verifiedCard,
+      head: { branch: 'main', oid: winningOid, detached: false },
+      positionVersion: 2,
+      positionMutationId: 'mut_card_snapshot_race',
+    },
+    transitions: [],
+    parked: [],
+  });
+
+  assert.equal(outcome.state, 'waiting');
+  assert.equal(outcome.reason, 'local-card-changed-after-verification');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), lateLocalOid);
+  await assert.rejects(
+    git(repo, 'rev-parse', `refs/amalgm/parked/${lateLocalOid}`),
+  );
+});
+
 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' });

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

@@ -123,6 +123,32 @@ function checkpointValueReady(value) {
   return !value?.payload || value.payload.kind === 'chunks';
 }
 
+function checkpointForSharedState(existing, {
+  machine,
+  repoKey,
+  branch,
+  baseOid,
+  sharedValue,
+  parked,
+  capturedAt = new Date().toISOString(),
+}) {
+  if (existing?.baseOid === baseOid && existing.branch === branch) {
+    return { ...existing, parked };
+  }
+  if (parked.length === 0) return null;
+  return {
+    checkpoint: CHECKPOINT_CONTRACT,
+    machine,
+    repoKey,
+    branch,
+    baseOid,
+    from: sharedValue,
+    to: sharedValue,
+    parked,
+    capturedAt,
+  };
+}
+
 function readCheckpointValue(baseOid, value) {
   let indexDiff = typeof value?.indexDiff === 'string' ? value.indexDiff : '';
   let worktreeDiff = typeof value?.worktreeDiff === 'string' ? value.worktreeDiff : '';
@@ -191,9 +217,23 @@ async function publishPass(replicaId = null) {
 
       // Exact equality means the working tree merely materialized the shared
       // checkpoint. Keep the writer's last transition because it remains part
-      // of the reducer input, but do not invent an echo operation.
+      // of the reducer input. A newly parked commit still rides as metadata on
+      // a no-op transition; the working tree itself is never echoed.
       if (sharedRevision === localRevision) {
-        const refreshed = existing ? { ...existing, parked } : null;
+        const refreshed = checkpointForSharedState(existing, {
+          machine,
+          repoKey,
+          branch: card.head.branch,
+          baseOid: card.head.oid,
+          sharedValue: checkpointValue(
+            machine,
+            repoKey,
+            card.head.oid,
+            reduced.indexDiff,
+            reduced.worktreeDiff,
+          ),
+          parked,
+        });
         if (refreshed && !sameTransition(existing, refreshed)) {
           fs.writeFileSync(file, `${JSON.stringify(refreshed)}\n`);
           appendStateEvent({
@@ -331,6 +371,9 @@ function checkpointStats() {
 }
 
 module.exports = {
+  _test: {
+    checkpointForSharedState,
+  },
   CHECKPOINT_CONTRACT,
   MAX_INLINE_DIFF_BYTES,
   checkpointFile,

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

@@ -124,6 +124,7 @@ function reduceWall(entries) {
         && entry.branch === repo.card.head?.branch
       ))
       .sort((left, right) => left.version - right.version);
+    repo.parked = uniqueParked(repo.parked);
     if (repo.card.head?.branch) {
       const held = repo.branchMap.get(repo.card.head.branch);
       if (!held || repo.card.positionVersion > held.version) {
@@ -146,7 +147,10 @@ function uniqueParked(entries) {
   const byOid = new Map();
   for (const entry of entries || []) {
     if (typeof entry?.oid === 'string' && /^[0-9a-f]{40,64}$/.test(entry.oid)) {
-      byOid.set(entry.oid, entry);
+      const held = byOid.get(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));
@@ -206,6 +210,12 @@ async function moveToWinningCard(localCard, targetCard) {
   const current = await headAndDirty(localCard.path);
   const operation = await operationState(localCard.path);
   if (operation !== 'none') return { state: 'waiting', reason: 'local-operation-in-flight' };
+  if (
+    current.head.oid !== localCard.head?.oid
+    || current.head.branch !== localCard.head?.branch
+  ) {
+    return { state: 'waiting', reason: 'local-card-changed-after-verification' };
+  }
   if (
     current.head.oid === targetCard.head?.oid
     && current.head.branch === targetCard.head?.branch
@@ -448,7 +458,7 @@ function captureIsOnRail(plan, captured, localMachine = machineId()) {
 }
 
 async function materializeRepo(localCardInput, plan) {
-  const refreshed = await refreshRepoCard(localCardInput.replica) || localCardInput;
+  const refreshed = localCardInput;
   const cardResult = await moveToWinningCard(refreshed, plan.card);
   if (cardResult.state !== 'ready') return cardResult;