amalgm 0.1.245 → 0.1.246

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

@@ -13,10 +13,7 @@
  * real local edit or revert is one new transition.
  *
  * Checkpoint files below are local capture cache only. Their operations ride
- * inside the project stream, so the entire repo has one ordered rail.
- *
- * Axiom 4: only an exact local observation may create or update intent.
- * Proven by workspace-local-intent.test.js.
+ * inside the machine wall, so the entire repo has one ordered stream.
  */
 
 const crypto = require('crypto');
@@ -26,10 +23,9 @@ const { AMALGM_DIR } = require('../config');
 const { appendStateEvent, subscribeStateEvents } = require('../state/events');
 const { machineId } = require('./identity');
 const { listRepoCards } = require('./cards');
-const durable = require('./durable');
-const { describeBytes, manifestChecksum, sha256 } = require('./content');
+const { captureCheckpoint } = require('./git');
 
-const CHECKPOINT_CONTRACT = 'repo-checkpoint@11';
+const CHECKPOINT_CONTRACT = 'repo-checkpoint@8';
 const MAX_INLINE_DIFF_BYTES = 512 * 1024;
 const PUBLISH_QUIET_MS = 25;
 const RECONCILE_INTERVAL_MS = 30_000;
@@ -58,75 +54,15 @@ function checkpointFile(machine, repoKey) {
     .update(`${CHECKPOINT_CONTRACT}|${machine}|${repoKey}`)
     .digest('hex')
     .slice(0, 24);
-  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v11', `${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 sectionIdentity(text) {
-  return manifestChecksum(describeBytes(Buffer.from(text, 'utf8')));
-}
-
-function revisionOfSections(baseOid, indexSections, worktreeSections) {
-  const index = [...indexSections].sort();
-  const worktree = [...worktreeSections].sort();
-  if (index.length === 0 && worktree.length === 0) return null;
-  return sha256(Buffer.from(JSON.stringify({ baseOid, index, worktree }), 'utf8'));
+  return path.join(AMALGM_DIR, 'state', 'repo-checkpoints-v8', `${digest}.json`);
 }
 
 function revisionOf(baseOid, indexDiff, worktreeDiff = '') {
-  return revisionOfSections(
-    baseOid,
-    patchSections(indexDiff).map(sectionIdentity),
-    patchSections(worktreeDiff).map(sectionIdentity),
-  );
-}
-
-function revisionOfValue(baseOid, value) {
-  if (
-    typeof value?.indexDiff === 'string'
-    && typeof value?.worktreeDiff === 'string'
-  ) return revisionOf(baseOid, value.indexDiff, value.worktreeDiff);
-  if (!value?.sections) throw new Error('checkpoint value has no content');
-  const identities = (layer) => {
-    if (!Array.isArray(value.sections[layer])) throw new Error('checkpoint sections are invalid');
-    return value.sections[layer].map((section) => {
-      if (typeof section?.text === 'string' && section.text.length > 0) {
-        return sectionIdentity(section.text);
-      }
-      if (/^[0-9a-f]{64}$/.test(String(section?.payload?.checksum || ''))) {
-        return section.payload.checksum;
-      }
-      throw new Error('checkpoint section has no content identity');
-    });
-  };
-  return revisionOfSections(baseOid, identities('index'), identities('worktree'));
+  return indexDiff === '' && worktreeDiff === ''
+    ? null
+    : crypto.createHash('sha256')
+      .update(`${baseOid}\nindex\n${indexDiff}\nworktree\n${worktreeDiff}`, 'utf8')
+      .digest('hex');
 }
 
 function parseCheckpoint(text) {
@@ -153,16 +89,6 @@ 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);
-  durable.writeJson(file, { ...existing, mutationId });
-  return true;
-}
-
 function valueIdentity(value) {
   return JSON.stringify({
     revision: value?.revision ?? null,
@@ -170,502 +96,81 @@ function valueIdentity(value) {
   });
 }
 
+function parkedIdentity(parked) {
+  return JSON.stringify((parked || []).map((entry) => {
+    const stable = { ...entry };
+    delete stable.version;
+    return stable;
+  }));
+}
+
 function sameTransition(left, right) {
   return left
     && left.baseOid === right.baseOid
     && left.branch === right.branch
     && valueIdentity(left.from) === valueIdentity(right.from)
-    && valueIdentity(left.to) === valueIdentity(right.to);
-}
-
-function sectionEntry(machine, repoKey, baseOid, layer, text, external) {
-  if (!external) return { text };
-  const digest = crypto.createHash('sha256').update(text, 'utf8').digest('hex');
-  return {
-    payload: require('./objects').publishPayload(
-      `${CHECKPOINT_CONTRACT}\n${machine}\n${repoKey}\n${baseOid}\n${layer}\n${digest}`,
-      Buffer.from(text, 'utf8'),
-      repoKey,
-    ),
-  };
+    && valueIdentity(left.to) === valueIdentity(right.to)
+    && parkedIdentity(left.parked) === parkedIdentity(right.parked);
 }
 
 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;
-  }
-
+  const bytes = Buffer.from(JSON.stringify({ indexDiff, worktreeDiff }), 'utf8');
+  if (bytes.length <= MAX_INLINE_DIFF_BYTES) return { revision, indexDiff, worktreeDiff };
   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),
