amalgm 0.1.175 → 0.1.176

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

@@ -1,26 +1,13 @@
 'use strict';
 
 /**
- * The machine wall: every machine's repo cards, shared across the
- * account's devices on the wave-3 rail.
+ * One ordered card+checkpoint stream per code project.
  *
- * The wall is one shared live document per account — a jsonl file where
- * each machine owns exactly one line, its full card set. Single-writer
- * per line means concurrent publishes from different machines are
- * disjoint edits the doc rail merges perfectly; the doc itself rides the
- * exact journal → outbox → gateway-stamp → fanout → catch-up spine every
- * shared document rides. No new transport, no new failure modes.
- *
- * The wall's resource id is derived from the account, so every machine
- * finds it without a rendezvous service: attach first; if the cloud has
- * never heard of it, promote it into existence; if two machines race,
- * exactly one create wins and the loser attaches. Access is enforced by
- * the gateway's membership check — another account attaching this id gets
- * a flat 403, which is the cross-account gate this slice must prove.
- *
- * Publishing is gated on the replica binding: until the wall is attached,
- * the local file stays empty (which is exactly what attachment requires)
- * and nothing is written. Cards therefore never ride an unbound file.
+ * 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');
@@ -30,21 +17,23 @@ const { AMALGM_DIR } = require('../config');
 const { subscribeStateEvents } = require('../state/events');
 const { machineId, userId } = require('./identity');
 const { listRepoCards } = require('./cards');
+const { readCheckpoint, repoKeyOfCard } = require('./checkpoint');
 
-const WALL_CONTRACT = 'machine-cards@4';
-const WALL_FILE = path.join(AMALGM_DIR, 'state', 'machine-cards-v4.jsonl');
+const WALL_CONTRACT = 'code-project@1';
+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 ENSURE_STEP_TIMEOUT_MS = 20_000;
-const ENSURE_RETRY_MS = 15_000;
+const ENSURE_INTERVAL_MS = 15_000;
 const ATTACH_REJECTED = /shared_resource_read_forbidden/;
 
 const service = {
   started: false,
-  stopRequested: false,
   publishTimer: null,
-  ensureTimer: null,
+  ensureInterval: null,
   unsubscribe: null,
-  ensure: { state: 'idle', attempts: 0, lastError: null },
+  ensuring: new Map(),
+  ensure: new Map(),
   counters: { publishes: 0, publishSkips: 0, publishFailures: 0 },
   lastPublishedAt: null,
 };
@@ -53,90 +42,230 @@ function sha256(text) {
   return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
 }
 
-/** The account's wall resource id — same on every machine of the account. */
-function wallResourceId(forUserId = userId()) {
-  if (!forUserId) return null;
+function readRegistry() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(REGISTRY_FILE, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeRegistry(registry) {
+  fs.mkdirSync(PROJECT_DIR, { recursive: true });
+  fs.writeFileSync(REGISTRY_FILE, `${JSON.stringify(registry, null, 2)}\n`);
+}
+
+function projectResourceId(repoKey, ownerUserId = userId()) {
+  if (!repoKey || !ownerUserId) return null;
   const digest = crypto.createHash('sha256')
-    .update(`amalgm-machine-wall@4|${forUserId}`)
+    .update(`amalgm-code-project@1|${ownerUserId}|${repoKey}`)
     .digest('base64url');
-  return `shr_mw4${digest.slice(0, 40)}`;
+  return `shr_cp1${digest.slice(0, 40)}`;
+}
+
+function projectFile(resourceId) {
+  const digest = crypto.createHash('sha256').update(resourceId).digest('hex').slice(0, 24);
+  return path.join(PROJECT_DIR, `${digest}.jsonl`);
 }
 
-function wallReplica() {
-  const resourceId = wallResourceId();
-  if (!resourceId) return null;
-  return require('../state/replicas').getReplicaByResourceId(resourceId);
+function projectForRepo(repoKey) {
+  if (!repoKey) return null;
+  const bound = readRegistry()[repoKey];
+  const ownerUserId = bound?.ownerUserId || userId();
+  const resourceId = bound?.resourceId || projectResourceId(repoKey, ownerUserId);
+  return resourceId ? { repoKey, resourceId, ownerUserId, file: projectFile(resourceId) } : null;
+}
+
+function bindProject(repoKey, resourceId, ownerUserId = 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');
+  }
+  const registry = readRegistry();
+  registry[repoKey] = {
+    resourceId,
+    ownerUserId: ownerUserId || null,
+    joinedAt: new Date().toISOString(),
+  };
+  writeRegistry(registry);
+  if (service.started) ensureProjectBound(projectForRepo(repoKey)).catch(() => {});
+  return projectForRepo(repoKey);
+}
+
+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 wallReplica(project) {
+  return require('../state/replicas').getReplicaByResourceId(project.resourceId);
 }
 
 function parseWallLine(line) {
   try {
     const entry = JSON.parse(line);
-    if (entry?.wall !== WALL_CONTRACT || !entry.machine || !Array.isArray(entry.cards)) return null;
+    if (
+      entry?.wall !== WALL_CONTRACT
+      || !entry.project
+      || !entry.machine
+      || !Array.isArray(entry.cards)
+    ) return null;
     return entry;
   } catch {
     return null;
   }
 }
 
-/**
- * Every machine's published line, keyed by machine — the wall as this
- * machine currently sees it. Lines that do not parse as wall entries are
- * ignored; the next publish from their machine replaces them.
- */
-function readWall() {
-  if (!fs.existsSync(WALL_FILE)) return [];
+function readProjectWall(project) {
+  if (!fs.existsSync(project.file)) return [];
   const entries = new Map();
-  for (const line of require('../state/docs').getDocText(WALL_FILE).split('\n')) {
+  for (const line of require('../state/docs').getDocText(project.file).split('\n')) {
     if (!line) continue;
     const entry = parseWallLine(line);
-    if (entry) entries.set(entry.machine, entry);
+    if (entry?.project === project.repoKey) entries.set(entry.machine, entry);
   }
   return [...entries.values()];
 }
 
-/**
- * Write this machine's line — and only this machine's line — into the
- * wall. Other machines' parseable lines are preserved byte-for-byte in
- * place, so the resulting doc edit is exactly one line's splice and
- * concurrent publishes from other machines never overlap it.
- *
- * Lines that do not parse as wall entries are deleted, not preserved: a
- * garbled line is nobody's line (every writer replaces its own on the
- * next publish), and keeping it would make corruption permanent — no
- * writer would ever own the bytes. Deleting it is safe under concurrent
- * publishes because valid lines are disjoint per machine and the doc
- * rail merges a delete of garbage with any machine's splice of its own
- * line.
- */
-function publishWall() {
-  const replica = wallReplica();
-  if (!replica) {
-    service.counters.publishSkips += 1;
-    return { published: false, reason: 'wall-not-bound' };
+function readWall(repoKey = null) {
+  const selected = repoKey ? [projectForRepo(repoKey)].filter(Boolean) : projects();
+  return selected.flatMap((project) => readProjectWall(project));
+}
+
+function samePosition(left, right) {
+  const sameHead = left?.head?.branch === right?.head?.branch
+    && left?.head?.oid === right?.head?.oid
+    && Boolean(left?.head?.detached) === Boolean(right?.head?.detached);
+  if (!sameHead) return false;
+  const previousRefs = new Map((left?.branches || []).map((ref) => [ref.name, ref.oid ?? null]));
+  const currentRefs = new Map((right?.refs || []).map((ref) => [ref.name, ref.oid]));
+  const names = new Set([...previousRefs.keys(), ...currentRefs.keys()]);
+  for (const name of names) {
+    if ((previousRefs.get(name) ?? null) !== (currentRefs.get(name) ?? null)) return false;
   }
+  return true;
+}
 
-  const docs = require('../state/docs');
-  const current = docs.getDocText(WALL_FILE);
-  const mine = JSON.stringify({
-    wall: WALL_CONTRACT,
-    machine: machineId(),
-    publishedAt: new Date().toISOString(),
-    cards: listRepoCards(),
+function checkpointIdentity(checkpoint) {
+  if (!checkpoint) return null;
+  return JSON.stringify({
+    baseOid: checkpoint.baseOid,
+    branch: checkpoint.branch,
+    from: checkpoint.from,
+    to: checkpoint.to,
+    parked: checkpoint.parked || [],
+  });
+}
+
+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 stampBranches(refs, previousBranches, mutationId, resourceId) {
+  const current = new Map((refs || []).map((ref) => [ref.name, ref]));
+  const previous = new Map((previousBranches || []).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 oid = observed?.oid ?? null;
+    const unchanged = before && (before.oid ?? null) === oid;
+    const mutation = unchanged && before.mutationId ? before.mutationId : mutationId;
+    const carried = unchanged && Number.isInteger(before.version) ? before.version : null;
+    return {
+      name,
+      oid,
+      ...(observed?.objects ? { objects: observed.objects } : {}),
+      mutationId: mutation,
+      version: carried ?? officialVersion(resourceId, mutation),
+    };
+  });
+}
+
+function stampCards(cards, previousCards, 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 positionMutationId = samePosition(previous, card) && previous?.positionMutationId
+      ? previous.positionMutationId
+      : mutationId;
+    const carriedPosition = samePosition(previous, card)
+      && Number.isInteger(previous?.positionVersion)
+      ? previous.positionVersion
+      : null;
+    const checkpoint = readCheckpoint(machineId(), project.repoKey);
+    const currentCheckpoint = checkpoint
+      && checkpoint.baseOid === card.head?.oid
+      && checkpoint.branch === card.head?.branch
+      ? checkpoint
+      : null;
+    const sameCheckpoint = checkpointIdentity(previous?.checkpoint) === checkpointIdentity(currentCheckpoint);
+    const checkpointMutationId = currentCheckpoint
+      ? (sameCheckpoint && previous?.checkpointMutationId ? previous.checkpointMutationId : mutationId)
+      : null;
+    const checkpointVersion = currentCheckpoint
+      ? (sameCheckpoint && Number.isInteger(previous?.checkpointVersion)
+        ? previous.checkpointVersion
+        : officialVersion(project.resourceId, checkpointMutationId))
+      : null;
+    const { refs, ...cardWithoutRawRefs } = card;
+    return {
+      ...cardWithoutRawRefs,
+      positionMutationId,
+      positionVersion: carriedPosition ?? officialVersion(project.resourceId, positionMutationId),
+      branches: stampBranches(refs, previous?.branches, mutationId, project.resourceId),
+      ...(currentCheckpoint ? {
+        checkpoint: currentCheckpoint,
+        checkpointMutationId,
+        checkpointVersion,
+      } : {}),
+    };
   });
+}
+
+function withoutPublishedAt(line) {
+  const entry = parseWallLine(line);
+  if (!entry) return line;
+  const { publishedAt, ...rest } = entry;
+  return JSON.stringify(rest);
+}
 
+function publishProject(project, rawCards) {
+  const replica = wallReplica(project);
+  if (!replica) {
+    service.counters.publishSkips += 1;
+    return { published: false, reason: 'project-not-bound', repoKey: project.repoKey };
+  }
+  const docs = require('../state/docs');
+  const current = docs.getDocText(project.file);
   const lines = [];
   let previous = null;
+  let previousEntry = null;
+  let slot = -1;
   let dropped = 0;
   for (const line of current.split('\n')) {
     if (!line) continue;
     const entry = parseWallLine(line);
-    if (!entry) {
+    if (!entry || entry.project !== project.repoKey) {
       dropped += 1;
     } else if (entry.machine === machineId()) {
-      // Duplicate own lines (a healed fork) collapse into the first slot.
       if (previous === null) {
         previous = line;
-        lines.push(mine);
+        previousEntry = entry;
+        slot = lines.length;
+        lines.push('');
       } else {
         dropped += 1;
       }
@@ -144,122 +273,129 @@ function publishWall() {
       lines.push(line);
     }
   }
-  if (previous === null) lines.push(mine);
 
+  const mutationId = `mut_project_${crypto.randomBytes(16).toString('base64url')}`;
+  const cards = stampCards(rawCards, previousEntry?.cards, mutationId, project);
+  const mine = JSON.stringify({
+    wall: WALL_CONTRACT,
+    project: project.repoKey,
+    machine: machineId(),
+    publishedAt: new Date().toISOString(),
+    cards,
+  });
+  if (slot < 0) lines.push(mine);
+  else lines[slot] = mine;
   const unchanged = dropped === 0
     && previous !== null
     && withoutPublishedAt(previous) === withoutPublishedAt(mine);
   if (unchanged) {
     service.counters.publishSkips += 1;
-    return { published: false, reason: 'unchanged' };
+    return { published: false, reason: 'unchanged', repoKey: project.repoKey };
   }
 
-  const result = docs.writeDocText(WALL_FILE, `${lines.join('\n')}\n`, { baseHash: sha256(current) });
+  const result = docs.writeDocText(
+    project.file,
+    `${lines.join('\n')}\n`,
+    { baseHash: sha256(current), mutationId },
+  );
   service.counters.publishes += 1;
   service.lastPublishedAt = new Date().toISOString();
-  return { published: true, merge: result.merge, cards: listRepoCards().length, dropped };
+  return {
+    published: true,
+    repoKey: project.repoKey,
+    resourceId: project.resourceId,
+    mutationId: result.mutationId,
+    merge: result.merge,
+    cards: cards.length,
+    dropped,
+  };
 }
 
-function withoutPublishedAt(line) {
-  const entry = parseWallLine(line);
-  if (!entry) return line;
-  const { publishedAt, ...rest } = entry;
-  return JSON.stringify(rest);
+function publishWall(repoKey = null) {
+  const allCards = listRepoCards();
+  const selected = repoKey ? [projectForRepo(repoKey)].filter(Boolean) : projects();
+  const results = selected.map((project) => publishProject(
+    project,
+    allCards.filter((card) => repoKeyOfCard(card) === project.repoKey),
+  ));
+  if (repoKey) return results[0] || { published: false, reason: 'project-missing', repoKey };
+  return {
+    published: results.some((result) => result.published),
+    results,
+  };
 }
 
-// --- binding the wall to the rail -----------------------------------------
-
-function sleep(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-    service.ensureTimer = timer;
+function callLocal(handler, body) {
+  return new Promise((resolve, reject) => {
+    handler(body, (status, payload) => {
+      if (status >= 400) reject(new Error(payload?.error || `local shared route failed with ${status}`));
+      else resolve(payload);
+    });
   });
 }
 
-async function waitForSettled(read) {
+async function waitForSettled(project, read) {
   const deadline = Date.now() + ENSURE_STEP_TIMEOUT_MS;
-  while (Date.now() < deadline && !service.stopRequested) {
-    if (wallReplica()) return read();
+  while (Date.now() < deadline) {
+    if (!service.started || wallReplica(project)) return read();
     const row = read();
     if (row && row.state !== 'pending' && row.state !== 'syncing') return row;
-    await sleep(500);
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, 500);
+      timer.unref?.();
+    });
   }
   return read();
 }
 
-/**
- * Bind this machine to the account wall, retrying for as long as the
- * service runs. The attachment row is the one durable request per
- * resource: create it if absent, cycle it back to pending after a
- * refusal, and — when the refusal means the cloud has never heard of the
- * wall — promote the empty file into existence exactly once. Two
- * machines racing the creation resolve cleanly: one create wins, the
- * loser's next attach retry finds the wall existing. The tunnel delivers
- * queued requests whenever it connects, so an offline boot binds on
- * reconnect.
- */
-async function ensureWallBound() {
-  const resourceId = wallResourceId();
-  if (!resourceId) {
-    service.ensure.state = 'no-account';
-    return;
-  }
+async function ensureProject(project) {
+  if (!project || wallReplica(project)) return;
   const shared = require('../state/shared-rest');
   const attachments = require('../state/attachments');
   const promotions = require('../state/promotions');
+  fs.mkdirSync(path.dirname(project.file), { recursive: true });
+  if (!fs.existsSync(project.file)) fs.writeFileSync(project.file, '');
 
-  while (!service.stopRequested && !wallReplica()) {
-    service.ensure.attempts += 1;
-    try {
-      fs.mkdirSync(path.dirname(WALL_FILE), { recursive: true });
-      if (!fs.existsSync(WALL_FILE)) fs.writeFileSync(WALL_FILE, '');
-
-      let request = attachments.getAttachmentByResource(resourceId);
-      if (!request) {
-        service.ensure.state = 'attaching';
-        await callLocal(shared.handleAttachmentStart, { resourceId, path: WALL_FILE });
-      } else if (request.state === 'rejected') {
-        if (ATTACH_REJECTED.test(request.lastError || '') && !promotions.getPromotionByResource(resourceId)) {
-          // The cloud has never heard of this wall — or access is gone,
-          // and a create attempt on an existing id is refused, so trying
-          // is safe either way. Promote the empty file into existence.
-          service.ensure.state = 'creating';
-          await callLocal(shared.handlePromotionStart, { resourceId, path: WALL_FILE });
-          await waitForSettled(() => promotions.getPromotionByResource(resourceId));
-          if (wallReplica()) break;
-        }
-        service.ensure.state = 'attaching';
-        attachments.retryAttachment(resourceId);
-      }
-      const settled = await waitForSettled(() => attachments.getAttachmentByResource(resourceId));
-      service.ensure.lastError = settled?.lastError || null;
-    } catch (error) {
-      service.ensure.lastError = error.message;
+  let request = attachments.getAttachmentByResource(project.resourceId);
+  if (!request) {
+    await callLocal(shared.handleAttachmentStart, {
+      resourceId: project.resourceId,
+      path: project.file,
+    });
+  } else if (request.state === 'rejected') {
+    if (
+      ATTACH_REJECTED.test(request.lastError || '')
+      && project.resourceId === projectResourceId(project.repoKey, userId())
+      && !promotions.getPromotionByResource(project.resourceId)
+    ) {
+      await callLocal(shared.handlePromotionStart, {
+        resourceId: project.resourceId,
+        path: project.file,
+      });
+      await waitForSettled(project, () => promotions.getPromotionByResource(project.resourceId));
     }
-    if (wallReplica()) break;
-    service.ensure.state = 'waiting';
-    await sleep(ENSURE_RETRY_MS);
-  }
-
-  if (wallReplica()) {
-    service.ensure.state = 'bound';
-    service.ensure.lastError = null;
-    schedulePublish();
+    if (!wallReplica(project)) attachments.retryAttachment(project.resourceId);
   }
+  await waitForSettled(project, () => attachments.getAttachmentByResource(project.resourceId));
+  if (wallReplica(project)) schedulePublish();
 }
 
-/** Adapt a shared-rest handler (which speaks sendJson) into a promise. */
-function callLocal(handler, body) {
-  return new Promise((resolve, reject) => {
-    handler(body, (status, payload) => {
-      if (status >= 400) reject(new Error(payload?.error || `local shared route failed with ${status}`));
-      else resolve(payload);
-    });
-  });
+function ensureProjectBound(project) {
+  if (!project) return Promise.resolve();
+  const running = service.ensuring.get(project.resourceId);
+  if (running) return running;
+  const promise = ensureProject(project)
+    .catch((error) => {
+      service.ensure.set(project.resourceId, { state: 'failed', lastError: error.message });
+    })
+    .finally(() => service.ensuring.delete(project.resourceId));
+  service.ensuring.set(project.resourceId, promise);
+  return promise;
 }
 
-// --- service ---------------------------------------------------------------
+function ensureProjects() {
+  return Promise.all(projects().map((project) => ensureProjectBound(project)));
+}
 
 function schedulePublish() {
   if (!service.started || service.publishTimer) return;
@@ -269,7 +405,7 @@ function schedulePublish() {
       publishWall();
     } catch (error) {
       service.counters.publishFailures += 1;
-      console.warn('[MachineWall] publish failed:', error.message);
+      console.warn('[CodeProject] publish failed:', error.message);
     }
   }, PUBLISH_QUIET_MS);
   service.publishTimer.unref?.();
@@ -278,58 +414,73 @@ function schedulePublish() {
 function startWallService() {
   if (service.started) return;
   service.started = true;
-  service.stopRequested = false;
   service.unsubscribe = subscribeStateEvents((event) => {
-    if (event.resource === 'repo-cards') schedulePublish();
-  });
-  ensureWallBound().catch((error) => {
-    service.ensure.state = 'failed';
-    service.ensure.lastError = error.message;
-    console.warn('[MachineWall] binding failed:', error.message);
+    const acknowledged = event.resource === 'shared-mutations'
+      && projects().some((project) => project.resourceId === event.sharedResourceId);
+    if (
+      event.resource === 'repo-cards'
+      || event.resource === 'repo-checkpoints'
+      || acknowledged
+    ) {
+      ensureProjects().catch(() => {});
+      schedulePublish();
+    }
   });
+  service.ensureInterval = setInterval(() => ensureProjects().catch(() => {}), ENSURE_INTERVAL_MS);
+  service.ensureInterval.unref?.();
+  ensureProjects().catch(() => {});
 }
 
 function stopWallService() {
   if (!service.started) return;
   service.started = false;
-  service.stopRequested = true;
   service.unsubscribe?.();
   service.unsubscribe = null;
   if (service.publishTimer) clearTimeout(service.publishTimer);
+  if (service.ensureInterval) clearInterval(service.ensureInterval);
   service.publishTimer = null;
-  if (service.ensureTimer) clearTimeout(service.ensureTimer);
-  service.ensureTimer = null;
+  service.ensureInterval = null;
 }
 
 function wallStats() {
-  const replica = wallReplica();
+  const rows = projects().map((project) => {
+    const replica = wallReplica(project);
+    return {
+      repoKey: project.repoKey,
+      resourceId: project.resourceId,
+      ownerUserId: project.ownerUserId,
+      path: project.file,
+      replica: replica && {
+        appliedVersion: replica.appliedVersion,
+        snapshotVersion: replica.snapshotVersion,
+        authorityEpoch: replica.authorityEpoch,
+        syncStatus: replica.syncStatus,
+        lastError: replica.lastError,
+        updatedAt: replica.updatedAt,
+      },
+      machines: readProjectWall(project).length,
+    };
+  });
   return {
     contract: WALL_CONTRACT,
-    resourceId: wallResourceId(),
-    path: WALL_FILE,
-    replica: replica && {
-      appliedVersion: replica.appliedVersion,
-      snapshotVersion: replica.snapshotVersion,
-      authorityEpoch: replica.authorityEpoch,
-      syncStatus: replica.syncStatus,
-      lastError: replica.lastError,
-      updatedAt: replica.updatedAt,
-    },
-    ensure: { ...service.ensure },
+    projects: rows,
+    paths: rows.map((row) => row.path),
     publishes: service.counters.publishes,
     publishSkips: service.counters.publishSkips,
     publishFailures: service.counters.publishFailures,
     lastPublishedAt: service.lastPublishedAt,
-    machines: readWall().length,
   };
 }
 
 module.exports = {
   WALL_CONTRACT,
+  bindProject,
+  projectFile,
+  projectForRepo,
+  projectResourceId,
   publishWall,
   readWall,
   startWallService,
   stopWallService,
-  wallResourceId,
   wallStats,
 };