amalgm 0.1.245 → 0.1.246

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

@@ -1,11 +1,13 @@
 'use strict';
 
 /**
- * Local adapter between a checkout and its one canonical project stream.
+ * One ordered card+checkpoint stream per code project.
  *
- * repoKey is only a local lookup alias. resourceId is the sole cloud key.
- * The cloud stores exactly one card and one checkpoint; this file derives
- * one card.set or checkpoint.set proposal from the current checkout.
+ * A project is the authorization pool for one repository. Same-user
+ * machines derive the same resource from (owner, repo identity). A
+ * collaborator binds that repo identity to the owner's resource after the
+ * owner grants membership. Every authorized machine is then an ordinary
+ * writer in the same stream.
  */
 
 const crypto = require('crypto');
@@ -13,22 +15,22 @@ const fs = require('fs');
 const path = require('path');
 const { AMALGM_DIR } = require('../config');
 const { subscribeStateEvents } = require('../state/events');
-const durable = require('./durable');
 const { machineId, userId } = require('./identity');
 const { listRepoCards } = require('./cards');
 const {
   CHECKPOINT_CONTRACT,
+  checkpointValue,
   checkpointValueReady,
   readCheckpoint,
   repoKeyOfCard,
-  stampCheckpointMutation,
+  sameTransition,
 } = require('./checkpoint');
-const projectStream = require('./project-stream');
 
-const { WALL_CONTRACT } = projectStream;
-const PROJECT_DIR = path.join(AMALGM_DIR, 'state', 'code-projects-v2');
+const WALL_CONTRACT = 'code-project@4';
+const PROJECT_DIR = path.join(AMALGM_DIR, 'state', 'code-projects');
 const REGISTRY_FILE = path.join(PROJECT_DIR, 'projects.json');
 const PUBLISH_QUIET_MS = 25;
+const COMPACT_AT_BYTES = 1024 * 1024;
 const ENSURE_STEP_TIMEOUT_MS = 20_000;
 const ENSURE_INTERVAL_MS = 15_000;
 const ATTACH_REJECTED = /shared_resource_read_forbidden/;
@@ -44,6 +46,10 @@ const service = {
   lastPublishedAt: null,
 };
 
