amalgm 0.1.238 → 0.1.240

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

@@ -14,9 +14,9 @@ const {
   renameWorkspace,
   upsertWorkspace,
 } = require('./store');
-const { listRepoCards, refreshRepoCards, repoCardServiceStats } = require('./cards');
+const { listRepoCards, refreshRepoCards } = require('./cards');
 const { machineId } = require('./identity');
-const { readWall, wallStats } = require('./wall');
+const { readWall } = require('./wall');
 
 const execFileAsync = promisify(execFile);
 const MAX_BUFFER = 10 * 1024 * 1024;
@@ -66,6 +66,10 @@ function enrollWorkspaceTree(workspace) {
   return require('./tree-store').enrollWorkspace(workspace.id);
 }
 
+function workspaceAfterTreeEnrollment(workspace) {
+  return listWorkspaces().find((entry) => entry.id === workspace.id) || workspace;
+}
+
 async function uniqueProjectPath(workspaceRoot, requestedName) {
   const name = sanitizeProjectName(requestedName);
   let candidate = path.join(workspaceRoot, name);
@@ -216,15 +220,20 @@ async function handleProjectRegister(body, sendJson) {
     });
     ensureProjectMemory(workspace, 'workspace:register');
     const tree = enrollWorkspaceTree(workspace);
+    const enrolledWorkspace = workspaceAfterTreeEnrollment(workspace);
 
     sendJson(200, {
       success: true,
-      workspace,
+      workspace: enrolledWorkspace,
       path: workspace.path,
       name: workspace.name,
       uri: workspace.uri,
       workspaceRoot,
-      tree: { nodes: tree.nodes.length, created: tree.created },
+      tree: {
+        nodes: tree.nodes.length,
+        created: tree.created,
+        observation: enrolledWorkspace.treeObservation,
+      },
     });
   } catch (error) {
     sendJson(500, {
@@ -351,14 +360,19 @@ async function handleImport(body, sendJson) {
       });
       ensureProjectMemory(workspace, 'workspace:import');
       const tree = enrollWorkspaceTree(workspace);
+      const enrolledWorkspace = workspaceAfterTreeEnrollment(workspace);
       sendJson(200, {
         success: true,
         path: workspace.path,
         name: workspace.name,
-        workspace,
+        workspace: enrolledWorkspace,
         workspaceRoot,
         alreadyInWorkspace: true,
-        tree: { nodes: tree.nodes.length, created: tree.created },
+        tree: {
+          nodes: tree.nodes.length,
+          created: tree.created,
+          observation: enrolledWorkspace.treeObservation,
+        },
       });
       return;
     }
@@ -384,15 +398,20 @@ async function handleImport(body, sendJson) {
     });
     ensureProjectMemory(workspace, 'workspace:import');
     const tree = enrollWorkspaceTree(workspace);
+    const enrolledWorkspace = workspaceAfterTreeEnrollment(workspace);
 
     sendJson(200, {
       success: true,
       path: workspace.path,
       name: workspace.name,
-      workspace,
+      workspace: enrolledWorkspace,
       workspaceRoot,
       alreadyInWorkspace: false,
-      tree: { nodes: tree.nodes.length, created: tree.created },
+      tree: {
+        nodes: tree.nodes.length,
+        created: tree.created,
+        observation: enrolledWorkspace.treeObservation,
+      },
     });
   } catch (error) {
     sendJson(500, {
@@ -433,13 +452,18 @@ async function handleClone(body, sendJson) {
       });
       ensureProjectMemory(workspace, 'workspace:clone');
       const tree = enrollWorkspaceTree(workspace);
+      const enrolledWorkspace = workspaceAfterTreeEnrollment(workspace);
       sendJson(200, {
         success: true,
         path: workspace.path,
-        workspace,
+        workspace: enrolledWorkspace,
         workspaceRoot,
         alreadyExists: true,
-        tree: { nodes: tree.nodes.length, created: tree.created },
+        tree: {
+          nodes: tree.nodes.length,
+          created: tree.created,
+          observation: enrolledWorkspace.treeObservation,
+        },
       });
       return;
     }
@@ -477,14 +501,19 @@ async function handleClone(body, sendJson) {
   });
   ensureProjectMemory(workspace, 'workspace:clone');
   const tree = enrollWorkspaceTree(workspace);
