amalgm 0.1.179 → 0.1.181

package/package.json

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

@@ -26,7 +26,12 @@ const { closeLocalDb } = require('../state/db');
 const { captureCheckpoint, captureWorktreeDiff } = require('../workspace/git');
 const merge = require('../workspace/merge');
 const { applyPatch } = require('../workspace/transition');
-const { checkpointFile, revisionOf } = require('../workspace/checkpoint');
+const {
+  checkpointFile,
+  checkpointValueReady,
+  readCheckpointValue,
+  revisionOf,
+} = require('../workspace/checkpoint');
 
 test.after(() => {
   closeLocalDb();
@@ -161,3 +166,17 @@ test('checkpoint captures are local cache; their operations travel on the one wa
   assert.notEqual(first, checkpointFile('m1', 'https://github.com/a/c'));
   assert.match(first, /repo-checkpoints-v5/);
 });
+
+test('an uploading checkpoint payload is not published as a transition', () => {
+  const pending = {
+    revision: 'a'.repeat(64),
+    payload: {
+      kind: 'pending',
+      contract: 'opaque-chunks@1',
+      checksum: 'b'.repeat(64),
+    },
+  };
+  assert.equal(checkpointValueReady(pending), false);
+  assert.equal(readCheckpointValue('c'.repeat(40), pending).state, 'payload-pending');
+  assert.equal(checkpointValueReady({ revision: null, indexDiff: '', worktreeDiff: '' }), true);
+});

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

@@ -22,7 +22,14 @@ fs.writeFileSync(
 
 const { closeLocalDb } = require('../state/db');
 const { revisionOf } = require('../workspace/checkpoint');
-const { hydrateRepo, materializeRepo, readRepoState, reduceWall } = require('../workspace/reducer');
+const {
+  captureIsOnRail,
+  hydrateRepo,
+  materializeRepo,
+  readRepoState,
+  reduceCheckpoint,
+  reduceWall,
+} = require('../workspace/reducer');
 
 test.after(() => {
   closeLocalDb();
@@ -123,6 +130,24 @@ test('a stale lower rail card cannot roll back a newer branch and commit', () =>
   assert.equal(plan.card.positionVersion, 12);
 });
 
+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' });
+  const pending = transition('machine-a', 2, oid, '', '');
+  pending.from = {
+    revision: 'a'.repeat(64),
+    payload: { kind: 'pending', contract: 'opaque-chunks@1', checksum: 'b'.repeat(64) },
+  };
+  pending.to = pending.from;
+  const complete = transition('machine-a', 3, oid, '', diff);
+  const reduced = await reduceCheckpoint(
+    { path: repo },
+    { card: card(repo, oid, 1), transitions: [pending, complete] },
+  );
+  assert.equal(reduced.state, 'ready');
+  assert.match(reduced.indexDiff, /a1/);
+});
+
 test('an empty project folder hydrates from the winning card bundle without cloning', async () => {
   const sourceRepo = await makeRepo('hydrate-source');
   const source = sourceRepo.repo;
@@ -272,6 +297,39 @@ 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('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' });
+  const remotePatch = await patchFor(repo, { 'a.txt': 'remote answer\n' });
+  const localTransition = transition('machine-local', 2, oid, '', localPatch);
+  const plan = {
+    repoKey: 'root:test',
+    card: card(repo, oid, 1),
+    transitions: [
+      localTransition,
+      transition('machine-remote', 3, oid, '', remotePatch),
+    ],
+  };
+
+  fs.writeFileSync(path.join(repo, 'a.txt'), 'local answer\n');
+  await git(repo, 'add', 'a.txt');
+  assert.equal(captureIsOnRail(plan, {
+    baseOid: oid,
+    indexDiff: localPatch,
+    worktreeDiff: '',
+  }), true);
+
+  const outcome = await materializeRepo(plan.card, plan);
+  assert.equal(outcome.state, 'conflict');
+  const first = fs.readFileSync(path.join(repo, 'a.txt'), 'utf8');
+  assert.match(first, /local answer/);
+  assert.match(first, /remote answer/);
+  assert.match(first, /<<<<<<< current/);
+
+  await materializeRepo(plan.card, plan);
+  assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), first);
+});
+
 test('a writer publishing again cannot erase its earlier uncommitted work', async () => {
   const { repo, oid } = await makeRepo('checkpoint-history');
   const patchA = await patchFor(repo, { 'a.txt': 'a1\n' });

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

@@ -119,10 +119,17 @@ function checkpointValue(machine, repoKey, baseOid, indexDiff, worktreeDiff) {
   };
 }
 
+function checkpointValueReady(value) {
+  return !value?.payload || value.payload.kind === 'chunks';
+}
+
 function readCheckpointValue(baseOid, value) {
   let indexDiff = typeof value?.indexDiff === 'string' ? value.indexDiff : '';
   let worktreeDiff = typeof value?.worktreeDiff === 'string' ? value.worktreeDiff : '';
   if (value?.payload) {
+    if (value.payload.kind === 'pending') {
+      return { state: 'payload-pending', indexDiff: null, worktreeDiff: null };
+    }
     const payload = require('./objects').readPayload(value.payload);
     if (payload.state !== 'ready') {
       return { state: payload.state, indexDiff: null, worktreeDiff: null };
@@ -203,26 +210,32 @@ async function publishPass(replicaId = null) {
         continue;
       }
 
+      const from = checkpointValue(
+        machine,
+        repoKey,
+        card.head.oid,
+        reduced.indexDiff,
+        reduced.worktreeDiff,
+      );
+      const to = checkpointValue(
+        machine,
+        repoKey,
+        card.head.oid,
+        captured.indexDiff,
+        captured.worktreeDiff,
+      );
+      if (!checkpointValueReady(from) || !checkpointValueReady(to)) {
+        run.waiting += 1;
+        continue;
+      }
       const envelope = {
         checkpoint: CHECKPOINT_CONTRACT,
         machine,
         repoKey,
         branch: card.head.branch,
         baseOid: card.head.oid,
-        from: checkpointValue(
-          machine,
-          repoKey,
-          card.head.oid,
-          reduced.indexDiff,
-          reduced.worktreeDiff,
-        ),
-        to: checkpointValue(
-          machine,
-          repoKey,
-          card.head.oid,
-          captured.indexDiff,
-          captured.worktreeDiff,
-        ),
+        from,
+        to,
         parked,
         capturedAt: new Date().toISOString(),
       };
@@ -322,6 +335,7 @@ module.exports = {
   MAX_INLINE_DIFF_BYTES,
   checkpointFile,
   checkpointStats,
+  checkpointValueReady,
   parseCheckpoint,
   publishCheckpoints,
   readCheckpoint,

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

@@ -32,6 +32,7 @@ const {
   repoKeyOfCard,
   revisionOf,
 } = require('./checkpoint');
+const { machineId } = require('./identity');
 const merge = require('./merge');
 const transition = require('./transition');
 
@@ -378,6 +379,7 @@ async function reduceCheckpoint(localCard, plan) {
   for (const operation of plan.transitions) {
     const from = readCheckpointValue(baseOid, operation.from);
     const to = readCheckpointValue(baseOid, operation.to);
+    if (from.state === 'payload-pending' || to.state === 'payload-pending') continue;
     if (from.state !== 'ready' || to.state !== 'ready') {
       return { state: 'waiting', reason: `checkpoint-${from.state !== 'ready' ? from.state : to.state}` };
     }
@@ -415,6 +417,25 @@ async function reduceCheckpoint(localCard, plan) {
   };
 }
 
+function captureIsOnRail(plan, captured, localMachine = machineId()) {
+  if (
+    !captured
+    || captured.indexDiff === null
+    || captured.baseOid !== plan.card.head.oid
+  ) return false;
+  const latest = [...plan.transitions]
+    .reverse()
+    .find((operation) => operation.machine === localMachine);
+  return Boolean(
+    latest
+    && latest.to?.revision === revisionOf(
+      captured.baseOid,
+      captured.indexDiff,
+      captured.worktreeDiff,
+    ),
+  );
+}
+
 async function materializeRepo(localCardInput, plan) {
   const refreshed = await refreshRepoCard(localCardInput.replica) || localCardInput;
   const cardResult = await moveToWinningCard(refreshed, plan.card);
@@ -435,16 +456,28 @@ async function materializeRepo(localCardInput, plan) {
   if (reduced.state !== 'ready') return reduced;
 
   const baseTree = await merge.treeOf(localCard.path, plan.card.head.oid);
-  const heldWorktree = previous?.baseOid === plan.card.head.oid
-    && previous.heldTree
-    && await merge.hasTree(localCard.path, previous.heldTree)
-    ? previous.heldTree
-    : baseTree;
-  const heldIndex = previous?.baseOid === plan.card.head.oid
-    && previous.heldIndexTree
-    && await merge.hasTree(localCard.path, previous.heldIndexTree)
-    ? previous.heldIndexTree
-    : baseTree;
+  const captured = await captureCheckpoint(localCard.path);
+  const represented = captureIsOnRail(plan, captured);
+  const capturedIndex = represented
+    ? await merge.treeOfPatch(localCard.path, plan.card.head.oid, captured.indexDiff)
+    : null;
+  const capturedWorktree = represented
+    ? await merge.treeOfPatch(localCard.path, capturedIndex, captured.worktreeDiff)
+    : null;
+  const heldWorktree = capturedWorktree || (
+    previous?.baseOid === plan.card.head.oid
+      && previous.heldTree
+      && await merge.hasTree(localCard.path, previous.heldTree)
+      ? previous.heldTree
+      : baseTree
+  );
+  const heldIndex = capturedIndex || (
+    previous?.baseOid === plan.card.head.oid
+      && previous.heldIndexTree
+      && await merge.hasTree(localCard.path, previous.heldIndexTree)
+      ? previous.heldIndexTree
+      : baseTree
+  );
   const currentIndex = await merge.indexTree(localCard.path);
   const reducedLocalIndex = await merge.reduceTree(
     localCard.path,
@@ -641,9 +674,11 @@ function reducerStats() {
 }
 
 module.exports = {
+  captureIsOnRail,
   hydrateRepo,
   materializeRepo,
   readRepoState,
+  reduceCheckpoint,
   reduceNow,
   reduceWall,
   reducerStats,