amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/browser-cookie-cloud.test.js

@@ -23,7 +23,6 @@ const {
   claimCloudMutations,
   getMutation,
 } = require('../state/mutations');
-const { getReplicaByResourceId } = require('../state/replicas');
 const {
   COOKIE_CLOUD_CONTRACT,
   applyCloudCookieMutation,
@@ -90,21 +89,6 @@ test('official cookie mutations materialize in order and deletions stay tombston
     version: 1,
     committedAt: '2026-07-20T20:00:00.000Z',
   }, { database: db });
-  assert.equal(
-    getReplicaByResourceId(localClaim.envelope.resourceId, { database: db }).appliedVersion,
-    0,
-    'the acknowledgement records the number but does not apply it',
-  );
-  applyCloudCookieMutation({
-    version: 1,
-    committedAt: '2026-07-20T20:00:00.000Z',
-    envelope: localClaim.envelope,
-  }, { database: db });
-  assert.equal(
-    getReplicaByResourceId(localClaim.envelope.resourceId, { database: db }).appliedVersion,
-    1,
-    'the writer advances only when its committed event passes through the ordered inbox',
-  );
 
   const remoteCookie = cookie('remote', 'remote-secret');
   const key = require('../browser/cookie-jar').cookieKey(remoteCookie);
@@ -194,181 +178,4 @@ test('a stale cloud base never re-emits local cookies as bootstrap mutations', (
   assert.equal(result.bootstrapDeferred, true);
   assert.equal(result.bootstrappedMutations, 0);
   assert.equal(db.prepare('SELECT COUNT(*) AS count FROM mutation_journal').get().count, 0);
-  assert.equal(
-    readCookieJar().cookies.some((item) => item.name === 'already-synced'),
-    true,
-    'a stale prefix cannot roll the physical jar backward',
-  );
-});
-
-test('a private snapshot ahead of cloud head is rejected before changing the jar', () => {
-  const before = JSON.stringify(readCookieJar());
-  const resourceId = privateCookieResourceId(userId);
-  const bytes = Buffer.from(JSON.stringify({
-    schemaVersion: 1,
-    version: 8,
-    updatedAt: '2026-07-20T19:00:00.000Z',
-    records: [],
-    tombstones: [],
-  }), 'utf8');
-  assert.throws(() => installCookieCloudBootstrap({
-    resourceId,
-    authorityEpoch: 1,
-    headVersion: 7,
-    snapshotVersion: 8,
-    snapshotChecksum: require('crypto').createHash('sha256').update(bytes).digest('hex'),
-    snapshotBase64: bytes.toString('base64'),
-    contract: COOKIE_CLOUD_CONTRACT,
-    schemaVersion: 1,
-  }), /cannot exceed headVersion/);
-  assert.equal(JSON.stringify(readCookieJar()), before);
-});
-
-test('a stale cookie prefix ahead of the local cursor cannot claim application', () => {
-  mergeCookieJar({ sourceId: 'machine-a', upserts: [cookie('local-only', 'keep-me')] });
-  const db = openLocalDb();
-  db.prepare('DELETE FROM mutation_journal').run();
-  const resourceId = privateCookieResourceId(userId);
-  const before = JSON.stringify(readCookieJar());
-  const bytes = Buffer.from(JSON.stringify({
-    schemaVersion: 1,
-    version: 3,
-    updatedAt: '2026-07-20T19:00:00.000Z',
-    records: [],
-    tombstones: [],
-  }), 'utf8');
-
-  const result = installCookieCloudBootstrap({
-    resourceId,
-    authorityEpoch: 1,
-    headVersion: 7,
-    snapshotVersion: 3,
-    snapshotChecksum: require('crypto').createHash('sha256').update(bytes).digest('hex'),
-    snapshotBase64: bytes.toString('base64'),
-    contract: COOKIE_CLOUD_CONTRACT,
-    schemaVersion: 1,
-  }, { database: db });
-
-  assert.equal(result.bootstrapDeferred, true);
-  assert.equal(result.replica.appliedVersion, 0);
-  assert.equal(JSON.stringify(readCookieJar()), before);
-});
-
-test('cookie bootstrap journals legacy local state before replacing the physical jar', () => {
-  mergeCookieJar({
-    sourceId: 'legacy-browser',
-    upserts: [cookie('legacy-session', 'must-survive')],
-  });
-  const db = openLocalDb();
-  db.prepare('DELETE FROM mutation_journal').run();
-  const resourceId = privateCookieResourceId(userId);
-  const bytes = Buffer.from(JSON.stringify({
-    schemaVersion: 1,
-    version: 0,
-    updatedAt: '2026-07-20T19:00:00.000Z',
-    records: [],
-    tombstones: [],
-  }), 'utf8');
-  const input = {
-    resourceId,
-    authorityEpoch: 1,
-    headVersion: 0,
-    snapshotVersion: 0,
-    snapshotChecksum: require('crypto').createHash('sha256').update(bytes).digest('hex'),
-    snapshotBase64: bytes.toString('base64'),
-    contract: COOKIE_CLOUD_CONTRACT,
-    schemaVersion: 1,
-  };
-
-  assert.throws(
-    () => installCookieCloudBootstrap(input, {
-      database: db,
-      testHooks: { crashAfterSnapshotPersist: true },
-    }),
-    /simulated cookie bootstrap crash/,
-  );
-  assert.equal(
-    db.prepare(`
-      SELECT COUNT(*) AS count FROM mutation_journal
-      WHERE shared_resource_id = ? AND mutation_origin = 'local'
-    `).get(resourceId).count,
-    1,
-    'the local cookie is durable before the jar is replaced',
-  );
-
-  installCookieCloudBootstrap(input, { database: db });
-  assert.equal(
-    readCookieJar().cookies.some((item) => (
-      item.name === 'legacy-session' && item.value === 'must-survive'
-    )),
-    true,
-  );
-  assert.equal(
-    db.prepare(`
-      SELECT COUNT(*) AS count FROM mutation_journal
-      WHERE shared_resource_id = ? AND mutation_origin = 'local'
-    `).get(resourceId).count,
-    1,
-    'restart does not mint a second birth certificate',
-  );
-});
-
-test('cookie bootstrap completes a crash-left saving-local birth instead of replaying forever', () => {
-  mergeCookieJar({
-    sourceId: 'crashing-browser',
-    upserts: [cookie('crash-left', 'must-recover')],
-  });
-  const db = openLocalDb();
-  const row = db.prepare(`
-    SELECT * FROM mutation_journal
-    WHERE operation_kind = 'cookie.upsert'
-    ORDER BY journal_id DESC
-    LIMIT 1
-  `).get();
-  db.prepare(`
-    UPDATE mutation_journal
-    SET mutation_state = 'saving-local',
-        materialized_at = NULL,
-        event_seq = NULL
-    WHERE journal_id = ?
-  `).run(row.journal_id);
-  db.prepare('DELETE FROM event_log').run();
-
-  const bytes = Buffer.from(JSON.stringify({
-    schemaVersion: 1,
-    version: 0,
-    updatedAt: '2026-07-20T19:00:00.000Z',
-    records: [],
-    tombstones: [],
-  }), 'utf8');
-  installCookieCloudBootstrap({
-    resourceId: row.shared_resource_id,
-    authorityEpoch: 1,
-    headVersion: 0,
-    snapshotVersion: 0,
-    snapshotChecksum: require('crypto').createHash('sha256').update(bytes).digest('hex'),
-    snapshotBase64: bytes.toString('base64'),
-    contract: COOKIE_CLOUD_CONTRACT,
-    schemaVersion: 1,
-  }, { database: db });
-
-  const repaired = db.prepare(`
-    SELECT mutation_state, materialized_at, event_seq
-    FROM mutation_journal
-    WHERE journal_id = ?
-  `).get(row.journal_id);
-  assert.equal(repaired.mutation_state, 'saved-local');
-  assert.ok(repaired.materialized_at);
-  assert.ok(repaired.event_seq);
-  assert.equal(
-    readCookieJar().cookies.some((item) => (
-      item.name === 'crash-left' && item.value === 'must-recover'
-    )),
-    true,
-  );
-  assert.equal(
-    db.prepare('SELECT COUNT(*) AS count FROM mutation_journal').get().count,
-    1,
-    'recovery completes the original birth instead of minting another',
-  );
 });

