amalgm 0.1.180 → 0.1.181

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.180",
+  "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-reducer.test.js

@@ -23,6 +23,7 @@ fs.writeFileSync(
 const { closeLocalDb } = require('../state/db');
 const { revisionOf } = require('../workspace/checkpoint');
 const {
+  captureIsOnRail,
   hydrateRepo,
   materializeRepo,
   readRepoState,
@@ -296,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/reducer.js

@@ -32,6 +32,7 @@ const {
   repoKeyOfCard,
   revisionOf,
 } = require('./checkpoint');
+const { machineId } = require('./identity');
 const merge = require('./merge');
 const transition = require('./transition');
 
@@ -416,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);
@@ -436,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,
@@ -642,6 +674,7 @@ function reducerStats() {
 }
 
 module.exports = {
+  captureIsOnRail,
   hydrateRepo,
   materializeRepo,
   readRepoState,