amalgm 0.1.220 → 0.1.234

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

@@ -25,7 +25,7 @@ const { machineId } = require('./identity');
 const { listRepoCards } = require('./cards');
 const { captureCheckpoint } = require('./git');
 
-const CHECKPOINT_CONTRACT = 'repo-checkpoint@8';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@9';
 const MAX_INLINE_DIFF_BYTES = 512 * 1024;
 const PUBLISH_QUIET_MS = 25;
 const RECONCILE_INTERVAL_MS = 30_000;
@@ -54,14 +54,45 @@ function checkpointFile(machine, repoKey) {
     .update(`${CHECKPOINT_CONTRACT}|${machine}|${repoKey}`)
     .digest('hex')
     .slice(0, 24);
-  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v8', `${digest}.json`);
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v9', `${digest}.json`);
+}
+
+/**
+ * Git can print the same tree in different file order depending on whether
+ * a path is tracked or still untracked. File order is transport formatting,
+ * not content identity, so sort complete file patches before hashing them.
+ */
+function patchSections(diff) {
+  if (!diff) return [];
+  if (!diff.startsWith('diff --git ')) return [diff];
+  const sections = [];
+  let start = 0;
+  for (;;) {
+    const next = diff.indexOf('\ndiff --git ', start + 1);
+    if (next === -1) {
+      sections.push(diff.slice(start));
+      break;
+    }
+    sections.push(diff.slice(start, next + 1));
+    start = next + 1;
+  }
+  return sections.sort((left, right) => (
+    left < right ? -1 : left > right ? 1 : 0
+  ));
+}
+
+function canonicalPatch(diff) {
+  return patchSections(diff).join('');
 }
 
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {
   return indexDiff === '' && worktreeDiff === ''
     ? null
     : crypto.createHash('sha256')
-      .update(`${baseOid}\nindex\n${indexDiff}\nworktree\n${worktreeDiff}`, 'utf8')
+      .update(
+        `${baseOid}\nindex\n${canonicalPatch(indexDiff)}\nworktree\n${canonicalPatch(worktreeDiff)}`,
+        'utf8',
+      )
       .digest('hex');
 }
 
@@ -89,6 +120,17 @@ function readCheckpoint(machine, repoKey) {
   }
 }
 
