amalgm 0.1.213 → 0.1.215

package/package.json

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

@@ -243,6 +243,37 @@ test('a clean losing commit travels as parked metadata on a no-op checkpoint', (
   assert.deepEqual(checkpoint.parked, parked);
 });
 
+test('only this machine keeps announcing its parked commits', () => {
+  const baseOid = 'a'.repeat(40);
+  const localOid = 'b'.repeat(40);
+  const peerOid = 'c'.repeat(40);
+  const pendingOid = 'd'.repeat(40);
+  const existing = {
+    branch: 'main',
+    baseOid,
+    parked: [{ oid: localOid, objects: { kind: 'pending' } }],
+  };
+  const reduced = {
+    parked: [
+      { oid: localOid, version: 10, objects: { kind: 'pending' } },
+      { oid: peerOid, version: 11, objects: { kind: 'bundle' } },
+      { oid: pendingOid, objects: { kind: 'pending' } },
+    ],
+  };
+  const card = { head: { branch: 'main', oid: baseOid } };
+
+  assert.deepEqual(
+    _test.localParkedEntries(existing, reduced, card).map((entry) => entry.oid),
+    [localOid, pendingOid],
+  );
+  assert.deepEqual(
+    _test.localParkedEntries(existing, reduced, {
+      head: { branch: 'main', oid: 'e'.repeat(40) },
+    }).map((entry) => entry.oid),
+    [pendingOid],
+  );
+});
+
 test('a server rail number does not turn the same parked checkpoint into new work', () => {
   const value = { revision: null, indexDiff: '', worktreeDiff: '' };
   const checkpoint = {

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

@@ -28,6 +28,7 @@ const {
   hydrateRepo,
   localCardMayMaterialize,
   materializeRepo,
+  parkedForState,
   pathForRepo,
   readRepoState,
   reduceCheckpoint,
@@ -175,6 +176,17 @@ test('a ready parked bundle never regresses to pending', () => {
   assert.equal(plan.parked[0].objects.kind, 'bundle');
 });
 
+test('an unpublished local parked commit stays active until the rail records it', () => {
+  const oid = 'f'.repeat(40);
+  const local = { oid, objects: { kind: 'bundle', checksum: 'local' } };
+  assert.deepEqual(parkedForState([local], [], []), [local]);
+  assert.deepEqual(parkedForState([local], [{ ...local, version: 7 }], []), [{
+    ...local,
+    version: 7,
+  }]);
+  assert.deepEqual(parkedForState([{ ...local, version: 7 }], [], []), []);
+});
+
 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';
@@ -507,6 +519,32 @@ 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]);
+
+  const sharedParked = readRepoState('root:test').parked.map((entry) => ({
+    ...entry,
+    version: 2,
+  }));
+  await materializeRepo(card(repo, winningOid, 2), {
+    repoKey: 'root:test',
+    card: winningCard,
+    transitions: [],
+    parked: sharedParked,
+  });
+
+  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

@@ -157,6 +157,17 @@ function checkpointForSharedState(existing, {
   };
 }
 
+function localParkedEntries(existing, reduced, card) {
+  const held = existing?.baseOid === card.head?.oid
+    && existing.branch === card.head?.branch
+    ? existing.parked || []
+    : [];
+  const unpublished = (reduced?.parked || []).filter((entry) => (
+    !Number.isInteger(entry.version) || entry.version < 1
+  ));
+  return [...new Map([...held, ...unpublished].map((entry) => [entry.oid, entry])).values()];
+}
+
 function readCheckpointValue(baseOid, value) {
   let indexDiff = typeof value?.indexDiff === 'string' ? value.indexDiff : '';
   let worktreeDiff = typeof value?.worktreeDiff === 'string' ? value.worktreeDiff : '';
@@ -228,7 +239,7 @@ async function publishPass(replicaId = null) {
       const localRevision = revisionOf(card.head.oid, captured.indexDiff, captured.worktreeDiff);
       const file = checkpointFile(machine, repoKey);
       const existing = readCheckpoint(machine, repoKey);
-      const parked = await Promise.all((reduced.parked || []).map(async (entry) => ({
+      const parked = await Promise.all(localParkedEntries(existing, reduced, card).map(async (entry) => ({
         ...entry,
         objects: await require('./objects').bundleSourceFor(card.path, repoKey, entry.oid),
       })));
@@ -393,6 +404,7 @@ module.exports = {
     checkpointBaseReady,
     checkpointForSharedState,
     checkpointMayPublish,
+    localParkedEntries,
   },
   CHECKPOINT_CONTRACT,
   MAX_INLINE_DIFF_BYTES,

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

@@ -176,6 +176,18 @@ function uniqueParked(entries) {
   return order.map((oid) => byOid.get(oid));
 }
 
+function parkedForState(previous, shared, discovered) {
+  const sharedOids = new Set((shared || []).map((entry) => entry.oid));
+  const unpublished = (previous || []).filter((entry) => (
+    !validVersion(entry.version) && !sharedOids.has(entry.oid)
+  ));
+  return uniqueParked([
+    ...(shared || []),
+    ...unpublished,
+    ...(discovered || []),
+  ]);
+}
+
 async function obtainCardObjects(localCard, targetCard) {
   const oid = targetCard.head?.oid;
   if (!oid || await hasCommit(localCard.path, oid)) return { state: 'ready' };
@@ -512,11 +524,11 @@ async function materializeRepo(localCardInput, plan) {
     ? await refreshRepoCard(refreshed.replica) || refreshed
     : refreshed;
   const previous = readRepoState(plan.repoKey);
-  const parked = uniqueParked([
-    ...(previous?.parked || []),
-    ...(plan.parked || []),
-    ...(cardResult.parked || []),
-  ]);
+  const parked = parkedForState(
+    previous?.parked,
+    plan.parked,
+    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));
@@ -785,6 +797,7 @@ module.exports = {
   localCardMayMaterialize,
   materializeRepo,
   pathForRepo,
+  parkedForState,
   readRepoState,
   reduceCheckpoint,
   reduceNow,

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

@@ -260,7 +260,8 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
   }
 
   if (
-    checkpoint
+    onRail
+    && checkpoint
     && checkpoint.baseOid === card.head?.oid
     && checkpoint.branch === card.head?.branch
   ) {