amalgm 0.1.218 → 0.1.220

package/package.json

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

@@ -176,6 +176,46 @@ test('a checkpoint base replaces covered history and keeps only newer mutations'
   assert.equal(reduced.checkpointRevision, revisionOf(oid, patchAB, ''));
 });
 
+test('an unfinished checkpoint base cannot replace the last complete base', () => {
+  const oid = 'a'.repeat(40);
+  const complete = card('/complete', oid, 1);
+  complete.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 4,
+    value: value(oid, 'complete-patch'),
+  };
+  complete.checkpoints = [
+    transition('machine-a', 5, oid, 'complete-patch', 'later-patch'),
+  ];
+
+  const unfinished = card('/unfinished', oid, 1);
+  unfinished.checkpointBase = {
+    checkpoint: CHECKPOINT_CONTRACT,
+    baseOid: oid,
+    branch: 'main',
+    through: 6,
+    value: {
+      revision: 'b'.repeat(64),
+      payload: {
+        kind: 'pending',
+        contract: 'opaque-chunks@1',
+        checksum: 'c'.repeat(64),
+      },
+    },
+  };
+
+  const plan = reduceWall([
+    { machine: 'machine-a', cards: [complete] },
+    { machine: 'machine-b', cards: [unfinished] },
+  ]).get('root:test');
+
+  assert.equal(plan.checkpointBase.through, 4);
+  assert.equal(plan.checkpointBaseConflict, false);
+  assert.deepEqual(plan.transitions.map((entry) => entry.version), [5]);
+});
+
 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);
@@ -685,6 +725,51 @@ test('a local commit made after the verified card snapshot is never parked or ov
   );
 });
 