+function stampCheckpointMutation(machine, repoKey, checkpoint, mutationId) {
+  if (!mutationId) return false;
+  const existing = readCheckpoint(machine, repoKey);
+  if (!existing || !sameTransition(existing, checkpoint)) return false;
+  if (existing.mutationId === mutationId) return true;
+  const file = checkpointFile(machine, repoKey);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ ...existing, mutationId })}\n`);
+  return true;
+}
+
 function valueIdentity(value) {
   return JSON.stringify({
     revision: value?.revision ?? null,
@@ -113,25 +155,100 @@ function sameTransition(left, right) {
     && parkedIdentity(left.parked) === parkedIdentity(right.parked);
 }
 
-function checkpointValue(machine, repoKey, baseOid, indexDiff, worktreeDiff) {
-  const revision = revisionOf(baseOid, indexDiff, worktreeDiff);
-  const bytes = Buffer.from(JSON.stringify({ indexDiff, worktreeDiff }), 'utf8');
-  if (bytes.length <= MAX_INLINE_DIFF_BYTES) return { revision, indexDiff, worktreeDiff };
+function sectionEntry(machine, repoKey, baseOid, layer, text, external) {
+  if (!external) return { text };
+  const digest = crypto.createHash('sha256').update(text, 'utf8').digest('hex');
   return {
-    revision,
     payload: require('./objects').publishPayload(
-      `${CHECKPOINT_CONTRACT}\n${machine}\n${repoKey}\n${baseOid}\n${revision || 'clean'}`,
-      bytes,
+      `${CHECKPOINT_CONTRACT}\n${machine}\n${repoKey}\n${baseOid}\n${layer}\n${digest}`,
+      Buffer.from(text, 'utf8'),
       repoKey,
     ),
   };
 }
 
+function checkpointValue(machine, repoKey, baseOid, indexDiff, worktreeDiff) {
+  const revision = revisionOf(baseOid, indexDiff, worktreeDiff);
+  const canonicalIndex = canonicalPatch(indexDiff);
+  const canonicalWorktree = canonicalPatch(worktreeDiff);
+  const bytes = Buffer.from(
+    JSON.stringify({ indexDiff: canonicalIndex, worktreeDiff: canonicalWorktree }),
+    'utf8',
+  );
+  if (bytes.length <= MAX_INLINE_DIFF_BYTES) {
+    return { revision, indexDiff: canonicalIndex, worktreeDiff: canonicalWorktree };
+  }
+
+  const sections = [
+    ...patchSections(canonicalIndex).map((text, index) => ({
+      key: `index:${index}`,
+      layer: 'index',
+      text,
+      bytes: Buffer.byteLength(text, 'utf8'),
+    })),
+    ...patchSections(canonicalWorktree).map((text, index) => ({
+      key: `worktree:${index}`,
+      layer: 'worktree',
+      text,
+      bytes: Buffer.byteLength(text, 'utf8'),
+    })),
+  ];
+  const external = new Set(
+    sections.filter((section) => section.bytes > MAX_INLINE_DIFF_BYTES)
+      .map((section) => section.key),
+  );
+  let inlineBytes = sections
+    .filter((section) => !external.has(section.key))
+    .reduce((total, section) => total + section.bytes, 0);
+  for (const section of sections
+    .filter((candidate) => !external.has(candidate.key))
+    .sort((left, right) => right.bytes - left.bytes || left.key.localeCompare(right.key))) {
+    if (inlineBytes <= MAX_INLINE_DIFF_BYTES) break;
+    external.add(section.key);
+    inlineBytes -= section.bytes;
+  }
+
+  return {
+    revision,
+    sections: {
+      index: sections
+        .filter((section) => section.layer === 'index')
+        .map((section) => sectionEntry(
+          machine,
+          repoKey,
+          baseOid,
+          section.layer,
+          section.text,
+          external.has(section.key),
+        )),
+      worktree: sections
+        .filter((section) => section.layer === 'worktree')
+        .map((section) => sectionEntry(
+          machine,
+          repoKey,
+          baseOid,
+          section.layer,
+          section.text,
+          external.has(section.key),
+        )),
+    },
+  };
+}
+
 function checkpointValueReady(value) {
+  if (value?.sections) {
+    return ['index', 'worktree'].every((layer) => (
+      Array.isArray(value.sections[layer])
+      && value.sections[layer].every((section) => (
+        typeof section?.text === 'string'
+        || section?.payload?.kind === 'chunks'
+      ))
+    ));
+  }
   return !value?.payload || value.payload.kind === 'chunks';
 }
 
-function checkpointForSharedState(existing, {
+function checkpointForSharedState({
   machine,
   repoKey,
   branch,
@@ -140,9 +257,6 @@ function checkpointForSharedState(existing, {
   parked,
   capturedAt = new Date().toISOString(),
 }) {
-  if (existing?.baseOid === baseOid && existing.branch === branch) {
-    return { ...existing, parked };
-  }
   if (parked.length === 0) return null;
   return {
     checkpoint: CHECKPOINT_CONTRACT,
@@ -158,9 +272,12 @@ function checkpointForSharedState(existing, {
 }
 
 function localParkedEntries(existing, reduced, card) {
+  const published = new Set((reduced?.parked || []).filter((entry) => (
+    Number.isInteger(entry.version) && entry.version > 0
+  )).map((entry) => entry.oid));
   const held = existing?.baseOid === card.head?.oid
     && existing.branch === card.head?.branch
-    ? existing.parked || []
+    ? (existing.parked || []).filter((entry) => !published.has(entry.oid))
     : [];
   const unpublished = (reduced?.parked || []).filter((entry) => (
     !Number.isInteger(entry.version) || entry.version < 1
@@ -171,6 +288,36 @@ function localParkedEntries(existing, reduced, card) {
 function readCheckpointValue(baseOid, value) {
   let indexDiff = typeof value?.indexDiff === 'string' ? value.indexDiff : '';
   let worktreeDiff = typeof value?.worktreeDiff === 'string' ? value.worktreeDiff : '';
+  if (value?.sections) {
+    const readSections = (layer) => {
+      if (!Array.isArray(value.sections[layer])) return { state: 'payload-invalid', text: null };
+      const parts = [];
+      for (const section of value.sections[layer]) {
+        if (typeof section?.text === 'string') {
+          parts.push(section.text);
+          continue;
+        }
+        if (section?.payload?.kind === 'pending') {
+          return { state: 'payload-pending', text: null };
+        }
+        if (!section?.payload) return { state: 'payload-invalid', text: null };
+        const payload = require('./objects').readPayload(section.payload);
+        if (payload.state !== 'ready') return { state: payload.state, text: null };
+        parts.push(payload.bytes.toString('utf8'));
+      }
+      return { state: 'ready', text: parts.join('') };
+    };
+    const index = readSections('index');
+    if (index.state !== 'ready') {
+      return { state: index.state, indexDiff: null, worktreeDiff: null };
+    }
+    const worktree = readSections('worktree');
+    if (worktree.state !== 'ready') {
+      return { state: worktree.state, indexDiff: null, worktreeDiff: null };
+    }
+    indexDiff = index.text;
+    worktreeDiff = worktree.text;
+  }
   if (value?.payload) {
     if (value.payload.kind === 'pending') {
       return { state: 'payload-pending', indexDiff: null, worktreeDiff: null };
@@ -208,6 +355,17 @@ function checkpointBaseReady(card, reduced, publication) {
   );
 }
 
+function checkpointWasAcknowledged(checkpoint, card, localRevision, version) {
+  return Boolean(
+    checkpoint
+    && Number.isInteger(version)
+    && version > 0
+    && checkpoint.baseOid === card.head?.oid
+    && checkpoint.branch === card.head?.branch
+    && checkpoint.to?.revision === localRevision
+  );
+}
+
 function checkpointMayPublish(repoKey) {
   return !require('./reducer').isMaterializing(repoKey);
 }
@@ -250,12 +408,11 @@ async function publishPass(replicaId = null) {
         continue;
       }
 
-      // Exact equality means the working tree merely materialized the shared
-      // checkpoint. Keep the writer's last transition because it remains part
-      // of the reducer input. A newly parked commit still rides as metadata on
-      // a no-op transition; the working tree itself is never echoed.
+      // Exact equality means the working tree has no pending file write.
+      // Remove an accepted local transition. A newly archived commit still
+      // rides as metadata on one no-op transition until the rail accepts it.
       if (sharedRevision === localRevision) {
-        const refreshed = checkpointForSharedState(existing, {
+        const refreshed = checkpointForSharedState({
           machine,
           repoKey,
           branch: card.head.branch,
@@ -269,6 +426,21 @@ async function publishPass(replicaId = null) {
           ),
           parked,
         });
+        if (!refreshed) {
+          const project = wall.projectForRepo(repoKey);
+          const version = wall.mutationVersion(
+            project?.resourceId,
+            existing?.mutationId,
+            repoKey,
+          );
+          if (checkpointWasAcknowledged(existing, card, localRevision, version)) {
+            run.skips += 1;
+            continue;
+          }
+          fs.rmSync(file, { force: true });
+          run.skips += 1;
+          continue;
+        }
         if (refreshed && !sameTransition(existing, refreshed)) {
           fs.writeFileSync(file, `${JSON.stringify(refreshed)}\n`);
           appendStateEvent({
@@ -410,6 +582,7 @@ module.exports = {
     checkpointBaseReady,
     checkpointForSharedState,
     checkpointMayPublish,
+    checkpointWasAcknowledged,
     localParkedEntries,
   },
   CHECKPOINT_CONTRACT,
@@ -425,6 +598,7 @@ module.exports = {
   repoKeyOfCard,
   revisionOf,
   sameTransition,
+  stampCheckpointMutation,
   startCheckpointService,
   stopCheckpointService,
 };

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

@@ -360,6 +360,23 @@ async function captureWorktreeDiff(worktreeRoot, { maxBytes = Infinity } = {}) {
  * Untracked, non-ignored files belong to the working-tree layer. Keeping
  * these deltas separate preserves what the user deliberately staged.
  */
+function checkpointCaptureResult({
+  baseOid,
+  observedOid,
+  indexDiff,
+  worktreeDiff,
+  bytes,
+  maxBytes,
+}) {
+  if (observedOid !== baseOid) {
+    return { baseOid, indexDiff: null, worktreeDiff: null, reason: 'head-moved', bytes };
+  }
+  if (bytes > maxBytes) {
+    return { baseOid, indexDiff: null, worktreeDiff: null, reason: 'too-large', bytes };
+  }
+  return { baseOid, indexDiff, worktreeDiff, bytes };
+}
+
 async function captureCheckpoint(worktreeRoot, { maxBytes = Infinity } = {}) {
   const baseOid = await headOid(worktreeRoot);
   if (!baseOid) return { baseOid: null, indexDiff: null, worktreeDiff: null, reason: 'unborn' };
@@ -388,18 +405,19 @@ async function captureCheckpoint(worktreeRoot, { maxBytes = Infinity } = {}) {
     worktreeParts.push(creation.stdout);
     bytes += Buffer.byteLength(creation.stdout);
   }
-  if (bytes > maxBytes) {
-    return { baseOid, indexDiff: null, worktreeDiff: null, reason: 'too-large', bytes };
-  }
-  return {
+  const observedOid = await headOid(worktreeRoot);
+  return checkpointCaptureResult({
     baseOid,
+    observedOid,
     indexDiff: staged.stdout,
     worktreeDiff: worktreeParts.join(''),
     bytes,
-  };
+    maxBytes,
+  });
 }
 
 module.exports = {
+  _test: { checkpointCaptureResult },
   GitError,
   captureCheckpoint,
   captureWorktreeDiff,

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

@@ -1,33 +1,21 @@
 'use strict';
 
 /**
- * The coexistence engine.
+ * Ordered file-state application.
  *
- * The workspace rule: every writer — human, agent, or remote machine —
- * writes into the same working tree, and no writer's work is ever
- * silently lost. This module is the mechanism. A peer's contribution to
- * a local working tree is represented as a git tree oid ("base commit
- * plus exactly the peer content folded in so far"), and the only verb is
- * advance: move that contribution from the tree we hold to the tree the
- * peer just published, file by file, around whatever else lives in the
- * working tree.
+ * Every official transition changes a tree from one exact state to another.
+ * Transitions are applied in rail order. Different paths combine; when two
+ * official transitions touch the same path, the later transition wins.
  *
- * Per file, in order:
- * - working file already matches the peer's version → fold without
- *   writing (this is what makes echoes and replays no-ops);
- * - working file untouched since the held version → take the peer's
- *   version verbatim (create, update, or delete);
- * - both sides changed text → content-level three-way merge; a clean
- *   merge writes, an overlapping one holds the file aside untouched
- *   with a named conflict kind. Both versions survive: local in the
- *   tree, the peer's in their checkpoint.
+ * The visible working tree may also contain a pending local write. Applying
+ * an earlier official transition advances the confirmed tree underneath that
+ * write without replacing its visible bytes. The pending write is published
+ * later from the new confirmed state.
  *
- * Everything here computes against the object database with scratch
- * index files; the only worktree mutation is the final write set, which
- * goes through transition.applyMergedFiles so it lands in the journal.
+ * Everything computes against the object database with scratch index files;
+ * the only worktree mutation is the final ordered write set.
  */
 
-const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -171,124 +159,20 @@ function workMatches(work, entry, blobBytes) {
     && work.content.equals(blobBytes);
 }
 
-function isText(buffer) {
-  return buffer !== null && !buffer.includes(0);
-}
-
-/** Content-level three-way merge; { ok, content } — never writes markers to disk. */
-async function mergeFileContents(ours, base, theirs, labels = {}) {
-  return withScratch(async (dir) => {
-    const oursFile = path.join(dir, 'ours');
-    const baseFile = path.join(dir, 'base');
-    const theirsFile = path.join(dir, 'theirs');
-    await fs.promises.writeFile(oursFile, ours);
-    await fs.promises.writeFile(baseFile, base);
-    await fs.promises.writeFile(theirsFile, theirs);
-    const conflictCodes = Array.from({ length: 127 }, (_, i) => i + 1);
-    const result = await run(
-      [
-        'merge-file', '-p',
-        '-L', labels.ours || 'current',
-        '-L', labels.base || 'base',
-        '-L', labels.theirs || 'incoming',
-        oursFile, baseFile, theirsFile,
-      ],
-      dir,
-      { okCodes: conflictCodes, binary: true },
-    );
-    return { ok: result.exitCode === 0, content: result.stdout };
-  });
-}
-
-function sameEntry(left, right) {
-  return left === null
-    ? right === null
-    : right !== null && left.mode === right.mode && left.type === right.type && left.oid === right.oid;
-}
-
-async function storedBlob(worktreeRoot, content, scratchDir, name) {
-  const file = path.join(scratchDir, name);
-  await fs.promises.writeFile(file, content);
-  const { stdout } = await run(['hash-object', '-w', file], worktreeRoot);
-  return stdout.trim();
-}
-
-function conflictCopyPath(relPath, label) {
-  const digest = crypto.createHash('sha256').update(`${label}\0${relPath}`).digest('hex').slice(0, 16);
-  return `.amalgm-conflicts/${digest}/${relPath}`;
-}
-
 /**
- * Pure checkpoint reduction. Apply one published transition
- * (`baseTree → targetTree`) to the currently reduced tree. No working file
- * is read or written. Disjoint changes combine, identical changes fold, and
- * overlaps produce the same conflict bytes and paths on every machine.
+ * Apply one official transition (`baseTree → targetTree`) to the current
+ * confirmed tree. Every path changed by the transition takes its target
+ * state. Rail order alone decides the winner.
  */
-async function reduceTree(worktreeRoot, currentTree, baseTree, targetTree, { label = 'rail' } = {}) {
+async function reduceTree(worktreeRoot, currentTree, baseTree, targetTree) {
   const updates = [];
-  const conflicts = [];
-
-  await withScratch(async (dir) => {
-    let stored = 0;
-    for (const relPath of await changedPaths(worktreeRoot, baseTree, targetTree)) {
-      if (unsafePath(relPath)) {
-        conflicts.push({ path: relPath, kind: 'unsafe-path', label });
-        continue;
-      }
-      const base = await entryAt(worktreeRoot, baseTree, relPath);
-      const current = await entryAt(worktreeRoot, currentTree, relPath);
-      const target = await entryAt(worktreeRoot, targetTree, relPath);
-
-      if (sameEntry(current, target) || sameEntry(base, target)) continue;
-      if (sameEntry(current, base)) {
-        updates.push({ path: relPath, entry: target });
-        continue;
-      }
-
-      const baseBytes = base?.type === 'blob' ? await readBlob(worktreeRoot, base.oid) : null;
-      const currentBytes = current?.type === 'blob' ? await readBlob(worktreeRoot, current.oid) : null;
-      const targetBytes = target?.type === 'blob' ? await readBlob(worktreeRoot, target.oid) : null;
-      const mergeable = base && current && target
-        && base.type === 'blob' && current.type === 'blob' && target.type === 'blob'
-        && base.mode !== '120000' && current.mode !== '120000' && target.mode !== '120000'
-        && isText(baseBytes) && isText(currentBytes) && isText(targetBytes);
-
-      if (mergeable) {
-        const merged = await mergeFileContents(currentBytes, baseBytes, targetBytes, {
-          ours: 'current',
-          base: 'shared-base',
-          theirs: `rail-${label}`,
-        });
-        const oid = await storedBlob(worktreeRoot, merged.content, dir, `merged-${stored++}`);
-        updates.push({ path: relPath, entry: { mode: current.mode, type: 'blob', oid } });
-        if (!merged.ok) conflicts.push({ path: relPath, kind: 'content-overlap', label });
-        continue;
-      }
-
-      // Binary/delete/add conflicts retain the current path and, when the
-      // incoming side has bytes, preserve those bytes at one deterministic
-      // conflict path. The reducer's conflict record preserves delete intent.
-      const kind = !target
-        ? 'delete-vs-change'
-        : !current
-          ? 'change-vs-delete'
-          : !base
-            ? 'add-add'
-            : 'binary-overlap';
-      const conflict = { path: relPath, kind, label };
-      if (targetBytes) {
-        const copyPath = conflictCopyPath(relPath, label);
-        const oid = await storedBlob(worktreeRoot, targetBytes, dir, `conflict-${stored++}`);
-        updates.push({ path: copyPath, entry: { mode: '100644', type: 'blob', oid } });
-        conflict.copyPath = copyPath;
-      }
-      conflicts.push(conflict);
-    }
-  });
+  for (const relPath of await changedPaths(worktreeRoot, baseTree, targetTree)) {
+    if (unsafePath(relPath)) throw new Error(`unsafe path: ${relPath}`);
+    updates.push({ path: relPath, entry: await entryAt(worktreeRoot, targetTree, relPath) });
+  }
 
   return {
     tree: updates.length ? await updateHeldTree(worktreeRoot, currentTree, updates) : currentTree,
-    conflicts,
   };
 }
 
@@ -318,81 +202,35 @@ function unsafePath(relPath) {
 }
 
 /**
- * Advance the peer's contribution in this working tree from heldTree to
- * targetTree. Returns { applied, conflicts, heldTree, wrote } — applied
- * paths are folded into the returned heldTree; conflicted paths are left
- * exactly as the working tree had them, each with a named kind.
+ * Advance confirmed state from heldTree to targetTree. A working file that
+ * differs from heldTree is a later pending local write, so it stays visible
+ * while the confirmed tree advances underneath it.
  */
 async function advance(worktreeRoot, heldTree, targetTree, { label } = {}) {
   const applied = [];
-  const conflicts = [];
   const writes = [];
 
   for (const relPath of await changedPaths(worktreeRoot, heldTree, targetTree)) {
-    if (unsafePath(relPath)) {
-      conflicts.push({ path: relPath, kind: 'unsafe-path' });
-      continue;
-    }
+    if (unsafePath(relPath)) throw new Error(`unsafe path: ${relPath}`);
     const held = await entryAt(worktreeRoot, heldTree, relPath);
     const target = await entryAt(worktreeRoot, targetTree, relPath);
-    if ((held && held.type !== 'blob') || (target && target.type !== 'blob')) {
-      conflicts.push({ path: relPath, kind: 'unsupported-entry' });
-      continue;
-    }
+    if ((held && held.type !== 'blob') || (target && target.type !== 'blob')) continue;
     const heldBytes = held ? await readBlob(worktreeRoot, held.oid) : null;
     const targetBytes = target ? await readBlob(worktreeRoot, target.oid) : null;
     const work = workFileState(worktreeRoot, relPath);
 
-    if (workMatches(work, target, targetBytes)) {
-      // Already there — a replayed or echoed change folds without a write.
-      applied.push({ path: relPath, entry: target });
-      continue;
-    }
     if (workMatches(work, held, heldBytes)) {
-      // Untouched locally since what we hold — take the peer's version.
       writes.push(target
         ? { path: relPath, content: targetBytes, mode: target.mode }
         : { path: relPath, content: null });
-      applied.push({ path: relPath, entry: target });
-      continue;
-    }
-
-    // The working file differs from both what we hold and what the peer
-    // published: two writers touched it. Merge or preserve — never pick.
-    if (!target) {
-      conflicts.push({ path: relPath, kind: 'delete-vs-edit' });
-      continue;
-    }
-    if (!work) {
-      conflicts.push({ path: relPath, kind: 'edit-vs-delete' });
-      continue;
-    }
-    if (!held) {
-      conflicts.push({ path: relPath, kind: 'add-add' });
-      continue;
-    }
-    const mergeable = work.kind === 'file'
-      && target.mode !== '120000'
-      && held.mode !== '120000'
-      && isText(work.content) && isText(heldBytes) && isText(targetBytes);
-    if (!mergeable) {
-      conflicts.push({ path: relPath, kind: 'binary-overlap' });
-      continue;
-    }
-    const merged = await mergeFileContents(work.content, heldBytes, targetBytes);
-    if (!merged.ok) {
-      conflicts.push({ path: relPath, kind: 'content-overlap' });
-      continue;
     }
-    writes.push({ path: relPath, content: merged.content, mode: work.exec ? '100755' : '100644' });
     applied.push({ path: relPath, entry: target });
   }
 
-  if (writes.length) await transition.applyMergedFiles(worktreeRoot, writes, label);
+  if (writes.length) await transition.applyFiles(worktreeRoot, writes, label);
   const newHeldTree = applied.length ? await updateHeldTree(worktreeRoot, heldTree, applied) : heldTree;
   return {
     applied: applied.map((a) => a.path),
-    conflicts,
     heldTree: newHeldTree,
     wrote: writes.length,
   };

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

@@ -132,7 +132,10 @@ function publishPayload(key, bytesInput, repoKey) {
   if (!project?.resourceId) {
     return { kind: 'pending', contract: PAYLOAD_CONTRACT, checksum };
   }
-  const file = payloadFile(project.resourceId, key);
+  // Payload content is its identity. A later checkpoint that still contains
+  // the same large file must reference the already-uploaded bytes instead of
+  // creating another upload merely because the surrounding checkpoint moved.
+  const file = payloadFile(project.resourceId, checksum);
   let manifest = readJson(file);
   if (!manifest || manifest.checksum !== checksum) {
     manifest = {
@@ -282,6 +285,15 @@ function readPayload(locator) {
   if (bytes.length !== locator.bytes || sha256(bytes) !== locator.checksum) {
     throw new Error('checkpoint payload verification failed');
   }
+  writeJson(payloadFile(locator.resourceId, locator.checksum), {
+    contract: PAYLOAD_CONTRACT,
+    resourceId: locator.resourceId,
+    repoKey: null,
+    checksum: locator.checksum,
+    bytes: locator.bytes,
+    chunks: locator.chunks.map((chunk) => ({ ...chunk, uploaded: true })),
+    createdAt: new Date().toISOString(),
+  });
   return { state: 'ready', bytes };
 }