+function sha256(text) {
+  return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
 function readRegistry() {
   try {
     const parsed = JSON.parse(fs.readFileSync(REGISTRY_FILE, 'utf8'));
@@ -54,225 +60,155 @@ function readRegistry() {
 }
 
 function writeRegistry(registry) {
-  durable.writeJson(REGISTRY_FILE, registry, { pretty: true });
+  fs.mkdirSync(PROJECT_DIR, { recursive: true });
+  fs.writeFileSync(REGISTRY_FILE, `${JSON.stringify(registry, null, 2)}\n`);
 }
 
-function projectFile(resourceId) {
-  const digest = crypto.createHash('sha256').update(resourceId).digest('hex').slice(0, 24);
-  return path.join(PROJECT_DIR, `${digest}.json`);
-}
-
-function canonicalPath(localPath) {
-  const resolved = path.resolve(localPath);
-  const tail = [];
-  let existing = resolved;
-  while (!fs.existsSync(existing)) {
-    const parent = path.dirname(existing);
-    if (parent === existing) return resolved;
-    tail.unshift(path.basename(existing));
-    existing = parent;
-  }
-  return path.join(fs.realpathSync.native(existing), ...tail);
+function projectResourceId(repoKey, ownerUserId = userId()) {
+  if (!repoKey || !ownerUserId) return null;
+  const digest = crypto.createHash('sha256')
+    .update(`amalgm-code-project@1|${ownerUserId}|${repoKey}`)
+    .digest('base64url');
+  return `shr_cp1${digest.slice(0, 40)}`;
 }
 
-function projectRecord(bound) {
-  if (!bound?.resourceId) return null;
-  return {
-    repoKey: `code-folder:${bound.resourceId}`,
-    resourceId: bound.resourceId,
-    ownerUserId: bound.ownerUserId || null,
-    path: bound?.path || null,
-    file: projectFile(bound.resourceId),
-  };
-}
-
-function projects() {
-  return Object.values(readRegistry()).map(projectRecord).filter(Boolean);
-}
-
-function projectForPath(localPath) {
-  if (!localPath) return null;
-  const resolved = canonicalPath(localPath);
-  return projects().find((project) => (
-    project.path && canonicalPath(project.path) === resolved
-  )) || null;
+function projectFile(resourceId) {
+  const digest = crypto.createHash('sha256').update(resourceId).digest('hex').slice(0, 24);
+  return path.join(PROJECT_DIR, `${digest}.jsonl`);
 }
 
 function projectForRepo(repoKey) {
   if (!repoKey) return null;
-  const direct = projects().find((project) => project.repoKey === repoKey);
-  if (direct) return direct;
-  const card = listRepoCards().find((candidate) => repoKeyOfCard(candidate) === repoKey);
-  return projectForPath(card?.path);
-}
-
-function projectForResource(resourceId) {
-  return projects().find((project) => project.resourceId === resourceId) || null;
+  const bound = readRegistry()[repoKey];
+  const ownerUserId = bound?.ownerUserId || userId();
+  const resourceId = bound?.resourceId || projectResourceId(repoKey, ownerUserId);
+  return resourceId ? {
+    repoKey,
+    resourceId,
+    ownerUserId,
+    path: bound?.path || null,
+    file: projectFile(resourceId),
+  } : null;
 }
 
-function bindProject(resourceId, ownerUserId = null, localPath = null) {
-  const identity = require('./tree/identity');
-  if (!identity.isUuid(String(resourceId || ''))) {
-    throw new Error('resourceId must be the code-folder UUID');
+function bindProject(repoKey, resourceId, ownerUserId = null, localPath = null) {
+  if (!repoKey || typeof repoKey !== 'string') throw new Error('repoKey is required');
+  if (!/^shr_[A-Za-z0-9_-]{16,128}$/.test(String(resourceId || ''))) {
+    throw new Error('resourceId must be an opaque shared resource id');
   }
-  if (!identity.isUuid(String(ownerUserId || ''))) {
-    throw new Error('ownerUserId must be a user UUID');
-  }
-  if (typeof localPath !== 'string' || !path.isAbsolute(localPath)) {
+  if (localPath !== null && (typeof localPath !== 'string' || !path.isAbsolute(localPath))) {
     throw new Error('path must be an absolute folder path');
   }
   const registry = readRegistry();
-  const key = resourceId.toLowerCase();
-  const owner = ownerUserId.toLowerCase();
-  const boundPath = canonicalPath(localPath);
-  const existing = registry[key];
-  if (existing) {
-    if (
-      existing.resourceId === key
-      && existing.ownerUserId === owner
-      && canonicalPath(existing.path) === boundPath
-    ) return projectRecord(existing);
-    throw new Error('that code-folder UUID is already bound differently');
-  }
-  const pathOwner = Object.values(registry).find((bound) => (
-    bound?.path && canonicalPath(bound.path) === boundPath
-  ));
-  if (pathOwner) throw new Error('that folder path is already bound to another code-folder UUID');
-  registry[key] = {
-    resourceId: key,
-    ownerUserId: owner,
-    path: boundPath,
+  const previous = registry[repoKey];
+  registry[repoKey] = {
+    resourceId,
+    ownerUserId: ownerUserId || null,
+    path: localPath || previous?.path || null,
     joinedAt: new Date().toISOString(),
   };
   writeRegistry(registry);
-  require('./store').upsertWorkspace({
-    path: boundPath,
-    name: path.basename(boundPath),
-    source: 'computer',
-    managed: false,
-  }, { source: 'workspace:code-project-bind' });
-  const project = projectRecord(registry[key]);
   if (service.started) {
-    ensureProjectBound(project)
+    ensureProjectBound(projectForRepo(repoKey))
       .then(() => {
         schedulePublish();
         return require('./reducer').reduceNow();
       })
       .catch(() => {});
   }
-  return project;
+  return projectForRepo(repoKey);
 }
 
-function wallReplica(project) {
-  const replica = require('../state/replicas').getReplicaByResourceId(project.resourceId);
-  return replica?.contract === projectStream.STREAM_CONTRACT ? replica : null;
+function projects() {
+  const byRepo = new Map();
+  for (const card of listRepoCards()) {
+    const repoKey = repoKeyOfCard(card);
+    if (repoKey && !byRepo.has(repoKey)) byRepo.set(repoKey, projectForRepo(repoKey));
+  }
+  for (const repoKey of Object.keys(readRegistry())) {
+    if (!byRepo.has(repoKey)) byRepo.set(repoKey, projectForRepo(repoKey));
+  }
+  return [...byRepo.values()].filter(Boolean);
 }
 
-function outboundState(rows) {
-  const terminal = rows.find((row) => row.state === 'rejected' || row.state === 'conflicted');
-  return {
-    pending: rows.length,
-    terminalError: terminal
-      ? terminal.lastError || `code publication ${terminal.mutationId} was ${terminal.state}`
-      : null,
-  };
+function wallReplica(project) {
+  return require('../state/replicas').getReplicaByResourceId(project.resourceId);
 }
 
 function publicationStatus(repoKey, reduced = undefined) {
   const project = projectForRepo(repoKey);
   const replica = project ? wallReplica(project) : null;
   const receivedThrough = replica?.appliedVersion ?? null;
-  if (project && Number.isInteger(receivedThrough)) {
-    require('../state/mutations').retireStaleCodeMutations(
-      project.resourceId,
-      receivedThrough,
-    );
-  }
   const baseline = reduced === undefined
-    ? require('./reducer').readRepoState(repoKey, project?.resourceId)
+    ? require('./reducer').readRepoState(repoKey)
     : reduced;
   const appliedThrough = Number.isInteger(baseline?.appliedThrough)
     ? baseline.appliedThrough
     : receivedThrough === 0 && !baseline ? 0 : null;
-  const mutations = require('../state/mutations');
-  const pendingRows = project
-    ? mutations.listPendingCloudMutations(project.resourceId)
-    : [];
-  const officialRows = project
-    ? mutations.listUnappliedOfficialMutations(project.resourceId)
-    : [];
-  const outgoing = outboundState(pendingRows);
+  const pending = project
+    ? require('../state/mutations').listPendingCloudMutations(project.resourceId).length
+    : 0;
   return {
     receivedThrough,
     appliedThrough,
-    ...outgoing,
-    awaitingOfficial: officialRows.length,
+    pending,
     current: receivedThrough !== null
       && appliedThrough === receivedThrough
-      && outgoing.pending === 0
-      && officialRows.length === 0,
+      && pending === 0,
   };
 }
 
-function localRepo(card, repoKey) {
-  return card?.repo || (
-    repoKey.startsWith('root:')
-      ? { remote: null, rootCommit: repoKey.slice(5) }
-      : { remote: repoKey, rootCommit: null }
-  );
+function parseWallLine(line) {
+  try {
+    const entry = JSON.parse(line);
+    if (
+      entry?.wall !== WALL_CONTRACT
+      || !entry.project
+      || !entry.machine
+      || !entry.mutationId
+      || !Array.isArray(entry.cards)
+    ) return null;
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+function sealCardVersions(project, card) {
+  return {
+    ...card,
+    positionVersion: validVersion(card.positionVersion)
+      ? card.positionVersion
+      : officialVersion(project.resourceId, card.positionMutationId),
+    branches: (card.branches || []).map((ref) => ({
+      ...ref,
+      version: validVersion(ref.version)
+        ? ref.version
+        : officialVersion(project.resourceId, ref.mutationId),
+    })),
+    checkpoints: (card.checkpoints || []).map((checkpoint) => ({
+      ...checkpoint,
+      version: validVersion(checkpoint.version)
+        ? checkpoint.version
+        : officialVersion(project.resourceId, checkpoint.mutationId),
+    })),
+  };
 }
 
-/**
- * The reducer still consumes its local card-shaped projection. This adapter
- * is not shared state: it injects the local repo alias and derives one exact
- * clean→current checkpoint transition from the canonical two values.
- */
 function readProjectWall(project) {
-  const snapshot = projectStream.readSnapshot(project.file, project.resourceId);
-  if (!snapshot.card || !snapshot.checkpoint) return [];
-  const card = snapshot.card;
-  const checkpoint = snapshot.checkpoint;
-  return [{
-    wall: WALL_CONTRACT,
-    project: project.resourceId,
-    resourceId: project.resourceId,
-    machine: card.machine,
-    mutationId: card.mutationId,
-    version: snapshot.version,
-    cards: [{
-      card: projectStream.CARD_CONTRACT,
-      machine: card.machine,
-      replica: `official:${project.resourceId}`,
-      repo: localRepo(null, project.repoKey),
-      kind: 'primary',
-      health: 'healthy',
-      head: card.head,
-      objects: card.objects,
-      positionMachine: card.machine,
-      positionMutationId: card.mutationId,
-      positionVersion: card.version,
-      branches: card.branches.map((branch) => ({
-        ...branch,
-        machine: card.machine,
-        mutationId: card.mutationId,
-        version: card.version,
-      })),
-      checkpoints: [{
-        checkpoint: CHECKPOINT_CONTRACT,
-        machine: checkpoint.machine,
-        baseOid: checkpoint.baseOid,
-        branch: checkpoint.branch,
-        from: {
-          revision: null,
-          indexDiff: '',
-          worktreeDiff: '',
-        },
-        to: checkpoint.value,
-        mutationId: checkpoint.mutationId,
-        version: checkpoint.version,
-      }],
-    }],
-  }];
+  if (!fs.existsSync(project.file)) return [];
+  const entries = new Map();
+  for (const line of require('../state/docs').getDocText(project.file).split('\n')) {
+    if (!line) continue;
+    const entry = parseWallLine(line);
+    if (entry?.project !== project.repoKey) continue;
+    entries.set(entry.machine, {
+      ...entry,
+      resourceId: project.resourceId,
+      cards: entry.cards.map((card) => sealCardVersions(project, card)),
+    });
+  }
+  return [...entries.values()];
 }
 
 function readWall(repoKey = null) {
@@ -280,120 +216,365 @@ function readWall(repoKey = null) {
   return selected.flatMap((project) => readProjectWall(project));
 }
 
+function publishedCardFor(card) {
+  const repoKey = repoKeyOfCard(card);
+  if (!repoKey) return null;
+  const own = readWall(repoKey).find((entry) => entry.machine === machineId());
+  const published = own?.cards?.find((candidate) => candidate.replica === card.replica);
+  if (
+    !published
+    || !Number.isInteger(published.positionVersion)
+    || published.positionVersion < 1
+    || published.head?.branch !== card.head?.branch
+    || published.head?.oid !== card.head?.oid
+    || Boolean(published.head?.detached) !== Boolean(card.head?.detached)
+    || hasObjectUpgrade(card, { card: published, branches: published.branches })
+  ) return null;
+  return published;
+}
+
 function samePosition(left, right) {
   return left?.head?.branch === right?.head?.branch
     && left?.head?.oid === right?.head?.oid
     && Boolean(left?.head?.detached) === Boolean(right?.head?.detached);
 }
 
-function branchIdentity(refs) {
-  return JSON.stringify((refs || [])
-    .map((ref) => ({ name: ref.name, oid: ref.oid }))
-    .sort((left, right) => left.name.localeCompare(right.name)));
-}
-
-function sameCardState(localCard, officialCard) {
-  return samePosition(localCard, officialCard)
-    && branchIdentity(localCard?.refs || localCard?.branches)
-      === branchIdentity(officialCard?.refs || officialCard?.branches);
-}
-
-function publishedCardFor(card) {
-  const project = projectForPath(card?.path);
-  if (!project) return null;
-  const projected = readProjectWall(project)[0]?.cards?.[0] || null;
-  return projected && sameCardState(card, projected) ? projected : null;
-}
-
-function isCommittedCard(card) {
-  return typeof card?.head?.oid === 'string'
-    && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(card.head.oid);
-}
-
-function cardPayloadsReady(card) {
-  if (card.head?.oid && card.objects?.kind !== 'bundle') return false;
-  return (card.refs || card.branches || []).every((ref) => (
-    !ref.oid || ref.objects?.kind === 'bundle'
-  ));
+function oidMap(refs) {
+  return new Map((refs || []).map((ref) => [ref.name, ref.oid ?? null]));
 }
 
-function hasPendingContributionObjects(card) {
-  return !cardPayloadsReady(card);
-}
+/**
+ * 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, previousCard = 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
+    && !baseline.pendingCard;
+  const alreadyPublished = validVersion(previousCard?.positionVersion)
+    && samePosition(card, previousCard);
+  const reversesPublishedSharedPosition = previousCard
+    && validVersion(previousCard.positionVersion)
+    && samePosition(previousCard, plan.card)
+    && !alreadyPublished;
+  if ((!onRail && !atBaseline && !alreadyPublished) || reversesPublishedSharedPosition) return true;
+
+  const currentRefs = oidMap(card.refs);
+  const railRefs = oidMap(plan.branches);
+  const baselineRefs = oidMap(baseline?.branches);
+  const previousRefs = new Map(
+    (previousCard?.branches || previousCard?.refs || []).map((ref) => [ref.name, ref]),
+  );
+  for (const name of new Set([
+    ...currentRefs.keys(),
+    ...baselineRefs.keys(),
+    ...previousRefs.keys(),
+  ])) {
+    const current = currentRefs.get(name) ?? null;
+    const shared = railRefs.get(name) ?? null;
+    const previous = baselineRefs.get(name) ?? null;
+    const publishedRef = previousRefs.get(name);
+    const published = publishedRef?.oid ?? null;
+    const matchesBaseline = baselineRefs.has(name) && current === previous;
+    const matchesPublished = validVersion(publishedRef?.version) && current === published;
+    const reversesPublishedSharedValue = validVersion(publishedRef?.version)
+      && published === shared
+      && current !== published;
+    if (
+      current !== shared
+      && ((!matchesBaseline && !matchesPublished) || reversesPublishedSharedValue)
+    ) return true;
+  }
 
-function checkpointForCard(card, repoKey) {
-  const checkpoint = readCheckpoint(machineId(), repoKey);
   if (
-    checkpoint
-    && checkpoint.checkpoint === CHECKPOINT_CONTRACT
+    onRail
+    && checkpoint
     && checkpoint.baseOid === card.head?.oid
     && checkpoint.branch === card.head?.branch
-    && checkpointValueReady(checkpoint.to)
-  ) return checkpoint;
-  const dirty = card.dirty || {};
-  const clean = ['staged', 'unstaged', 'untracked', 'conflicted', 'submodulesChanged']
-    .every((key) => Number(dirty[key] || 0) === 0);
-  return clean ? {
+  ) {
+    const latest = [...(plan.transitions || [])]
+      .reverse()
+      .find((entry) => entry.machine === checkpoint.machine);
+    if (!sameTransition(latest, 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 checkpointBaseFor(card, baseline, project, shared = null) {
+  if (
+    !baseline
+    || baseline.baseOid !== card.head?.oid
+    || baseline.branch !== card.head?.branch
+    || !Number.isInteger(baseline.appliedThrough)
+    || baseline.appliedThrough < 0
+  ) return null;
+  const value = checkpointValue(
+    machineId(),
+    project.repoKey,
+    card.head.oid,
+    baseline.indexDiff || '',
+    baseline.worktreeDiff || '',
+  );
+  if (!checkpointValueReady(value)) return null;
+  const reusableThrough = shared
+    && shared.baseOid === card.head.oid
+    && shared.branch === card.head.branch
+    && shared.value?.revision === value.revision
+    && Number.isInteger(shared.through)
+    && shared.through >= 0;
+  return {
     checkpoint: CHECKPOINT_CONTRACT,
     baseOid: card.head.oid,
     branch: card.head.branch,
-    from: { revision: null, indexDiff: '', worktreeDiff: '' },
-    to: { revision: null, indexDiff: '', worktreeDiff: '' },
-  } : null;
+    through: reusableThrough ? shared.through : baseline.appliedThrough,
+    value,
+  };
 }
 
-function cardSet(card, checkpoint) {
-  return {
-    kind: 'card.set',
-    card: projectStream.CARD_CONTRACT,
-    head: {
-      branch: card.head.branch ?? null,
-      oid: card.head.oid,
-      detached: Boolean(card.head.detached),
-    },
-    objects: card.objects,
-    branches: (card.refs || card.branches || []).map((ref) => ({
-      name: ref.name,
-      oid: ref.oid,
-      objects: ref.objects,
-    })),
-    checkpoint: {
-      checkpoint: CHECKPOINT_CONTRACT,
-      baseOid: card.head.oid,
-      branch: card.head.branch ?? null,
-      value: checkpoint.to,
-    },
-  };
+function hasCheckpointBaseUpgrade(card, plan, baseline, project) {
+  const shared = plan?.card?.checkpointBase;
+  const candidate = checkpointBaseFor(card, baseline, project, shared);
+  return Boolean(shared && candidate) && (
+    candidate.through === shared.through
+    && candidate.value?.revision === shared.value?.revision
+    && JSON.stringify(candidate.value) !== JSON.stringify(shared.value)
+  );
 }
 
-function checkpointSet(card, checkpoint, officialCheckpoint) {
+function validVersion(value) {
+  return Number.isInteger(value) && value > 0;
+}
+
+function knownMutation(resourceId, mutationId) {
+  if (!mutationId) return false;
+  return Boolean(require('../state/mutations').getMutation(`resource:${resourceId}`, mutationId));
+}
+
+function officialVersion(resourceId, mutationId) {
+  if (!mutationId) return null;
+  const mutation = require('../state/mutations').getMutation(`resource:${resourceId}`, mutationId);
+  return Number.isInteger(mutation?.officialCloudVersion) ? mutation.officialCloudVersion : null;
+}
+
+function sealedVersion(resourceId, mutationId, ...versions) {
+  return versions.find(validVersion)
+    || officialVersion(resourceId, mutationId)
+    || null;
+}
+
+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 previousReusable = unchanged
+      && before.mutationId
+      && (validVersion(before.version) || knownMutation(resourceId, before.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,
+      ...(observed?.objects ? { objects: observed.objects } : {}),
+      mutationId: mutation,
+      version: sealedVersion(
+        resourceId,
+        mutation,
+        mutation === before?.mutationId ? before.version : null,
+        mutation === onRail?.mutationId ? onRail.version : null,
+        mutation === materialized?.mutationId ? materialized.version : null,
+      ),
+    };
+  });
+}
+
+function sharedCard(card) {
   return {
-    kind: 'checkpoint.set',
-    checkpoint: CHECKPOINT_CONTRACT,
-    baseOid: card.head.oid,
-    branch: card.head.branch ?? null,
-    from: officialCheckpoint.value,
-    to: checkpoint.to,
+    card: card.card,
+    machine: card.machine,
+    replica: card.replica,
+    repo: card.repo,
+    objects: card.objects,
+    kind: card.kind,
+    head: {
+      branch: card.head?.branch ?? null,
+      oid: card.head?.oid ?? null,
+      detached: Boolean(card.head?.detached),
+    },
+    health: card.health,
   };
 }
 
-function hasLocalContribution(card, plan) {
-  return !plan?.card || !sameCardState(card, plan.card);
+function isCommittedCard(card) {
+  return typeof card?.head?.oid === 'string' && /^[0-9a-f]{40,64}$/.test(card.head.oid);
 }
 
-function publishProject(project, rawCards) {
-  const intents = require('./intent');
-  const intent = intents.readOwnedIntent(project);
-  if (intent?.terminal) {
-    service.counters.publishSkips += 1;
+function stampCards(cards, previousCards, sharedPlan, baseline, mutationId, project) {
+  const previousByReplica = new Map(
+    (previousCards || []).filter((card) => card?.replica).map((card) => [card.replica, card]),
+  );
+  return cards.map((card) => {
+    const previous = previousByReplica.get(card.replica);
+    const reusablePosition = samePosition(previous, card)
+      && previous?.positionMutationId
+      && (
+        validVersion(previous.positionVersion)
+        || knownMutation(project.resourceId, previous.positionMutationId)
+      );
+    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 positionVersion = sealedVersion(
+      project.resourceId,
+      positionMutationId,
+      positionMutationId === previous?.positionMutationId ? previous.positionVersion : null,
+      positionMutationId === sharedPlan?.card?.positionMutationId
+        ? sharedPlan.card.positionVersion
+        : null,
+      positionMutationId === baseline?.cardMutationId ? baseline.cardVersion : null,
+    );
+    const checkpoint = readCheckpoint(machineId(), project.repoKey);
+    const currentCheckpoint = checkpoint
+      && checkpoint.baseOid === card.head?.oid
+      && checkpoint.branch === card.head?.branch
+      ? checkpoint
+      : null;
+    const checkpointBase = checkpointBaseFor(
+      card,
+      baseline,
+      project,
+      sharedPlan?.card?.checkpointBase,
+    );
+    const sameBase = previous?.head?.oid === card.head?.oid
+      && previous?.head?.branch === card.head?.branch;
+    const history = sameBase && Array.isArray(previous?.checkpoints)
+      ? previous.checkpoints.map((entry) => ({
+        ...entry,
+        version: sealedVersion(
+          project.resourceId,
+          entry.mutationId,
+          entry.version,
+        ),
+      })).filter((entry) => (
+        validVersion(entry.version)
+        && (!checkpointBase || entry.version > checkpointBase.through)
+      ))
+      : [];
+    const last = history.at(-1);
+    const checkpoints = currentCheckpoint
+      ? (sameTransition(last, currentCheckpoint)
+        ? history
+        : [...history, { ...currentCheckpoint, mutationId }])
+      : history;
     return {
-      published: false,
-      reason: 'local-intent-rejected',
-      terminalError: intent.terminal.message,
-      terminalCode: intent.terminal.code,
-      repoKey: project.repoKey,
+      ...sharedCard(card),
+      positionMutationId,
+      positionVersion,
+      branches: stampBranches(
+        card.refs,
+        previous?.branches,
+        sharedPlan?.branches,
+        baseline?.branches,
+        mutationId,
+        project.resourceId,
+      ),
+      ...(checkpointBase ? { checkpointBase } : {}),
+      ...(checkpoints.length ? { checkpoints } : {}),
     };
+  });
+}
+
+function withoutPublishedAt(line) {
+  const entry = parseWallLine(line);
+  if (!entry) return line;
+  const { publishedAt, mutationId, ...rest } = entry;
+  return JSON.stringify(rest);
+}
+
+/**
+ * Keep every machine's newest complete record and delete the largest span
+ * containing none of them. Repeating this as the wall grows removes all
+ * obsolete history, even when a retired machine's last record is near the
+ * beginning. Each pass is one deletion, so concurrent appends commute in Yjs.
+ */
+function compactWallText(current, repoKey) {
+  const latest = new Map();
+  const lines = current.split('\n');
+  let offset = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const entry = line ? parseWallLine(line) : null;
+    const end = offset + line.length + (index < lines.length - 1 ? 1 : 0);
+    if (entry?.project === repoKey) latest.set(entry.machine, { start: offset, end });
+    offset = end;
+  }
+  if (latest.size === 0) return current;
+  const records = [...latest.values()].sort((left, right) => left.start - right.start);
+  const gaps = [{ start: 0, end: records[0].start }];
+  for (let index = 0; index < records.length - 1; index += 1) {
+    gaps.push({ start: records[index].end, end: records[index + 1].start });
   }
+  const gap = gaps.reduce((largest, candidate) => (
+    candidate.end - candidate.start > largest.end - largest.start ? candidate : largest
+  ));
+  if (gap.end <= gap.start) return current;
+  return `${current.slice(0, gap.start)}${current.slice(gap.end)}`;
+}
+
+function publishProject(project, rawCards) {
   const replica = wallReplica(project);
   if (!replica) {
     service.counters.publishSkips += 1;
@@ -403,110 +584,116 @@ function publishProject(project, rawCards) {
     service.counters.publishSkips += 1;
     return { published: false, reason: 'repo-materializing', repoKey: project.repoKey };
   }
-  const status = publicationStatus(project.repoKey);
-  if (!status.current) {
+  const docs = require('../state/docs');
+  let current = docs.getDocText(project.file);
+  let previous = null;
+  let previousEntry = null;
+  for (const line of current.split('\n')) {
+    if (!line) continue;
+    const entry = parseWallLine(line);
+    if (entry?.project === project.repoKey && entry.machine === machineId()) {
+      previous = line;
+      previousEntry = entry;
+    }
+  }
+
+  const reducer = require('./reducer');
+  const sharedPlan = reducer.reduceWall(readProjectWall(project)).get(project.repoKey);
+  const baseline = reducer.readRepoState(project.repoKey);
+  const previousCards = (previousEntry?.cards || []).map((card) => sealCardVersions(project, card));
+  const previousReplicas = new Set(previousCards.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);
+    const previousCard = previousCards.find((entry) => entry.replica === card.replica);
+    return hasLocalContribution(card, sharedPlan, baseline, checkpoint, previousCard)
+      || hasObjectUpgrade(card, sharedPlan)
+      || hasCheckpointBaseUpgrade(card, sharedPlan, baseline, project);
+  });
+  if (!removed && !contributes) {
     service.counters.publishSkips += 1;
-    return {
-      published: false,
-      reason: status.terminalError ? 'publication-rejected' : 'project-not-current',
-      mayMaterialize: true,
-      repoKey: project.repoKey,
-      ...status,
-    };
+    return { published: false, reason: 'shared-state-covered', repoKey: project.repoKey };
   }
-  if (!intent) {
+  const mutationId = `mut_project_${crypto.randomBytes(16).toString('base64url')}`;
+  const cards = stampCards(
+    rawCards,
+    previousCards,
+    sharedPlan,
+    baseline,
+    mutationId,
+    project,
+  );
+  const mine = JSON.stringify({
+    wall: WALL_CONTRACT,
+    project: project.repoKey,
+    machine: machineId(),
+    mutationId,
+    publishedAt: new Date().toISOString(),
+    cards,
+  });
+  const unchanged = previous !== null
+    && withoutPublishedAt(previous) === withoutPublishedAt(mine);
+  if (unchanged) {
     service.counters.publishSkips += 1;
-    return {
-      published: false,
-      reason: 'shared-state-covered',
-      mayMaterialize: true,
-      repoKey: project.repoKey,
-    };
+    return { published: false, reason: 'unchanged', repoKey: project.repoKey };
   }
-  if (intent.base.through !== status.appliedThrough) {
+  const status = publicationStatus(project.repoKey, baseline);
+  if (!status.current) {
     service.counters.publishSkips += 1;
     return {
       published: false,
-      reason: 'local-intent-refreshing',
-      mayMaterialize: true,
+      reason: 'project-not-current',
       repoKey: project.repoKey,
+      ...status,
     };
   }
-  const card = intent.local.card;
-  const checkpoint = {
-    checkpoint: CHECKPOINT_CONTRACT,
-    baseOid: intent.local.checkpoint.baseOid,
-    branch: intent.local.checkpoint.branch,
-    from: null,
-    to: intent.local.checkpoint.value,
-  };
-  const snapshot = projectStream.readSnapshot(project.file, project.resourceId);
-  let delta = null;
-  if (!snapshot.card || !sameCardState(card, snapshot.card)) {
-    if (!cardPayloadsReady(card)) {
-      service.counters.publishSkips += 1;
-      return { published: false, reason: 'objects-preparing', repoKey: project.repoKey };
+
+  const separator = current && !current.endsWith('\n') ? '\n' : '';
+  if (Buffer.byteLength(`${current}${separator}${mine}\n`, 'utf8') > COMPACT_AT_BYTES) {
+    const compacted = compactWallText(current, project.repoKey);
+    if (compacted !== current) {
+      docs.writeDocText(project.file, compacted, {
+        baseHash: sha256(current),
+        mutationId: `mut_project_compact_${crypto.randomBytes(16).toString('base64url')}`,
+      });
+      current = docs.getDocText(project.file);
     }
-    delta = cardSet(card, checkpoint);
-  } else if (checkpoint.to.revision !== snapshot.checkpoint?.value?.revision) {
-    delta = checkpointSet(card, checkpoint, snapshot.checkpoint);
-  }
-  if (!delta) {
-    delta = checkpointSet(card, checkpoint, snapshot.checkpoint);
-  }
-  const reserved = intents.reservePublication(project, intent);
-  if (!reserved?.publication?.mutationId) {
-    service.counters.publishSkips += 1;
-    return {
-      published: false,
-      reason: 'local-intent-refreshing',
-      mayMaterialize: true,
-      repoKey: project.repoKey,
-    };
   }
-  const result = projectStream.publish(
-    project,
-    delta,
-    reserved.publication.mutationId,
+  const nextSeparator = current && !current.endsWith('\n') ? '\n' : '';
+  const result = docs.writeDocText(
+    project.file,
+    `${current}${nextSeparator}${mine}\n`,
+    { baseHash: sha256(current), mutationId },
   );
-  stampCheckpointMutation(machineId(), project.repoKey, checkpoint, result.mutation.mutationId);
   service.counters.publishes += 1;
   service.lastPublishedAt = new Date().toISOString();
   return {
     published: true,
     repoKey: project.repoKey,
     resourceId: project.resourceId,
-    mutationId: result.mutation.mutationId,
-    delta: delta.kind,
+    mutationId: result.mutationId,
+    merge: result.merge,
+    cards: cards.length,
   };
 }
 
 function publishSelected(selected, allCards, publisher = publishProject) {
   return selected.map((project) => {
     try {
-      const cards = allCards.filter((card) => (
-        projectForPath(card.path)?.resourceId === project.resourceId
-        && isCommittedCard(card)
-        && card.kind === 'primary'
-        && card.health === 'healthy'
-        && card.operation === 'none'
-      ));
-      if (cards.length === 0) {
-        service.counters.publishSkips += 1;
-        return {
-          published: false,
-          reason: 'local-checkout-unavailable',
-          repoKey: project.repoKey,
-        };
-      }
-      return publisher(project, cards);
+      return publisher(
+        project,
+        allCards.filter((card) => (
+          repoKeyOfCard(card) === project.repoKey
+          && isCommittedCard(card)
+        )),
+      );
     } catch (error) {
       service.counters.publishFailures += 1;
       console.warn(`[CodeProject] ${project.repoKey} publish failed:`, error.message);
       return {
         published: false,
         reason: 'publish-failed',
-        terminalError: error.message,
         repoKey: project.repoKey,
         error: error.message,
       };
@@ -554,38 +741,27 @@ async function ensureProject(project) {
   const attachments = require('../state/attachments');
   const promotions = require('../state/promotions');
   fs.mkdirSync(path.dirname(project.file), { recursive: true });
-  if (!fs.existsSync(project.file)) {
-    projectStream.writeSnapshot(project.file, projectStream.emptySnapshot(project.resourceId));
-  }
+  if (!fs.existsSync(project.file)) fs.writeFileSync(project.file, '');
 
-  const request = attachments.getAttachmentByResource(project.resourceId);
+  let request = attachments.getAttachmentByResource(project.resourceId);
   if (!request) {
     await callLocal(shared.handleAttachmentStart, {
       resourceId: project.resourceId,
       path: project.file,
-      contract: projectStream.STREAM_CONTRACT,
     });
   } else if (request.state === 'rejected') {
-    let promotion = promotions.getPromotionByResource(project.resourceId);
     if (
       ATTACH_REJECTED.test(request.lastError || '')
-      && project.ownerUserId === userId()
-      && !promotion
+      && project.resourceId === projectResourceId(project.repoKey, userId())
+      && !promotions.getPromotionByResource(project.resourceId)
     ) {
       await callLocal(shared.handlePromotionStart, {
         resourceId: project.resourceId,
         path: project.file,
-        contract: projectStream.STREAM_CONTRACT,
-        schemaVersion: 2,
       });
-      promotion = await waitForSettled(
-        project,
-        () => promotions.getPromotionByResource(project.resourceId),
-      );
-    }
-    if (!wallReplica(project) && promotion?.state === 'promoted') {
-      attachments.retryAttachment(project.resourceId);
+      await waitForSettled(project, () => promotions.getPromotionByResource(project.resourceId));
     }
+    if (!wallReplica(project)) attachments.retryAttachment(project.resourceId);
   }
   await waitForSettled(project, () => attachments.getAttachmentByResource(project.resourceId));
   if (wallReplica(project)) schedulePublish();
@@ -626,12 +802,13 @@ function startWallService() {
   if (service.started) return;
   service.started = true;
   service.unsubscribe = subscribeStateEvents((event) => {
+    const acknowledged = event.resource === 'shared-mutations'
+      && projects().some((project) => project.resourceId === event.sharedResourceId);
     if (
       event.resource === 'repo-cards'
       || event.resource === 'repo-checkpoints'
       || event.resource === 'repo-objects'
-      || event.resource === 'shared-mutations'
-      || String(event.resource || '').startsWith(projectStream.LOCAL_RESOURCE_PREFIX)
+      || acknowledged
     ) {
       ensureProjects().catch(() => {});
       schedulePublish();
@@ -660,7 +837,6 @@ function stopWallService() {
 function wallStats() {
   const rows = projects().map((project) => {
     const replica = wallReplica(project);
-    const snapshot = projectStream.readSnapshot(project.file, project.resourceId);
     return {
       repoKey: project.repoKey,
       resourceId: project.resourceId,
@@ -674,7 +850,7 @@ function wallStats() {
         lastError: replica.lastError,
         updatedAt: replica.updatedAt,
       },
-      version: snapshot.version,
+      machines: readProjectWall(project).length,
     };
   });
   return {
@@ -689,28 +865,20 @@ function wallStats() {
 }
 
 module.exports = {
-  _test: {
-    cardPayloadsReady,
-    checkpointForCard,
-    hasPendingContributionObjects,
-    ensureProject,
-    outboundState,
-    publishProject,
-    publishSelected,
-    sameCardState,
-  },
+  _test: { publishSelected },
   WALL_CONTRACT,
   bindProject,
+  compactWallText,
   hasLocalContribution,
   isCommittedCard,
   projectFile,
-  projectForPath,
   projectForRepo,
-  projectForResource,
+  projectResourceId,
   publicationStatus,
   publishedCardFor,
   publishWall,
   readWall,
+  stampCards,
   startWallService,
   stopWallService,
   wallStats,