amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/workspace/access-store.js

@@ -52,11 +52,7 @@ function resolveAccess(nodeId, userIdInput, options = {}) {
   const database = options.database || openLocalDb();
   const userId = cleanUserId(userIdInput);
   const target = nodeRow(database, nodeId);
-  // `missing_at` is a durable observation that the physical node disappeared;
-  // it does not erase the UUID or its inherited authority. Reconciliation must
-  // still be able to authorize and journal that offline deletion. Purge alone
-  // retires the identity.
-  if (!target || target.purged_at) return null;
+  if (!target || target.purged_at || target.missing_at) return null;
   const parents = new Map(
     database.prepare('SELECT id, parent_id FROM workspace_nodes WHERE workspace_id = ?')
       .all(target.workspace_id)

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

@@ -23,7 +23,7 @@ const {
 } = require('./git');
 const { cacheRootCommit, machineId, replicaForGitDir } = require('./identity');
 
-const CARD_CONTRACT = 'repo-card@3';
+const CARD_CONTRACT = 'repo-card@2';
 
 // A transportable identity needs a dotted host: bare names resolve through
 // this machine's own config (ssh aliases, LAN names) and identify nothing
@@ -60,12 +60,7 @@ function cardKind(classified) {
   return classified.linked ? 'linked-worktree' : 'primary';
 }
 
-function reusableObjectSource(previousOid, currentOid, source, resourceId) {
-  if (previousOid !== currentOid) return null;
-  return source?.kind === 'bundle' && source.resourceId === resourceId ? source : null;
-}
-
-async function observeWorktree(classified, previousCard = null) {
+async function observeWorktree(classified) {
   const worktreeRoot = classified.toplevel;
   const gitDir = await fs.promises.realpath(classified.gitDir);
   const replica = replicaForGitDir(gitDir);
@@ -82,32 +77,14 @@ async function observeWorktree(classified, previousCard = null) {
   }
 
   const repoIdentity = remote === null ? null : remoteIdentity(remote);
-  const repoKey = repoIdentity || (anchor ? `root:${anchor}` : null);
-  const resourceId = repoKey
-    ? require('./wall').projectForPath(worktreeRoot)?.resourceId
+  const objects = head.oid && repoIdentity
+    ? await require('./objects').objectSourceFor(worktreeRoot, repoIdentity, head.oid)
     : null;
-  const previous = previousCard?.replica === replica.replicaId
-    && previousCard.repo?.remote === repoIdentity
-    ? previousCard
-    : null;
-  const previousRefs = new Map((previous?.refs || []).map((ref) => [ref.name, ref]));
-  const objectSources = new Map();
-  const sourceFor = (oid, priorOid, priorSource) => {
-    if (!oid || !repoKey) return null;
-    if (objectSources.has(oid)) return objectSources.get(oid);
-    const source = reusableObjectSource(priorOid, oid, priorSource, resourceId)
-      || require('./objects').objectSourceFor(worktreeRoot, repoKey, oid);
-    objectSources.set(oid, source);
-    return source;
-  };
-  const objects = await sourceFor(head.oid, previous?.head?.oid, previous?.objects);
   const refs = await Promise.all(branches.map(async (branch) => ({
     ...branch,
-    objects: await sourceFor(
-      branch.oid,
-      previousRefs.get(branch.name)?.oid,
-      previousRefs.get(branch.name)?.objects,
-    ),
+    objects: repoIdentity
+      ? await require('./objects').objectSourceFor(worktreeRoot, repoIdentity, branch.oid)
+      : null,
   })));
   return {
     card: CARD_CONTRACT,
@@ -131,7 +108,7 @@ async function observeWorktree(classified, previousCard = null) {
 }
 
 /**
- * Build the repo-card@3 for one worktree. `dirPath` may be any directory
+ * Build the repo-card@2 for one worktree. `dirPath` may be any directory
  * inside the worktree; the card is always for the worktree root. Throws
  * on anything that is not a worktree — discovery filters first.
  *
@@ -140,14 +117,14 @@ async function observeWorktree(classified, previousCard = null) {
  * moved. A repo still in motion after that simply cards again on the next
  * doorbell; every card is a true observation of some moment.
  */
-async function buildRepoCard(dirPath, previousCard = null) {
+async function buildRepoCard(dirPath) {
   const classified = await classifyDirectory(dirPath);
   if (classified.kind !== 'worktree') {
     throw new Error(`cannot card ${classified.path}: ${classified.kind}`);
   }
-  const observed = await observeWorktree(classified, previousCard);
+  const observed = await observeWorktree(classified);
   if (observed.head.oid === await headOid(classified.toplevel)) return observed;
-  return observeWorktree(classified, observed);
+  return observeWorktree(classified);
 }
 
 /**
@@ -229,7 +206,6 @@ async function discoverWorktrees(rootPath) {
 }
 
 module.exports = {
-  _test: { reusableObjectSource },
   CARD_CONTRACT,
   buildRepoCard,
   cardFingerprint,

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

@@ -37,7 +37,7 @@ const service = {
   reconcileTimer: null,
   workspaceTimer: null,
   unsubscribe: null,
-  doorbells: new Map(), // replicaId → { watchSet, timer }
+  doorbells: new Map(), // replicaId → { watchers, timer }
   counters: { refreshes: 0, doorbellRings: 0 },
   lastRefresh: null,
 };
@@ -171,7 +171,6 @@ async function runRefresh() {
   service.counters.refreshes += 1;
 
   const roots = trackedRoots();
-  const previousByPath = new Map(listRepoCards().map((card) => [card.path, card]));
   const targets = new Map(); // worktree root → registry root that reached it
   const skipped = [];
   const rootErrors = [];
@@ -190,7 +189,7 @@ async function runRefresh() {
   const built = [];
   for (const [target, root] of targets) {
     try {
-      built.push({ card: await buildRepoCard(target, previousByPath.get(target)), root });
+      built.push({ card: await buildRepoCard(target), root });
     } catch (error) {
       skipped.push({ path: target, reason: 'observation-failed', error: error.message });
     }
@@ -322,7 +321,7 @@ async function refreshRepoCard(replicaId) {
   const row = db.prepare('SELECT * FROM repo_cards WHERE replica_id = ?').get(replicaId);
   if (!row) return null;
 
-  const observedCard = await buildRepoCard(row.path, rowToCard(row));
+  const observedCard = await buildRepoCard(row.path);
   if (observedCard.replica !== replicaId) return refreshRepoCards();
   const card = observedCard;
   const fingerprint = cardFingerprint(card);
@@ -443,7 +442,7 @@ function nestedDirectories(root) {
 }
 
 function watchGitDir(card) {
-  const watchSet = { handles: [], complete: true };
+  const watchers = [];
   const ring = () => ringDoorbell(card.replica);
   // The git dir itself carries HEAD, index, and operation markers; logs/
   // carries the reflog, which moves on every commit, checkout, and reset.
@@ -459,13 +458,9 @@ function watchGitDir(card) {
   for (const dir of new Set([...direct, ...refDirectories])) {
     try {
       const watcher = fs.watch(dir, ring);
-      watcher.on('error', () => {
-        watchSet.complete = false;
-        watcher.close();
-      });
-      watchSet.handles.push(watcher);
+      watcher.on('error', () => watcher.close());
+      watchers.push(watcher);
     } catch {
-      watchSet.complete = false;
       // The directory vanished between observation and watch; the next
       // reconcile pass re-syncs the bells.
     }
@@ -476,31 +471,27 @@ function watchGitDir(card) {
       if (relative === '.git' || relative.startsWith('.git/')) return;
       ring();
     });
-    watcher.on('error', () => {
-      watchSet.complete = false;
-      watcher.close();
-    });
-    watchSet.handles.push(watcher);
+    watcher.on('error', () => watcher.close());
+    watchers.push(watcher);
   } catch {
-    watchSet.complete = false;
     // The periodic card refresh remains the fallback on filesystems that
     // cannot watch a checkout recursively.
   }
-  return watchSet;
+  return watchers;
 }
 
 function rebuildDoorbell(replicaId, card) {
   const bell = service.doorbells.get(replicaId);
   if (!bell) return;
-  const previous = bell.watchSet;
-  for (const watcher of previous.handles) watcher.close();
-  bell.watchSet = watchGitDir(card);
+  const previous = bell.watchers;
+  bell.watchers = watchGitDir(card);
+  for (const watcher of previous) watcher.close();
 }
 
 function dropDoorbell(replicaId) {
   const bell = service.doorbells.get(replicaId);
   if (!bell) return;
-  for (const watcher of bell.watchSet.handles) watcher.close();
+  for (const watcher of bell.watchers) watcher.close();
   if (bell.timer) clearTimeout(bell.timer);
   service.doorbells.delete(replicaId);
 }
@@ -515,9 +506,7 @@ function syncDoorbells(cards) {
   }
   for (const [replicaId, card] of healthy) {
     if (!service.doorbells.has(replicaId)) {
-      service.doorbells.set(replicaId, { watchSet: watchGitDir(card), timer: null });
-    } else if (!service.doorbells.get(replicaId).watchSet.complete) {
-      rebuildDoorbell(replicaId, card);
+      service.doorbells.set(replicaId, { watchers: watchGitDir(card), timer: null });
     }
   }
 }
@@ -562,8 +551,6 @@ function repoCardServiceStats() {
     refreshes: service.counters.refreshes,
     doorbellRings: service.counters.doorbellRings,
     doorbells: service.doorbells.size,
-    incompleteDoorbells: Array.from(service.doorbells.values())
-      .filter((bell) => !bell.watchSet.complete).length,
     lastRefresh: service.lastRefresh,
   };
 }
@@ -575,16 +562,4 @@ module.exports = {
   repoCardServiceStats,
   startRepoCardService,
   stopRepoCardService,
-  // Test hooks only. Filesystem delivery itself belongs to the host; these
-  // expose the deterministic doorbell boundary behind that latency hint.
-  _private: {
-    rebuildDoorbell,
-    ringDoorbell,
-    watcherCount(replicaId) {
-      return service.doorbells.get(replicaId)?.watchSet.handles.length || 0;
-    },
-    watcherComplete(replicaId) {
-      return service.doorbells.get(replicaId)?.watchSet.complete === true;
-    },
-  },
 };