+test('a pending descendant commit catches up without becoming a losing commit', async () => {
+  const { repo, oid: baseOid } = await makeRepo('pending-descendant-card');
+  const firstPatch = await patchFor(repo, { 'a.txt': 'before commit\n' });
+  const secondPatch = await patchFor(repo, {
+    'a.txt': 'before commit\n',
+    'b.txt': 'after commit\n',
+  });
+  const winningCard = card(repo, baseOid, 1);
+  const before = {
+    repoKey: 'root:test',
+    card: winningCard,
+    transitions: [transition('machine-peer', 2, baseOid, '', firstPatch)],
+    parked: [],
+  };
+
+  await materializeRepo(winningCard, before, 2);
+  await git(repo, 'add', '.');
+  await git(repo, 'commit', '-m', 'local pending card');
+  const pendingOid = (await git(repo, 'rev-parse', 'HEAD')).trim();
+
+  const pendingCard = card(repo, pendingOid, null);
+  const caughtUp = await materializeRepo(pendingCard, {
+    ...before,
+    transitions: [
+      ...before.transitions,
+      transition('machine-peer', 3, baseOid, firstPatch, secondPatch),
+    ],
+  }, 3);
+
+  assert.equal(caughtUp.state, 'in-sync');
+  assert.equal((await git(repo, 'rev-parse', 'HEAD')).trim(), pendingOid);
+  assert.equal(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8'), 'before commit\n');
+  assert.equal(fs.readFileSync(path.join(repo, 'b.txt'), 'utf8'), 'after commit\n');
+  const staged = (await git(repo, 'diff', '--cached', '--name-only')).trim();
+  const status = (await git(repo, 'status', '--short')).trim();
+  assert.equal(staged, 'b.txt', status);
+  await assert.rejects(
+    git(repo, 'rev-parse', `refs/amalgm/parked/${pendingOid}`),
+  );
+  const state = readRepoState('root:test');
+  assert.equal(state.baseOid, pendingOid);
+  assert.equal(state.appliedThrough, 3);
+  assert.equal(state.cardVersion, null);
+});
+
 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();

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

@@ -148,6 +148,15 @@ test('only a value different from both the materialized baseline and the rail is
     branches: [{ name: 'main', oid: oidC }],
   };
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline), false);
+  assert.equal(hasLocalContribution({
+    ...local,
+    head: { branch: 'main', oid: oidB, detached: false },
+    refs: [{ name: 'main', oid: oidB }],
+  }, remoteAdvance, {
+    ...baseline,
+    baseOid: oidB,
+    pendingCard: true,
+  }), true);
   assert.equal(hasLocalContribution(local, remoteAdvance, baseline, {
     checkpoint: 'repo-checkpoint@8',
     machine: 'machine-a',
@@ -444,6 +453,20 @@ test('a checkpoint base replaces history already covered by the applied rail', a
   assert.deepEqual(settleProject(), [3]);
 });
 
+test('an uploading checkpoint base is not announced as complete', () => {
+  const card = readWall(repoKey)[0].cards[0];
+  const [stamped] = stampCards([card], [], { card, branches: [], transitions: [] }, {
+    repoKey,
+    baseOid: card.head.oid,
+    branch: card.head.branch,
+    appliedThrough: 3,
+    indexDiff: 'x'.repeat(600 * 1024),
+    worktreeDiff: '',
+  }, 'mut_project_pending_base', project);
+
+  assert.equal(stamped.checkpointBase, undefined);
+});
+
 test('one failed project publisher cannot block the next repo', () => {
   const selected = [{ repoKey: 'root:first' }, { repoKey: 'root:second' }];
   const calls = [];

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

@@ -153,6 +153,7 @@ function reduceWall(entries) {
       .filter((entry) => (
         entry.baseOid === repo.card.head?.oid
         && entry.branch === repo.card.head?.branch
+        && checkpointValueReady(entry.value)
       ))
       .sort((left, right) => right.through - left.through);
     const newestThrough = matchingBases[0]?.through ?? null;
@@ -288,6 +289,14 @@ async function moveToWinningCard(localCard, targetCard) {
     && current.head.branch === targetCard.head?.branch
   ) return { state: 'ready', moved: false };
 
+  const pendingCard = current.head.oid
+    && targetCard.head?.oid
+    && current.head.branch === targetCard.head?.branch
+    && await isAncestor(localCard.path, targetCard.head.oid, current.head.oid);
+  if (pendingCard) {
+    return { state: 'ready', moved: false, pendingCard: true, conflicts: [] };
+  }
+
   const objects = await obtainCardObjects(localCard, targetCard);
   if (objects.state !== 'ready') return { state: 'waiting', reason: objects.state };
 
@@ -594,38 +603,87 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   const reduced = await reduceCheckpoint(localCard, plan);
   if (reduced.state !== 'ready') return reduced;
 
-  const baseTree = await merge.treeOf(localCard.path, plan.card.head.oid);
-  const captured = await captureCheckpoint(localCard.path);
-  const represented = captureIsOnRail(plan, captured);
-  const capturedIndex = represented
-    ? await merge.treeOfPatch(localCard.path, plan.card.head.oid, captured.indexDiff)
-    : null;
-  const capturedWorktree = represented
-    ? await merge.treeOfPatch(localCard.path, capturedIndex, captured.worktreeDiff)
-    : null;
-  const heldWorktree = capturedWorktree || (
+  const sharedBaseTree = await merge.treeOf(localCard.path, plan.card.head.oid);
+  const previousHeldWorktree = (
     previous?.baseOid === plan.card.head.oid
       && previous.heldTree
       && await merge.hasTree(localCard.path, previous.heldTree)
       ? previous.heldTree
-      : baseTree
+      : sharedBaseTree
   );
-  const heldIndex = capturedIndex || (
+  const previousHeldIndex = (
     previous?.baseOid === plan.card.head.oid
       && previous.heldIndexTree
       && await merge.hasTree(localCard.path, previous.heldIndexTree)
       ? previous.heldIndexTree
-      : baseTree
+      : sharedBaseTree
   );
+  let stateBaseOid = plan.card.head.oid;
+  let stateBranch = plan.card.head.branch;
+  let stateCardVersion = plan.card.positionVersion;
+  let stateCardMutationId = plan.card.positionMutationId;
+  let stateIndexDiff = reduced.indexDiff;
+  let stateWorktreeDiff = reduced.worktreeDiff;
+  let heldWorktree;
+  let heldIndex;
+  let targetWorktree;
+  let targetIndex;
+  const pendingConflicts = [];
+
+  if (cardResult.pendingCard) {
+    const pendingBaseTree = await merge.treeOf(localCard.path, localCard.head.oid);
+    const rebasedIndex = await merge.reduceTree(
+      localCard.path,
+      pendingBaseTree,
+      previousHeldIndex,
+      reduced.indexTree,
+      { label: `pending-card-index-${appliedThrough ?? 'local'}` },
+    );
+    const rebasedWorktree = await merge.reduceTree(
+      localCard.path,
+      pendingBaseTree,
+      previousHeldWorktree,
+      reduced.worktreeTree,
+      { label: `pending-card-worktree-${appliedThrough ?? 'local'}` },
+    );
+    heldIndex = pendingBaseTree;
+    heldWorktree = pendingBaseTree;
+    targetIndex = rebasedIndex.tree;
+    targetWorktree = rebasedWorktree.tree;
+    stateBaseOid = localCard.head.oid;
+    stateBranch = localCard.head.branch;
+    stateCardVersion = null;
+    stateCardMutationId = null;
+    stateIndexDiff = await merge.diffOfTree(localCard.path, stateBaseOid, targetIndex);
+    stateWorktreeDiff = await merge.diffOfTree(localCard.path, targetIndex, targetWorktree);
+    pendingConflicts.push(
+      ...rebasedIndex.conflicts.map((item) => ({ ...item, layer: 'pending-card-index' })),
+      ...rebasedWorktree.conflicts.map((item) => ({ ...item, layer: 'pending-card-worktree' })),
+    );
+  } else {
+    const captured = await captureCheckpoint(localCard.path);
+    const represented = captureIsOnRail(plan, captured);
+    const capturedIndex = represented
+      ? await merge.treeOfPatch(localCard.path, plan.card.head.oid, captured.indexDiff)
+      : null;
+    const capturedWorktree = represented
+      ? await merge.treeOfPatch(localCard.path, capturedIndex, captured.worktreeDiff)
+      : null;
+    heldWorktree = capturedWorktree || previousHeldWorktree;
+    heldIndex = capturedIndex || previousHeldIndex;
+    targetWorktree = reduced.worktreeTree;
+    targetIndex = reduced.indexTree;
+  }
+
   const currentIndex = await merge.indexTree(localCard.path);
   const reducedLocalIndex = await merge.reduceTree(
     localCard.path,
     currentIndex,
     heldIndex,
-    reduced.indexTree,
+    targetIndex,
     { label: `index-${reduced.checkpointRevision || 'clean'}` },
   );
-  const applied = await merge.advance(localCard.path, heldWorktree, reduced.worktreeTree, {
+  const applied = await merge.advance(localCard.path, heldWorktree, targetWorktree, {
     label: `checkpoint-${reduced.checkpointRevision || 'clean'}`,
   });
   const indexResult = await advanceIndex(localCard.path, currentIndex, reducedLocalIndex.tree);
@@ -633,28 +691,30 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   const state = writeRepoState(plan.repoKey, {
     path: localCard.path,
     replica: localCard.replica,
-    branch: plan.card.head.branch,
-    baseOid: plan.card.head.oid,
-    cardVersion: plan.card.positionVersion,
-    cardMutationId: plan.card.positionMutationId,
+    branch: stateBranch,
+    baseOid: stateBaseOid,
+    cardVersion: stateCardVersion,
+    cardMutationId: stateCardMutationId,
+    pendingCard: Boolean(cardResult.pendingCard),
     appliedThrough,
-    checkpointRevision: reduced.checkpointRevision,
-    indexDiff: reduced.indexDiff,
-    worktreeDiff: reduced.worktreeDiff,
+    checkpointRevision: revisionOf(stateBaseOid, stateIndexDiff, stateWorktreeDiff),
+    indexDiff: stateIndexDiff,
+    worktreeDiff: stateWorktreeDiff,
     checkpointVersions: plan.transitions.map((entry) => entry.version),
     branches: plan.branches || [],
     heldTree: applied.heldTree,
-    heldIndexTree: reduced.indexTree,
+    heldIndexTree: targetIndex,
     parked,
     parkedWaiting: [...parkedWaiting, ...branchResult.waiting],
     conflicts: [
       ...(cardResult.conflicts || []),
       ...reduced.conflicts,
+      ...pendingConflicts,
       ...reducedLocalIndex.conflicts.map((item) => ({ ...item, layer: 'index-materialize' })),
       ...applied.conflicts,
     ],
-    materialized: applied.heldTree === reduced.worktreeTree
-      && reducedLocalIndex.tree === reduced.indexTree,
+    materialized: applied.heldTree === targetWorktree
+      && reducedLocalIndex.tree === targetIndex,
   });
   appendStateEvent({
     resource: 'workspace-reducer',

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

@@ -20,6 +20,7 @@ const { listRepoCards } = require('./cards');
 const {
   CHECKPOINT_CONTRACT,
   checkpointValue,
+  checkpointValueReady,
   readCheckpoint,
   repoKeyOfCard,
   sameTransition,
@@ -252,7 +253,8 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
   const onRail = samePosition(card, plan.card);
   const atBaseline = baseline
     && card.head?.branch === baseline.branch
-    && card.head?.oid === baseline.baseOid;
+    && card.head?.oid === baseline.baseOid
+    && !baseline.pendingCard;
   const alreadyPublished = validVersion(previousCard?.positionVersion)
     && samePosition(card, previousCard);
   const reversesPublishedSharedPosition = previousCard
@@ -330,6 +332,7 @@ function checkpointBaseFor(card, baseline, project, shared = null) {
     baseline.indexDiff || '',
     baseline.worktreeDiff || '',
   );
+  if (!checkpointValueReady(value)) return null;
   const reusableThrough = shared
     && shared.baseOid === card.head.oid
     && shared.branch === card.head.branch