amalgm 0.1.189 → 0.1.191

package/package.json

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

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

@@ -31,12 +31,14 @@ const { refreshRepoCards } = require('../workspace/cards');
 const { checkpointFile, repoKeyOfCard } = require('../workspace/checkpoint');
 const {
   bindProject,
+  hasLocalContribution,
   isCommittedCard,
   projectForRepo,
   projectResourceId,
   publishedCardFor,
   publishWall,
   readWall,
+  stampCards,
   wallStats,
 } = require('../workspace/wall');
 
@@ -71,6 +73,115 @@ test('no commit means no shared card', () => {
   assert.equal(isCommittedCard({ head: { branch: 'main', oid: 'a'.repeat(40) } }), 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);
+  const oidC = 'c'.repeat(40);
+  const local = {
+    head: { branch: 'main', oid: oidA, detached: false },
+    refs: [{ name: 'main', oid: oidA }],
+  };
+  const plan = {
+    card: { head: { branch: 'main', oid: oidA, detached: false } },
+    branches: [
+      { name: 'main', oid: oidA },
+      { name: 'feature', oid: oidB },
+    ],
+    transitions: [],
+  };
+  const baseline = {
+    branch: 'main',
+    baseOid: oidA,
+    branches: [{ name: 'main', oid: oidA }],
+  };
+
+  assert.equal(hasLocalContribution(local, plan, baseline), false);
+  assert.equal(hasLocalContribution({
+    ...local,
+    refs: [...local.refs, { name: 'feature', oid: oidB }],
+  }, plan, baseline), false);
+  assert.equal(hasLocalContribution({
+    ...local,
+    head: { branch: 'main', oid: oidC, detached: false },
+    refs: [{ name: 'main', oid: oidC }],
+  }, plan, baseline), true);
+  assert.equal(hasLocalContribution(local, plan, {
+    ...baseline,
+    branches: [...baseline.branches, { name: 'feature', oid: oidB }],
+  }), true);
+
+  const remoteAdvance = {
+    ...plan,
+    card: { head: { branch: 'main', oid: oidC, detached: false } },
+    branches: [{ name: 'main', oid: oidC }],
+  };
+  assert.equal(hasLocalContribution(local, remoteAdvance, baseline), false);
+  assert.equal(hasLocalContribution(local, plan, baseline, {
+    checkpoint: 'repo-checkpoint@7',
+    machine: 'machine-a',
+    branch: 'main',
+    baseOid: oidA,
+    from: { revision: null, indexDiff: '', worktreeDiff: '' },
+    to: { revision: 'local-work', indexDiff: '', worktreeDiff: 'patch' },
+    parked: [],
+  }), true);
+});
+
+test('checkpoint work on the materialized baseline keeps the baseline card and branch numbers', () => {
+  const baselineOid = 'a'.repeat(40);
+  const railOid = 'b'.repeat(40);
+  const card = {
+    card: 'repo-card@2',
+    machine: 'machine-a',
+    replica: 'rpl_baseline',
+    kind: 'primary',
+    head: { branch: 'main', oid: baselineOid, detached: false },
+    refs: [{ name: 'main', oid: baselineOid }],
+    health: 'healthy',
+  };
+  const stamped = stampCards(
+    [card],
+    [{
+      ...card,
+      head: { branch: 'old', oid: 'c'.repeat(40), detached: false },
+      positionMutationId: 'mut_stale_card_01',
+      positionVersion: 8,
+      branches: [],
+    }],
+    {
+      card: {
+        ...card,
+        head: { branch: 'main', oid: railOid, detached: false },
+        positionMutationId: 'mut_winning_card1',
+        positionVersion: 12,
+      },
+      branches: [{
+        name: 'main',
+        oid: railOid,
+        mutationId: 'mut_winning_ref01',
+        version: 12,
+      }],
+    },
+    {
+      branch: 'main',
+      baseOid: baselineOid,
+      cardMutationId: 'mut_baseline_card',
+      cardVersion: 9,
+      branches: [{
+        name: 'main',
+        oid: baselineOid,
+        mutationId: 'mut_baseline_ref1',
+        version: 9,
+      }],
+    },
+    'mut_checkpoint_only',
+    { repoKey: 'root:baseline-stamp', resourceId: 'shr_baseline_stamp_test' },
+  )[0];
+
+  assert.equal(stamped.positionMutationId, 'mut_baseline_card');
+  assert.equal(stamped.branches[0].mutationId, 'mut_baseline_ref1');
+});
+
 test('a collaborator binds the same repo to the owner project, not a parallel project', () => {
   const shared = projectResourceId('repo-shared', '22222222-2222-4222-8222-222222222222');
   const localPath = path.join(tempRoot, 'projects/shared');
@@ -129,7 +240,7 @@ test('a repo project carries exactly one line per machine, replaced in place', a
   });
   const sealed = publishWall(repoKey);
   assert.equal(sealed.published, false);
-  assert.equal(sealed.reason, 'unchanged');
+  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);
@@ -137,7 +248,7 @@ test('a repo project carries exactly one line per machine, replaced in place', a
 
   const again = publishWall(repoKey);
   assert.equal(again.published, false);
-  assert.equal(again.reason, 'unchanged');
+  assert.equal(again.reason, 'shared-state-covered');
 
   fs.writeFileSync(path.join(repo, 'new.txt'), 'x\n');
   await refreshRepoCards();
@@ -192,6 +303,34 @@ test('checkpoint transitions append until the next card and carry their official
   assert.deepEqual(history.map((entry) => entry.mutationId), [first.mutationId, second.mutationId]);
 });
 
