amalgm 0.1.221 → 0.1.234

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

@@ -28,16 +28,16 @@ const { appendStateEvent } = require('../state/events');
 const {
   acknowledgeCloudMutation,
   listPendingCloudMutations,
+  pruneMutationJournal,
 } = require('../state/mutations');
 const { registerReplica } = require('../state/replicas');
-const { openDoc, getDocText, writeDocText } = require('../state/docs');
 const { upsertWorkspace } = require('../workspace/store');
 const { refreshRepoCards } = require('../workspace/cards');
 const { checkpointFile, repoKeyOfCard } = require('../workspace/checkpoint');
+const projectStream = require('../workspace/project-stream');
 const {
   _test: wallTest,
   bindProject,
-  compactWallText,
   hasLocalContribution,
   isCommittedCard,
   projectForRepo,
@@ -105,6 +105,24 @@ test('no commit means no shared card', () => {
   assert.equal(isCommittedCard({ head: { branch: 'main', oid: 'a'.repeat(40) } }), true);
 });
 
+test('transport metadata alone does not make a new code record', () => {
+  const base = {
+    wall: 'code-project@6',
+    project: 'root:ordered',
+    machine: 'machine-a',
+    mutationId: 'mut_older_transport',
+    version: 10,
+    publishedAt: '2026-07-26T00:00:00.000Z',
+    cards: [{ marker: 'same-content' }],
+  };
+  assert.equal(wallTest.samePublishedRecord(base, {
+    ...base,
+    mutationId: 'mut_newer_transport',
+    version: 11,
+    publishedAt: '2026-07-26T00:01:00.000Z',
+  }), true);
+});
+
 test('only a value different from both the materialized baseline and the rail is new work', () => {
   const oidA = 'a'.repeat(40);
   const oidB = 'b'.repeat(40);
@@ -158,7 +176,7 @@ test('only a value different from both the materialized baseline and the rail is
     pendingCard: true,
   }), true);
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline, {
-    checkpoint: 'repo-checkpoint@8',
+    checkpoint: 'repo-checkpoint@9',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -228,7 +246,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@8',
+    checkpoint: 'repo-checkpoint@9',
     machine: 'machine-a',
     branch: 'main',
     baseOid: oidA,
@@ -322,14 +340,12 @@ test('a repo project appends immutable machine records', async () => {
   repoKey = repoKeyOfCard(refreshed.cards[0]);
   project = projectForRepo(repoKey);
 
-  fs.mkdirSync(path.dirname(project.file), { recursive: true });
-  fs.writeFileSync(project.file, '');
-  const opened = openDoc(project.file);
+  projectStream.writeSnapshot(project.file, projectStream._test.emptySnapshot(repoKey));
   registerReplica({
     resourceId: project.resourceId,
-    localResource: opened.resource,
+    localResource: `${projectStream.LOCAL_RESOURCE_PREFIX}${project.resourceId}`,
     localPath: project.file,
-    contract: 'text-yjs@1',
+    contract: projectStream.STREAM_CONTRACT,
     schemaVersion: 1,
     authorityEpoch: 1,
   });
@@ -338,7 +354,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@4');
+  assert.equal(entries[0].wall, 'code-project@6');
   assert.equal(entries[0].project, repoKey);
   assert.equal(entries[0].machine, 'machine-a');
   assert.equal(entries[0].cards.length, 1);
@@ -361,12 +377,10 @@ test('a repo project appends immutable machine records', async () => {
   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(sealedLines.at(-1)).cards[0].positionVersion,
-    null,
-  );
+  const sealedSnapshot = projectStream.readSnapshot(project.file, repoKey);
+  assert.equal(sealedSnapshot.records.length, 1);
+  assert.equal(sealedSnapshot.records[0].version, 1);
+  assert.equal(sealedSnapshot.records[0].cards[0].positionVersion ?? null, null);
   assert.equal(publishedCardFor(refreshed.cards[0]).positionVersion, 1);
   const readyObjects = {
     ...refreshed.cards[0],
@@ -376,7 +390,11 @@ test('a repo project appends immutable machine records', async () => {
       objects: { kind: 'bundle' },
     })),
   };
-  assert.equal(publishedCardFor(readyObjects), null);
+  assert.equal(
+    publishedCardFor(readyObjects).positionVersion,
+    1,
+    'transport readiness does not turn an accepted card into new Git work',
+  );
 
   const again = publishWall(repoKey);
   assert.equal(again.published, false);
@@ -391,7 +409,7 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(Object.hasOwn(after[0].cards[0], 'dirty'), false);
   assert.equal(after[0].cards[0].positionMutationId, first.mutationId);
   assert.equal(after[0].cards[0].positionVersion, 1);
-  assert.equal(getDocText(project.file).trim().split('\n').length, 1);
+  assert.equal(projectStream.readSnapshot(project.file, repoKey).records.length, 1);
 });
 
 test('a checkpoint base replaces history already covered by the applied rail', async () => {
@@ -399,7 +417,7 @@ test('a checkpoint base replaces history already covered by the applied rail', a
   const file = checkpointFile('machine-a', repoKey);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const firstCheckpoint = {
-    checkpoint: 'repo-checkpoint@8',
+    checkpoint: 'repo-checkpoint@9',
     machine: 'machine-a',
     repoKey,
     branch: card.head.branch,
@@ -418,9 +436,10 @@ test('a checkpoint base replaces history already covered by the applied rail', a
   assert.deepEqual(settleProject(), [2]);
   assert.equal(readWall(repoKey)[0].cards[0].checkpoints[0].version, 2);
   assert.equal(publishWall(repoKey).published, false);
-  const checkpointLines = getDocText(project.file).trim().split('\n');
+  const checkpointSnapshot = projectStream.readSnapshot(project.file, repoKey);
+  assert.equal(checkpointSnapshot.records[0].version, 2);
   assert.equal(
-    JSON.parse(checkpointLines.at(-1)).cards[0].checkpoints[0].version ?? null,
+    checkpointSnapshot.records[0].cards[0].checkpoints[0].version ?? null,
     null,
   );
   const reducerFile = path.join(
@@ -487,14 +506,14 @@ test('side branches keep one rail operation while the checked-out card advances'
 
   await run(repo, 'branch', branch);
   await refreshRepoCards();
-  const beforeMaterialization = getDocText(project.file);
+  const beforeMaterialization = fs.readFileSync(project.file, 'utf8');
   const blocked = await require('../workspace/reducer').withMaterialization(
     repoKey,
     async () => publishWall(repoKey),
   );
   assert.equal(blocked.published, false);
   assert.equal(blocked.reason, 'repo-materializing');
-  assert.equal(getDocText(project.file), beforeMaterialization);
+  assert.equal(fs.readFileSync(project.file, 'utf8'), beforeMaterialization);
 
   const created = publishWall(repoKey);
   assert.equal(created.published, true);
@@ -524,18 +543,39 @@ test('side branches keep one rail operation while the checked-out card advances'
   assert.deepEqual(settleProject(), [6]);
 });
 
-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@4',
-    project: repoKey,
-    machine: 'machine-b',
-    mutationId: 'mut_project_peer',
-    publishedAt: '2026-07-19T00:00:00.000Z',
-    cards: [{ card: 'repo-card@2', machine: 'machine-b', replica: 'rpl_peer', path: '/work/app', head: { branch: 'preview' } }],
+test('an inbound numbered record and a later local publish keep one record per machine', async () => {
+  const peerMutationId = 'mut_project_peer_0001';
+  projectStream.applyCloudMutation({
+    version: 7,
+    committedAt: '2026-07-26T12:00:07.000Z',
+    envelope: {
+      resourceId: project.resourceId,
+      authorityEpoch: 1,
+      mutationId: peerMutationId,
+      deviceId: 'machine-b',
+      baseVersion: 6,
+      contract: projectStream.STREAM_CONTRACT,
+      schemaVersion: 1,
+      operationKind: 'code.publish',
+      operation: {
+        kind: 'code.publish',
+        record: {
+          wall: 'code-project@6',
+          project: repoKey,
+          machine: 'machine-b',
+          mutationId: peerMutationId,
+          publishedAt: '2026-07-26T12:00:07.000Z',
+          cards: [],
+        },
+      },
+    },
   });
-  writeDocText(project.file, `${getDocText(project.file)}${peerLine}\n`);
-  assert.deepEqual(settleProject(), [7]);
+  nextCloudVersion = 8;
+  markReducerApplied(7);
+  assert.deepEqual(
+    readWall(repoKey).map((entry) => [entry.machine, entry.version]),
+    [['machine-a', 6], ['machine-b', 7]],
+  );
 
   const repo = path.join(tempRoot, 'projects/app');
   fs.writeFileSync(path.join(repo, 'another.txt'), 'y\n');
@@ -544,197 +584,50 @@ test('peer records and earlier local history survive later publishes', async ()
   await refreshRepoCards();
   const result = publishWall(repoKey);
   assert.equal(result.published, true);
-
-  const lines = getDocText(project.file).trim().split('\n');
-  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']);
   assert.deepEqual(settleProject(), [8]);
+  assert.equal(projectStream.readSnapshot(project.file, repoKey).records.length, 2);
 });
 
-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('wall compaction deletes only records superseded for every machine', () => {
-  const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@4',
-    project: repoKey,
-    machine,
-    mutationId: `mut_project_${machine}_${value}`,
-    cards: [{ value }],
-  });
-  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@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);
-
-  assert.equal(compacted, `${latestA}\n${torn}\n${latestB}\n`);
-  assert.equal(compacted.includes(oldA), false);
-  assert.equal(compacted.includes(oldB), false);
-});
+test('official code order survives mutation-journal pruning', () => {
+  const recordBeforePrune = readWall(repoKey).find((entry) => entry.machine === 'machine-a');
+  assert.equal(recordBeforePrune.version, 8);
+  assert.equal(recordBeforePrune.cards[0].positionVersion, 8);
 
-test('an unordered legacy record cannot pin wall compaction', () => {
-  const unordered = JSON.stringify({
-    wall: 'code-project@4',
-    project: repoKey,
-    machine: '16.612Z',
-    cards: [{ value: 'corrupted-legacy-record' }],
-  });
-  const ordered = (machine) => JSON.stringify({
-    wall: 'code-project@4',
-    project: repoKey,
-    machine,
-    mutationId: `mut_project_${machine}`,
-    cards: [{ value: machine }],
+  const pruned = pruneMutationJournal({
+    cutoffIso: '2100-01-01T00:00:00.000Z',
+    batchSize: 10_000,
   });
-  const latestA = ordered('machine-a');
-  const latestB = ordered('machine-b');
-
+  assert.ok(pruned.deleted >= 8);
   assert.equal(
-    compactWallText(`${unordered}\n${latestA}\n${latestB}\n`, repoKey),
-    `${latestA}\n${latestB}\n`,
+    require('../state/mutations').getMutation(
+      `resource:${project.resourceId}`,
+      recordBeforePrune.mutationId,
+    ),
+    null,
   );
-});
-
-test('retired machine values stay represented without pinning obsolete active history', () => {
-  const line = (machine, value) => JSON.stringify({
-    wall: 'code-project@4',
-    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');
 
+  const durable = readWall(repoKey).find((entry) => entry.machine === 'machine-a');
+  assert.equal(durable.version, 8);
+  assert.equal(durable.cards[0].positionVersion, 8);
   assert.equal(
-    compactWallText(
-      `${retiredA}\n${retiredB}\n${oldA}\n${oldB}\n${latestA}\n${latestB}\n`,
+    require('../workspace/wall').mutationVersion(
+      project.resourceId,
+      durable.mutationId,
       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({
-    wall: 'code-project@4',
-    project: repoKey,
-    machine,
-    mutationId: `mut_project_${machine}_${value}`,
-    cards: [{ value }],
-  });
-  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');
-  const baseText = `${oldA}\n${oldB}\n${latestA}\n${latestB}\n`;
-  const compacted = compactWallText(baseText, repoKey);
-  const base = new Y.Doc();
-  base.getText('content').insert(0, baseText);
-  const baseUpdate = Y.encodeStateAsUpdate(base);
-
-  const writerUpdate = (change) => {
-    const writer = new Y.Doc();
-    Y.applyUpdate(writer, baseUpdate);
-    let update = null;
-    writer.on('update', (value) => {
-      update = value;
-    });
-    change(writer.getText('content'));
-    return update;
-  };
-  const compactUpdate = writerUpdate((text) => {
-    text.delete(0, baseText.length - compacted.length);
-  });
-  const appendLine = `${line('machine-c', 'latest-c')}\n`;
-  const appendUpdate = writerUpdate((text) => {
-    text.insert(text.length, appendLine);
-  });
-
-  const replicas = [
-    [compactUpdate, appendUpdate],
-    [appendUpdate, compactUpdate],
-  ].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((entry) => JSON.parse(entry).cards[0].value),
-    ['latest-a', 'latest-b', 'latest-c'],
+    8,
   );
-});
-
-test('a torn line is ignored by readers, never fatal', () => {
-  writeDocText(
-    project.file,
-    `${getDocText(project.file)}{"wall":"code-project@4","project":"${repoKey}","machine":"machine-c","car\n`,
+  assert.equal(
+    require('../workspace/reducer').reduceWall(readWall(repoKey)).get(repoKey).card.positionVersion,
+    8,
   );
-  settleProject();
-  assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
-});
-
-test('publishing compacts an oversized history before appending the new record', async () => {
-  const before = getDocText(project.file);
-  writeDocText(project.file, `${'obsolete\n'.repeat(132_000)}${before}`);
-  settleProject();
-  assert.ok(Buffer.byteLength(getDocText(project.file), 'utf8') > 1024 * 1024);
-
-  const repo = path.join(tempRoot, 'projects/app');
-  fs.writeFileSync(path.join(repo, 'after-compaction.txt'), 'bounded\n');
-  await run(repo, 'add', '.');
-  await run(repo, 'commit', '-m', 'publish after compaction');
-  await refreshRepoCards();
-  const result = publishWall(repoKey);
-
-  assert.equal(result.published, true);
-  assert.ok(Buffer.byteLength(getDocText(project.file), 'utf8') < 1024 * 1024);
-  assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
-  settleProject();
 });
 
 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@4');
+  assert.equal(stats.contract, 'code-project@6');
   assert.equal(row.resourceId, project.resourceId);
   assert.equal(row.replica.appliedVersion >= 0, true);
   assert.equal(row.machines, 2);

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

@@ -60,7 +60,13 @@ function cardKind(classified) {
   return classified.linked ? 'linked-worktree' : 'primary';
 }
 
-async function observeWorktree(classified) {
+function reusableObjectSource(previousOid, currentOid, source) {
+  return previousOid === currentOid && ['remote', 'bundle'].includes(source?.kind)
+    ? source
+    : null;
+}
+
+async function observeWorktree(classified, previousCard = null) {
   const worktreeRoot = classified.toplevel;
   const gitDir = await fs.promises.realpath(classified.gitDir);
   const replica = replicaForGitDir(gitDir);
@@ -77,14 +83,28 @@ async function observeWorktree(classified) {
   }
 
   const repoIdentity = remote === null ? null : remoteIdentity(remote);
-  const objects = head.oid && repoIdentity
-    ? await require('./objects').objectSourceFor(worktreeRoot, repoIdentity, head.oid)
+  const previous = previousCard?.replica === replica.replicaId
+    && previousCard.repo?.remote === repoIdentity
+    ? previousCard
     : null;
+  const previousRefs = new Map((previous?.refs || []).map((ref) => [ref.name, ref]));
+  const objectSources = new Map();
+  const sourceFor = (oid, priorOid, priorSource) => {
+    if (!oid || !repoIdentity) return null;
+    if (objectSources.has(oid)) return objectSources.get(oid);
+    const source = reusableObjectSource(priorOid, oid, priorSource)
+      || require('./objects').objectSourceFor(worktreeRoot, repoIdentity, oid);
+    objectSources.set(oid, source);
+    return source;
+  };
+  const objects = await sourceFor(head.oid, previous?.head?.oid, previous?.objects);
   const refs = await Promise.all(branches.map(async (branch) => ({
     ...branch,
-    objects: repoIdentity
-      ? await require('./objects').objectSourceFor(worktreeRoot, repoIdentity, branch.oid)
-      : null,
+    objects: await sourceFor(
+      branch.oid,
+      previousRefs.get(branch.name)?.oid,
+      previousRefs.get(branch.name)?.objects,
+    ),
   })));
   return {
     card: CARD_CONTRACT,
@@ -117,14 +137,14 @@ async function observeWorktree(classified) {
  * moved. A repo still in motion after that simply cards again on the next
  * doorbell; every card is a true observation of some moment.
  */
-async function buildRepoCard(dirPath) {
+async function buildRepoCard(dirPath, previousCard = null) {
   const classified = await classifyDirectory(dirPath);
   if (classified.kind !== 'worktree') {
     throw new Error(`cannot card ${classified.path}: ${classified.kind}`);
   }
-  const observed = await observeWorktree(classified);
+  const observed = await observeWorktree(classified, previousCard);
   if (observed.head.oid === await headOid(classified.toplevel)) return observed;
-  return observeWorktree(classified);
+  return observeWorktree(classified, observed);
 }
 
 /**
@@ -206,6 +226,7 @@ async function discoverWorktrees(rootPath) {
 }
 
 module.exports = {
+  _test: { reusableObjectSource },
   CARD_CONTRACT,
   buildRepoCard,
   cardFingerprint,

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

@@ -171,6 +171,7 @@ async function runRefresh() {
   service.counters.refreshes += 1;
 
   const roots = trackedRoots();
+  const previousByPath = new Map(listRepoCards().map((card) => [card.path, card]));
   const targets = new Map(); // worktree root → registry root that reached it
   const skipped = [];
   const rootErrors = [];
@@ -189,7 +190,7 @@ async function runRefresh() {
   const built = [];
   for (const [target, root] of targets) {
     try {
-      built.push({ card: await buildRepoCard(target), root });
+      built.push({ card: await buildRepoCard(target, previousByPath.get(target)), root });
     } catch (error) {
       skipped.push({ path: target, reason: 'observation-failed', error: error.message });
     }
@@ -321,7 +322,7 @@ async function refreshRepoCard(replicaId) {
   const row = db.prepare('SELECT * FROM repo_cards WHERE replica_id = ?').get(replicaId);
   if (!row) return null;
 
-  const observedCard = await buildRepoCard(row.path);
+  const observedCard = await buildRepoCard(row.path, rowToCard(row));
   if (observedCard.replica !== replicaId) return refreshRepoCards();
   const card = observedCard;
   const fingerprint = cardFingerprint(card);