amalgm 0.1.184 → 0.1.186

package/package.json

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

@@ -309,6 +309,41 @@ test('one materializer converges to the reduced checkpoint and later removes a r
   assert.equal(fs.readFileSync(path.join(repo, 'b.txt'), 'utf8'), 'b1\n');
 });
 
+test('a mode-only checkpoint makes the peer working file executable', async () => {
+  const { repo, oid } = await makeRepo('materialize-mode');
+  fs.chmodSync(path.join(repo, 'a.txt'), 0o755);
+  const modePatch = await git(repo, 'diff', 'HEAD', '--binary', '--full-index');
+  await git(repo, 'reset', '--hard', 'HEAD');
+  const localCard = card(repo, oid, 1);
+  const clean = { revision: null, indexDiff: '', worktreeDiff: '' };
+  const executable = {
+    revision: revisionOf(oid, '', modePatch),
+    indexDiff: '',
+    worktreeDiff: modePatch,
+  };
+  const plan = {
+    repoKey: 'root:test',
+    card: localCard,
+    transitions: [{
+      checkpoint: CHECKPOINT_CONTRACT,
+      machine: 'machine-remote',
+      repoKey: 'root:test',
+      branch: 'main',
+      baseOid: oid,
+      from: clean,
+      to: executable,
+      version: 2,
+      mutationId: 'mut_mode_only_02',
+    }],
+  };
+
+  const outcome = await materializeRepo(localCard, plan);
+  assert.equal(outcome.state, 'in-sync');
+  assert.notEqual(fs.statSync(path.join(repo, 'a.txt')).mode & 0o100, 0);
+  assert.match(await git(repo, 'diff', '--binary', '--full-index'), /new mode 100755/);
+  assert.equal(await git(repo, 'diff', '--cached', '--binary', '--full-index'), '');
+});
+
 test('once local work is on the rail, a checkpoint conflict materializes exactly without echoing', async () => {
   const { repo, oid } = await makeRepo('materialize-conflict');
   const localPatch = await patchFor(repo, { 'a.txt': 'local answer\n' });
@@ -415,6 +450,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/merge.js

@@ -166,7 +166,9 @@ function workMatches(work, entry, blobBytes) {
   if (!entry) return work === null;
   if (work === null) return false;
   if (entry.mode === '120000') return work.kind === 'symlink' && work.content.equals(blobBytes);
-  return work.kind === 'file' && work.content.equals(blobBytes);
+  return work.kind === 'file'
+    && work.exec === (entry.mode === '100755')
+    && work.content.equals(blobBytes);
 }
 
 function isText(buffer) {

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

@@ -206,6 +206,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 +454,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;