+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];
+  const branch = 'storm/persistent-ref';
+
+  await run(repo, 'branch', branch);
+  await refreshRepoCards();
+  const created = publishWall(repoKey);
+  assert.equal(created.published, true);
+  let card = readWall(repoKey)[0].cards[0];
+  const ref = card.branches.find((entry) => entry.name === branch);
+  assert.equal(card.positionMutationId, before.positionMutationId);
+  assert.equal(ref.mutationId, created.mutationId);
+
+  acknowledgeCloudMutation(project.resourceId, created.mutationId, {
+    version: 3,
+    committedAt: '2026-07-23T00:00:04.000Z',
+  });
+  await run(repo, 'add', 'new.txt');
+  await run(repo, 'commit', '-m', 'advance without moving side branch');
+  await refreshRepoCards();
+  const advanced = publishWall(repoKey);
+  assert.equal(advanced.published, true);
+  card = readWall(repoKey)[0].cards[0];
+  assert.equal(card.positionMutationId, advanced.mutationId);
+  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 () => {
   const peerLine = JSON.stringify({
     wall: 'code-project@3',

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

@@ -197,17 +197,9 @@ function publishedCardFor(card) {
 }
 
 function samePosition(left, right) {
-  const sameHead = left?.head?.branch === right?.head?.branch
+  return left?.head?.branch === right?.head?.branch
     && left?.head?.oid === right?.head?.oid
     && Boolean(left?.head?.detached) === Boolean(right?.head?.detached);
-  if (!sameHead) return false;
-  const previousRefs = new Map((left?.branches || []).map((ref) => [ref.name, ref.oid ?? null]));
-  const currentRefs = new Map((right?.refs || []).map((ref) => [ref.name, ref.oid]));
-  const names = new Set([...previousRefs.keys(), ...currentRefs.keys()]);
-  for (const name of names) {
-    if ((previousRefs.get(name) ?? null) !== (currentRefs.get(name) ?? null)) return false;
-  }
-  return true;
 }
 
 function checkpointIdentity(checkpoint) {
@@ -221,6 +213,59 @@ function checkpointIdentity(checkpoint) {
   });
 }
 
+function oidMap(refs) {
+  return new Map((refs || []).map((ref) => [ref.name, ref.oid ?? null]));
+}
+
+/**
+ * Publishing is a transition from the last shared state this checkout
+ * 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) {
+  if (!plan?.card) return true;
+  const onRail = samePosition(card, plan.card);
+  const atBaseline = baseline
+    && card.head?.branch === baseline.branch
+    && card.head?.oid === baseline.baseOid;
+  if (!onRail && !atBaseline) return true;
+
+  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 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;
+  }
+
+  if (
+    checkpoint
+    && checkpoint.baseOid === card.head?.oid
+    && checkpoint.branch === card.head?.branch
+  ) {
+    const latest = [...(plan.transitions || [])]
+      .reverse()
+      .find((entry) => entry.machine === checkpoint.machine);
+    if (checkpointIdentity(latest) !== checkpointIdentity(checkpoint)) return true;
+  }
+  return false;
+}
+
+function hasObjectUpgrade(card, plan) {
+  if (!plan?.card || !samePosition(card, plan.card)) return false;
+  if (card.objects?.kind === 'bundle' && plan.card.objects?.kind !== 'bundle') return true;
+  const shared = new Map((plan.branches || []).map((ref) => [ref.name, ref]));
+  return (card.refs || []).some((ref) => {
+    const onRail = shared.get(ref.name);
+    return onRail
+      && onRail.oid === ref.oid
+      && ref.objects?.kind === 'bundle'
+      && onRail.objects?.kind !== 'bundle';
+  });
+}
+
 function validVersion(value) {
   return Number.isInteger(value) && value > 0;
 }
@@ -236,19 +281,42 @@ function officialVersion(resourceId, mutationId) {
   return Number.isInteger(mutation?.officialCloudVersion) ? mutation.officialCloudVersion : null;
 }
 
-function stampBranches(refs, previousBranches, mutationId, resourceId) {
+function stampBranches(
+  refs,
+  previousBranches,
+  sharedBranches,
+  baselineBranches,
+  mutationId,
+  resourceId,
+) {
   const current = new Map((refs || []).map((ref) => [ref.name, ref]));
   const previous = new Map((previousBranches || []).map((ref) => [ref.name, ref]));
+  const shared = new Map((sharedBranches || []).map((ref) => [ref.name, ref]));
+  const baseline = new Map((baselineBranches || []).map((ref) => [ref.name, ref]));
   const names = [...new Set([...current.keys(), ...previous.keys()])].sort();
   return names.map((name) => {
     const observed = current.get(name);
     const before = previous.get(name);
+    const onRail = shared.get(name);
+    const materialized = baseline.get(name);
     const oid = observed?.oid ?? null;
     const unchanged = before && (before.oid ?? null) === oid;
-    const reusable = unchanged
+    const previousReusable = unchanged
       && before.mutationId
       && (validVersion(before.version) || knownMutation(resourceId, before.mutationId));
-    const mutation = reusable ? before.mutationId : mutationId;
+    const railReusable = onRail
+      && (onRail.oid ?? null) === oid
+      && onRail.mutationId
+      && validVersion(onRail.version);
+    const baselineReusable = materialized
+      && (materialized.oid ?? null) === oid
+      && materialized.mutationId
+      && validVersion(materialized.version);
+    const mutation = previousReusable
+      ? before.mutationId
+      : railReusable
+        ? onRail.mutationId
+        : baselineReusable ? materialized.mutationId : mutationId;
     return {
       name,
       oid,
@@ -279,7 +347,7 @@ function isCommittedCard(card) {
   return typeof card?.head?.oid === 'string' && /^[0-9a-f]{40,64}$/.test(card.head.oid);
 }
 
-function stampCards(cards, previousCards, mutationId, project) {
+function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, project) {
   const previousByReplica = new Map(
     (previousCards || []).filter((card) => card?.replica).map((card) => [card.replica, card]),
   );
@@ -290,8 +358,20 @@ function stampCards(cards, previousCards, mutationId, project) {
       && (
         validVersion(previous.positionVersion)
         || knownMutation(project.resourceId, previous.positionMutationId)
-    );
-    const positionMutationId = reusablePosition ? previous.positionMutationId : mutationId;
+      );
+    const reusableRailPosition = samePosition(sharedPlan?.card, card)
+      && sharedPlan.card.positionMutationId
+      && validVersion(sharedPlan.card.positionVersion);
+    const reusableBaselinePosition = baseline
+      && card.head?.branch === baseline.branch
+      && card.head?.oid === baseline.baseOid
+      && baseline.cardMutationId
+      && validVersion(baseline.cardVersion);
+    const positionMutationId = reusablePosition
+      ? previous.positionMutationId
+      : reusableRailPosition
+        ? sharedPlan.card.positionMutationId
+        : reusableBaselinePosition ? baseline.cardMutationId : mutationId;
     const checkpoint = readCheckpoint(machineId(), project.repoKey);
     const currentCheckpoint = checkpoint
       && checkpoint.baseOid === card.head?.oid
@@ -314,7 +394,9 @@ function stampCards(cards, previousCards, mutationId, project) {
       positionMutationId,
       branches: stampBranches(
         card.refs,
-        sameBase ? previous?.branches : [],
+        previous?.branches,
+        sharedPlan?.branches,
+        baseline?.branches,
         mutationId,
         project.resourceId,
       ),
@@ -362,8 +444,30 @@ function publishProject(project, rawCards) {
     }
   }
 
+  const reducer = require('./reducer');
+  const sharedPlan = reducer.reduceWall(readProjectWall(project)).get(project.repoKey);
+  const baseline = reducer.readRepoState(project.repoKey);
+  const previousReplicas = new Set((previousEntry?.cards || []).map((card) => card.replica));
+  const currentReplicas = new Set(rawCards.map((card) => card.replica));
+  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)
+      || hasObjectUpgrade(card, sharedPlan);
+  });
+  if (!removed && !contributes) {
+    service.counters.publishSkips += 1;
+    return { published: false, reason: 'shared-state-covered', repoKey: project.repoKey };
+  }
   const mutationId = `mut_project_${crypto.randomBytes(16).toString('base64url')}`;
-  const cards = stampCards(rawCards, previousEntry?.cards, mutationId, project);
+  const cards = stampCards(
+    rawCards,
+    previousEntry?.cards,
+    sharedPlan,
+    baseline,
+    mutationId,
+    project,
+  );
   const mine = JSON.stringify({
     wall: WALL_CONTRACT,
     project: project.repoKey,
@@ -566,6 +670,7 @@ function wallStats() {
 module.exports = {
   WALL_CONTRACT,
   bindProject,
+  hasLocalContribution,
   isCommittedCard,
   projectFile,
   projectForRepo,
@@ -573,6 +678,7 @@ module.exports = {
   publishedCardFor,
   publishWall,
   readWall,
+  stampCards,
   startWallService,
   stopWallService,
   wallStats,