amalgm 0.1.180 → 0.1.182

package/package.json

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

@@ -164,7 +164,7 @@ test('checkpoint captures are local cache; their operations travel on the one wa
   assert.equal(first, checkpointFile('m1', 'https://github.com/a/b'));
   assert.notEqual(first, checkpointFile('m2', 'https://github.com/a/b'));
   assert.notEqual(first, checkpointFile('m1', 'https://github.com/a/c'));
-  assert.match(first, /repo-checkpoints-v5/);
+  assert.match(first, /repo-checkpoints-v6/);
 });
 
 test('an uploading checkpoint payload is not published as a transition', () => {

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

@@ -21,8 +21,9 @@ fs.writeFileSync(
 );
 
 const { closeLocalDb } = require('../state/db');
-const { revisionOf } = require('../workspace/checkpoint');
+const { CHECKPOINT_CONTRACT, revisionOf } = require('../workspace/checkpoint');
 const {
+  captureIsOnRail,
   hydrateRepo,
   materializeRepo,
   readRepoState,
@@ -72,7 +73,7 @@ function value(baseOid, diff) {
 
 function transition(machine, version, baseOid, from, to) {
   return {
-    checkpoint: 'repo-checkpoint@5',
+    checkpoint: CHECKPOINT_CONTRACT,
     machine,
     repoKey: 'root:test',
     branch: 'main',
@@ -129,6 +130,18 @@ test('a stale lower rail card cannot roll back a newer branch and commit', () =>
   assert.equal(plan.card.positionVersion, 12);
 });
 
+test('checkpoint reduction reads only the current rail contract', () => {
+  const current = card('/current-contract', 'a'.repeat(40), 1);
+  const stale = transition('machine-local', 2, current.head.oid, '', 'stale');
+  stale.checkpoint = 'repo-checkpoint@5';
+  current.checkpoints = [
+    stale,
+    transition('machine-local', 3, current.head.oid, '', 'current'),
+  ];
+  const plan = reduceWall([{ machine: 'machine-local', cards: [current] }]).get('root:test');
+  assert.deepEqual(plan.transitions.map((item) => item.version), [3]);
+});
+
 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' });
@@ -296,6 +309,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/tests/workspace-wall.test.js

@@ -155,7 +155,7 @@ test('checkpoint transitions append until the next card and carry their official
   const file = checkpointFile('machine-a', repoKey);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const firstCheckpoint = {
-    checkpoint: 'repo-checkpoint@5',
+    checkpoint: 'repo-checkpoint@6',
     machine: 'machine-a',
     repoKey,
     branch: card.head.branch,

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

@@ -25,7 +25,7 @@ const { machineId } = require('./identity');
 const { listRepoCards } = require('./cards');
 const { captureCheckpoint } = require('./git');
 
-const CHECKPOINT_CONTRACT = 'repo-checkpoint@5';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@6';
 const MAX_INLINE_DIFF_BYTES = 512 * 1024;
 const PUBLISH_QUIET_MS = 25;
 const RECONCILE_INTERVAL_MS = 30_000;
@@ -54,7 +54,7 @@ function checkpointFile(machine, repoKey) {
     .update(`${CHECKPOINT_CONTRACT}|${machine}|${repoKey}`)
     .digest('hex')
     .slice(0, 24);
-  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v5', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v6', `${digest}.json`);
 }
 
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {

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

@@ -28,10 +28,12 @@ const {
   operationState,
 } = require('./git');
 const {
+  CHECKPOINT_CONTRACT,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
 } = require('./checkpoint');
+const { machineId } = require('./identity');
 const merge = require('./merge');
 const transition = require('./transition');
 
@@ -105,7 +107,8 @@ function reduceWall(entries) {
       }
       for (const checkpoint of card.checkpoints || []) {
         if (
-          validVersion(checkpoint.version)
+          checkpoint.checkpoint === CHECKPOINT_CONTRACT
+          && validVersion(checkpoint.version)
           && checkpoint.machine === wallEntry.machine
         ) {
           repo.transitions.push(checkpoint);
@@ -416,6 +419,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 +458,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 +676,7 @@ function reducerStats() {
 }
 
 module.exports = {
+  captureIsOnRail,
   hydrateRepo,
   materializeRepo,
   readRepoState,