amalgm 0.1.220 → 0.1.234

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

@@ -5,7 +5,7 @@
  *
  * The reducer reads the single rail-ordered wall and derives exactly:
  *   - one winning card (highest official card version), and
- *   - one checkpoint tree (checkpoint transitions folded in official order).
+ *   - one checkpoint tree (checkpoint transitions applied in official order).
  *
  * The materializer has no peer branches. It obtains the winning commit,
  * moves to that exact card when safe, advances the one held checkpoint tree
@@ -30,6 +30,7 @@ const {
 const {
   CHECKPOINT_CONTRACT,
   checkpointValueReady,
+  readCheckpoint,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
@@ -80,20 +81,40 @@ function readRepoState(repoKey) {
   }
 }
 
-function writeRepoState(repoKey, state) {
+function repoStateIdentity(state) {
+  if (!state) return null;
+  const { indexDiff, worktreeDiff, updatedAt, ...identity } = state;
+  return JSON.stringify(identity);
+}
+
+function persistRepoState(repoKey, state) {
   fs.mkdirSync(STATE_DIR, { recursive: true });
   const next = { repoKey, ...state, updatedAt: new Date().toISOString() };
+  const previous = readRepoState(repoKey);
+  if (repoStateIdentity(previous) === repoStateIdentity(next)) {
+    return { state: previous, changed: false };
+  }
   fs.writeFileSync(stateFile(repoKey), `${JSON.stringify(next, null, 2)}\n`);
-  return next;
+  return { state: next, changed: true };
+}
+
+function repoStateEventValue(state) {
+  const { indexDiff, worktreeDiff, ...value } = state;
+  return value;
 }
 
 function validVersion(value) {
   return Number.isInteger(value) && value > 0;
 }
 
+function preferBundleObjects(held, candidate) {
+  if (held?.objects?.kind === 'bundle' || candidate?.objects?.kind !== 'bundle') return held;
+  return { ...held, objects: candidate.objects };
+}
+
 /**
  * Pure wall reduction. Machine identity never chooses a winner. Checkpoint
- * transitions remain in the wall until the next card folds them into a
+ * transitions remain in the wall until the next card includes them in a
  * commit, so reducing current state never forgets an earlier edit.
  */
 function reduceWall(entries) {
@@ -121,11 +142,25 @@ function reduceWall(entries) {
       }
       if (!repo.card || card.positionVersion > repo.card.positionVersion) {
         repo.card = { ...card, writer: wallEntry.machine };
+      } else if (
+        card.positionVersion === repo.card.positionVersion
+        && card.positionMutationId === repo.card.positionMutationId
+        && card.head?.oid === repo.card.head?.oid
+      ) {
+        repo.card = preferBundleObjects(repo.card, card);
       }
       for (const ref of card.branches || []) {
         if (!ref?.name || !validVersion(ref.version)) continue;
         const held = repo.branchMap.get(ref.name);
-        if (!held || ref.version > held.version) repo.branchMap.set(ref.name, ref);
+        if (!held || ref.version > held.version) {
+          repo.branchMap.set(ref.name, ref);
+        } else if (
+          ref.version === held.version
+          && ref.mutationId === held.mutationId
+          && ref.oid === held.oid
+        ) {
+          repo.branchMap.set(ref.name, preferBundleObjects(held, ref));
+        }
       }
       for (const checkpoint of card.checkpoints || []) {
         if (
@@ -293,9 +328,7 @@ async function moveToWinningCard(localCard, targetCard) {
     && 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: [] };
-  }
+  if (pendingCard) return { state: 'ready', moved: false, pendingCard: true };
 
   const objects = await obtainCardObjects(localCard, targetCard);
   if (objects.state !== 'ready') return { state: 'waiting', reason: objects.state };
@@ -340,25 +373,14 @@ async function moveToWinningCard(localCard, targetCard) {
     });
   }
 
-  const commonTree = await merge.treeOf(localCard.path, commonOid);
   const winningTree = await merge.treeOf(localCard.path, targetCard.head.oid);
   const oldTree = await merge.treeOf(localCard.path, current.head.oid);
-  const committed = forward || current.head.oid === targetCard.head.oid
-    ? { tree: winningTree, conflicts: [] }
-    : await merge.reduceTree(
-      localCard.path,
-      winningTree,
-      commonTree,
-      oldTree,
-      { label: `parked-${current.head.oid.slice(0, 12)}` },
-    );
   const oldIndexTree = await merge.treeOfPatch(localCard.path, current.head.oid, movingIndexDiff);
   const staged = await merge.reduceTree(
     localCard.path,
-    committed.tree,
+    winningTree,
     oldTree,
     oldIndexTree,
-    { label: `staged-${current.head.oid.slice(0, 12)}` },
   );
   const oldWorktree = await merge.treeOfPatch(localCard.path, oldIndexTree, movingWorktreeDiff);
   const working = await merge.reduceTree(
@@ -366,13 +388,7 @@ async function moveToWinningCard(localCard, targetCard) {
     staged.tree,
     oldIndexTree,
     oldWorktree,
-    { label: `working-${current.head.oid.slice(0, 12)}` },
   );
-  const conflicts = [
-    ...committed.conflicts,
-    ...staged.conflicts,
-    ...working.conflicts,
-  ];
 
   const rollbackDir = path.join(STATE_DIR, 'card-moves');
   fs.mkdirSync(rollbackDir, { recursive: true });
@@ -398,7 +414,6 @@ async function moveToWinningCard(localCard, targetCard) {
     state: 'ready',
     moved: true,
     parked,
-    conflicts: [...conflicts, ...applied.conflicts],
   };
 }
 
@@ -427,9 +442,11 @@ async function materializeParked(localCard, entries) {
   return waiting;
 }
 
-async function materializeBranches(localCard, plan) {
+async function materializeBranches(localCard, plan, heldBranches = []) {
   const current = new Map((await localBranches(localCard.path)).map((ref) => [ref.name, ref.oid]));
+  const held = new Map(heldBranches.map((ref) => [ref.name, ref.oid]));
   const waiting = [];
+  const pending = [];
   let moved = false;
   for (const ref of plan.branches || []) {
     if (ref.name === plan.card.head?.branch) {
@@ -438,6 +455,13 @@ async function materializeBranches(localCard, plan) {
       }
       continue;
     }
+    const currentOid = current.get(ref.name) || null;
+    const heldOid = held.get(ref.name) || null;
+    if (currentOid !== heldOid && currentOid !== ref.oid) {
+      pending.push({ name: ref.name, oid: currentOid });
+      continue;
+    }
+    if (currentOid === ref.oid) continue;
     if (ref.oid === null) {
       if (current.has(ref.name)) {
         await transition.deleteBranchRef(localCard.path, ref.name);
@@ -468,7 +492,7 @@ async function materializeBranches(localCard, plan) {
       moved = true;
     }
   }
-  return { moved, waiting };
+  return { moved, waiting, pending };
 }
 
 async function reduceCheckpoint(localCard, plan) {
@@ -476,7 +500,6 @@ async function reduceCheckpoint(localCard, plan) {
   const baseTree = await merge.treeOf(localCard.path, baseOid);
   let indexTree = baseTree;
   let worktreeTree = baseTree;
-  const conflicts = [];
   if (plan.checkpointBaseConflict) {
     return { state: 'waiting', reason: 'checkpoint-base-disagrees' };
   }
@@ -493,32 +516,6 @@ async function reduceCheckpoint(localCard, plan) {
     );
   }
 
-  for (const entry of plan.parked || []) {
-    const commonOid = await mergeBase(localCard.path, baseOid, entry.oid);
-    if (!commonOid) return { state: 'waiting', reason: `parked-unrelated-${entry.oid}` };
-    const commonTree = await merge.treeOf(localCard.path, commonOid);
-    const parkedTree = await merge.treeOf(localCard.path, entry.oid);
-    const label = `parked-${entry.version || entry.oid.slice(0, 12)}`;
-    const reducedIndex = await merge.reduceTree(
-      localCard.path,
-      indexTree,
-      commonTree,
-      parkedTree,
-      { label },
-    );
-    indexTree = reducedIndex.tree;
-    conflicts.push(...reducedIndex.conflicts.map((item) => ({ ...item, layer: 'index' })));
-    const reducedWorktree = await merge.reduceTree(
-      localCard.path,
-      worktreeTree,
-      commonTree,
-      parkedTree,
-      { label },
-    );
-    worktreeTree = reducedWorktree.tree;
-    conflicts.push(...reducedWorktree.conflicts.map((item) => ({ ...item, layer: 'worktree' })));
-  }
-
   for (const operation of plan.transitions) {
     const from = readCheckpointValue(baseOid, operation.from);
     const to = readCheckpointValue(baseOid, operation.to);
@@ -528,11 +525,13 @@ async function reduceCheckpoint(localCard, plan) {
     }
     const fromIndexTree = await merge.treeOfPatch(localCard.path, baseOid, from.indexDiff);
     const toIndexTree = await merge.treeOfPatch(localCard.path, baseOid, to.indexDiff);
-    const reducedIndex = await merge.reduceTree(localCard.path, indexTree, fromIndexTree, toIndexTree, {
-      label: String(operation.version),
-    });
+    const reducedIndex = await merge.reduceTree(
+      localCard.path,
+      indexTree,
+      fromIndexTree,
+      toIndexTree,
+    );
     indexTree = reducedIndex.tree;
-    conflicts.push(...reducedIndex.conflicts.map((item) => ({ ...item, layer: 'index' })));
 
     const fromWorktreeTree = await merge.treeOfPatch(localCard.path, fromIndexTree, from.worktreeDiff);
     const toWorktreeTree = await merge.treeOfPatch(localCard.path, toIndexTree, to.worktreeDiff);
@@ -541,10 +540,8 @@ async function reduceCheckpoint(localCard, plan) {
       worktreeTree,
       fromWorktreeTree,
       toWorktreeTree,
-      { label: String(operation.version) },
     );
     worktreeTree = reducedWorktree.tree;
-    conflicts.push(...reducedWorktree.conflicts.map((item) => ({ ...item, layer: 'worktree' })));
   }
 
   const indexDiff = await merge.diffOfTree(localCard.path, baseOid, indexTree);
@@ -556,26 +553,32 @@ async function reduceCheckpoint(localCard, plan) {
     indexDiff,
     worktreeDiff,
     checkpointRevision: revisionOf(baseOid, indexDiff, worktreeDiff),
-    conflicts,
   };
 }
 
-function captureIsOnRail(plan, captured, localMachine = machineId()) {
+function captureIsOnRail(plan, captured, localMachine = machineId(), acknowledged = null) {
   if (
     !captured
     || captured.indexDiff === null
     || captured.baseOid !== plan.card.head.oid
   ) return false;
+  const revision = revisionOf(
+    captured.baseOid,
+    captured.indexDiff,
+    captured.worktreeDiff,
+  );
   const latest = [...plan.transitions]
     .reverse()
     .find((operation) => operation.machine === localMachine);
   return Boolean(
-    latest
-    && latest.to?.revision === revisionOf(
-      captured.baseOid,
-      captured.indexDiff,
-      captured.worktreeDiff,
-    ),
+    (latest && latest.to?.revision === revision)
+    || (
+      Number.isInteger(acknowledged?.version)
+      && acknowledged.version > 0
+      && acknowledged.baseOid === captured.baseOid
+      && acknowledged.branch === plan.card.head.branch
+      && acknowledged.to?.revision === revision
+    )
   );
 }
 
@@ -597,9 +600,31 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   const planParked = new Set((plan.parked || []).map((entry) => entry.oid));
   const requiredParkedWaiting = parkedWaiting.filter((entry) => planParked.has(entry.oid));
   if (requiredParkedWaiting.length > 0) {
+    // Parking is a local write. Remember it before waiting on an inbound
+    // bundle, so the next pass cannot replace unnumbered local work.
+    const persisted = persistRepoState(plan.repoKey, {
+      ...(previous || {}),
+      path: localCard.path,
+      replica: localCard.replica,
+      parked,
+      parkedWaiting,
+      materialized: false,
+    });
+    if (persisted.changed) {
+      appendStateEvent({
+        resource: 'workspace-reducer',
+        op: previous ? 'update' : 'insert',
+        id: localCard.replica,
+        value: repoStateEventValue(persisted.state),
+        source: 'workspace-reducer',
+      });
+    }
     return { state: 'waiting', reason: `parked-${requiredParkedWaiting[0].state}` };
   }
-  const branchResult = await materializeBranches(localCard, plan);
+  const branchResult = await materializeBranches(localCard, plan, previous?.branches);
+  if (branchResult.waiting.length > 0) {
+    return { state: 'waiting', reason: `branch-${branchResult.waiting[0].state}` };
+  }
   const reduced = await reduceCheckpoint(localCard, plan);
   if (reduced.state !== 'ready') return reduced;
 
@@ -628,23 +653,19 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   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'}` },
+      previousHeldIndex,
+      pendingBaseTree,
     );
     const rebasedWorktree = await merge.reduceTree(
       localCard.path,
-      pendingBaseTree,
-      previousHeldWorktree,
       reduced.worktreeTree,
-      { label: `pending-card-worktree-${appliedThrough ?? 'local'}` },
+      previousHeldWorktree,
+      pendingBaseTree,
     );
     heldIndex = pendingBaseTree;
     heldWorktree = pendingBaseTree;
@@ -656,13 +677,20 @@ async function materializeRepo(localCardInput, plan, appliedThrough = 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 wall = require('./wall');
+    const localCheckpoint = readCheckpoint(machineId(), plan.repoKey);
+    const project = wall.projectForRepo(plan.repoKey);
+    const acknowledged = localCheckpoint && {
+      ...localCheckpoint,
+      version: wall.mutationVersion(
+        project?.resourceId,
+        localCheckpoint.mutationId,
+        plan.repoKey,
+      ),
+    };
+    const represented = captureIsOnRail(plan, captured, machineId(), acknowledged);
     const capturedIndex = represented
       ? await merge.treeOfPatch(localCard.path, plan.card.head.oid, captured.indexDiff)
       : null;
@@ -678,17 +706,16 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
   const currentIndex = await merge.indexTree(localCard.path);
   const reducedLocalIndex = await merge.reduceTree(
     localCard.path,
-    currentIndex,
-    heldIndex,
     targetIndex,
-    { label: `index-${reduced.checkpointRevision || 'clean'}` },
+    heldIndex,
+    currentIndex,
   );
   const applied = await merge.advance(localCard.path, heldWorktree, targetWorktree, {
     label: `checkpoint-${reduced.checkpointRevision || 'clean'}`,
   });
   const indexResult = await advanceIndex(localCard.path, currentIndex, reducedLocalIndex.tree);
   if (indexResult.state !== 'ready') return indexResult;
-  const state = writeRepoState(plan.repoKey, {
+  const persisted = persistRepoState(plan.repoKey, {
     path: localCard.path,
     replica: localCard.replica,
     branch: stateBranch,
@@ -702,30 +729,26 @@ async function materializeRepo(localCardInput, plan, appliedThrough = null) {
     worktreeDiff: stateWorktreeDiff,
     checkpointVersions: plan.transitions.map((entry) => entry.version),
     branches: plan.branches || [],
+    pendingRefs: branchResult.pending,
     heldTree: applied.heldTree,
     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 === targetWorktree
       && reducedLocalIndex.tree === targetIndex,
   });
-  appendStateEvent({
-    resource: 'workspace-reducer',
-    op: previous ? 'update' : 'insert',
-    id: localCard.replica,
-    value: state,
-    source: 'workspace-reducer',
-  });
+  if (persisted.changed) {
+    appendStateEvent({
+      resource: 'workspace-reducer',
+      op: previous ? 'update' : 'insert',
+      id: localCard.replica,
+      value: repoStateEventValue(persisted.state),
+      source: 'workspace-reducer',
+    });
+  }
   return {
-    state: state.conflicts.length ? 'conflict' : 'in-sync',
-    reason: state.conflicts.length ? state.conflicts.map((item) => `${item.kind}:${item.path}`).join(', ') : null,
+    state: 'in-sync',
+    reason: null,
     moved: cardResult.moved || branchResult.moved || applied.applied.length > 0,
   };
 }

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

@@ -337,13 +337,13 @@ function setIndexTree(worktreeRoot, treeOid) {
 }
 
 /**
- * Land a merged write set in a working tree — the coexistence engine's
- * only mutation path. Each entry is { path, content, mode } (content a
+ * Apply one ordered file write set to a working tree. Each entry is
+ * { path, content, mode } (content a
  * Buffer, mode '100644' | '100755' | '120000') or { path, content: null }
  * for a deletion. Paths are confined to the worktree; the whole set lands
  * as one journal line.
  */
-function applyMergedFiles(worktreeRoot, writes, label) {
+function applyFiles(worktreeRoot, writes, label) {
   const root = path.resolve(worktreeRoot);
   const written = [];
   const removed = [];
@@ -368,20 +368,20 @@ function applyMergedFiles(worktreeRoot, writes, label) {
       }
       written.push(write.path);
     }
-    journal({ action: 'merge-files', worktree: root, label, written, removed, ok: true });
+    journal({ action: 'apply-files', worktree: root, label, written, removed, ok: true });
   } catch (error) {
     journal({
-      action: 'merge-files', worktree: root, label, written, removed, ok: false,
+      action: 'apply-files', worktree: root, label, written, removed, ok: false,
       error: String(error.message).slice(0, 500),
     });
-    throw new TransitionError('merge-files', root, String(error.message));
+    throw new TransitionError('apply-files', root, String(error.message));
   }
 }
 
 module.exports = {
   TransitionError,
   applyIndexPatch,
-  applyMergedFiles,
+  applyFiles,
   applyPatch,
   checkoutInitialCard,
   createBundle,