-        )),
-    },
+    payload: require('./objects').publishPayload(
+      `${CHECKPOINT_CONTRACT}\n${machine}\n${repoKey}\n${baseOid}\n${revision || 'clean'}`,
+      bytes,
+      repoKey,
+    ),
   };
 }
 
 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 exactCard(card) {
-  return {
-    head: {
-      branch: card.head.branch ?? null,
-      oid: card.head.oid,
-      detached: Boolean(card.head.detached),
-    },
-    objects: card.objects,
-    branches: (card.refs || card.branches || []).map((branch) => ({
-      name: branch.name,
-      oid: branch.oid,
-      objects: branch.objects,
-    })).sort((left, right) => left.name.localeCompare(right.name)),
-  };
-}
-
-function intentBase(state) {
-  if (
-    state?.verificationContract !== 'verified-repo-state@1'
-    || state.materialized !== true
-    || !Number.isInteger(state.appliedThrough)
-    || state.appliedThrough < 0
-    || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(String(state.targetCard?.oid || ''))
-    || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(String(state.heldIndexTree || ''))
-    || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(String(state.heldTree || ''))
-    || !Array.isArray(state.branches)
-  ) return null;
-  return {
-    through: state.appliedThrough,
-    card: {
-      head: {
-        branch: state.targetCard.branch ?? null,
-        oid: state.targetCard.oid,
-        detached: !state.targetCard.branch,
-      },
-      branches: state.branches.map((branch) => ({
-        name: branch.name,
-        oid: branch.oid,
-      })).sort((left, right) => left.name.localeCompare(right.name)),
-    },
-    indexTree: state.heldIndexTree,
-    worktreeTree: state.heldTree,
-  };
-}
-
-function hasIntentEffect(base, local) {
-  const card = require('./intent')._test.cardState;
-  return JSON.stringify(card(base.card)) !== JSON.stringify(card(local.card))
-    || base.indexTree !== local.indexTree
-    || base.worktreeTree !== local.worktreeTree;
-}
-
-async function initialIntentBase(project, card) {
-  if (project.ownerUserId !== require('./identity').userId()) return null;
-  const replica = require('../state/replicas').getReplicaByResourceId(project.resourceId);
-  if (!replica || replica.appliedVersion !== 0) return null;
-  const snapshot = require('./project-stream').readSnapshot(project.file, project.resourceId);
-  if (snapshot.version !== 0 || snapshot.card !== null || snapshot.checkpoint !== null) return null;
-  const emptyTree = await require('./transition').emptyTree(card.path);
-  return {
-    through: 0,
-    card: null,
-    indexTree: emptyTree,
-    worktreeTree: emptyTree,
-  };
-}
-
-async function gitlinkPaths(card, observed) {
-  const merge = require('./merge');
-  const trees = new Set([
-    observed.value.indexTree,
-    observed.value.worktreeTree,
-    card.head.oid,
-    ...(card.refs || card.branches || []).map((branch) => branch.oid),
-  ].filter(Boolean));
-  const paths = new Set();
-  for (const tree of trees) {
-    for (const entry of await merge.gitlinksInTree(card.path, tree)) paths.add(entry);
+function checkpointForSharedState(existing, {
+  machine,
+  repoKey,
+  branch,
+  baseOid,
+  sharedValue,
+  parked,
+  capturedAt = new Date().toISOString(),
+}) {
+  if (existing?.baseOid === baseOid && existing.branch === branch) {
+    return { ...existing, parked };
   }
-  return [...paths].sort();
-}
-
-/**
- * Capture is the only place physical state may become local authorship.
- * It requires a verified baseline (or an already-owned intent) and runs only
- * outside the reducer's materialization section.
- */
-async function recordObservedIntent(
-  project,
-  card,
-  checkpoint,
-  base,
-  observed,
-  options = {},
-) {
-  const intents = require('./intent');
-  const local = {
-    card: exactCard(card),
-    checkpoint: {
-      checkpoint: CHECKPOINT_CONTRACT,
-      baseOid: card.head.oid,
-      branch: card.head.branch ?? null,
-      value: checkpoint.to,
-    },
-    indexTree: observed.value.indexTree,
-    worktreeTree: observed.value.worktreeTree,
-    physicalDigest: observed.digest,
-  };
-  const links = await gitlinkPaths(card, observed);
-  const terminal = links.length > 0
-    ? {
-      code: 'unsupported_gitlink',
-      message: `unsupported gitlink/submodule at ${links[0]}`,
-    }
-    : null;
-  const previous = intents.readIntent(project);
-  const previousSuccessor = previous?.successor || null;
-  if (previous?.terminal && observed.digest === previous.local.physicalDigest) {
-    return {
-      state: 'rejected',
-      reason: previous.terminal.code,
-      intent: previous,
-      unchanged: true,
-    };
-  }
-  if (
-    previousSuccessor?.terminal
-    && observed.digest === previousSuccessor.local.physicalDigest
-  ) {
-    return {
-      state: 'rejected',
-      reason: previousSuccessor.terminal.code,
-      intent: previous,
-      successor: previousSuccessor,
-      unchanged: true,
-    };
-  }
-  const nextSemanticDigest = intents._test.semanticDigest({ local });
-  const acknowledgement = previous
-    ? intents.officialAcknowledgement(project, previous)
-    : null;
-  if (
-    acknowledgement
-    && previous.semanticDigest === nextSemanticDigest
-    && base.through <= acknowledgement.version
-  ) {
-    if (previousSuccessor) intents.clearSuccessor(project, previous);
-    return { state: 'silent', reason: 'officially-acknowledged' };
-  }
-  const mayReplaceAnchored = Boolean(
-    previous?.publication
-    && (
-      previous.semanticDigest === options.replaceAnchoredIntent
-      || (acknowledgement && acknowledgement.version <= base.through)
-      || intents.publicationMayRebase(project, previous, base.through)
-    )
-  );
-  if (
-    previous?.publication
-    && previous.semanticDigest !== nextSemanticDigest
-    && !mayReplaceAnchored
-  ) {
-    const successor = intents.writeSuccessor(project, previous, {
-      local,
-      terminal,
-    });
-    if (!successor) {
-      return {
-        state: 'waiting',
-        reason: 'local-intent-moving',
-        intent: previous,
-      };
-    }
-    return {
-      state: terminal ? 'rejected' : 'captured',
-      reason: terminal ? terminal.code : 'successor-captured',
-      intent: previous,
-      successor,
-      mayMaterialize: true,
-    };
-  }
-  if (!terminal && !hasIntentEffect(base, local)) {
-    if (
-      options.preserveNoEffectIntent === true
-      && previous
-      && !previous.publication
-    ) {
-      const saved = intents.writeIntent(project, {
-        base,
-        local,
-        terminal: null,
-        publication: null,
-        birthMutationId: previous.birthMutationId,
-        preserveBirthMutationId: true,
-      });
-      return {
-        state: 'captured',
-        reason: 'identity-confirmation',
-        intent: saved,
-      };
-    }
-    if (!previous?.publication || mayReplaceAnchored) {
-      intents.clearIntent(project);
-      return { state: 'silent', reason: 'no-local-effect' };
-    }
-    if (acknowledgement && acknowledgement.version <= base.through) {
-      return { state: 'silent', reason: 'officially-acknowledged' };
-    }
-  }
-  const candidate = {
-    base,
-    local,
-    terminal,
-    successor: null,
-    publication: (
-      previous?.semanticDigest === nextSemanticDigest
-      && previous.publication?.baseThrough === base.through
-    )
-      ? previous.publication
-      : null,
-    birthMutationId: options.preserveBirthMutationId === true
-      ? previous?.birthMutationId
-      : mayReplaceAnchored
-        ? previousSuccessor?.birthMutationId
-        : null,
-    preserveBirthMutationId: options.preserveBirthMutationId === true,
-  };
-  const saved = intents.writeIntent(project, candidate);
-  return terminal
-    ? { state: 'rejected', reason: terminal.code, intent: saved }
-    : { state: 'captured', intent: saved };
-}
-
-async function captureIntentObservationWithinTurn(project, card, checkpoint) {
-  const reducer = require('./reducer');
-  const state = reducer.readRepoState(project.repoKey, project.resourceId);
-  const base = intentBase(state) || await initialIntentBase(project, card);
-  if (!base) {
-    return { state: 'silent', reason: 'no-verified-baseline' };
-  }
-  const observed = await reducer.observePhysicalRepo(card.path);
-  if (observed.state !== 'ready') return { state: 'waiting', reason: 'local-state-moving' };
-  const observedRevision = revisionOf(
-    observed.captured.baseOid,
-    observed.captured.indexDiff,
-    observed.captured.worktreeDiff,
-  );
-  const observedCard = {
-    head: {
-      branch: observed.value.head.branch ?? null,
-      oid: observed.value.head.oid,
-      detached: !observed.value.head.branch,
-    },
-    branches: observed.value.branches,
-  };
-  const intents = require('./intent');
-  if (
-    observed.captured.baseOid !== card.head.oid
-    || (
-      checkpoint
-      && (
-        checkpoint.to?.revision !== observedRevision
-        || checkpoint.baseOid !== observed.captured.baseOid
-        || (checkpoint.branch ?? null) !== (observed.value.head.branch ?? null)
-      )
-    )
-    || JSON.stringify(intents._test.cardState(exactCard(card)))
-      !== JSON.stringify(intents._test.cardState(observedCard))
-  ) {
-    return { state: 'waiting', reason: 'local-state-moving' };
-  }
-  const to = checkpointValue(
-    machineId(),
-    project.repoKey,
-    observed.captured.baseOid,
-    observed.captured.indexDiff,
-    observed.captured.worktreeDiff,
-  );
-  if (!checkpointValueReady(to)) {
-    return { state: 'waiting', reason: 'checkpoint-payload-pending' };
-  }
-  const capturedCheckpoint = {
+  if (parked.length === 0) return null;
+  return {
     checkpoint: CHECKPOINT_CONTRACT,
-    machine: machineId(),
-    repoKey: project.repoKey,
-    branch: observed.value.head.branch ?? null,
-    baseOid: observed.captured.baseOid,
-    from: checkpoint?.from || null,
-    to,
-    capturedAt: new Date().toISOString(),
+    machine,
+    repoKey,
+    branch,
+    baseOid,
+    from: sharedValue,
+    to: sharedValue,
+    parked,
+    capturedAt,
   };
-  if (!intents.readIntent(project) && observed.digest === state?.observedPhysicalDigest) {
-    return {
-      state: 'silent',
-      reason: 'verified-state',
-      checkpoint: capturedCheckpoint,
-    };
-  }
-  const result = await recordObservedIntent(
-    project,
-    card,
-    capturedCheckpoint,
-    base,
-    observed,
-  );
-  return { ...result, checkpoint: capturedCheckpoint };
-}
-
-function captureIntentObservation(project, card, checkpoint) {
-  return require('./reducer').withRepoTurn(
-    project.repoKey,
-    'capture',
-    () => captureIntentObservationWithinTurn(project, card, checkpoint),
-  );
-}
-
-async function captureLocalIntent(project, card, checkpoint) {
-  const { checkpoint: capturedCheckpoint, ...outcome } = await captureIntentObservation(
-    project,
-    card,
-    checkpoint,
-  );
-  return outcome;
-}
-
-/**
- * A valid apply WAL is also an exact baseline. Recovery first resolves every
- * source/target component to target while retaining values that equal
- * neither. Only then does this function durably name the retained state as
- * local intent over the official WAL target.
- */
-async function captureIntentAgainst(project, card, base, observed, options = {}) {
-  if (!base || observed?.state !== 'ready' || !observed.captured) {
-    return { state: 'waiting', reason: 'local-state-moving' };
-  }
-  const to = checkpointValue(
-    machineId(),
-    project.repoKey,
-    card.head.oid,
-    observed.captured.indexDiff,
-    observed.captured.worktreeDiff,
-  );
-  if (!checkpointValueReady(to)) {
-    return { state: 'waiting', reason: 'checkpoint-payload-pending' };
-  }
-  return recordObservedIntent(project, card, { to }, base, observed, options);
 }
 
-/**
- * Observe one card and turn a real local change into durable intent.
- *
- * The reducer calls this before ordered apply so an inbound event cannot beat
- * the debounced filesystem watcher. It still obeys the same capture rule:
- * without a verified baseline, the physical checkout is not authorship.
- */
-async function captureIntentForCard(project, card) {
-  if (!project || !card?.head?.oid) {
-    return { state: 'silent', reason: 'no-registered-card' };
-  }
-  return captureLocalIntent(project, card, null);
+function localParkedEntries(existing, reduced, card) {
+  const held = existing?.baseOid === card.head?.oid
+    && existing.branch === card.head?.branch
+    ? existing.parked || []
+    : [];
+  const unpublished = (reduced?.parked || []).filter((entry) => (
+    !Number.isInteger(entry.version) || entry.version < 1
+  ));
+  return [...new Map([...held, ...unpublished].map((entry) => [entry.oid, entry])).values()];
 }
 
 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 };
@@ -692,6 +197,17 @@ function readCheckpointValue(baseOid, value) {
   return { state: 'ready', indexDiff, worktreeDiff };
 }
 
+function checkpointBaseReady(card, reduced, publication) {
+  return Boolean(
+    reduced
+    && publication?.current
+    && reduced.baseOid === card.head?.oid
+    && reduced.branch === card.head?.branch
+    && typeof reduced.indexDiff === 'string'
+    && typeof reduced.worktreeDiff === 'string'
+  );
+}
+
 function checkpointMayPublish(repoKey) {
   return !require('./reducer').isMaterializing(repoKey);
 }
@@ -702,62 +218,108 @@ async function publishPass(replicaId = null) {
   for (const card of listRepoCards()) {
     if (replicaId && card.replica !== replicaId) continue;
     if (card.health !== 'healthy' || card.kind !== 'primary' || card.operation !== 'none') continue;
-    const wall = require('./wall');
-    const project = wall.projectForPath(card.path);
-    const repoKey = project?.repoKey;
+    const repoKey = repoKeyOfCard(card);
     if (!repoKey || !card.head?.oid) continue;
     if (!checkpointMayPublish(repoKey)) {
       run.waiting += 1;
       continue;
     }
     try {
-      const intent = await captureIntentObservation(project, card, null);
-      if (intent.state === 'waiting') {
+      const reduced = require('./reducer').readRepoState(repoKey);
+      const wall = require('./wall');
+      if (!checkpointBaseReady(card, reduced, wall.publicationStatus(repoKey, reduced))) {
         run.waiting += 1;
         continue;
       }
-      if (intent.state === 'rejected') {
-        if (intent.unchanged) run.skips += 1;
-        else run.failures += 1;
-        continue;
-      }
-      if (!intent.checkpoint) {
-        run.skips += 1;
+
+      const captured = await captureCheckpoint(card.path);
+      if (captured.indexDiff === null || captured.baseOid !== card.head.oid) {
+        run.waiting += 1;
         continue;
       }
+      const sharedRevision = revisionOf(card.head.oid, reduced.indexDiff, reduced.worktreeDiff);
+      const localRevision = revisionOf(card.head.oid, captured.indexDiff, captured.worktreeDiff);
       const file = checkpointFile(machine, repoKey);
       const existing = readCheckpoint(machine, repoKey);
-      const to = intent.checkpoint.to;
-      const snapshot = project && fs.existsSync(project.file)
-        ? require('./project-stream').readSnapshot(project.file, project.resourceId)
-        : null;
-      const onOfficialCard = snapshot?.card
-        && wall._test.sameCardState(card, snapshot.card);
-      const from = onOfficialCard
-        ? snapshot.checkpoint.value
-        : { revision: null, indexDiff: '', worktreeDiff: '' };
-      const envelope = {
-        ...intent.checkpoint,
-        from,
-      };
-      if (onOfficialCard && valueIdentity(from) === valueIdentity(to)) {
-        if (existing) {
-          fs.rmSync(file, { force: true });
+      const parked = await Promise.all(localParkedEntries(existing, reduced, card).map(async (entry) => ({
+        ...entry,
+        objects: await require('./objects').bundleSourceFor(card.path, repoKey, entry.oid),
+      })));
+      if (!wall.publicationStatus(repoKey, reduced).current) {
+        run.waiting += 1;
+        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.
+      if (sharedRevision === localRevision) {
+        const refreshed = checkpointForSharedState(existing, {
+          machine,
+          repoKey,
+          branch: card.head.branch,
+          baseOid: card.head.oid,
+          sharedValue: checkpointValue(
+            machine,
+            repoKey,
+            card.head.oid,
+            reduced.indexDiff,
+            reduced.worktreeDiff,
+          ),
+          parked,
+        });
+        if (refreshed && !sameTransition(existing, refreshed)) {
+          fs.writeFileSync(file, `${JSON.stringify(refreshed)}\n`);
           appendStateEvent({
             resource: 'repo-checkpoints',
-            op: 'delete',
+            op: 'update',
             id: card.replica,
-            source: 'repo-checkpoint:covered',
+            value: refreshed,
+            source: 'repo-checkpoint:parked-objects',
           });
+          run.published += 1;
+          continue;
         }
         run.skips += 1;
         continue;
       }
+
+      const from = checkpointValue(
+        machine,
+        repoKey,
+        card.head.oid,
+        reduced.indexDiff,
+        reduced.worktreeDiff,
+      );
+      const to = checkpointValue(
+        machine,
+        repoKey,
+        card.head.oid,
+        captured.indexDiff,
+        captured.worktreeDiff,
+      );
+      if (!checkpointValueReady(from) || !checkpointValueReady(to)) {
+        run.waiting += 1;
+        continue;
+      }
+      const envelope = {
+        checkpoint: CHECKPOINT_CONTRACT,
+        machine,
+        repoKey,
+        branch: card.head.branch,
+        baseOid: card.head.oid,
+        from,
+        to,
+        parked,
+        capturedAt: new Date().toISOString(),
+      };
       if (sameTransition(existing, envelope)) {
         run.skips += 1;
         continue;
       }
-      durable.writeJson(file, envelope);
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, `${JSON.stringify(envelope)}\n`);
       appendStateEvent({
         resource: 'repo-checkpoints',
         op: existing ? 'update' : 'insert',
@@ -845,7 +407,10 @@ function checkpointStats() {
 
 module.exports = {
   _test: {
+    checkpointBaseReady,
+    checkpointForSharedState,
     checkpointMayPublish,
+    localParkedEntries,
   },
   CHECKPOINT_CONTRACT,
   MAX_INLINE_DIFF_BYTES,
@@ -853,18 +418,13 @@ module.exports = {
   checkpointStats,
   checkpointValue,
   checkpointValueReady,
-  captureIntentAgainst,
-  captureIntentForCard,
-  captureLocalIntent,
   parseCheckpoint,
   publishCheckpoints,
   readCheckpoint,
   readCheckpointValue,
   repoKeyOfCard,
   revisionOf,
-  revisionOfValue,
   sameTransition,
-  stampCheckpointMutation,
   startCheckpointService,
   stopCheckpointService,
 };