amalgm 0.1.217 → 0.1.218

package/package.json

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

@@ -180,7 +180,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-v7/);
+  assert.match(first, /repo-checkpoints-v8/);
 });
 
 test('a materialized peer card is immediately a valid checkpoint base', () => {

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

@@ -258,7 +258,7 @@ test('two concurrent compacting publishers converge without losing either latest
   const Y = require('yjs');
   const repoKey = 'root:compaction-collision';
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_${machine}_${value}`,

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

@@ -152,6 +152,56 @@ test('wall reduction chooses one rail winner and orders checkpoint transitions b
   ]);
 });
 
+test('a checkpoint base replaces covered history and keeps only newer mutations', async () => {
+  const { repo, oid } = await makeRepo('checkpoint-base');
+  const patchA = await patchFor(repo, { 'a.txt': 'a1\n' });
+  const patchAB = await patchFor(repo, { 'a.txt': 'a1\n', 'b.txt': 'b1\n' });
+  const current = card(repo, oid, 1);
+  current.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, patchA),
+  };
+  current.checkpoints = [
+    transition('machine-a', 2, oid, '', patchA),
+    transition('machine-a', 5, oid, patchA, patchAB),
+  ];
+  const plan = reduceWall([{ machine: 'machine-a', cards: [current] }]).get('root:test');
+  assert.equal(plan.checkpointBase.through, 4);
+  assert.deepEqual(plan.transitions.map((entry) => entry.version), [5]);
+  const reduced = await reduceCheckpoint(current, plan);
+  assert.equal(reduced.state, 'ready');
+  assert.equal(reduced.checkpointRevision, revisionOf(oid, patchAB, ''));
+});
+
+test('different snapshots claiming the same rail position stop instead of choosing a winner', () => {
+  const oid = 'a'.repeat(40);
+  const first = card('/first', oid, 1);
+  first.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'patch-a'),
+  };
+  const second = card('/second', oid, 1);
+  second.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'patch-b'),
+  };
+  const plan = reduceWall([
+    { machine: 'machine-a', cards: [first] },
+    { machine: 'machine-b', cards: [second] },
+  ]).get('root:test');
+  assert.equal(plan.checkpointBase, null);
+  assert.equal(plan.checkpointBaseConflict, true);
+});
+
 test('a ready parked bundle never regresses to pending', () => {
   const oid = 'c'.repeat(40);
   const ready = card('/ready', 'a'.repeat(40), 1);

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

@@ -35,6 +35,7 @@ const { upsertWorkspace } = require('../workspace/store');
 const { refreshRepoCards } = require('../workspace/cards');
 const { checkpointFile, repoKeyOfCard } = require('../workspace/checkpoint');
 const {
+  _test: wallTest,
   bindProject,
   compactWallText,
   hasLocalContribution,
@@ -148,7 +149,7 @@ test('only a value different from both the materialized baseline and the rail is
   };
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline), false);
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline, {
-    checkpoint: 'repo-checkpoint@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -218,7 +219,7 @@ test('only a value different from both the materialized baseline and the rail is
     },
   ), true);
   assert.equal(hasLocalContribution(local, plan, baseline, {
-    checkpoint: 'repo-checkpoint@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -328,7 +329,7 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(first.published, true);
   const entries = readWall(repoKey);
   assert.equal(entries.length, 1);
-  assert.equal(entries[0].wall, 'code-project@3');
+  assert.equal(entries[0].wall, 'code-project@4');
   assert.equal(entries[0].project, repoKey);
   assert.equal(entries[0].machine, 'machine-a');
   assert.equal(entries[0].cards.length, 1);
@@ -384,12 +385,12 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(getDocText(project.file).trim().split('\n').length, 1);
 });
 
-test('checkpoint transitions append until the next card and carry their official rail numbers', async () => {
+test('a checkpoint base replaces history already covered by the applied rail', async () => {
   const card = readWall(repoKey)[0].cards[0];
   const file = checkpointFile('machine-a', repoKey);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const firstCheckpoint = {
-    checkpoint: 'repo-checkpoint@7',
+    checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
     repoKey,
     branch: card.head.branch,
@@ -413,6 +414,20 @@ test('checkpoint transitions append until the next card and carry their official
     JSON.parse(checkpointLines.at(-1)).cards[0].checkpoints[0].version ?? null,
     null,
   );
+  const reducerFile = path.join(
+    process.env.AMALGM_DIR,
+    'state',
+    'repo-reducer',
+    `${crypto.createHash('sha256').update(repoKey).digest('hex').slice(0, 24)}.json`,
+  );
+  fs.writeFileSync(reducerFile, `${JSON.stringify({
+    repoKey,
+    baseOid: card.head.oid,
+    branch: card.head.branch,
+    appliedThrough: 2,
+    indexDiff: '',
+    worktreeDiff: 'patch-a',
+  })}\n`);
 
   fs.writeFileSync(file, `${JSON.stringify({
     ...firstCheckpoint,
@@ -422,12 +437,26 @@ test('checkpoint transitions append until the next card and carry their official
   })}\n`);
   const second = publishWall(repoKey);
   assert.equal(second.published, true);
-  const history = readWall(repoKey)[0].cards[0].checkpoints;
-  assert.equal(history.length, 2);
-  assert.deepEqual(history.map((entry) => entry.mutationId), [first.mutationId, second.mutationId]);
+  const latestCard = readWall(repoKey)[0].cards[0];
+  assert.equal(latestCard.checkpointBase.through, 2);
+  assert.equal(latestCard.checkpoints.length, 1);
+  assert.deepEqual(latestCard.checkpoints.map((entry) => entry.mutationId), [second.mutationId]);
   assert.deepEqual(settleProject(), [3]);
 });
 
+test('one failed project publisher cannot block the next repo', () => {
+  const selected = [{ repoKey: 'root:first' }, { repoKey: 'root:second' }];
+  const calls = [];
+  const results = wallTest.publishSelected(selected, [], (selectedProject) => {
+    calls.push(selectedProject.repoKey);
+    if (selectedProject.repoKey === 'root:first') throw new Error('too large');
+    return { published: true, repoKey: selectedProject.repoKey };
+  });
+  assert.deepEqual(calls, ['root:first', 'root:second']);
+  assert.equal(results[0].reason, 'publish-failed');
+  assert.equal(results[1].published, true);
+});
+
 test('side branches keep one rail operation while the checked-out card advances', async () => {
   const repo = path.join(tempRoot, 'projects/app');
   const before = readWall(repoKey)[0].cards[0];
@@ -475,7 +504,7 @@ test('side branches keep one rail operation while the checked-out card advances'
 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',
+    wall: 'code-project@4',
     project: repoKey,
     machine: 'machine-b',
     mutationId: 'mut_project_peer',
@@ -532,7 +561,7 @@ test('three concurrent append records stay whole under Yjs ordering', () => {
 
 test('wall compaction deletes only records superseded for every machine', () => {
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -541,7 +570,7 @@ test('wall compaction deletes only records superseded for every machine', () =>
   const oldA = line('machine-a', 'old-a');
   const oldB = line('machine-b', 'old-b');
   const latestA = line('machine-a', 'latest-a');
-  const torn = '{"wall":"code-project@3","machine":"torn"';
+  const torn = '{"wall":"code-project@4","machine":"torn"';
   const latestB = line('machine-b', 'latest-b');
   const current = `${oldA}\n${oldB}\n${latestA}\n${torn}\n${latestB}\n`;
   const compacted = compactWallText(current, repoKey);
@@ -553,13 +582,13 @@ test('wall compaction deletes only records superseded for every machine', () =>
 
 test('an unordered legacy record cannot pin wall compaction', () => {
   const unordered = JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine: '16.612Z',
     cards: [{ value: 'corrupted-legacy-record' }],
   });
   const ordered = (machine) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}`,
@@ -576,7 +605,7 @@ test('an unordered legacy record cannot pin wall compaction', () => {
 
 test('retired machine values stay represented without pinning obsolete active history', () => {
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -601,7 +630,7 @@ test('retired machine values stay represented without pinning obsolete active hi
 test('a concurrent deletion-only compaction and append commute in Yjs', () => {
   const Y = require('yjs');
   const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@3',
+    wall: 'code-project@4',
     project: repoKey,
     machine,
     mutationId: `mut_project_${machine}_${value}`,
@@ -654,7 +683,7 @@ test('a concurrent deletion-only compaction and append commute in Yjs', () => {
 test('a torn line is ignored by readers, never fatal', () => {
   writeDocText(
     project.file,
-    `${getDocText(project.file)}{"wall":"code-project@3","project":"${repoKey}","machine":"machine-c","car\n`,
+    `${getDocText(project.file)}{"wall":"code-project@4","project":"${repoKey}","machine":"machine-c","car\n`,
   );
   settleProject();
   assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
@@ -682,7 +711,7 @@ test('publishing compacts an oversized history before appending the new record',
 test('project stats name every project resource, binding, and publish counter', () => {
   const stats = wallStats();
   const row = stats.projects.find((entry) => entry.repoKey === repoKey);
-  assert.equal(stats.contract, 'code-project@3');
+  assert.equal(stats.contract, 'code-project@4');
   assert.equal(row.resourceId, project.resourceId);
   assert.equal(row.replica.appliedVersion >= 0, true);
   assert.equal(row.machines, 2);

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@7';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@8';
 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-v7', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v8', `${digest}.json`);
 }
 
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {
@@ -416,6 +416,7 @@ module.exports = {
   MAX_INLINE_DIFF_BYTES,
   checkpointFile,
   checkpointStats,
+  checkpointValue,
   checkpointValueReady,
   parseCheckpoint,
   publishCheckpoints,

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

@@ -29,6 +29,7 @@ const {
 } = require('./git');
 const {
   CHECKPOINT_CONTRACT,
+  checkpointValueReady,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
@@ -108,7 +109,14 @@ function reduceWall(entries) {
       ) continue;
       let repo = repos.get(repoKey);
       if (!repo) {
-        repo = { repoKey, card: null, transitions: [], parked: [], branchMap: new Map() };
+        repo = {
+          repoKey,
+          card: null,
+          checkpointBases: [],
+          transitions: [],
+          parked: [],
+          branchMap: new Map(),
+        };
         repos.set(repoKey, repo);
       }
       if (!repo.card || card.positionVersion > repo.card.positionVersion) {
@@ -128,13 +136,39 @@ function reduceWall(entries) {
           repo.transitions.push(checkpoint);
         }
       }
+      const checkpointBase = card.checkpointBase;
+      if (
+        checkpointBase?.checkpoint === CHECKPOINT_CONTRACT
+        && Number.isInteger(checkpointBase.through)
+        && checkpointBase.through >= 0
+        && checkpointBase.baseOid === card.head?.oid
+        && checkpointBase.branch === card.head?.branch
+      ) {
+        repo.checkpointBases.push(checkpointBase);
+      }
     }
   }
   for (const repo of repos.values()) {
+    const matchingBases = repo.checkpointBases
+      .filter((entry) => (
+        entry.baseOid === repo.card.head?.oid
+        && entry.branch === repo.card.head?.branch
+      ))
+      .sort((left, right) => right.through - left.through);
+    const newestThrough = matchingBases[0]?.through ?? null;
+    const newestBases = matchingBases
+      .filter((entry) => entry.through === newestThrough)
+      .sort((left, right) => (
+        Number(checkpointValueReady(right.value)) - Number(checkpointValueReady(left.value))
+      ));
+    const baseRevisions = new Set(newestBases.map((entry) => entry.value?.revision ?? null));
+    repo.checkpointBaseConflict = baseRevisions.size > 1;
+    repo.checkpointBase = repo.checkpointBaseConflict ? null : newestBases[0] || null;
     repo.transitions = repo.transitions
       .filter((entry) => (
         entry.baseOid === repo.card.head?.oid
         && entry.branch === repo.card.head?.branch
+        && (!repo.checkpointBase || entry.version > repo.checkpointBase.through)
       ))
       .sort((left, right) => left.version - right.version);
     repo.parked = uniqueParked(repo.transitions.flatMap((checkpoint) => (
@@ -157,6 +191,7 @@ function reduceWall(entries) {
     }
     repo.branches = [...repo.branchMap.values()].sort((left, right) => left.name.localeCompare(right.name));
     delete repo.branchMap;
+    delete repo.checkpointBases;
   }
   return repos;
 }
@@ -433,6 +468,21 @@ async function reduceCheckpoint(localCard, plan) {
   let indexTree = baseTree;
   let worktreeTree = baseTree;
   const conflicts = [];
+  if (plan.checkpointBaseConflict) {
+    return { state: 'waiting', reason: 'checkpoint-base-disagrees' };
+  }
+  if (plan.checkpointBase) {
+    const snapshot = readCheckpointValue(baseOid, plan.checkpointBase.value);
+    if (snapshot.state !== 'ready') {
+      return { state: 'waiting', reason: `checkpoint-base-${snapshot.state}` };
+    }
+    indexTree = await merge.treeOfPatch(localCard.path, baseOid, snapshot.indexDiff);
+    worktreeTree = await merge.treeOfPatch(
+      localCard.path,
+      indexTree,
+      snapshot.worktreeDiff,
+    );
+  }
 
   for (const entry of plan.parked || []) {
     const commonOid = await mergeBase(localCard.path, baseOid, entry.oid);

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

@@ -17,9 +17,15 @@ const { AMALGM_DIR } = require('../config');
 const { subscribeStateEvents } = require('../state/events');
 const { machineId, userId } = require('./identity');
 const { listRepoCards } = require('./cards');
-const { readCheckpoint, repoKeyOfCard, sameTransition } = require('./checkpoint');
-
-const WALL_CONTRACT = 'code-project@3';
+const {
+  CHECKPOINT_CONTRACT,
+  checkpointValue,
+  readCheckpoint,
+  repoKeyOfCard,
+  sameTransition,
+} = require('./checkpoint');
+
+const WALL_CONTRACT = 'code-project@4';
 const PROJECT_DIR = path.join(AMALGM_DIR, 'state', 'code-projects');
 const REGISTRY_FILE = path.join(PROJECT_DIR, 'projects.json');
 const PUBLISH_QUIET_MS = 25;
@@ -309,6 +315,46 @@ function hasObjectUpgrade(card, plan) {
   });
 }
 
+function checkpointBaseFor(card, baseline, project, shared = null) {
+  if (
+    !baseline
+    || baseline.baseOid !== card.head?.oid
+    || baseline.branch !== card.head?.branch
+    || !Number.isInteger(baseline.appliedThrough)
+    || baseline.appliedThrough < 0
+  ) return null;
+  const value = checkpointValue(
+    machineId(),
+    project.repoKey,
+    card.head.oid,
+    baseline.indexDiff || '',
+    baseline.worktreeDiff || '',
+  );
+  const reusableThrough = shared
+    && shared.baseOid === card.head.oid
+    && shared.branch === card.head.branch
+    && shared.value?.revision === value.revision
+    && Number.isInteger(shared.through)
+    && shared.through >= 0;
+  return {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: card.head.oid,
+    branch: card.head.branch,
+    through: reusableThrough ? shared.through : baseline.appliedThrough,
+    value,
+  };
+}
+
+function hasCheckpointBaseUpgrade(card, plan, baseline, project) {
+  const shared = plan?.card?.checkpointBase;
+  const candidate = checkpointBaseFor(card, baseline, project, shared);
+  return Boolean(shared && candidate) && (
+    candidate.through === shared.through
+    && candidate.value?.revision === shared.value?.revision
+    && JSON.stringify(candidate.value) !== JSON.stringify(shared.value)
+  );
+}
+
 function validVersion(value) {
   return Number.isInteger(value) && value > 0;
 }
@@ -443,6 +489,12 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
       && checkpoint.branch === card.head?.branch
       ? checkpoint
       : null;
+    const checkpointBase = checkpointBaseFor(
+      card,
+      baseline,
+      project,
+      sharedPlan?.card?.checkpointBase,
+    );
     const sameBase = previous?.head?.oid === card.head?.oid
       && previous?.head?.branch === card.head?.branch;
     const history = sameBase && Array.isArray(previous?.checkpoints)
@@ -453,7 +505,10 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
           entry.mutationId,
           entry.version,
         ),
-      }))
+      })).filter((entry) => (
+        validVersion(entry.version)
+        && (!checkpointBase || entry.version > checkpointBase.through)
+      ))
       : [];
     const last = history.at(-1);
     const checkpoints = currentCheckpoint
@@ -473,6 +528,7 @@ function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, proj
         mutationId,
         project.resourceId,
       ),
+      ...(checkpointBase ? { checkpointBase } : {}),
       ...(checkpoints.length ? { checkpoints } : {}),
     };
   });
@@ -549,7 +605,8 @@ function publishProject(project, rawCards) {
     const checkpoint = readCheckpoint(machineId(), project.repoKey);
     const previousCard = previousCards.find((entry) => entry.replica === card.replica);
     return hasLocalContribution(card, sharedPlan, baseline, checkpoint, previousCard)
-      || hasObjectUpgrade(card, sharedPlan);
+      || hasObjectUpgrade(card, sharedPlan)
+      || hasCheckpointBaseUpgrade(card, sharedPlan, baseline, project);
   });
   if (!removed && !contributes) {
     service.counters.publishSkips += 1;
@@ -618,16 +675,33 @@ function publishProject(project, rawCards) {
   };
 }
 
+function publishSelected(selected, allCards, publisher = publishProject) {
+  return selected.map((project) => {
+    try {
+      return publisher(
+        project,
+        allCards.filter((card) => (
+          repoKeyOfCard(card) === project.repoKey
+          && isCommittedCard(card)
+        )),
+      );
+    } catch (error) {
+      service.counters.publishFailures += 1;
+      console.warn(`[CodeProject] ${project.repoKey} publish failed:`, error.message);
+      return {
+        published: false,
+        reason: 'publish-failed',
+        repoKey: project.repoKey,
+        error: error.message,
+      };
+    }
+  });
+}
+
 function publishWall(repoKey = null) {
   const allCards = listRepoCards();
   const selected = repoKey ? [projectForRepo(repoKey)].filter(Boolean) : projects();
-  const results = selected.map((project) => publishProject(
-    project,
-    allCards.filter((card) => (
-      repoKeyOfCard(card) === project.repoKey
-      && isCommittedCard(card)
-    )),
-  ));
+  const results = publishSelected(selected, allCards);
   if (repoKey) return results[0] || { published: false, reason: 'project-missing', repoKey };
   return {
     published: results.some((result) => result.published),
@@ -788,6 +862,7 @@ function wallStats() {
 }
 
 module.exports = {
+  _test: { publishSelected },
   WALL_CONTRACT,
   bindProject,
   compactWallText,