amalgm 0.1.246 → 0.1.247

package/runtime/scripts/amalgm-mcp/tests/entity-content.test.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const Database = require('better-sqlite3');
+const { createRegistry } = require('../registry');
+const { createEntityCloud } = require('../registration/entity-cloud');
+const { CHUNK_BYTES, createEntityContent } = require('../registration/entity-content');
+
+function sha256(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+
+test('file bytes are captured as bounded immutable chunks, then acknowledged before their entity record is claimable', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-entity-content-'));
+  const source = path.join(dir, 'notes.bin');
+  const bytes = Buffer.concat([Buffer.alloc(CHUNK_BYTES, 0x61), Buffer.from('tail')]);
+  const contentHash = sha256(bytes);
+  fs.writeFileSync(source, bytes);
+
+  const content = createEntityContent({ dir });
+  const captured = content.captureFile({ filePath: source, contentHash });
+  assert.equal(captured.chunks.length, 2, 'transport chunks bound frame size without changing the file head');
+  assert.equal(captured.bytes, bytes.length);
+
+  const db = new Database(':memory:');
+  const cloud = createEntityCloud({ db, userId: 'user-1', deviceId: 'device-1', content });
+  const registry = createRegistry({ db, ephemeral: true, emit: () => {}, journal: cloud.journal });
+  const root = registry.enrollRoot({ type: 'workspace', name: 'ground' });
+  const bootstrap = cloud.bootstrap(registry);
+  cloud.install({
+    registry,
+    resourceId: bootstrap.resourceId,
+    authorityEpoch: 1,
+    headVersion: 0,
+    snapshotBase64: bootstrap.snapshotBase64,
+    snapshotChecksum: bootstrap.snapshotChecksum,
+  });
+
+  const file = registry.create({
+    type: 'file.binary', parentUUID: root.uuid, name: 'notes.bin', payloadVersion: contentHash,
+  });
+  assert.deepEqual(cloud.claim(), [], 'the cloud record is held until its immutable bytes are acknowledged');
+
+  const first = cloud.claimContent();
+  assert.equal(first.kind, 'chunk');
+  assert.equal(first.partIndex, 0);
+  assert.equal(first.bytes, CHUNK_BYTES);
+  cloud.acknowledgeContent({ ...first, contentHash, resourceId: bootstrap.resourceId });
+
+  const second = cloud.claimContent();
+  assert.equal(second.kind, 'chunk');
+  assert.equal(second.partIndex, 1);
+  assert.equal(Buffer.from(second.dataBase64, 'base64').toString(), 'tail');
+  cloud.acknowledgeContent({ ...second, contentHash, resourceId: bootstrap.resourceId });
+
+  const manifest = cloud.claimContent();
+  assert.equal(manifest.kind, 'manifest');
+  assert.equal(manifest.partIndex, 2);
+  cloud.acknowledgeContent({ ...manifest, contentHash, resourceId: bootstrap.resourceId });
+
+  const mutation = cloud.claim();
+  assert.equal(mutation.length, 1);
+  assert.equal(mutation[0].operation.record.uuid, file.uuid);
+  assert.equal(mutation[0].operation.record.payloadVersion, contentHash);
+
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('a later file version never substitutes its bytes for an earlier captured head', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-entity-content-race-'));
+  const source = path.join(dir, 'notes.txt');
+  fs.writeFileSync(source, 'first');
+  const firstHead = sha256(Buffer.from('first'));
+  fs.writeFileSync(source, 'second');
+  const content = createEntityContent({ dir });
+  assert.throws(
+    () => content.captureFile({ filePath: source, contentHash: firstHead }),
+    /file changed while its content was being captured/,
+  );
+  assert.equal(content.uploaded({ resourceId: 'pvr_test', contentHash: firstHead }), false);
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('a cloud manifest and its immutable chunks rebuild exact bytes in another machine cache', () => {
+  const sourceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-entity-content-source-'));
+  const targetDir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-entity-content-target-'));
+  const sourceFile = path.join(sourceDir, 'message.txt');
+  const bytes = Buffer.concat([Buffer.alloc(CHUNK_BYTES, 0x62), Buffer.from('from another machine')]);
+  const contentHash = sha256(bytes);
+  fs.writeFileSync(sourceFile, bytes);
+
+  const source = createEntityContent({ dir: sourceDir });
+  source.captureFile({ filePath: sourceFile, contentHash });
+  source.ensureUpload({ resourceId: 'pvr_test', contentHash });
+  const parts = [];
+  while (true) {
+    const part = source.claim({ resourceId: 'pvr_test' });
+    if (!part) break;
+    parts.push(part);
+    source.acknowledge({
+      resourceId: 'pvr_test', contentHash, kind: part.kind, partIndex: part.partIndex,
+    });
+  }
+
+  const target = createEntityContent({ dir: targetDir });
+  const manifest = parts.find((part) => part.kind === 'manifest');
+  target.receive({
+    contentHash, kind: 'manifest', partIndex: 0, sha256: manifest.sha256, dataBase64: manifest.dataBase64,
+  });
+  for (const part of parts.filter((item) => item.kind === 'chunk')) {
+    target.receive({
+      contentHash, kind: 'chunk', partIndex: part.partIndex, sha256: part.sha256, dataBase64: part.dataBase64,
+    });
+  }
+
+  assert.equal(target.complete({ contentHash }), true);
+  assert.deepEqual(target.bytes({ contentHash }), bytes);
+  fs.rmSync(sourceDir, { recursive: true, force: true });
+  fs.rmSync(targetDir, { recursive: true, force: true });
+});

package/runtime/scripts/amalgm-mcp/tests/entity-materialization.test.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const Database = require('better-sqlite3');
+const { createRegistry } = require('../registry');
+const { createEntityCloud, snapshotFromRecords } = require('../registration/entity-cloud');
+const { createEntityContent } = require('../registration/entity-content');
+const { createRegistrationService } = require('../registration/service');
+
+function sha256(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+
+function uploadedParts(content, resourceId, contentHash) {
+  content.ensureUpload({ resourceId, contentHash });
+  const parts = [];
+  while (true) {
+    const part = content.claim({ resourceId });
+    if (!part) return parts;
+    parts.push(part);
+    content.acknowledge({ resourceId, contentHash, kind: part.kind, partIndex: part.partIndex });
+  }
+}
+
+test('add materializes one compacted cloud head, preserves its UUIDs, and starts a local watcher without creating an outbound history replay', async () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-add-materialization-'));
+  const sourceDir = path.join(rootDir, 'source');
+  const targetState = path.join(rootDir, 'target-state');
+  const targetParent = path.join(rootDir, 'checkout');
+  fs.mkdirSync(sourceDir, { recursive: true });
+  fs.mkdirSync(targetParent, { recursive: true });
+  const bytes = Buffer.from('# arrives from cloud\n');
+  const contentHash = sha256(bytes);
+  const sourceFile = path.join(sourceDir, 'readme.md');
+  fs.writeFileSync(sourceFile, bytes);
+
+  const sourceDb = new Database(':memory:');
+  const sourceContent = createEntityContent({ dir: sourceDir });
+  const sourceCloud = createEntityCloud({
+    db: sourceDb, userId: 'user-1', deviceId: 'source-device', content: sourceContent,
+  });
+  const sourceRegistry = createRegistry({ db: sourceDb, ephemeral: true, emit: () => {}, journal: sourceCloud.journal });
+  const root = sourceRegistry.enrollRoot({ type: 'workspace', name: 'project' });
+  const file = sourceRegistry.create({
+    type: 'file.text', parentUUID: root.uuid, name: 'readme.md', payloadVersion: contentHash,
+  });
+  sourceContent.captureFile({ filePath: sourceFile, contentHash });
+  const parts = uploadedParts(sourceContent, sourceCloud.identity().resourceId, contentHash);
+  const snapshot = snapshotFromRecords(sourceRegistry.syncRecords());
+  const snapshotBytes = Buffer.from(JSON.stringify(snapshot), 'utf8');
+
+  const target = createRegistrationService({
+    dir: targetState,
+    homeDir: path.join(rootDir, 'target-home'),
+    cloudUserId: 'user-1',
+    cloudDeviceId: 'target-device',
+  });
+  try {
+    target.entityCloud.install({
+      registry: target.registration.registry,
+      resourceId: sourceCloud.identity().resourceId,
+      authorityEpoch: 7,
+      headVersion: 41,
+      snapshotBase64: snapshotBytes.toString('base64'),
+      snapshotChecksum: sha256(snapshotBytes),
+    });
+    assert.deepEqual(target.registration.registry.syncRecords(), [], 'the compacted cloud graph is not watched before add');
+
+    const manifest = parts.find((part) => part.kind === 'manifest');
+    target.entityCloud.receiveDownload({
+      resourceId: sourceCloud.identity().resourceId,
+      contentHash,
+      kind: 'manifest',
+      partIndex: 0,
+      sha256: manifest.sha256,
+      dataBase64: manifest.dataBase64,
+    });
+    for (const part of parts.filter((entry) => entry.kind === 'chunk')) {
+      target.entityCloud.receiveDownload({
+        resourceId: sourceCloud.identity().resourceId,
+        contentHash,
+        kind: 'chunk',
+        partIndex: part.partIndex,
+        sha256: part.sha256,
+        dataBase64: part.dataBase64,
+      });
+    }
+
+    const job = await target.add({ uuid: root.uuid, targetPath: targetParent });
+    assert.equal(job.state, 'complete');
+    const destination = path.join(targetParent, 'project');
+    assert.deepEqual(fs.readFileSync(path.join(destination, 'readme.md')), bytes);
+    assert.equal(target.registration.registry.syncRecord(root.uuid).uuid, root.uuid);
+    assert.equal(target.registration.registry.syncRecord(file.uuid).uuid, file.uuid);
+    const watchers = target.observer.status();
+    assert.equal(watchers.find((entry) => entry.path === fs.realpathSync(destination))?.watching, true, JSON.stringify(watchers));
+    const targetDb = new Database(path.join(targetState, 'identity.db'), { readonly: true });
+    try {
+      assert.equal(
+        targetDb.prepare('SELECT COUNT(*) AS count FROM entity_cloud_mutations').get().count,
+        0,
+        'binding an authoritative cloud snapshot does not emit a new outbound mutation history',
+      );
+    } finally {
+      targetDb.close();
+    }
+  } finally {
+    target.close();
+    sourceDb.close();
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});

package/runtime/scripts/amalgm-mcp/tests/entity.registry.test.js

@@ -83,6 +83,72 @@ test('first initialization mints the sentinel; reopening finds the same registry
   assert.deepEqual(rootOf(reopened), reopened.record(root.uuid));
 });
 
+test('the additive entity-cloud migration preserves a generation-2 registry', () => {
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE registry_meta (singleton INTEGER PRIMARY KEY, epoch_uuid TEXT NOT NULL, created_at_ms INTEGER NOT NULL);
+    CREATE TABLE entities (uuid TEXT PRIMARY KEY, type TEXT NOT NULL, parent_uuid TEXT, name TEXT NOT NULL, status TEXT NOT NULL, payload_version TEXT);
+    CREATE TABLE channel_bindings (channel_id TEXT PRIMARY KEY, scope_id TEXT NOT NULL, entity_uuid TEXT NOT NULL);
+    CREATE TABLE contested_ground (scope_id TEXT NOT NULL, rel_path TEXT NOT NULL, claimant_uuid TEXT NOT NULL, kind TEXT NOT NULL, PRIMARY KEY (scope_id, rel_path));
+  `);
+  db.prepare('INSERT INTO registry_meta (singleton, epoch_uuid, created_at_ms) VALUES (1, ?, ?)')
+    .run('legacy-epoch', 1);
+  db.pragma('user_version = 2');
+
+  const registry = createRegistry({ db, ephemeral: true, emit: () => {} });
+  assert.equal(registry.epoch(), 'legacy-epoch', 'the existing identity epoch survives');
+  assert.equal(db.pragma('user_version', { simple: true }), 6);
+  assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'repo_states'").get(),
+    'the repo-state document table is added without replacing identity');
+  assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'entity_cloud_mutations'").get(),
+    'the entity-cloud outbox is added beside the existing UUID graph');
+  assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'entity_cloud_catalog_state'").get(),
+    'the snapshot-head marker is added beside the existing UUID graph');
+});
+
+test('the active-snapshot marker migrates beside an existing materialization catalog', () => {
+  const db = new Database(':memory:');
+  createRegistry({ db, ephemeral: true, emit: () => {} });
+  db.exec('DROP TABLE entity_cloud_catalog_state');
+  db.pragma('user_version = 5');
+
+  const reopened = createRegistry({ db, ephemeral: true, emit: () => {} });
+  assert.ok(reopened.epoch(), 'the previous identity database remains usable');
+  assert.equal(db.pragma('user_version', { simple: true }), 6);
+  assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'entity_cloud_catalog_state'").get(),
+    'the separate pinned-snapshot marker is created without rewriting identities');
+});
+
+test('an entity commit and its cloud delivery intent are one SQLite transaction', () => {
+  const db = new Database(':memory:');
+  let nextMutation = 0;
+  const registry = createRegistry({
+    db,
+    ephemeral: true,
+    emit: () => {},
+    journal: ({ record }) => {
+      db.prepare(`
+        INSERT INTO entity_cloud_mutations (
+          resource_id, mutation_id, operation_json, mutation_state, created_at, updated_at
+        ) VALUES ('pvr_test', ?, ?, 'pending', 'now', 'now')
+      `).run(`ent_test_${nextMutation += 1}`, JSON.stringify({ kind: 'entity.upsert', record }));
+    },
+  });
+  const root = registry.enrollRoot({ type: 'workspace', name: 'clouded' });
+  assert.equal(db.prepare('SELECT COUNT(*) AS count FROM entity_cloud_mutations').get().count, 1);
+  assert.equal(db.prepare('SELECT COUNT(*) AS count FROM entities WHERE uuid = ?').get(root.uuid).count, 1);
+
+  const failing = createRegistry({
+    db: new Database(':memory:'),
+    ephemeral: true,
+    emit: () => {},
+    journal: () => { throw new Error('outbox unavailable'); },
+  });
+  assert.throws(() => failing.enrollRoot({ type: 'workspace', name: 'must-not-land' }), /outbox unavailable/);
+  assert.equal(failing.roots().length, 0,
+    'a failed cloud intent rolls the entity birth back instead of leaving local-only identity');
+});
+
 test('a registry that existed is never silently replaced', () => {
   const dir = fs.mkdtempSync(path.join(tempRoot, 'loss-'));
   const sentinelPath = path.join(dir, 'registry.epoch');
@@ -154,11 +220,11 @@ test('a failed notification is a pending bell, never a permanent miss', () => {
   const renamed = registry.move(file.uuid, { parentUUID: root.uuid, name: 'b.txt' });
   assert.equal(renamed.name, 'b.txt', 'the commit succeeded — the registry is truth');
   assert.equal(events.length, 0, 'the notification was missed');
-  registry.setPayloadVersion(file.uuid, 'h2');
+  registry.attest(file.uuid, { payloadVersion: 'h2', type: 'file.text' });
   assert.equal(events.length, 0, 'two misses collapse into one owed comparison');
 
   down = false;
-  registry.setPayloadVersion(file.uuid, 'h3');
+  registry.attest(file.uuid, { payloadVersion: 'h3', type: 'file.text' });
   assert.deepEqual(events.map((event) => event.type), ['registry.changed', 'entity.committed'],
     'the next commit rings the pending bell first, then its own event');
   assert.deepEqual(registry.record(file.uuid), events[1].record,
@@ -202,7 +268,7 @@ test('trees in one registry: parentless records are roots, and a tree boundary i
   assert.deepEqual(registry.roots().map((record) => record.uuid), [other.uuid],
     'the adopted tree is no longer parentless — it lives inside its new tree');
 
-  // The ratified extension (`amalgm add <file>`): a single registered
+  // The ratified extension (`amalgm register <file>`): a single registered
   // file is a tree of one — its root record IS the file entity.
   const { registry: soloRegistry } = makeRegistry();
   const solo = soloRegistry.enrollRoot({ type: 'file.text', name: 'notes.md', payloadVersion: 'h1' });
@@ -210,7 +276,7 @@ test('trees in one registry: parentless records are roots, and a tree boundary i
   assert.throws(() => soloRegistry.create({ type: 'file.text', parentUUID: solo.uuid, name: 'x' }),
     /only containers hold active children/, 'a tree of one stays a tree of one');
 
-  // And its sibling (amended 2026-08-01): `amalgm add` names an ADDRESS,
+  // And its sibling (amended 2026-08-01): `amalgm register` names an ADDRESS,
   // so a pointer added explicitly is an entity of its own — a tree of
   // one of the pointer kind, its payload the written target text.
   const { registry: ptrRegistry } = makeRegistry();
@@ -227,7 +293,9 @@ test('a reference\'s payload is identity, never an attestation', () => {
     type: 'reference', parentUUID: root.uuid, name: 'proj', payloadVersion: 'target-uuid-123',
   });
   assert.equal(ref.type, 'reference');
-  assert.throws(() => registry.setPayloadVersion(ref.uuid, 'other'), /never an attestation/,
+  assert.throws(
+    () => registry.attest(ref.uuid, { payloadVersion: 'other', type: 'reference' }),
+    /never an attestation/,
     'the evidence path cannot write a reference\'s payload: ground attests bytes, never identity');
   assert.throws(() => registry.create({ type: 'file.text', parentUUID: ref.uuid, name: 'x' }),
     /only containers hold active children/, 'a reference holds no children');
@@ -266,10 +334,57 @@ test('rename and move preserve the uuid; the version is a state fingerprint', ()
   assert.equal(home.version, born.version,
     'identical state is the identical version — a fingerprint, not a history counter');
 
-  const edited = registry.setPayloadVersion(file.uuid, 'hash-2');
+  const edited = registry.attest(file.uuid, { payloadVersion: 'hash-2', type: 'file.text' });
   assert.notEqual(edited.version, home.version);
-  assert.equal(registry.setPayloadVersion(file.uuid, 'hash-2').version, edited.version,
-    'an equal attestation is silence');
+  assert.equal(
+    registry.attest(file.uuid, { payloadVersion: 'hash-2', type: 'file.text' }).version,
+    edited.version, 'an equal attestation is silence');
+});
+
+test('one observation is one transition: payload and type land in a single commit', () => {
+  const { registry, events, file } = makeGraph();
+  events.length = 0;
+
+  // The same look that found these bytes says they are bytes, not text.
+  const after = registry.attest(file.uuid, { payloadVersion: 'hash-2', type: 'file.binary' });
+  assert.equal(after.type, 'file.binary');
+  assert.equal(events.length, 1, 'one look, one bell — never a hash commit and a type commit');
+  assert.equal(events[0].record.type, 'file.binary');
+  assert.equal(events[0].previous.type, 'file.text');
+  // The state nobody may ever hear or store: new bytes wearing the old
+  // type. Two writes would publish exactly that, and the equal-payload
+  // silence on the next pass would never heal it.
+  assert.equal(registry.record(file.uuid).type, 'file.binary');
+
+  // A pointer replacing bytes on the same slot is the same one transition.
+  events.length = 0;
+  const asLink = registry.attest(file.uuid, { payloadVersion: '../elsewhere', type: 'link' });
+  assert.equal(asLink.type, 'link');
+  assert.equal(events.length, 1);
+});
+
+test('only leaf ground attests: membership and identity are never observed', () => {
+  const { registry, root, folder, file } = makeGraph();
+  for (const [uuid, what] of [[root.uuid, 'workspace'], [folder.uuid, 'folder']]) {
+    assert.throws(() => registry.attest(uuid, { payloadVersion: 'h', type: 'file.text' }),
+      /payload is derived membership/, `${what} payload is its members, never a look's answer`);
+  }
+  // Both ends are judged: what the record is now, and what the bytes claim.
+  assert.throws(() => registry.attest(file.uuid, { payloadVersion: 'h', type: 'folder' }),
+    /payload is derived membership/);
+  assert.throws(() => registry.attest(file.uuid, { payloadVersion: 'h', type: 'reference' }),
+    /never an attestation/);
+  assert.throws(() => registry.attest(file.uuid, { payloadVersion: 'h', type: 'directory' }),
+    /unknown entity type/);
+});
+
+test('a tree\'s top record attests only a type a root may wear', () => {
+  const { registry } = makeRegistry();
+  const root = registry.enrollRoot({ type: 'file.text', name: 'notes.md', payloadVersion: 'h1' });
+  assert.equal(registry.attest(root.uuid, { payloadVersion: 'h2', type: 'file.binary' }).type,
+    'file.binary', 'a registered single file changes kind on its own UUID');
+  assert.throws(() => registry.attest(root.uuid, { payloadVersion: 'h3', type: 'folder' }),
+    /payload is derived membership/);
 });
 
 test('the slot admits one active owner — and the schema itself convicts', () => {
@@ -377,7 +492,7 @@ test('a trashed record is not ground: it never moves, never attests, never re-ty
   registry.trash(file.uuid);
   assert.throws(() => registry.move(file.uuid, { parentUUID: root.uuid, name: 'x.txt' }),
     /only an active entity moves/);
-  assert.throws(() => registry.setPayloadVersion(file.uuid, 'h9'),
+  assert.throws(() => registry.attest(file.uuid, { payloadVersion: 'h9', type: 'file.text' }),
     /only an active entity attests/);
   assert.throws(() => registry.changeType(file.uuid, 'folder'),
     /only an active entity changes type/);
@@ -442,7 +557,7 @@ test('a container\'s version is its active membership, nothing else', () => {
   const { registry, folder, file } = makeGraph();
   const v0 = registry.record(folder.uuid).version;
 
-  registry.setPayloadVersion(file.uuid, 'hash-2');
+  registry.attest(file.uuid, { payloadVersion: 'hash-2', type: 'file.text' });
   assert.equal(registry.record(folder.uuid).version, v0,
     'a child\'s content edit does not change its parent\'s version');
 
@@ -483,7 +598,7 @@ test('every commit emits the record and its previous; no-ops emit nothing', () =
   assert.notEqual(events[0].previous.version, moved.version);
 
   events.length = 0;
-  registry.setPayloadVersion(file.uuid, 'hash-1'); // equal attestation
+  registry.attest(file.uuid, { payloadVersion: 'hash-1', type: 'file.text' }); // equal attestation
   registry.changeType(file.uuid, 'file.text'); // same type
   assert.equal(events.length, 0, 'silence when nothing changed');
 

package/runtime/scripts/amalgm-mcp/tests/entity.rig.js

@@ -32,8 +32,14 @@ const defaultPolicy = require('../workspace/tree/inclusion').shouldEnroll;
 // The RIG's explicit classification policy — injected into the model
 // exactly like the enrollment policy. "NUL byte means binary" is a choice
 // these tests make; the model owns no such rule.
-const classify = (bytes) => (
-  (Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)).includes(0) ? 'file.binary' : 'file.text');
+//
+// ONE law, two askers. The oracle holds the bytes and looks for the NUL
+// itself; the evidence lens is handed the observer's report on the bytes
+// it already hashed. Neither re-reads the ground to answer, so the two
+// can never grade the same file differently.
+const typeOf = (binary) => (binary ? 'file.binary' : 'file.text');
+const classify = (bytes) => typeOf(
+  (Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)).includes(0));
 
 const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-entity-rig-'));
 
@@ -113,9 +119,10 @@ function makeKit(name, { policy = defaultPolicy, watch, settleMs } = {}) {
       // born here — birth reads store truth, exactly like the boundary.
       evidence = createEvidence({
         observer, registry, memory, rootId: kit.rootId,
-        // The evidence layer's injected classification policy reads the
-        // ground it is classifying — the same NUL rule the model got.
-        classify: (absPath) => classify(fs.readFileSync(absPath)),
+        // The SAME rule the model got, asked of the SAME evidence: the
+        // observer's own report on the bytes it hashed. No bridge, no
+        // second read — that is the point of the law.
+        classify: ({ binary }) => typeOf(binary),
       });
       kit.evidence = evidence;
       evidence.reconcile();
@@ -207,7 +214,14 @@ function fakeWatchKit() {
   return {
     watch: (rootPath, onDirty) => {
       bells.set(rootPath, onDirty);
-      return { degraded: false, close: () => bells.delete(rootPath) };
+      // A doorbell held in a Map has no arming window: pressing it answers.
+      const handle = {
+        degraded: false,
+        heard: true,
+        press: () => { handle.heard = true; },
+        close: () => bells.delete(rootPath),
+      };
+      return handle;
     },
     ring: (rootPath, relPath) => bells.get(rootPath)(relPath),
     /** Every open watcher whose ground covers this absolute path rings,

package/runtime/scripts/amalgm-mcp/tests/fake-watch.js

@@ -22,6 +22,14 @@ function installFakeWatch() {
     return entry;
   };
   return {
+    /**
+     * An OS that delivers only what the exam delivers has no arming
+     * window to cross, so there is nothing to prove about its doorbells.
+     * Pass this as the observer's `prove` wherever this stand-in is
+     * installed; the real proof is exercised where the real OS is
+     * (registration.service.test.js).
+     */
+    prove: async () => false,
     /** Ring every open doorbell on `target` with one raw name. */
     deliver(target, name) {
       for (const entry of [...watchers]) {

package/runtime/scripts/amalgm-mcp/tests/observer.rig.js

@@ -91,7 +91,14 @@ function fakeWatchKit() {
   return {
     watch: (rootPath, onDirty) => {
       bells.set(rootPath, onDirty);
-      return { degraded: false, close: () => bells.delete(rootPath) };
+      // A doorbell held in a Map has no arming window: pressing it answers.
+      const handle = {
+        degraded: false,
+        heard: true,
+        press: () => { handle.heard = true; },
+        close: () => bells.delete(rootPath),
+      };
+      return handle;
     },
     ring: (rootPath, relPath) => bells.get(rootPath)(relPath),
   };