amalgm 0.1.164 → 0.1.165

package/lib/shared-realtime-tunnel.js

@@ -12,9 +12,11 @@ const crypto = require('crypto');
 const http = require('http');
 
 const CAPABILITY = 'shared.mutation.v1';
+const PRESENCE_CAPABILITY = 'shared.presence.v1';
 const CLAIM_LIMIT = 16;
 const CLAIM_LEASE_MS = 30_000;
 const RETRY_MS = 1_000;
+const REAUTHORIZE_MS = 30_000;
 
 function createSharedRealtimeTunnel({
   send,
@@ -31,6 +33,7 @@ function createSharedRealtimeTunnel({
   const inboundChains = new Map();
 
   let enabled = false;
+  let presenceEnabled = false;
   let mutationDrain = null;
   let promotionDrain = null;
   let attachmentDrain = null;
@@ -39,6 +42,7 @@ function createSharedRealtimeTunnel({
   let mutationRetryTimer = null;
   let promotionRetryTimer = null;
   let attachmentRetryTimer = null;
+  let reauthorizeTimer = null;
   let localFailures = 0;
 
   async function ensurePrivateCookieResource() {
@@ -261,11 +265,23 @@ function createSharedRealtimeTunnel({
     await attachmentDrain;
   }
 
-  async function joinReplicas() {
+  function scheduleReauthorize() {
+    if (!enabled || reauthorizeTimer) return;
+    reauthorizeTimer = setTimeout(() => {
+      reauthorizeTimer = null;
+      void joinReplicas({ revokedOnly: true });
+    }, REAUTHORIZE_MS);
+    reauthorizeTimer.unref?.();
+  }
+
+  async function joinReplicas(options = {}) {
     try {
       const result = await localStateJson('GET', '/state/shared/replicas');
+      let revoked = false;
       for (const replica of Array.isArray(result?.replicas) ? result.replicas : []) {
         if (!replica?.resourceId) continue;
+        if (replica.accessStatus === 'revoked') revoked = true;
+        if (options.revokedOnly && replica.accessStatus !== 'revoked') continue;
         const requestId = `join_${crypto.randomBytes(12).toString('hex')}`;
         const queued = send({
           type: 'shared.resource.join',
@@ -275,9 +291,25 @@ function createSharedRealtimeTunnel({
         });
         if (queued) joinInflight.set(requestId, replica.resourceId);
       }
+      if (revoked) scheduleReauthorize();
     } catch {
       // The local service can still be starting; wake reconnect retries.
+      if (options.revokedOnly) scheduleReauthorize();
+    }
+  }
+
+  function handleRevoked(resourceId, reason) {
+    if (!resourceId) return;
+    for (const [requestId, identity] of mutationInflight) {
+      if (identity.resourceId === resourceId) mutationInflight.delete(requestId);
     }
+    void localStateJson('POST', '/state/shared/replicas/revoked', {
+      resourceId,
+      reason,
+    }).catch((error) => {
+      warn(`shared revocation was not persisted for ${resourceId}: ${error?.message || error}`);
+    });
+    scheduleReauthorize();
   }
 
   function parseWakeChunk(state, chunk) {
@@ -303,6 +335,22 @@ function createSharedRealtimeTunnel({
         } catch {
           // The stream is only a wake signal; durable queues remain truth.
         }
+      } else if (eventType === 'presence-publish' && presenceEnabled && data.length > 0) {
+        try {
+          const presence = JSON.parse(data.join('\n'));
+          if (presence?.cloudResourceId && presence?.session) {
+            send({
+              type: 'shared.presence.publish',
+              resource_id: presence.cloudResourceId,
+              session: presence.session,
+              ...(presence.leave
+                ? { leave: true }
+                : { blob: presence.blob ?? null, active: presence.active === true }),
+            });
+          }
+        } catch {
+          // Presence is replaceable; the next position or heartbeat repairs it.
+        }
       }
       boundary = state.buffer.indexOf('\n\n');
     }
@@ -461,6 +509,13 @@ function createSharedRealtimeTunnel({
     const joinedResource = joinInflight.get(frame.request_id);
     if (joinedResource) {
       joinInflight.delete(frame.request_id);
+      if (frame.status === 403 || frame.status === 404) {
+        handleRevoked(
+          joinedResource,
+          frame.status === 404 ? 'resource-unavailable' : 'access-removed',
+        );
+        return;
+      }
       if (
         frame.code === 'shared_tail_pruned'
         || frame.code === 'shared_tail_too_large'
@@ -514,6 +569,14 @@ function createSharedRealtimeTunnel({
       mutationId: frame.mutation_id,
     };
     if (!identity.resourceId || !identity.mutationId) return;
+    if (frame.status === 403 || frame.status === 404) {
+      mutationInflight.delete(frame.request_id);
+      handleRevoked(
+        identity.resourceId,
+        frame.status === 404 ? 'resource-unavailable' : 'access-removed',
+      );
+      return;
+    }
     void localStateJson('POST', '/state/mutations/fail', {
       resourceId: identity.resourceId,
       mutationId: identity.mutationId,
@@ -562,6 +625,18 @@ function createSharedRealtimeTunnel({
           warn(`shared tree resync request failed for ${frame.resource_id}: ${error?.message || error}`);
         });
         return true;
+      case 'shared.resource.revoked':
+        handleRevoked(frame.resource_id, frame.reason);
+        return true;
+      case 'shared.presence':
+        if (!presenceEnabled) return false;
+        void localStateJson('POST', '/state/shared/presence/apply', {
+          resourceId: frame.resource_id,
+          peers: frame.peers,
+        }).catch((error) => {
+          warn(`shared presence was not applied for ${frame.resource_id}: ${error?.message || error}`);
+        });
+        return true;
       case 'shared.mutation.committed':
         handleCommitted(frame);
         return true;
@@ -577,6 +652,7 @@ function createSharedRealtimeTunnel({
           contract: frame.contract,
           schemaVersion: frame.schema_version,
         }).then(async (replica) => {
+          scheduleMutationDrain();
           if (frame.contract === 'workspace-tree@1' && replica.authorityChanged) {
             await localStateJson('POST', '/state/shared/replicas/rehydrate', {
               resourceId: frame.resource_id,
@@ -606,11 +682,13 @@ function createSharedRealtimeTunnel({
       return;
     }
     enabled = true;
+    presenceEnabled = capabilities.includes(PRESENCE_CAPABILITY);
     startPump();
   }
 
   function stop() {
     enabled = false;
+    presenceEnabled = false;
     mutationInflight.clear();
     promotionInflight.clear();
     attachmentInflight.clear();
@@ -623,13 +701,15 @@ function createSharedRealtimeTunnel({
     clearTimeout(mutationRetryTimer);
     clearTimeout(promotionRetryTimer);
     clearTimeout(attachmentRetryTimer);
+    clearTimeout(reauthorizeTimer);
     wakeRetryTimer = null;
     mutationRetryTimer = null;
     promotionRetryTimer = null;
     attachmentRetryTimer = null;
+    reauthorizeTimer = null;
   }
 
   return { enable, handleFrame, stop };
 }
 
-module.exports = { CAPABILITY, createSharedRealtimeTunnel };
+module.exports = { CAPABILITY, PRESENCE_CAPABILITY, createSharedRealtimeTunnel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.164",
+  "version": "0.1.165",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/server/routes/state.js

@@ -99,6 +99,14 @@ async function handleStateRoutes(ctx) {
       await sharedRest.handleReplicaAuthority(await ctx.readJsonBody(), ctx.sendJson);
       return true;
     }
+    if (ctx.pathname === '/state/shared/replicas/revoked') {
+      await sharedRest.handleReplicaRevoked(await ctx.readJsonBody(), ctx.sendJson);
+      return true;
+    }
+    if (ctx.pathname === '/state/shared/presence/apply') {
+      await sharedRest.handlePresenceApply(await ctx.readJsonBody(), ctx.sendJson);
+      return true;
+    }
     if (ctx.pathname === '/state/shared/replicas/rehydrate') {
       await sharedRest.handleReplicaRehydrate(await ctx.readJsonBody(), ctx.sendJson);
       return true;

package/runtime/scripts/amalgm-mcp/state/db.js

@@ -150,6 +150,9 @@ function migrate(database = openLocalDb()) {
       applied_version INTEGER NOT NULL DEFAULT 0 CHECK (applied_version >= 0),
       snapshot_version INTEGER NOT NULL DEFAULT 0 CHECK (snapshot_version >= 0),
       snapshot_checksum TEXT,
+      access_status TEXT NOT NULL DEFAULT 'active'
+        CHECK (access_status IN ('active', 'revoked')),
+      access_reason TEXT,
       sync_status TEXT NOT NULL DEFAULT 'synced'
         CHECK (sync_status IN (
           'saving-local',
@@ -700,6 +703,13 @@ function migrate(database = openLocalDb()) {
   // Wave-3 canaries created shared_resource_promotions before the fence
   // cursor existed.
   ensureColumn(database, 'shared_resource_promotions', 'journal_cursor', 'INTEGER NOT NULL DEFAULT 0');
+  ensureColumn(
+    database,
+    'shared_resource_replicas',
+    'access_status',
+    "TEXT NOT NULL DEFAULT 'active' CHECK (access_status IN ('active', 'revoked'))",
+  );
+  ensureColumn(database, 'shared_resource_replicas', 'access_reason', 'TEXT');
   require('./migrations').runLegacyMigrations(database);
 }
 

package/runtime/scripts/amalgm-mcp/state/mutations.js

@@ -643,6 +643,12 @@ function claimCloudMutations(options = {}) {
       WHERE shared_resource_id IS NOT NULL
         AND mutation_origin = 'local'
         AND materialized_at IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1
+          FROM shared_resource_replicas replica
+          WHERE replica.resource_id = mutation_journal.shared_resource_id
+            AND replica.access_status = 'revoked'
+        )
         AND (
           mutation_state = 'saved-local'
           OR (

package/runtime/scripts/amalgm-mcp/state/presence.js

@@ -35,7 +35,7 @@ const SWEEP_INTERVAL_MS = 10_000;
 /** Positions are small facts; anything bigger is data smuggling on the lane. */
 const MAX_BLOB_JSON_BYTES = 8 * 1024;
 
-/** resource -> (session -> { session, user, blob, at, activeAt }) */
+/** resource -> (session -> public peer fields + local/cloud source metadata) */
 const channels = new Map();
 let sweepTimer = null;
 
@@ -60,7 +60,13 @@ function stampedUser() {
 
 function peersOf(resource) {
   const peers = channels.get(resource);
-  return peers ? Array.from(peers.values()) : [];
+  return peers ? Array.from(peers.values(), (peer) => ({
+    session: peer.session,
+    user: peer.user,
+    blob: peer.blob,
+    at: peer.at,
+    activeAt: peer.activeAt,
+  })) : [];
 }
 
 function broadcast(resource) {
@@ -74,8 +80,14 @@ function ensureSweeper() {
     for (const [resource, peers] of channels) {
       let changed = false;
       for (const [session, entry] of peers) {
-        if (entry.at < cutoff) {
+        if (entry.freshAt < cutoff) {
           peers.delete(session);
+          if (entry.source === 'local') publishLocal({
+            resource,
+            cloudResourceId: entry.cloudResourceId,
+            session,
+            leave: true,
+          });
           changed = true;
         }
       }
@@ -91,6 +103,20 @@ function ensureSweeper() {
   if (typeof sweepTimer.unref === 'function') sweepTimer.unref();
 }
 
+function cloudResourceIdFor(resource) {
+  try {
+    const replica = require('./replicas').getReplicaByLocalResource(resource);
+    return replica?.accessStatus === 'revoked' ? null : (replica?.resourceId || null);
+  } catch {
+    return null;
+  }
+}
+
+function publishLocal(change) {
+  if (!change.cloudResourceId) return;
+  emitter.emit('presence-publish', change);
+}
+
 /**
  * Publish one binding's presence on a resource. `blob` is the surface's
  * opaque position state (may be null — present without a position);
@@ -114,15 +140,26 @@ function updatePresence(input) {
     channels.set(resource, peers);
   }
   const previous = peers.get(session);
+  const cloudResourceId = cloudResourceIdFor(resource);
   peers.set(session, {
     session,
     user: stampedUser(),
     blob,
     at: now,
     activeAt: input?.active ? now : (previous?.activeAt ?? now),
+    freshAt: now,
+    source: 'local',
+    cloudResourceId,
   });
   ensureSweeper();
   broadcast(resource);
+  publishLocal({
+    resource,
+    cloudResourceId,
+    session,
+    blob,
+    active: input?.active === true,
+  });
   return { resource, session, peers: peers.size };
 }
 
@@ -131,9 +168,18 @@ function leavePresence(input) {
   const resource = requireString(input?.resource, 'resource');
   const session = requireString(input?.session, 'session');
   const peers = channels.get(resource);
-  if (!peers || !peers.delete(session)) return { resource, session, peers: peers?.size ?? 0 };
+  const previous = peers?.get(session);
+  if (!peers || previous?.source !== 'local' || !peers.delete(session)) {
+    return { resource, session, peers: peers?.size ?? 0 };
+  }
   if (peers.size === 0) channels.delete(resource);
   broadcast(resource);
+  publishLocal({
+    resource,
+    cloudResourceId: previous.cloudResourceId,
+    session,
+    leave: true,
+  });
   return { resource, session, peers: peers?.size ?? 0 };
 }
 
@@ -145,12 +191,52 @@ function leavePresence(input) {
 function evictSession(session) {
   if (typeof session !== 'string' || !session) return;
   for (const [resource, peers] of Array.from(channels)) {
-    if (!peers.delete(session)) continue;
+    const previous = peers.get(session);
+    if (previous?.source !== 'local' || !peers.delete(session)) continue;
     if (peers.size === 0) channels.delete(resource);
     broadcast(resource);
+    publishLocal({
+      resource,
+      cloudResourceId: previous.cloudResourceId,
+      session,
+      leave: true,
+    });
   }
 }
 
+/** Replace cloud peers for one local replica while preserving local bindings. */
+function replaceCloudPresence(input) {
+  const resource = requireString(input?.resource, 'resource');
+  const incoming = Array.isArray(input?.peers) ? input.peers : [];
+  let peers = channels.get(resource);
+  if (!peers) {
+    peers = new Map();
+    channels.set(resource, peers);
+  }
+  for (const [session, entry] of Array.from(peers)) {
+    if (entry.source === 'cloud') peers.delete(session);
+  }
+  const now = Date.now();
+  for (const peer of incoming) {
+    if (!peer || typeof peer.session !== 'string' || typeof peer.user !== 'string') continue;
+    if (peers.get(peer.session)?.source === 'local') continue;
+    peers.set(peer.session, {
+      session: peer.session,
+      user: peer.user,
+      blob: peer.blob ?? null,
+      at: Number(peer.at) || now,
+      activeAt: Number(peer.activeAt) || now,
+      freshAt: now,
+      source: 'cloud',
+      cloudResourceId: null,
+    });
+  }
+  if (peers.size === 0) channels.delete(resource);
+  else ensureSweeper();
+  broadcast(resource);
+  return { resource, peers: peers.size };
+}
+
 /**
  * Current state as broadcast frames — sent to a stream on connect so a late
  * joiner sees existing peers immediately instead of waiting out their next
@@ -165,11 +251,18 @@ function subscribePresence(callback) {
   return () => emitter.off('presence', callback);
 }
 
+function subscribePresencePublishes(callback) {
+  emitter.on('presence-publish', callback);
+  return () => emitter.off('presence-publish', callback);
+}
+
 module.exports = {
   PRESENCE_TTL_MS,
   evictSession,
   leavePresence,
+  replaceCloudPresence,
   snapshotFrames,
   subscribePresence,
+  subscribePresencePublishes,
   updatePresence,
 };

package/runtime/scripts/amalgm-mcp/state/replicas.js

@@ -13,6 +13,7 @@ const { trace } = require('./trace');
 const { isCloudResourceId } = require('./cloud-resource-id');
 
 const CONTRACT = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,127}$/;
+const ACCESS_REASONS = new Set(['access-removed', 'resource-unavailable']);
 
 function invalid(message, statusCode = 400) {
   return Object.assign(new Error(message), { statusCode });
@@ -46,6 +47,8 @@ function normalizeReplica(row) {
     appliedVersion: Number(row.applied_version),
     snapshotVersion: Number(row.snapshot_version),
     snapshotChecksum: row.snapshot_checksum || null,
+    accessStatus: row.access_status,
+    accessReason: row.access_reason || null,
     syncStatus: row.sync_status,
     lastError: row.last_error || null,
     createdAt: row.created_at,
@@ -179,10 +182,13 @@ function refreshReplicaAuthority(input, options = {}) {
   if (authorityEpoch < Number(row.authority_epoch)) {
     return { ...normalizeReplica(row), authorityChanged: false };
   }
-  const authorityChanged = authorityEpoch > Number(row.authority_epoch);
+  const authorityChanged = authorityEpoch > Number(row.authority_epoch)
+    || row.access_status !== 'active';
   cachedStatement(database, `
     UPDATE shared_resource_replicas
     SET authority_epoch = ?,
+        access_status = 'active',
+        access_reason = NULL,
         sync_status = CASE WHEN applied_version < ? THEN 'syncing' ELSE sync_status END,
         last_error = CASE
           WHEN applied_version < ? THEN 'official tail recovery required'
@@ -194,6 +200,24 @@ function refreshReplicaAuthority(input, options = {}) {
   return { ...getReplicaByResourceId(resourceId, { database }), authorityChanged };
 }
 
+function markReplicaRevoked(input, options = {}) {
+  const resourceId = requiredText(input?.resourceId, 'resourceId', 132);
+  const reason = requiredText(input?.reason, 'reason', 64);
+  if (!ACCESS_REASONS.has(reason)) throw invalid('reason must describe an access revocation');
+  const database = options.database || openLocalDb();
+  const now = new Date().toISOString();
+  const result = cachedStatement(database, `
+    UPDATE shared_resource_replicas
+    SET access_status = 'revoked',
+        access_reason = ?,
+        updated_at = ?
+    WHERE resource_id = ?
+  `).run(reason, now, resourceId);
+  if (!result.changes) throw invalid(`unknown shared replica ${resourceId}`, 404);
+  trace('replica-revoked', { resourceId, reason });
+  return getReplicaByResourceId(resourceId, { database });
+}
+
 /**
  * A freshly attached official snapshot subsumes every version at or before
  * it, so the replica's cursors jump forward to the snapshot — never backward:
@@ -241,6 +265,7 @@ module.exports = {
   getReplicaByLocalResource,
   getReplicaByResourceId,
   listReplicas,
+  markReplicaRevoked,
   refreshReplicaAuthority,
   registerReplica,
 };

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

@@ -219,6 +219,7 @@ function handleStream(req, res, query) {
   let heartbeat = null;
   let unsubscribe = null;
   let unsubscribePresence = null;
+  let unsubscribePresencePublishes = null;
   let tornDown = false;
   const teardown = () => {
     if (tornDown) return;
@@ -226,6 +227,7 @@ function handleStream(req, res, query) {
     if (heartbeat) clearInterval(heartbeat);
     if (unsubscribe) unsubscribe();
     if (unsubscribePresence) unsubscribePresence();
+    if (unsubscribePresencePublishes) unsubscribePresencePublishes();
     // The connection was the presence: its death removes this session's
     // entries everywhere, and the broadcast tells every other stream.
     if (presenceSession) presence.evictSession(presenceSession);
@@ -304,6 +306,9 @@ function handleStream(req, res, query) {
   unsubscribePresence = presence.subscribePresence((frame) => {
     writeSafe(() => sendSseControl(res, 'presence', frame));
   });
+  unsubscribePresencePublishes = presence.subscribePresencePublishes((frame) => {
+    writeSafe(() => sendSseControl(res, 'presence-publish', frame));
+  });
 
   // A named event (not an SSE comment) so EventSource clients can observe it
   // and detect a silently dead stream, e.g. tunnel frame drops. It doubles as

package/runtime/scripts/amalgm-mcp/state/shared-rest.js

@@ -63,6 +63,39 @@ async function handleReplicaAuthority(body, sendJson) {
   }
 }
 
+async function handleReplicaRevoked(body, sendJson) {
+  try {
+    const replica = require('./replicas').markReplicaRevoked({
+      resourceId: body?.resourceId,
+      reason: body?.reason,
+    });
+    require('./presence').replaceCloudPresence({
+      resource: replica.localResource,
+      peers: [],
+    });
+    sendJson(200, replica);
+  } catch (error) {
+    sendHandlerError(error, sendJson);
+  }
+}
+
+async function handlePresenceApply(body, sendJson) {
+  try {
+    const replica = require('./replicas').getReplicaByResourceId(body?.resourceId);
+    if (!replica || replica.accessStatus === 'revoked') {
+      const error = new Error(`unknown active shared replica ${body?.resourceId || ''}`);
+      error.statusCode = 404;
+      throw error;
+    }
+    sendJson(200, require('./presence').replaceCloudPresence({
+      resource: replica.localResource,
+      peers: body?.peers,
+    }));
+  } catch (error) {
+    sendHandlerError(error, sendJson);
+  }
+}
+
 async function handleReplicaRehydrate(body, sendJson) {
   try {
     sendJson(202, require('./attachments').requestRehydration({ resourceId: body?.resourceId }));
@@ -291,6 +324,7 @@ module.exports = {
   handleMutationClaim,
   handleMutationFail,
   handleMutationIngest,
+  handlePresenceApply,
   handlePromotionAck,
   handlePromotionClaim,
   handlePromotionFail,
@@ -300,5 +334,6 @@ module.exports = {
   handleReplicaList,
   handleReplicaRegister,
   handleReplicaRehydrate,
+  handleReplicaRevoked,
   handleWorkspaceContentDiscover,
 };

package/runtime/scripts/amalgm-mcp/tests/shared-presence-tunnel.test.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('http');
+
+const {
+  CAPABILITY,
+  PRESENCE_CAPABILITY,
+  createSharedRealtimeTunnel,
+} = require('../../../../packages/amalgm/lib/shared-realtime-tunnel');
+
+const RESOURCE = '77777777-7777-7777-8777-777777777777';
+
+async function until(predicate, label) {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    if (predicate()) return;
+    await new Promise((resolve) => { setTimeout(resolve, 10); });
+  }
+  assert.fail(`timed out waiting for ${label}`);
+}
+
+test('the runtime tunnel bridges presence in both directions without a durable queue', async () => {
+  const calls = [];
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.on('data', (chunk) => { body += chunk; });
+    req.on('end', () => {
+      const parsed = body ? JSON.parse(body) : null;
+      calls.push({ method: req.method, path: req.url, body: parsed });
+      if (req.url.startsWith('/state/stream')) {
+        res.writeHead(200, { 'content-type': 'text/event-stream' });
+        res.write('event: presence-publish\n');
+        res.write(`data: ${JSON.stringify({
+          cloudResourceId: RESOURCE,
+          session: 'ps_runtime',
+          blob: { kind: 'text-caret@1', anchor: 3, head: 5 },
+          active: true,
+        })}\n\n`);
+        return;
+      }
+      res.setHeader('content-type', 'application/json');
+      if (req.url === '/state/shared/replicas') {
+        res.end(JSON.stringify({ replicas: [] }));
+        return;
+      }
+      res.end(JSON.stringify({ mutations: [], promotions: [], attachments: [] }));
+    });
+  });
+  await new Promise((resolve) => { server.listen(0, '127.0.0.1', resolve); });
+  const sent = [];
+  const tunnel = createSharedRealtimeTunnel({
+    send: (frame) => { sent.push(frame); return true; },
+    sendLarge: (frame) => { sent.push(frame); return true; },
+    localPort: () => server.address().port,
+    localHeaders: (headers) => ({ ...headers }),
+    warn: () => {},
+  });
+
+  try {
+    tunnel.enable([CAPABILITY, PRESENCE_CAPABILITY]);
+    await until(
+      () => sent.some((frame) => frame.type === 'shared.presence.publish'),
+      'outbound presence',
+    );
+    assert.deepEqual(sent.find((frame) => frame.type === 'shared.presence.publish'), {
+      type: 'shared.presence.publish',
+      resource_id: RESOURCE,
+      session: 'ps_runtime',
+      blob: { kind: 'text-caret@1', anchor: 3, head: 5 },
+      active: true,
+    });
+
+    tunnel.handleFrame({
+      type: 'shared.presence',
+      resource_id: RESOURCE,
+      peers: [{
+        session: 'ps_direct',
+        user: 'direct-user',
+        blob: { anchor: 8 },
+        at: 20,
+        activeAt: 20,
+      }],
+    });
+    await until(
+      () => calls.some((call) => call.path === '/state/shared/presence/apply'),
+      'inbound presence apply',
+    );
+    const apply = calls.find((call) => call.path === '/state/shared/presence/apply');
+    assert.deepEqual(apply.body, {
+      resourceId: RESOURCE,
+      peers: [{
+        session: 'ps_direct',
+        user: 'direct-user',
+        blob: { anchor: 8 },
+        at: 20,
+        activeAt: 20,
+      }],
+    });
+  } finally {
+    tunnel.stop();
+    server.close();
+  }
+});

package/runtime/scripts/amalgm-mcp/tests/shared-tunnel-rehydration.test.js

@@ -22,7 +22,8 @@ async function until(predicate, label) {
 
 // The tunnel client against a real (local, in-test) state service: a join
 // answered with shared_tail_pruned or shared_tail_too_large must turn into a
-// rehydration request plus an attachment drain; any other join failure must not.
+// rehydration request plus an attachment drain. Permission failures are a
+// separate authority transition and must persist as revocation instead.
 test('a pruned-tail join answer triggers rehydration through the local state service', async () => {
   const calls = [];
   const server = http.createServer((req, res) => {
@@ -106,8 +107,31 @@ test('a pruned-tail join answer triggers rehydration through the local state ser
       status: 403,
       retryable: false,
     });
-    await sleep(50);
+    await until(
+      () => calls.some((call) => call.path === '/state/shared/replicas/revoked'),
+      'the durable revocation state',
+    );
     assert.equal(rehydrations(), before, 'a permission failure is not a rehydration signal');
+    const revoked = calls.find((call) => call.path === '/state/shared/replicas/revoked');
+    assert.deepEqual(revoked.body, { resourceId: RESOURCE, reason: 'access-removed' });
+
+    const revokedCalls = () => calls.filter(
+      (call) => call.path === '/state/shared/replicas/revoked',
+    ).length;
+    const beforeExplicitFrame = revokedCalls();
+    tunnel.handleFrame({
+      type: 'shared.resource.revoked',
+      resource_id: RESOURCE,
+      reason: 'resource-unavailable',
+    });
+    await until(
+      () => revokedCalls() === beforeExplicitFrame + 1,
+      'the explicit revocation frame',
+    );
+    assert.deepEqual(
+      calls.filter((call) => call.path === '/state/shared/replicas/revoked').at(-1).body,
+      { resourceId: RESOURCE, reason: 'resource-unavailable' },
+    );
   } finally {
     tunnel.stop();
     server.close();

package/runtime/scripts/amalgm-mcp/tests/state-presence.test.js

@@ -14,6 +14,8 @@ const { closeLocalDb } = require('../state/db');
 const { listEventsAfter } = require('../state/events');
 const presence = require('../state/presence');
 const rest = require('../state/rest');
+const sharedRest = require('../state/shared-rest');
+const { registerReplica } = require('../state/replicas');
 
 test.after(() => {
   closeLocalDb();
@@ -128,3 +130,59 @@ test('presence frames are absent from replay surfaces', () => {
   req.emit('close');
   presence.leavePresence({ resource: 'doc:t6', session: 'ps_r' });
 });
+
+test('shared presence forwards local facts, merges cloud peers, and clears them on revocation', async () => {
+  const cloudResourceId = '77777777-7777-7777-8777-777777777777';
+  const localResource = 'doc:shared-presence';
+  registerReplica({
+    resourceId: cloudResourceId,
+    localResource,
+    localPath: path.join(tempRoot, 'shared-presence.md'),
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    authorityEpoch: 1,
+  });
+  const frames = [];
+  const publishes = [];
+  const unsubscribeFrames = presence.subscribePresence((frame) => frames.push(frame));
+  const unsubscribePublishes = presence.subscribePresencePublishes((frame) => publishes.push(frame));
+
+  presence.updatePresence({
+    resource: localResource,
+    session: 'ps_local',
+    blob: { kind: 'text-caret@1', anchor: 2, head: 2 },
+    active: true,
+  });
+  assert.deepEqual(publishes, [{
+    resource: localResource,
+    cloudResourceId,
+    session: 'ps_local',
+    blob: { kind: 'text-caret@1', anchor: 2, head: 2 },
+    active: true,
+  }]);
+
+  presence.replaceCloudPresence({
+    resource: localResource,
+    peers: [
+      { session: 'ps_local', user: 'official-local', blob: null, at: 10, activeAt: 10 },
+      { session: 'ps_remote', user: 'remote-user', blob: { anchor: 9 }, at: 11, activeAt: 11 },
+    ],
+  });
+  assert.equal(publishes.length, 1, 'an inbound cloud roster never echoes back upstream');
+  assert.deepEqual(frames.at(-1).peers.map((peer) => peer.session).sort(), ['ps_local', 'ps_remote']);
+
+  await sharedRest.handleReplicaRevoked(
+    { resourceId: cloudResourceId, reason: 'access-removed' },
+    (status) => assert.equal(status, 200),
+  );
+  assert.deepEqual(
+    frames.at(-1).peers.map((peer) => peer.session),
+    ['ps_local'],
+    'revocation removes imported peers without disrupting local bindings',
+  );
+
+  presence.leavePresence({ resource: localResource, session: 'ps_local' });
+  assert.equal(publishes.at(-1).leave, true);
+  unsubscribeFrames();
+  unsubscribePublishes();
+});

package/runtime/scripts/amalgm-mcp/tests/state-shared-replica.test.js

@@ -27,7 +27,11 @@ const {
   claimPromotions,
   enqueuePromotion,
 } = require('../state/promotions');
-const { getReplicaByResourceId } = require('../state/replicas');
+const {
+  getReplicaByResourceId,
+  markReplicaRevoked,
+  refreshReplicaAuthority,
+} = require('../state/replicas');
 const {
   acknowledgeAttachment,
   claimAttachments,
@@ -529,3 +533,37 @@ test('a promotion-born replica (which never attached) gets an attachment row for
   assert.equal(requested.attachment.resourceId, resourceId);
   assert.equal(requested.attachment.localPath, target);
 });
+
+test('revoked authority pauses the outbox and a successful rejoin resumes it', () => {
+  const opened = docs.openDoc(target);
+  const client = clientFromState(opened.state);
+  const update = captureEdit(client, (text) => text.insert(text.length, 'revocation-safe\n'));
+  const mutationId = 'mut_revocation_resume_1';
+  docs.applyDocMutations(target, [{ mutationId, update }]);
+
+  const syncStatus = getReplicaByResourceId(resourceId).syncStatus;
+  const revoked = markReplicaRevoked({ resourceId, reason: 'access-removed' });
+  assert.equal(revoked.accessStatus, 'revoked');
+  assert.equal(revoked.syncStatus, syncStatus, 'authority does not rewrite sync progress');
+  assert.equal(
+    claimCloudMutations().some((claim) => claim.envelope.mutationId === mutationId),
+    false,
+    'revoked resources do not leave the local outbox',
+  );
+
+  const before = getReplicaByResourceId(resourceId);
+  const refreshed = refreshReplicaAuthority({
+    resourceId,
+    authorityEpoch: before.authorityEpoch + 1,
+    headVersion: before.appliedVersion,
+    contract: before.contract,
+    schemaVersion: before.schemaVersion,
+  });
+  assert.equal(refreshed.accessStatus, 'active');
+  assert.equal(refreshed.accessReason, null);
+  assert.equal(
+    claimCloudMutations().some((claim) => claim.envelope.mutationId === mutationId),
+    true,
+    'the same durable edit resumes after authority is restored',
+  );
+});

package/runtime/scripts/amalgm-mcp/tests/workspace-inclusion.test.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { shouldEnroll, shouldSync } = require('../workspace/tree/inclusion');
+
+test('workspace identity excludes credential material at every depth', () => {
+  const privatePaths = [
+    'server.pem',
+    'keys/deploy.key',
+    'keys/id_ed25519',
+    'mobile/signing.p12',
+    'infra/terraform.tfstate',
+    'config/service-account-prod.json',
+    'nested/.aws/credentials',
+    'nested/.kube/config',
+    '.npmrc',
+  ];
+  for (const relativePath of privatePaths) {
+    assert.equal(shouldEnroll(relativePath), false, relativePath);
+    assert.equal(shouldSync(relativePath), false, relativePath);
+  }
+});
+
+test('the credential fence does not exclude public templates or keys', () => {
+  for (const relativePath of [
+    '.env.example',
+    'keys/id_ed25519.pub',
+    'certificates/server.crt',
+    'docs/service-account.md',
+  ]) {
+    assert.equal(shouldEnroll(relativePath), true, relativePath);
+  }
+});

package/runtime/scripts/amalgm-mcp/tests/workspace-tree-store.test.js

@@ -177,6 +177,58 @@ test('direct shell creates and renames enter the same UUID tree journal', () =>
   assert.deepEqual(rows.map((row) => row.operation_kind), ['tree.create', 'tree.rename']);
 });
 
+test('moving a node requires write access at both source and destination', () => {
+  const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'move-authority');
+  const sourcePath = path.join(root, 'source');
+  const destinationPath = path.join(root, 'destination');
+  const filePath = path.join(sourcePath, 'note.md');
+  fs.mkdirSync(sourcePath, { recursive: true });
+  fs.mkdirSync(destinationPath, { recursive: true });
+  fs.writeFileSync(filePath, 'identity survives the move\n');
+  const workspace = upsertWorkspace({ path: root, name: 'Move authority', source: 'computer' });
+  enrollWorkspace(workspace.id);
+
+  const database = openLocalDb();
+  const source = nodeForPath(sourcePath).node;
+  const destination = nodeForPath(destinationPath).node;
+  const file = nodeForPath(filePath).node;
+  const memberId = 'member-move-authority';
+  const grant = database.prepare(`
+    INSERT INTO workspace_node_permissions(workspace_id, node_id, user_id, role)
+    VALUES (?, ?, ?, ?)
+  `);
+  grant.run(workspace.id, workspace.id, memberId, 'viewer');
+  grant.run(workspace.id, source.id, memberId, 'editor');
+  grant.run(workspace.id, destination.id, memberId, 'no_access');
+
+  const identity = require('../workspace/identity');
+  const currentUserId = identity.userId;
+  identity.userId = () => memberId;
+  try {
+    assert.throws(() => commitTreeOperation({
+      kind: 'tree.move',
+      workspaceId: workspace.id,
+      nodeId: file.id,
+      parentId: destination.id,
+    }), /tree destination is forbidden/);
+    assert.equal(nodeForPath(filePath).node.id, file.id);
+
+    database.prepare(`
+      UPDATE workspace_node_permissions SET role = 'editor'
+      WHERE node_id = ? AND user_id = ?
+    `).run(destination.id, memberId);
+    commitTreeOperation({
+      kind: 'tree.move',
+      workspaceId: workspace.id,
+      nodeId: file.id,
+      parentId: destination.id,
+    });
+    assert.equal(nodeForPath(path.join(destinationPath, 'note.md')).node.id, file.id);
+  } finally {
+    identity.userId = currentUserId;
+  }
+});
+
 test('recursive create enrolls missing parents without overwriting existing disk entries', () => {
   const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'recursive');
   fs.mkdirSync(root);

package/runtime/scripts/amalgm-mcp/workspace/tree/inclusion.js

@@ -4,10 +4,14 @@ const path = require('path');
 
 const EXCLUDED_DIRECTORIES = new Set([
   '.amalgm',
+  '.aws',
   '.cache',
+  '.docker',
   '.git',
+  '.gnupg',
   '.gradle',
   '.hg',
+  '.kube',
   '.mypy_cache',
   '.next',
   '.nyc_output',
@@ -41,7 +45,11 @@ function partsFor(relativePath) {
 
 function isPrivateFile(name) {
   if (/^\.env(?:\..+)?$/i.test(name) && !/\.example$/i.test(name)) return true;
-  return /^(?:credentials?|secrets?)\.(?:json|ya?ml|toml)$/i.test(name);
+  if (/^(?:credentials?|secrets?)\.(?:json|ya?ml|toml|ini|conf)$/i.test(name)) return true;
+  if (/^id_(?:dsa|ecdsa|ed25519|rsa)$/i.test(name)) return true;
+  if (/^(?:\.git-credentials|\.netrc|\.npmrc|\.pypirc|auth\.json|kubeconfig)$/i.test(name)) return true;
+  if (/^(?:service[-_]?account|firebase[-_]?adminsdk).*\.json$/i.test(name)) return true;
+  return /\.(?:key|keystore|kdbx|p12|pfx|pem|ppk|tfstate(?:\.backup)?)$/i.test(name);
 }
 
 // Machine-local metadata, dependencies, generated caches, and secrets never

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

@@ -275,8 +275,9 @@ function requirePathCapability(pathInput, capability, options = {}) {
 function commitTreeOperation(input, options = {}) {
   let operation = normalizeTreeOperation(input);
   const database = options.database || openLocalDb();
+  const accessStore = require('./access-store');
   const accessNodeId = operation.kind === 'tree.create' ? operation.parentId : operation.nodeId;
-  const role = options.role || require('./access-store').currentUserRole(accessNodeId, { database });
+  const role = options.role || accessStore.currentUserRole(accessNodeId, { database });
   if (!can(role, capabilityForOperation(operation.kind))) throw invalid('tree operation is forbidden', 403);
   const workspace = workspaceRow(operation.workspaceId, database);
   if (!workspace) throw invalid('workspace not found', 404);
@@ -285,6 +286,14 @@ function commitTreeOperation(input, options = {}) {
       .map(rowToNode)
       .map((node) => [node.id, node]),
   );
+  if (operation.kind === 'tree.move' || operation.kind === 'tree.restore') {
+    const destinationId = operation.parentId || before.get(operation.nodeId)?.parentId;
+    const destinationRole = options.role
+      || accessStore.currentUserRole(destinationId, { database });
+    if (!can(destinationRole, 'create')) {
+      throw invalid('tree destination is forbidden', 403);
+    }
+  }
   if (operation.kind === 'tree.move' && !operation.previousParentId) {
     operation = { ...operation, previousParentId: before.get(operation.nodeId)?.parentId || null };
   }