amalgm 0.1.196 → 0.1.198

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.196",
+  "version": "0.1.198",
   "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 { CHECKPOINT_CONTRACT, revisionOf } = require('../workspace/checkpoint');
 const {
+  advanceIndex,
   captureIsOnRail,
   hydrateRepo,
   localCardMayMaterialize,
@@ -530,6 +531,36 @@ test('a local commit made after the verified card snapshot is never parked or ov
   );
 });
 
+test('an empty index advance cannot overwrite a commit that just finished', async () => {
+  const { repo } = await makeRepo('index-commit-race');
+  const observedIndex = (await git(repo, 'write-tree')).trim();
+
+  fs.writeFileSync(path.join(repo, 'binary.bin'), Buffer.alloc(32 * 1024, 1));
+  await git(repo, 'add', 'binary.bin');
+  await git(repo, 'commit', '-m', 'concurrent binary commit');
+  const committedOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  const outcome = await advanceIndex(repo, observedIndex, observedIndex);
+  assert.deepEqual(outcome, { state: 'ready', moved: false });
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), committedOid);
+  assert.equal((await git(repo, 'status', '--porcelain')).trim(), '');
+});
+
+test('an index advance preserves unrelated work staged by another writer', async () => {
+  const { repo } = await makeRepo('index-writers');
+  const observedIndex = (await git(repo, 'write-tree')).trim();
+  const peerPatch = await patchFor(repo, { 'b.txt': 'peer\n' });
+  const peerTree = await require('../workspace/merge').treeOfPatch(repo, 'HEAD', peerPatch);
+
+  fs.writeFileSync(path.join(repo, 'a.txt'), 'local\n');
+  await git(repo, 'add', 'a.txt');
+  const outcome = await advanceIndex(repo, observedIndex, peerTree);
+
+  assert.deepEqual(outcome, { state: 'ready', moved: true });
+  const staged = await git(repo, 'diff', '--cached', '--name-only');
+  assert.deepEqual(staged.trim().split('\n').sort(), ['a.txt', 'b.txt']);
+});
+
 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/tests/workspace-wall.test.js

@@ -201,7 +201,7 @@ test('a collaborator binds the same repo to the owner project, not a parallel pr
   assert.equal(projectForRepo('repo-shared').path, localPath);
 });
 