package/runtime/scripts/amalgm-mcp/tests/doorbell.matrix.life.test.js

@@ -0,0 +1,449 @@
+'use strict';
+
+/**
+ * THE LIFE GRID — half of the doorbell grammar matrix: every physical
+ * kind Detect can see × every life event ground can undergo (create,
+ * change, rename, move, disappear, restart). One exam per box, proven
+ * TOTAL by construction: the rows are DERIVED from the adapter
+ * contract — exactly the alphabet types whose adapter binds the
+ * ratified detect socket — so a new type, or a blind type gaining its
+ * socket, convicts this suite until it takes its row. The one blind
+ * type today is asserted by name: `reference` has no detect socket by
+ * its own constitution (its truth is registry identity; the rendered
+ * symlink is derived state, proven in the registration suite) — a
+ * Detect row for it would invent semantics ahead of the socket.
+ *
+ * These cells prove DETECTION grammar at the scan entrance; live
+ * doorbell delivery is the other half's business
+ * (doorbell.matrix.watch.test.js).
+ *
+ * Grammar ratified here (each line observed on real ground first):
+ *   - Both file kinds share ONE row definition: the grammar cannot
+ *     care what the bytes are, because the same code speaks for both.
+ *   - A folder rename re-addresses every member at this layer
+ *     (dir.renamed + member file.renamed); "descendants silent" is the
+ *     REGISTRY's record-level law, proven in its own suites.
+ *   - Repository territory is path-keyed at this layer: a moved repo
+ *     is burial + discovery; identity continuity is the registry's
+ *     rescue, not the doorbell's.
+ *   - Recreation after a witnessed deletion is a new birth.
+ *   - A repo-kind root speaks once (repo.changed) for any member churn
+ *     — the RAW repo doorbell; the follower, a layer above, turns it
+ *     into card, checkpoint, or silence.
+ *   - Constructs (automations, agents, skills…) are plain ground: they
+ *     move through every box above with no voice of their own.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const { adapterFor } = require('../adapters');
+const { ENTITY_TYPES } = require('../registry');
+const {
+  afterRestart, clean, cleanup, filesRoot, gitInit, makeDir, makeObserver, speaks,
+} = require('./doorbell.matrix.rig');
+
+test.after(cleanup);
+
+const LIFE_EVENTS = Object.freeze(['create', 'change', 'rename', 'move', 'disappear', 'restart']);
+
+/**
+ * The six file cells, defined ONCE and instantiated for both file
+ * kinds: byte-indifference is proven by construction, not by claim.
+ */
+function fileRow(name, versionOne, versionTwo) {
+  const at = (dir, rel) => path.join(dir, rel);
+  return {
+    create: () => {
+      const rig = filesRoot();
+      fs.writeFileSync(at(rig.dir, name), versionOne);
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['file.created', { path: name }]]);
+      assert.match(rig.events[rig.mark].hash, /^[0-9a-f]{64}$/, 'born with its content hash');
+      clean(rig);
+    },
+    change: () => {
+      const rig = filesRoot((dir) => fs.writeFileSync(at(dir, name), versionOne));
+      fs.writeFileSync(at(rig.dir, name), versionTwo);
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['file.changed', { path: name }]]);
+      assert.notEqual(rig.events[rig.mark].hash, rig.events[rig.mark].previousHash,
+        'the version moved with the bytes');
+      clean(rig);
+    },
+    rename: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(at(dir, 'a'));
+        fs.writeFileSync(at(dir, `a/${name}`), versionOne);
+      });
+      fs.renameSync(at(rig.dir, `a/${name}`), at(rig.dir, `a/kept-${name}`));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['file.renamed', { from: `a/${name}`, to: `a/kept-${name}` }]],
+        'one rename: no delete, no create');
+      clean(rig);
+    },
+    move: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(at(dir, 'a'));
+        fs.mkdirSync(at(dir, 'b'));
+        fs.writeFileSync(at(dir, `a/${name}`), versionOne);
+      });
+      fs.renameSync(at(rig.dir, `a/${name}`), at(rig.dir, `b/${name}`));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['file.renamed', { from: `a/${name}`, to: `b/${name}` }]],
+        'a move is a rename across directories: same channel, new address');
+      clean(rig);
+    },
+    disappear: () => {
+      const rig = filesRoot((dir) => fs.writeFileSync(at(dir, name), versionOne));
+      fs.rmSync(at(rig.dir, name));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['file.deleted', { path: name }]]);
+      clean(rig);
+    },
+    restart: () => {
+      const rig = afterRestart(
+        (dir) => fs.writeFileSync(at(dir, name), versionOne),
+        (dir) => fs.writeFileSync(at(dir, name), versionTwo));
+      speaks(rig, [['file.changed', { path: name }]],
+        'an edit made while nothing ran is one change on the same channel');
+      clean(rig);
+    },
+  };
+}
+
+const PNG = (last) => Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, last]);
+
+const GRID = {
+  'file.binary': fileRow('img.png', PNG(1), PNG(2)),
+  'file.text': fileRow('notes.md', 'a quiet first draft', 'a louder second draft'),
+
+  folder: {
+    create: () => {
+      const rig = filesRoot();
+      fs.mkdirSync(path.join(rig.dir, 'docs'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['dir.created', { path: 'docs' }]]);
+      clean(rig);
+    },
+    change: () => {
+      const rig = filesRoot((dir) => fs.mkdirSync(path.join(dir, 'docs')));
+      fs.writeFileSync(path.join(rig.dir, 'docs', 'new.md'), 'n');
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['file.created', { path: 'docs/new.md' }]],
+        'a folder\'s only content is membership: the member speaks, the folder is silent');
+      clean(rig);
+    },
+    rename: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(path.join(dir, 'docs'));
+        fs.writeFileSync(path.join(dir, 'docs', 'one.md'), '1');
+      });
+      fs.renameSync(path.join(rig.dir, 'docs'), path.join(rig.dir, 'papers'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [
+        ['dir.renamed', { from: 'docs', to: 'papers' }],
+        ['file.renamed', { from: 'docs/one.md', to: 'papers/one.md' }],
+      ], 'the address layer re-addresses every member; record-level descendant silence is the registry\'s law');
+      clean(rig);
+    },
+    move: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(path.join(dir, 'docs'));
+        fs.writeFileSync(path.join(dir, 'docs', 'one.md'), '1');
+        fs.mkdirSync(path.join(dir, 'attic'));
+      });
+      fs.renameSync(path.join(rig.dir, 'docs'), path.join(rig.dir, 'attic', 'docs'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [
+        ['dir.renamed', { from: 'docs', to: 'attic/docs' }],
+        ['file.renamed', { from: 'docs/one.md', to: 'attic/docs/one.md' }],
+      ]);
+      clean(rig);
+    },
+    disappear: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(path.join(dir, 'docs'));
+        fs.writeFileSync(path.join(dir, 'docs', 'one.md'), '1');
+        fs.writeFileSync(path.join(dir, 'docs', 'two.md'), '2');
+      });
+      fs.rmSync(path.join(rig.dir, 'docs'), { recursive: true });
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [
+        ['dir.deleted', { path: 'docs' }],
+        ['file.deleted', { path: 'docs/one.md' }],
+        ['file.deleted', { path: 'docs/two.md' }],
+      ], 'death speaks for the folder AND every member: no silent burials');
+      clean(rig);
+    },
+    restart: () => {
+      const rig = afterRestart(() => {}, (dir) => fs.mkdirSync(path.join(dir, 'docs')));
+      speaks(rig, [['dir.created', { path: 'docs' }]]);
+      clean(rig);
+    },
+  },
+
+  link: {
+    create: () => {
+      const rig = filesRoot((dir) => fs.writeFileSync(path.join(dir, 'target.md'), 't'));
+      fs.symlinkSync('target.md', path.join(rig.dir, 'ln'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['link.created', { path: 'ln' }]]);
+      clean(rig);
+    },
+    change: () => {
+      const rig = filesRoot((dir) => {
+        fs.writeFileSync(path.join(dir, 'one.md'), '1');
+        fs.writeFileSync(path.join(dir, 'two.md'), '2');
+        fs.symlinkSync('one.md', path.join(dir, 'ln'));
+      });
+      fs.unlinkSync(path.join(rig.dir, 'ln'));
+      fs.symlinkSync('two.md', path.join(rig.dir, 'ln'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['link.changed', { path: 'ln' }]],
+        'a retarget is the same channel: the address absorbs the inode churn');
+      clean(rig);
+    },
+    rename: () => {
+      const rig = filesRoot((dir) => {
+        fs.writeFileSync(path.join(dir, 'target.md'), 't');
+        fs.symlinkSync('target.md', path.join(dir, 'ln'));
+      });
+      fs.renameSync(path.join(rig.dir, 'ln'), path.join(rig.dir, 'ln2'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['link.renamed', { from: 'ln', to: 'ln2' }]]);
+      clean(rig);
+    },
+    move: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(path.join(dir, 'a'));
+        fs.mkdirSync(path.join(dir, 'b'));
+        fs.writeFileSync(path.join(dir, 'target.md'), 't');
+        fs.symlinkSync('../target.md', path.join(dir, 'a', 'ln'));
+      });
+      fs.renameSync(path.join(rig.dir, 'a', 'ln'), path.join(rig.dir, 'b', 'ln'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['link.renamed', { from: 'a/ln', to: 'b/ln' }]]);
+      clean(rig);
+    },
+    disappear: () => {
+      const rig = filesRoot((dir) => {
+        fs.writeFileSync(path.join(dir, 'target.md'), 't');
+        fs.symlinkSync('target.md', path.join(dir, 'ln'));
+      });
+      fs.unlinkSync(path.join(rig.dir, 'ln'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['link.deleted', { path: 'ln' }]],
+        'only the pointer died: its target is untouched and says nothing');
+      clean(rig);
+    },
+    restart: () => {
+      const rig = afterRestart(
+        (dir) => {
+          fs.writeFileSync(path.join(dir, 'one.md'), '1');
+          fs.writeFileSync(path.join(dir, 'two.md'), '2');
+          fs.symlinkSync('one.md', path.join(dir, 'ln'));
+        },
+        (dir) => {
+          fs.unlinkSync(path.join(dir, 'ln'));
+          fs.symlinkSync('two.md', path.join(dir, 'ln'));
+        });
+      speaks(rig, [['link.changed', { path: 'ln' }]]);
+      clean(rig);
+    },
+  },
+
+  'repo.git': {
+    create: () => {
+      const rig = filesRoot();
+      fs.mkdirSync(path.join(rig.dir, 'lib'));
+      gitInit(path.join(rig.dir, 'lib'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['repo.discovered', { path: path.join(rig.dir, 'lib') }]],
+        'a .git claims its subtree: territory is born, not files');
+      clean(rig);
+    },
+    change: () => {
+      const dir = makeDir('cell');
+      gitInit(dir);
+      fs.writeFileSync(path.join(dir, 'a.md'), 'a');
+      const { observer, events } = makeObserver();
+      const root = observer.enrollRoot(dir);
+      assert.equal(root.kind, 'repo', 'territory is decided by disk');
+      const rig = { dir, events, observer, root, mark: events.length };
+      fs.writeFileSync(path.join(dir, 'b.md'), 'b');
+      observer.scanNow(root.rootId);
+      speaks(rig, [['repo.changed', {}]],
+        'a repository speaks once for any member churn: one raw repo doorbell, zero file events — the follower turns it into card, checkpoint, or silence');
+      clean(rig);
+    },
+    rename: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(path.join(dir, 'lib'));
+        gitInit(path.join(dir, 'lib'));
+      });
+      fs.renameSync(path.join(rig.dir, 'lib'), path.join(rig.dir, 'lib2'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [
+        ['repo.discovered', { path: path.join(rig.dir, 'lib2') }],
+        ['repo.removed', { path: path.join(rig.dir, 'lib') }],
+      ], 'territory is path-keyed here: burial + discovery; identity continuity is the registry\'s rescue');
+      clean(rig);
+    },
+    move: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(path.join(dir, 'lib'));
+        gitInit(path.join(dir, 'lib'));
+        fs.mkdirSync(path.join(dir, 'vendor'));
+      });
+      fs.renameSync(path.join(rig.dir, 'lib'), path.join(rig.dir, 'vendor', 'lib'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [
+        ['repo.discovered', { path: path.join(rig.dir, 'vendor', 'lib') }],
+        ['repo.removed', { path: path.join(rig.dir, 'lib') }],
+      ]);
+      clean(rig);
+    },
+    disappear: () => {
+      const rig = filesRoot((dir) => {
+        fs.mkdirSync(path.join(dir, 'lib'));
+        gitInit(path.join(dir, 'lib'));
+      });
+      fs.rmSync(path.join(rig.dir, 'lib'), { recursive: true, force: true });
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['repo.removed', { path: path.join(rig.dir, 'lib') }]]);
+      clean(rig);
+    },
+    restart: () => {
+      const rig = afterRestart(() => {}, (dir) => {
+        fs.mkdirSync(path.join(dir, 'lib'));
+        gitInit(path.join(dir, 'lib'));
+      });
+      speaks(rig, [['repo.discovered', { path: path.join(rig.dir, 'lib') }]],
+        'a repository born while nothing ran is discovered by the catch-up census');
+      clean(rig);
+    },
+  },
+
+  workspace: {
+    create: () => {
+      const rig = filesRoot((dir) => {
+        fs.writeFileSync(path.join(dir, 'notes.md'), 'n');
+        fs.mkdirSync(path.join(dir, 'sub'));
+        fs.writeFileSync(path.join(dir, 'sub', 'plan.md'), 'p');
+      });
+      assert.equal(rig.root.kind, 'files', 'no .git, so the ground is a workspace');
+      rig.mark = 0;
+      speaks(rig, [
+        ['dir.created', { path: 'sub' }],
+        ['file.created', { path: 'notes.md' }],
+        ['file.created', { path: 'sub/plan.md' }],
+      ], 'enrollment is the birth of the members');
+      clean(rig);
+    },
+    change: () => {
+      const rig = filesRoot((dir) => fs.writeFileSync(path.join(dir, 'notes.md'), 'v1'));
+      fs.writeFileSync(path.join(rig.dir, 'notes.md'), 'v2');
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['file.changed', { path: 'notes.md' }]],
+        'the workspace has no voice of its own: its members speak');
+      clean(rig);
+    },
+    rename: () => {
+      const rig = filesRoot((dir) => fs.writeFileSync(path.join(dir, 'notes.md'), 'n'));
+      const renamed = `${rig.dir}-v2`;
+      fs.renameSync(rig.dir, renamed);
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['root.moved', { from: rig.dir, to: renamed }]],
+        'a same-parent rename is followed: same identity, new address');
+      assert.equal(rig.observer.listRoots()[0].path, renamed);
+      clean(rig);
+    },
+    move: () => {
+      const rig = filesRoot((dir) => fs.writeFileSync(path.join(dir, 'notes.md'), 'n'));
+      const elsewhere = makeDir('elsewhere');
+      fs.renameSync(rig.dir, path.join(elsewhere, 'taken'));
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['root.unavailable', { path: rig.dir }]],
+        'beyond the parent is unwatched ground: honest absence, never a guess');
+      assert.equal(rig.observer.listRoots()[0].path, rig.dir,
+        'belief is preserved: the root stays enrolled at its last known address');
+    },
+    disappear: () => {
+      const rig = filesRoot((dir) => fs.writeFileSync(path.join(dir, 'notes.md'), 'n'));
+      fs.rmSync(rig.dir, { recursive: true });
+      rig.observer.scanNow(rig.root.rootId);
+      speaks(rig, [['root.unavailable', { path: rig.dir }]],
+        'presence is evidence, never lifecycle: no trash, no delete, no burial');
+      assert.equal(rig.observer.listRoots().length, 1, 'the root stays enrolled');
+    },
+    restart: () => {
+      let renamed;
+      const rig = afterRestart(
+        (dir) => fs.writeFileSync(path.join(dir, 'notes.md'), 'n'),
+        (dir) => {
+          renamed = `${dir}-r2`;
+          fs.renameSync(dir, renamed);
+        });
+      speaks(rig, [['root.moved', { from: rig.dir, to: renamed }]],
+        'a rename made while nothing ran is followed at the startup entrance');
+      assert.equal(rig.observer.listRoots()[0].path, renamed);
+      clean(rig);
+    },
+  },
+};
+
+test('the life grid is total: every kind Detect can see faces every life event — a missing box convicts', () => {
+  const sighted = ENTITY_TYPES.filter((type) => adapterFor(type).rails.detect);
+  const blind = ENTITY_TYPES.filter((type) => !adapterFor(type).rails.detect);
+  assert.deepEqual(Object.keys(GRID).sort(), sighted.sort(),
+    'the rows are exactly the alphabet types whose adapter binds the detect socket — a new type, or a blind one gaining its socket, must take its row here');
+  assert.deepEqual(blind, ['reference'],
+    'the one type Detect cannot see today: its truth is registry identity, its rendering derived state proven in the registration suite — a row here would invent semantics ahead of the socket');
+  for (const type of Object.keys(GRID)) {
+    assert.deepEqual(Object.keys(GRID[type]), LIFE_EVENTS,
+      `the ${type} row must face exactly the six life events`);
+  }
+});
+
+for (const type of Object.keys(GRID)) {
+  for (const [event, cell] of Object.entries(GRID[type])) {
+    test(`life grid — ${type} × ${event}`, cell);
+  }
+}
+
+// --- coda: constructs are plain ground ------------------------------------
+
+test('constructs are plain ground: automation, agent, and skill shapes speak only the physical grammar', () => {
+  const rig = filesRoot((dir) => {
+    fs.mkdirSync(path.join(dir, 'automations', 'daily-digest'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'automations', 'daily-digest', 'automation.md'), '# daily digest');
+    fs.writeFileSync(path.join(dir, 'automations', 'daily-digest', 'run.js'), 'export {}');
+    fs.mkdirSync(path.join(dir, 'agents', 'scribe'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'agents', 'scribe', 'agent.md'), '# scribe');
+    fs.mkdirSync(path.join(dir, 'skills', 'summarize'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'skills', 'summarize', 'SKILL.md'), '# summarize');
+  });
+  const birthVoice = new Set(rig.events.map((event) => event.type));
+  assert.deepEqual([...birthVoice].sort(), ['dir.created', 'file.created'],
+    'birth is folders and files — a construct has no voice of its own');
+
+  // A construct rename is a folder rename; a construct death is a
+  // folder death. Meaning is layered above; the grammar never changes.
+  rig.mark = rig.events.length;
+  fs.renameSync(path.join(rig.dir, 'automations', 'daily-digest'),
+    path.join(rig.dir, 'automations', 'weekly-digest'));
+  fs.rmSync(path.join(rig.dir, 'agents'), { recursive: true });
+  rig.observer.scanNow(rig.root.rootId);
+  speaks(rig, [
+    ['dir.renamed', { from: 'automations/daily-digest', to: 'automations/weekly-digest' }],
+    ['file.renamed', { from: 'automations/daily-digest/automation.md', to: 'automations/weekly-digest/automation.md' }],
+    ['file.renamed', { from: 'automations/daily-digest/run.js', to: 'automations/weekly-digest/run.js' }],
+    ['dir.deleted', { path: 'agents' }],
+    ['dir.deleted', { path: 'agents/scribe' }],
+    ['file.deleted', { path: 'agents/scribe/agent.md' }],
+  ]);
+  clean(rig);
+});