+  const enrolledWorkspace = workspaceAfterTreeEnrollment(workspace);
 
   sendJson(200, {
     success: true,
     path: workspace.path,
-    workspace,
+    workspace: enrolledWorkspace,
     workspaceRoot,
     alreadyExists: false,
-    tree: { nodes: tree.nodes.length, created: tree.created },
+    tree: {
+      nodes: tree.nodes.length,
+      created: tree.created,
+      observation: enrolledWorkspace.treeObservation,
+    },
   });
 }
 
@@ -714,17 +743,7 @@ async function handleRepoCardsRefresh(sendJson) {
 
 function handleWorkspaceSyncStats(sendJson) {
   try {
-    const cards = listRepoCards();
-    const health = { healthy: 0, missing: 0, broken: 0, inaccessible: 0 };
-    for (const card of cards) health[card.health] = (health[card.health] || 0) + 1;
-    sendJson(200, {
-      machine: machineId(),
-      cards: { total: cards.length, ...health },
-      service: repoCardServiceStats(),
-      wall: wallStats(),
-      checkpoints: require('./checkpoint').checkpointStats(),
-      reducer: require('./reducer').reducerStats(),
-    });
+    sendJson(200, require('./sync-stats').workspaceSyncStats());
   } catch (error) {
     sendJson(500, { error: error instanceof Error ? error.message : 'Failed to read sync stats' });
   }
@@ -732,8 +751,14 @@ function handleWorkspaceSyncStats(sendJson) {
 
 function handleCodeProjectJoin(body, sendJson) {
   try {
+    const keys = Object.keys(body || {}).sort();
+    if (
+      keys.length !== 3
+      || keys[0] !== 'ownerUserId'
+      || keys[1] !== 'path'
+      || keys[2] !== 'resourceId'
+    ) throw new Error('code project join requires exactly resourceId, path, and ownerUserId');
     const project = require('./wall').bindProject(
-      body?.repoKey,
       body?.resourceId,
       body?.ownerUserId,
       body?.path,
@@ -820,12 +845,8 @@ function handleTreeMutation(body, sendJson) {
     const actorUserId = require('./identity').userId();
     if (!actorUserId) throw Object.assign(new Error('this runtime is not enrolled to a user'), { statusCode: 401 });
     const operation = body?.operation || body;
-    const accessNodeId = operation?.kind === 'tree.create' ? operation?.parentId : operation?.nodeId;
-    const access = require('./access-store').resolveAccess(accessNodeId, actorUserId);
-    if (!access?.role) throw Object.assign(new Error('tree operation is forbidden'), { statusCode: 403 });
     sendJson(200, require('./tree-store').commitTreeOperation(operation, {
       mutationId: body?.mutationId,
-      role: access.role,
       source: 'workspace-tree:api',
     }));
   } catch (error) {

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

@@ -135,11 +135,17 @@ function ensureWorkspaceIdentityRows(database, workspace, options = {}) {
   }
 }
 
-function rowToWorkspace(row) {
+function rowToWorkspace(row, database = openLocalDb()) {
   if (!row) return null;
   const parsed = parseJson(row.workspace_json, {});
   const resolvedPath = row.path ? canonicalProjectPath(row.path) : row.path;
   const legacyManagedPath = row.path ? isLegacyManagedWorkspacePath(row.path) : false;
+  const syncHolds = require('./tree/observation-holds').list(row.id, database);
+  const status = syncHolds.length
+    ? 'held'
+    : resolvedPath && fs.existsSync(resolvedPath)
+      ? 'ready'
+      : row.status;
   return {
     ...parsed,
     id: row.id,
@@ -151,7 +157,13 @@ function rowToWorkspace(row) {
     computerId: row.computer_id || parsed.computerId || null,
     source: legacyManagedPath ? 'computer' : row.source,
     managed: legacyManagedPath ? false : row.managed === 1,
-    status: resolvedPath && fs.existsSync(resolvedPath) ? 'ready' : row.status,
+    status,
+    treeObservation: syncHolds.length ? {
+      state: 'held',
+      owner: 'workspace-tree',
+      retry: { kind: 'automatic' },
+      holds: syncHolds,
+    } : null,
     createdAt: row.created_at,
     updatedAt: row.updated_at,
   };
@@ -182,13 +194,71 @@ function publishEvents(events) {
 }
 
 function listWorkspaces() {
-  return openLocalDb()
+  const database = openLocalDb();
+  return database
     .prepare('SELECT * FROM workspaces ORDER BY lower(name), path')
     .all()
-    .map(rowToWorkspace)
+    .map((row) => rowToWorkspace(row, database))
     .filter(Boolean);
 }
 
+function replaceTreeObservationInTransaction(
+  workspaceId,
+  holds,
+  options = {},
+) {
+  const database = options.database || openLocalDb();
+  const changed = require('./tree/observation-holds').replace(
+    workspaceId,
+    holds,
+    database,
+    {
+      ownerKind: options.ownerKind,
+      ownerId: options.ownerId,
+    },
+  );
+  if (!changed) return { changed, events: [] };
+  const row = workspaceRow(database, workspaceId);
+  if (!row) return { changed, events: [] };
+  const workspace = rowToWorkspace(row, database);
+  return {
+    changed,
+    events: publishWorkspaceEvents(
+      database,
+      'update',
+      workspace,
+      options.source || 'workspace-tree:observation-hold',
+    ),
+  };
+}
+
+function publishTreeObservationCommit(result) {
+  publishEvents(result?.events || []);
+}
+
+function commitCompletedTreeObservation(workspaceId, holds, options = {}) {
+  const database = options.database || openLocalDb();
+  let result = { changed: false, events: [] };
+  database.transaction(() => {
+    if (typeof options.mutate === 'function') options.mutate();
+    result = replaceTreeObservationInTransaction(
+      workspaceId,
+      holds,
+      {
+        database,
+        ownerKind: options.ownerKind,
+        ownerId: options.ownerId,
+        source: options.source,
+      },
+    );
+  })();
+  publishTreeObservationCommit(result);
+  return {
+    changed: result.changed,
+    holds: require('./tree/observation-holds').list(workspaceId, database),
+  };
+}
+
 function upsertWorkspace(input, options = {}) {
   const db = openLocalDb();
   let workspace;
@@ -313,6 +383,9 @@ function removeWorkspace(identifier, options = {}) {
 }
 
 module.exports = {
+  commitCompletedTreeObservation,
+  publishTreeObservationCommit,
+  replaceTreeObservationInTransaction,
   listWorkspaces,
   normalizeWorkspaceRecord,
   removeWorkspace,

package/runtime/scripts/amalgm-mcp/workspace/sync-stats.js

@@ -0,0 +1,240 @@
+'use strict';
+
+/**
+ * Referee projection for the floor, physical verification, and local overlay.
+ *
+ * Referee axiom: a gate must see every active or successor intent. Proven by
+ * workspace-sync-stats.test.js and workspace-sync-harness-core.test.mjs.
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { listRepoCards, repoCardServiceStats } = require('./cards');
+const { repoKeyOfCard } = require('./checkpoint');
+const { machineId, userId } = require('./identity');
+const projectStream = require('./project-stream');
+const reducer = require('./reducer');
+const { listWorkspaces } = require('./store');
+const wall = require('./wall');
+const runtimeVersion = require('../../../../package.json').version;
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..', '..', '..');
+const RUNTIME_ROOT = path.resolve(__dirname, '..');
+
+function filesUnder(root) {
+  return fs.readdirSync(root, { withFileTypes: true })
+    .flatMap((entry) => {
+      const file = path.join(root, entry.name);
+      if (entry.isDirectory()) return filesUnder(file);
+      return entry.isFile() ? [file] : [];
+    })
+    .sort();
+}
+
+// The sync identity follows the architecture tree, not a hand-maintained
+// dependency list. New state/materialization modules and native workspace
+// helpers therefore enter the release identity automatically.
+const SYNC_FILES = [
+  path.join(RUNTIME_ROOT, 'state'),
+  path.join(RUNTIME_ROOT, 'workspace'),
+].flatMap(filesUnder);
+
+function fileFingerprint(files) {
+  const hash = crypto.createHash('sha256');
+  for (const file of files.filter((candidate) => fs.existsSync(candidate)).sort()) {
+    hash.update(path.relative(PACKAGE_ROOT, file));
+    hash.update('\0');
+    hash.update(fs.readFileSync(file));
+    hash.update('\0');
+  }
+  return `sha256:${hash.digest('hex')}`;
+}
+
+function sharedTunnelFiles() {
+  return [
+    path.join(PACKAGE_ROOT, 'lib', 'shared-realtime-tunnel.js'),
+    path.join(PACKAGE_ROOT, 'packages', 'amalgm', 'lib', 'shared-realtime-tunnel.js'),
+  ].filter((file) => fs.existsSync(file));
+}
+
+const runtimeBuildFingerprint = fileFingerprint([
+  path.join(PACKAGE_ROOT, 'package.json'),
+  ...filesUnder(RUNTIME_ROOT),
+  ...sharedTunnelFiles(),
+]);
+const runtimeSyncFingerprint = fileFingerprint([
+  ...SYNC_FILES,
+  ...sharedTunnelFiles(),
+]);
+
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, canonical(value[key])]),
+  );
+}
+
+function digest(value) {
+  return crypto.createHash('sha256')
+    .update(JSON.stringify(canonical(value)))
+    .digest('hex');
+}
+
+function samePath(left, right) {
+  return Boolean(left && right && path.resolve(left) === path.resolve(right));
+}
+
+function folderFor(project, cards, workspaces) {
+  const card = cards.find((entry) => (
+    entry.kind === 'primary'
+    && repoKeyOfCard(entry) === project.repoKey
+  ));
+  const folderPath = project.path || card?.path || null;
+  const workspace = workspaces.find((entry) => samePath(entry.path, folderPath));
+  return {
+    card,
+    folderPath,
+    folderUuid: workspace?.id || null,
+  };
+}
+
+function waitingFor(state, outcome) {
+  const waiting = [];
+  if (outcome?.state === 'waiting' || outcome?.state === 'error') {
+    waiting.push({
+      state: outcome.state,
+      reason: outcome.reason || null,
+    });
+  }
+  return waiting;
+}
+
+function verificationFor(state, outcome, pendingIntent = null) {
+  return {
+    contract: state?.verificationContract || null,
+    appliedThrough: Number.isSafeInteger(state?.appliedThrough)
+      ? state.appliedThrough
+      : null,
+    materialized: state?.materialized === true,
+    targetDigest: state?.targetDigest || null,
+    expectedPhysicalDigest: state?.expectedPhysicalDigest || null,
+    observedPhysicalDigest: state?.observedPhysicalDigest || null,
+    pendingIntent,
+    waiting: waitingFor(state, outcome),
+  };
+}
+
+function pendingIntentValue(value, owned) {
+  const successor = value?.successor || null;
+  if (!owned && !successor) return null;
+  const result = {
+    baseThrough: value.base.through,
+    semanticDigest: value.semanticDigest,
+    mutationId: value.birthMutationId || value.publication?.mutationId || null,
+    terminalCode: value.terminal?.code || null,
+  };
+  if (successor) {
+    result.successor = {
+      predecessorSemanticDigest: successor.predecessorSemanticDigest,
+      semanticDigest: successor.semanticDigest,
+      mutationId: successor.birthMutationId || null,
+      terminalCode: successor.terminal?.code || null,
+    };
+  }
+  return result;
+}
+
+function pendingIntentFor(project) {
+  const intents = require('./intent');
+  const value = intents.readIntent(project);
+  return pendingIntentValue(
+    value,
+    Boolean(value && !intents.officialAcknowledgement(project, value)),
+  );
+}
+
+function autoUpdateDisabled(env = process.env) {
+  const disabled = String(env.AMALGM_DISABLE_AUTO_UPDATE || '').trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(disabled)) return true;
+  const enabled = String(env.AMALGM_AUTO_UPDATE || '').trim().toLowerCase();
+  return ['0', 'false', 'no', 'off'].includes(enabled);
+}
+
+function projectObservation({
+  project,
+  cards,
+  workspaces,
+  reducerRepos,
+}) {
+  const folder = folderFor(project, cards, workspaces);
+  const state = reducer.readRepoState(project.repoKey, project.resourceId);
+  const exactState = (
+    state
+    && folder.folderPath
+    && samePath(state.path, folder.folderPath)
+    && (!folder.card || state.replica === folder.card.replica)
+  ) ? state : null;
+  const snapshot = projectStream.readSnapshot(project.file, project.resourceId);
+  const publication = wall.publicationStatus(project.repoKey, exactState);
+  const outcome = reducerRepos.find((entry) => (
+    entry.repoKey === project.repoKey
+    && (!folder.folderPath || !entry.path || samePath(entry.path, folder.folderPath))
+  )) || null;
+  return {
+    resourceId: project.resourceId,
+    repoKey: project.repoKey,
+    folderPath: folder.folderPath,
+    folderUuid: folder.folderUuid,
+    receivedThrough: publication.receivedThrough,
+    snapshotThrough: snapshot.version,
+    snapshotDigest: digest(snapshot),
+    pendingOutbound: publication.pending,
+    verification: verificationFor(exactState, outcome, pendingIntentFor(project)),
+  };
+}
+
+function workspaceSyncStats() {
+  const cards = listRepoCards();
+  const wallState = wall.wallStats();
+  const reducerState = reducer.reducerStats();
+  const workspaces = listWorkspaces();
+  const projects = wallState.projects.map((entry) => projectObservation({
+    project: wall.projectForRepo(entry.repoKey),
+    cards,
+    workspaces,
+    reducerRepos: reducerState.repos,
+  }));
+  const health = { healthy: 0, missing: 0, broken: 0, inaccessible: 0 };
+  for (const card of cards) health[card.health] = (health[card.health] || 0) + 1;
+  return {
+    machine: machineId(),
+    user: userId(),
+    runtimeVersion,
+    runtime: {
+      buildFingerprint: runtimeBuildFingerprint,
+      syncFingerprint: runtimeSyncFingerprint,
+      autoUpdateDisabled: autoUpdateDisabled(),
+    },
+    projects,
+    cards: { total: cards.length, ...health },
+    service: repoCardServiceStats(),
+    wall: wallState,
+    checkpoints: require('./checkpoint').checkpointStats(),
+    reducer: reducerState,
+  };
+}
+
+module.exports = {
+  _test: {
+    digest,
+    folderFor,
+    autoUpdateDisabled,
+    fileFingerprint,
+    syncFingerprintFiles: SYNC_FILES.map((file) => path.relative(RUNTIME_ROOT, file)),
+    pendingIntentFor,
+    pendingIntentValue,
+    verificationFor,
+  },
+  workspaceSyncStats,
+};