-test('a repo project carries exactly one line per machine, replaced in place', async () => {
+test('a repo project appends immutable machine records', async () => {
   const repo = path.join(tempRoot, 'projects/app');
   fs.mkdirSync(repo, { recursive: true });
   await run(repo, 'init', '-b', 'main');
@@ -243,13 +243,16 @@ test('a repo project carries exactly one line per machine, replaced in place', a
     committedAt: '2026-07-23T00:00:00.000Z',
   });
   const sealed = publishWall(repoKey);
-  assert.equal(sealed.published, true);
+  assert.equal(sealed.published, false);
+  assert.equal(sealed.reason, 'shared-state-covered');
   const sealedCard = readWall(repoKey)[0].cards[0];
   assert.equal(sealedCard.positionMutationId, first.mutationId);
   assert.equal(sealedCard.positionVersion, 1);
+  const sealedLines = getDocText(project.file).trim().split('\n');
+  assert.equal(sealedLines.length, 1);
   assert.equal(
-    JSON.parse(getDocText(project.file).trim()).cards[0].positionVersion,
-    1,
+    JSON.parse(sealedLines.at(-1)).cards[0].positionVersion,
+    null,
   );
   assert.equal(publishedCardFor(refreshed.cards[0]).positionVersion, 1);
 
@@ -295,10 +298,11 @@ test('checkpoint transitions append until the next card and carry their official
     committedAt: '2026-07-23T00:00:02.000Z',
   });
   assert.equal(readWall(repoKey)[0].cards[0].checkpoints[0].version, 2);
-  assert.equal(publishWall(repoKey).published, true);
+  assert.equal(publishWall(repoKey).published, false);
+  const checkpointLines = getDocText(project.file).trim().split('\n');
   assert.equal(
-    JSON.parse(getDocText(project.file).trim()).cards[0].checkpoints[0].version,
-    2,
+    JSON.parse(checkpointLines.at(-1)).cards[0].checkpoints[0].version ?? null,
+    null,
   );
 
   fs.writeFileSync(file, `${JSON.stringify({
@@ -342,7 +346,8 @@ test('side branches keep one rail operation while the checked-out card advances'
   assert.equal(card.branches.find((entry) => entry.name === branch).mutationId, created.mutationId);
 });
 
-test('a peer machine line is preserved byte-for-byte through local publishes', async () => {
+test('peer records and earlier local history survive later publishes', async () => {
+  const beforeLines = getDocText(project.file).trim().split('\n');
   const peerLine = JSON.stringify({
     wall: 'code-project@3',
     project: repoKey,
@@ -361,11 +366,41 @@ test('a peer machine line is preserved byte-for-byte through local publishes', a
   assert.equal(result.published, true);
 
   const lines = getDocText(project.file).trim().split('\n');
-  assert.equal(lines.length, 2);
+  assert.equal(lines.length, beforeLines.length + 2);
+  for (const line of beforeLines) assert.ok(lines.includes(line));
   assert.ok(lines.includes(peerLine));
   assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
 });
 
+test('three concurrent append records stay whole under Yjs ordering', () => {
+  const Y = require('yjs');
+  const base = new Y.Doc();
+  base.getText('content').insert(0, '{"machine":"existing"}\n');
+  const baseUpdate = Y.encodeStateAsUpdate(base);
+  const updates = ['machine-a', 'machine-b', 'machine-c'].map((machine) => {
+    const writer = new Y.Doc();
+    Y.applyUpdate(writer, baseUpdate);
+    let update = null;
+    writer.on('update', (value) => {
+      update = value;
+    });
+    const text = writer.getText('content');
+    text.insert(text.length, `${JSON.stringify({ machine })}\n`);
+    return update;
+  });
+  const replicas = [updates, [...updates].reverse()].map((order) => {
+    const replica = new Y.Doc();
+    Y.applyUpdate(replica, baseUpdate);
+    for (const update of order) Y.applyUpdate(replica, update);
+    return replica.getText('content').toString();
+  });
+  assert.equal(replicas[0], replicas[1]);
+  assert.deepEqual(
+    replicas[0].trim().split('\n').map((line) => JSON.parse(line).machine).sort(),
+    ['existing', 'machine-a', 'machine-b', 'machine-c'],
+  );
+});
+
 test('a torn line is ignored by readers, never fatal', () => {
   writeDocText(
     project.file,

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

@@ -510,7 +510,8 @@ async function materializeRepo(localCardInput, plan) {
   const applied = await merge.advance(localCard.path, heldWorktree, reduced.worktreeTree, {
     label: `checkpoint-${reduced.checkpointRevision || 'clean'}`,
   });
-  await transition.setIndexTree(localCard.path, reducedLocalIndex.tree);
+  const indexResult = await advanceIndex(localCard.path, currentIndex, reducedLocalIndex.tree);
+  if (indexResult.state !== 'ready') return indexResult;
   const state = writeRepoState(plan.repoKey, {
     path: localCard.path,
     replica: localCard.replica,
@@ -550,6 +551,20 @@ async function materializeRepo(localCardInput, plan) {
   };
 }
 
+async function advanceIndex(worktreeRoot, observedTree, targetTree) {
+  if (observedTree === targetTree) return { state: 'ready', moved: false };
+  const patch = await merge.diffOfTree(worktreeRoot, observedTree, targetTree);
+  try {
+    await transition.applyIndexPatch(worktreeRoot, patch);
+    return { state: 'ready', moved: true };
+  } catch (error) {
+    if (error instanceof transition.TransitionError) {
+      return { state: 'waiting', reason: 'local-index-moving', moved: false };
+    }
+    throw error;
+  }
+}
+
 function localCardMayMaterialize(publishedCard, publication) {
   return Boolean(publishedCard) || publication?.reason === 'shared-state-covered';
 }
@@ -700,6 +715,7 @@ function reducerStats() {
 }
 
 module.exports = {
+  advanceIndex,
   captureIsOnRail,
   hydrateRepo,
   localCardMayMaterialize,

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

@@ -294,6 +294,27 @@ function applyPatch(worktreeRoot, patchFile, { reverse = false } = {}) {
   ], { timeoutMs: 60_000 });
 }
 
+/**
+ * Apply only the index change the reducer computed. Git locks the index and
+ * verifies the patch's preimage, so a concurrent commit is serialized instead
+ * of being replaced by an old whole-index snapshot.
+ */
+async function applyIndexPatch(worktreeRoot, patch) {
+  if (!patch) return;
+  const stateDir = path.join(AMALGM_DIR, 'state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  const dir = fs.mkdtempSync(path.join(stateDir, 'index-patch-'));
+  const patchFile = path.join(dir, 'patch');
+  try {
+    fs.writeFileSync(patchFile, patch);
+    await run('apply-index-patch', worktreeRoot, [
+      '-C', worktreeRoot, 'apply', '--cached', '--whitespace=nowarn', patchFile,
+    ]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
 /** Set only Git's index; working files are left exactly as they are. */
 function setIndexTree(worktreeRoot, treeOid) {
   return run('set-index-tree', worktreeRoot, [
@@ -345,6 +366,7 @@ function applyMergedFiles(worktreeRoot, writes, label) {
 
 module.exports = {
   TransitionError,
+  applyIndexPatch,
   applyMergedFiles,
   applyPatch,
   checkoutInitialCard,

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

@@ -287,21 +287,6 @@ function sealedVersion(resourceId, mutationId, ...versions) {
     || null;
 }
 
-function entryNeedsSeal(entry, resourceId) {
-  return Boolean(entry?.cards?.some((card) => (
-    (!validVersion(card.positionVersion)
-      && validVersion(officialVersion(resourceId, card.positionMutationId)))
-    || (card.branches || []).some((ref) => (
-      !validVersion(ref.version)
-      && validVersion(officialVersion(resourceId, ref.mutationId))
-    ))
-    || (card.checkpoints || []).some((checkpoint) => (
-      !validVersion(checkpoint.version)
-      && validVersion(officialVersion(resourceId, checkpoint.mutationId))
-    ))
-  )));
-}
-
 function stampBranches(
   refs,
   previousBranches,
@@ -453,7 +438,7 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
 function withoutPublishedAt(line) {
   const entry = parseWallLine(line);
   if (!entry) return line;
-  const { publishedAt, ...rest } = entry;
+  const { publishedAt, mutationId, ...rest } = entry;
   return JSON.stringify(rest);
 }
 
@@ -465,27 +450,14 @@ function publishProject(project, rawCards) {
   }
   const docs = require('../state/docs');
   const current = docs.getDocText(project.file);
-  const lines = [];
   let previous = null;
   let previousEntry = null;
-  let slot = -1;
-  let dropped = 0;
   for (const line of current.split('\n')) {
     if (!line) continue;
     const entry = parseWallLine(line);
-    if (!entry || entry.project !== project.repoKey) {
-      dropped += 1;
-    } else if (entry.machine === machineId()) {
-      if (previous === null) {
-        previous = line;
-        previousEntry = entry;
-        slot = lines.length;
-        lines.push('');
-      } else {
-        dropped += 1;
-      }
-    } else {
-      lines.push(line);
+    if (entry?.project === project.repoKey && entry.machine === machineId()) {
+      previous = line;
+      previousEntry = entry;
     }
   }
 
@@ -500,7 +472,7 @@ function publishProject(project, rawCards) {
     return hasLocalContribution(card, sharedPlan, baseline, checkpoint)
       || hasObjectUpgrade(card, sharedPlan);
   });
-  if (!removed && !contributes && !entryNeedsSeal(previousEntry, project.resourceId)) {
+  if (!removed && !contributes) {
     service.counters.publishSkips += 1;
     return { published: false, reason: 'shared-state-covered', repoKey: project.repoKey };
   }
@@ -517,22 +489,21 @@ function publishProject(project, rawCards) {
     wall: WALL_CONTRACT,
     project: project.repoKey,
     machine: machineId(),
+    mutationId,
     publishedAt: new Date().toISOString(),
     cards,
   });
-  if (slot < 0) lines.push(mine);
-  else lines[slot] = mine;
-  const unchanged = dropped === 0
-    && previous !== null
+  const unchanged = previous !== null
     && withoutPublishedAt(previous) === withoutPublishedAt(mine);
   if (unchanged) {
     service.counters.publishSkips += 1;
     return { published: false, reason: 'unchanged', repoKey: project.repoKey };
   }
 
+  const separator = current && !current.endsWith('\n') ? '\n' : '';
   const result = docs.writeDocText(
     project.file,
-    `${lines.join('\n')}\n`,
+    `${current}${separator}${mine}\n`,
     { baseHash: sha256(current), mutationId },
   );
   service.counters.publishes += 1;
@@ -544,7 +515,6 @@ function publishProject(project, rawCards) {
     mutationId: result.mutationId,
     merge: result.merge,
     cards: cards.length,
-    dropped,
   };
 }