amalgm 0.1.205 → 0.1.207

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.205",
+  "version": "0.1.207",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/state/docs.js

@@ -120,9 +120,11 @@ function hashText(text) {
 function isInternalStateDoc(filePath) {
   const resolved = path.resolve(filePath);
   const parent = path.dirname(resolved);
+  const collection = path.basename(parent);
+  const isStateCollection = path.basename(path.dirname(parent)) === 'state';
   return (
-    path.basename(parent) === 'repo-checkpoints'
-    && path.basename(path.dirname(parent)) === 'state'
+    isStateCollection
+    && (collection === 'repo-checkpoints' || collection === 'code-projects')
   ) || /^machine-cards-v\d+\.jsonl$/.test(path.basename(resolved));
 }
 
@@ -221,7 +223,7 @@ function resolveDocPath(pathInput) {
   }
   const stats = fs.statSync(resolved);
   if (!stats.isFile()) throw invalid('path is not a file');
-  if (stats.size > MAX_DOC_BYTES) {
+  if (stats.size > MAX_DOC_BYTES && !isInternalStateDoc(resolved)) {
     throw invalid(`file exceeds the ${MAX_DOC_BYTES}-byte live document limit`, 413);
   }
   return resolved;

package/runtime/scripts/amalgm-mcp/tests/state-docs.test.js

@@ -135,19 +135,29 @@ test('external disk edits reconcile into the live doc via the watcher', async ()
 });
 
 test('internal protocol documents never treat their own disk flush as another writer', async () => {
-  const stateDir = path.join(process.env.AMALGM_DIR, 'state', 'repo-checkpoints');
-  fs.mkdirSync(stateDir, { recursive: true });
-  const target = path.join(stateDir, 'protocol.json');
+  const checkpointDir = path.join(process.env.AMALGM_DIR, 'state', 'repo-checkpoints');
+  const projectDir = path.join(process.env.AMALGM_DIR, 'state', 'code-projects');
+  fs.mkdirSync(checkpointDir, { recursive: true });
+  fs.mkdirSync(projectDir, { recursive: true });
+  const target = path.join(checkpointDir, 'protocol.json');
+  const project = path.join(projectDir, 'project.jsonl');
   fs.writeFileSync(target, '{"value":1}\n', 'utf8');
+  fs.writeFileSync(project, '{"value":1}\n', 'utf8');
   const opened = docs.openDoc(target);
+  const openedProject = docs.openDoc(project);
   const before = currentSeq();
 
   assert.equal(docs._private.isInternalStateDoc(target), true);
+  assert.equal(docs._private.isInternalStateDoc(project), true);
   fs.writeFileSync(target, '{"value":2}\n', 'utf8');
+  fs.writeFileSync(project, '{"value":2}\n', 'utf8');
   await sleep(700);
 
   assert.equal(docs.getDocText(target), '{"value":1}\n');
-  const events = listEventsAfter(before).filter((event) => event.resource === opened.resource);
+  assert.equal(docs.getDocText(project), '{"value":1}\n');
+  const events = listEventsAfter(before).filter((event) => (
+    event.resource === opened.resource || event.resource === openedProject.resource
+  ));
   assert.equal(events.length, 0);
 });
 
@@ -203,6 +213,11 @@ test('guards: binary, missing, oversized, and malformed inputs are rejected', ()
 
   const big = writeDoc('big.md', 'x'.repeat(2 * 1024 * 1024 + 1));
   assert.throws(() => docs.openDoc(big), /live document limit/);
+  const projectDir = path.join(process.env.AMALGM_DIR, 'state', 'code-projects');
+  fs.mkdirSync(projectDir, { recursive: true });
+  const largeProtocol = path.join(projectDir, 'large-project.jsonl');
+  fs.writeFileSync(largeProtocol, 'x'.repeat(2 * 1024 * 1024 + 1));
+  assert.doesNotThrow(() => docs.openDoc(largeProtocol));
 
   const target = writeDoc('guarded.md', 'ok\n');
   assert.throws(() => docs.applyDocUpdates(target, [123]), /base64-encoded/);

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

@@ -364,6 +364,18 @@ test('side branches keep one rail operation while the checked-out card advances'
   card = readWall(repoKey)[0].cards[0];
   assert.equal(card.positionMutationId, advanced.mutationId);
   assert.equal(card.branches.find((entry) => entry.name === branch).mutationId, created.mutationId);
+
+  acknowledgeCloudMutation(project.resourceId, advanced.mutationId, {
+    version: 4,
+    committedAt: '2026-07-23T00:00:05.000Z',
+  });
+  await run(repo, 'branch', '-D', branch);
+  await refreshRepoCards();
+  const deleted = publishWall(repoKey);
+  assert.equal(deleted.published, true);
+  card = readWall(repoKey)[0].cards[0];
+  assert.equal(card.branches.find((entry) => entry.name === branch).oid, null);
+  assert.equal(card.branches.find((entry) => entry.name === branch).mutationId, deleted.mutationId);
 });
 
 test('peer records and earlier local history survive later publishes', async () => {
@@ -466,6 +478,30 @@ 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',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  const retiredA = line('retired-a', 'latest-retired-a');
+  const retiredB = line('retired-b', 'latest-retired-b');
+  const oldA = line('machine-a', 'old-a');
+  const oldB = line('machine-b', 'old-b');
+  const latestA = line('machine-a', 'latest-a');
+  const latestB = line('machine-b', 'latest-b');
+
+  assert.equal(
+    compactWallText(
+      `${retiredA}\n${retiredB}\n${oldA}\n${oldB}\n${latestA}\n${latestB}\n`,
+      repoKey,
+    ),
+    `${retiredA}\n${retiredB}\n${latestA}\n${latestB}\n`,
+  );
+});
+
 test('a concurrent deletion-only compaction and append commute in Yjs', () => {
   const Y = require('yjs');
   const line = (machine, value) => JSON.stringify({

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

@@ -225,7 +225,7 @@ function oidMap(refs) {
  * materialized. A local value equal to either that baseline or the current
  * rail is not new work. Anything else is a local contribution.
  */
-function hasLocalContribution(card, plan, baseline, checkpoint = null) {
+function hasLocalContribution(card, plan, baseline, checkpoint = null, previousCard = null) {
   if (!plan?.card) return true;
   const onRail = samePosition(card, plan.card);
   const atBaseline = baseline
@@ -236,11 +236,21 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null) {
   const currentRefs = oidMap(card.refs);
   const railRefs = oidMap(plan.branches);
   const baselineRefs = oidMap(baseline?.branches);
-  for (const name of new Set([...currentRefs.keys(), ...baselineRefs.keys()])) {
+  const previousRefs = oidMap(previousCard?.branches || previousCard?.refs);
+  for (const name of new Set([
+    ...currentRefs.keys(),
+    ...baselineRefs.keys(),
+    ...previousRefs.keys(),
+  ])) {
     const current = currentRefs.get(name) ?? null;
     const shared = railRefs.get(name) ?? null;
     const previous = baselineRefs.get(name) ?? null;
-    if (current !== shared && (!baselineRefs.has(name) || current !== previous)) return true;
+    const changedFromPublished = previousRefs.has(name)
+      && current !== (previousRefs.get(name) ?? null);
+    if (
+      current !== shared
+      && (!baselineRefs.has(name) || current !== previous || changedFromPublished)
+    ) return true;
   }
 
   if (
@@ -446,12 +456,10 @@ function withoutPublishedAt(line) {
 }
 
 /**
- * Keep the newest complete record for every machine, plus anything after
- * the earliest of those records. Everything before that point is obsolete:
- * every machine represented there has a newer complete value later.
- *
- * Compaction is deletion-only. Concurrent deletions and appends commute in
- * Yjs, so this bounds the wall without bringing back whole-document races.
+ * Keep every machine's newest complete record and delete the largest span
+ * containing none of them. Repeating this as the wall grows removes all
+ * obsolete history, even when a retired machine's last record is near the
+ * beginning. Each pass is one deletion, so concurrent appends commute in Yjs.
  */
 function compactWallText(current, repoKey) {
   const latest = new Map();
@@ -460,12 +468,21 @@ function compactWallText(current, repoKey) {
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index];
     const entry = line ? parseWallLine(line) : null;
-    if (entry?.project === repoKey) latest.set(entry.machine, offset);
-    offset += line.length + (index < lines.length - 1 ? 1 : 0);
+    const end = offset + line.length + (index < lines.length - 1 ? 1 : 0);
+    if (entry?.project === repoKey) latest.set(entry.machine, { start: offset, end });
+    offset = end;
   }
   if (latest.size === 0) return current;
-  const cutoff = Math.min(...latest.values());
-  return cutoff > 0 ? current.slice(cutoff) : current;
+  const records = [...latest.values()].sort((left, right) => left.start - right.start);
+  const gaps = [{ start: 0, end: records[0].start }];
+  for (let index = 0; index < records.length - 1; index += 1) {
+    gaps.push({ start: records[index].end, end: records[index + 1].start });
+  }
+  const gap = gaps.reduce((largest, candidate) => (
+    candidate.end - candidate.start > largest.end - largest.start ? candidate : largest
+  ));
+  if (gap.end <= gap.start) return current;
+  return `${current.slice(0, gap.start)}${current.slice(gap.end)}`;
 }
 
 function publishProject(project, rawCards) {
@@ -499,7 +516,8 @@ function publishProject(project, rawCards) {
   const removed = [...previousReplicas].some((replica) => !currentReplicas.has(replica));
   const contributes = rawCards.some((card) => {
     const checkpoint = readCheckpoint(machineId(), project.repoKey);
-    return hasLocalContribution(card, sharedPlan, baseline, checkpoint)
+    const previousCard = previousEntry?.cards?.find((entry) => entry.replica === card.replica);
+    return hasLocalContribution(card, sharedPlan, baseline, checkpoint, previousCard)
       || hasObjectUpgrade(card, sharedPlan);
   });
   if (!removed && !contributes) {