amalgm 0.1.262 → 0.1.263

package/runtime/scripts/amalgm-mcp/tests/registration.service.test.js

@@ -770,15 +770,21 @@ test('register registers every entity before it starts Watch', async () => {
     identity.close();
     assert.ok(nested, 'the folder already has a durable identity');
     assert.ok(file, 'so does the file within it');
-    assert.equal(service.observer.status()[0].watching, false,
-      'the observer has not begun watching while registration is in progress');
+    // Watcher FIRST, conclusions LAST: by the time identity commits, the
+    // doorbell is already alive (it was proven before the walk began) —
+    // but HELD, so nothing has been observed or concluded yet. start()
+    // releasing the hold is the first moment Watch may speak.
+    assert.equal(service.observer.status()[0].watching, true,
+      'the doorbell was born and proven before identity committed');
+    assert.equal(service.observer.filesForRoot(rootId).length, 0,
+      'and held: no observation concluded while registration was in progress');
     checked = true;
     return start(rootId);
   };
 
   const { rootPath } = await service.register(ground);
   assert.equal(rootPath, ground);
-  assert.equal(checked, true, 'Watch begins only after the structural walk commits');
+  assert.equal(checked, true, 'the held doorbell releases only after the structural walk commits');
 });
 
 test('register never reserves or mutates a user filename for watching', async () => {

package/runtime/scripts/amalgm-mcp/tests/registration.test.js

@@ -911,13 +911,13 @@ test('add is one operation: a bare file registers, covered ground returns its tr
     'ground that would swallow a registered root refuses loudly');
 });
 
-test('add never claims success when a required watcher cannot open', () => {
+test('add refuses before identity commits when a required watcher cannot be born', () => {
   const dir = makeDir('degraded-add');
   const observer = createObserver({
     db: new Database(':memory:'),
     emit: () => {},
     shouldEnroll: () => true,
-    watch: () => ({ degraded: true, close: () => {} }),
+    watch: () => ({ degraded: true, reason: 'ENOSPC', close: () => {} }),
   });
   const identityDb = new Database(':memory:');
   const registration = createRegistration({
@@ -926,10 +926,14 @@ test('add never claims success when a required watcher cannot open', () => {
     classify: () => 'file.text',
   });
   try {
-    assert.throws(() => registration.add(dir), /could not start required watcher/,
-      'a registered tree with no live doorbell is an incomplete add, never a success');
-    assert.ok(registration.tree(dir)?.root(),
-      'identity remains durable for a later explicit retry; add only refuses to lie about Watch');
+    // Registration is synchronous, never optimistic: the watcher is proven
+    // FIRST, so a doorbell that cannot be born refuses with its reason and
+    // the remedy — and leaves NOTHING behind. No half-registered ghost, no
+    // local record the cloud never heard of.
+    assert.throws(() => registration.add(dir), /watcher could not be born \(ENOSPC\).*fs\.inotify\.max_user_watches/,
+      'the refusal names the kernel budget and the fix');
+    assert.ok(!registration.tree(dir)?.root(), 'no identity row survives the refusal');
+    assert.equal(observer.listRoots().length, 0, 'no observer root survives it either — zero residue');
   } finally {
     registration.stop();
     observer.stop();

package/runtime/scripts/amalgm-mcp/tests/repocard.scope.test.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * The warm checkpoint under exam: compute the state once, then let the
+ * doorbell keep it fresh — silence proves the written answer is still
+ * true, and a ding re-reads exactly what it named.
+ *
+ * The identity law above everything: a SCOPED capture's ids are
+ * byte-identical to a from-scratch capture's over the same ground.
+ * Scope changes what is READ, never what is TRUE.
+ */
+
+const assert = require('node:assert/strict');
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const test = require('node:test');
+
+const { capture } = require('../repocard/capture');
+const { createFollower } = require('../repocard/follow');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-repocard-scope-'));
+test.after(() => fs.rmSync(tempRoot, { recursive: true, force: true }));
+
+function repo(name) {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(tempRoot, `${name}-`)));
+  execFileSync('git', ['init', '-q'], { cwd: dir });
+  execFileSync('git', ['config', 'user.email', 'scope@amalgm.test'], { cwd: dir });
+  execFileSync('git', ['config', 'user.name', 'Scope'], { cwd: dir });
+  execFileSync('git', ['config', 'commit.gpgsign', 'false'], { cwd: dir });
+  return dir;
+}
+
+const previousOf = (snap) => snap.checkpoint.untracked.map(
+  ({ path: rel, mode, sha256 }) => ({ path: rel, mode, sha256 }),
+);
+
+test('a scoped capture is byte-identical to a from-scratch one — and reads less', () => {
+  const dir = repo('identity');
+  fs.writeFileSync(path.join(dir, 'kept.txt'), 'unchanged bytes');
+  fs.mkdirSync(path.join(dir, 'src'));
+  fs.writeFileSync(path.join(dir, 'src', 'edited.js'), 'v1');
+
+  const full = capture(dir, { withBundle: false });
+  fs.writeFileSync(path.join(dir, 'src', 'edited.js'), 'v2');
+
+  const scoped = capture(dir, {
+    withBundle: false,
+    suspects: ['src/edited.js'],
+    previousUntracked: previousOf(full),
+  });
+  const fresh = capture(dir, { withBundle: false });
+
+  assert.equal(scoped.stateId, fresh.stateId, 'scope changes what is read, never what is true');
+  assert.equal(scoped.checkpointId, fresh.checkpointId);
+  const kept = scoped.checkpoint.untracked.find((file) => file.path === 'kept.txt');
+  assert.equal(kept.reused, true, 'the unsuspected file was never opened');
+  assert.equal(kept.content, null);
+  assert.equal(kept.sha256, fresh.checkpoint.untracked.find((file) => file.path === 'kept.txt').sha256);
+  const edited = scoped.checkpoint.untracked.find((file) => file.path === 'src/edited.js');
+  assert.ok(!edited.reused, 'the suspect was read fresh');
+  assert.equal(edited.content.toString(), 'v2');
+});
+
+test('a directory-named suspect covers every file beneath it', () => {
+  const dir = repo('dir-suspect');
+  fs.mkdirSync(path.join(dir, 'notes'));
+  fs.writeFileSync(path.join(dir, 'notes', 'a.md'), 'a1');
+  fs.writeFileSync(path.join(dir, 'other.md'), 'other');
+  const full = capture(dir, { withBundle: false });
+
+  fs.writeFileSync(path.join(dir, 'notes', 'a.md'), 'a2');
+  const scoped = capture(dir, {
+    withBundle: false, suspects: ['notes'], previousUntracked: previousOf(full),
+  });
+  assert.equal(scoped.stateId, capture(dir, { withBundle: false }).stateId,
+    'the OS may name only the folder; everything under it is suspect');
+  assert.ok(!scoped.checkpoint.untracked.find((file) => file.path === 'notes/a.md').reused);
+  assert.equal(scoped.checkpoint.untracked.find((file) => file.path === 'other.md').reused, true);
+});
+
+test('new and deleted untracked files are truth regardless of scope', () => {
+  const dir = repo('churn');
+  fs.writeFileSync(path.join(dir, 'stays.txt'), 'stays');
+  fs.writeFileSync(path.join(dir, 'leaves.txt'), 'leaves');
+  const full = capture(dir, { withBundle: false });
+
+  fs.rmSync(path.join(dir, 'leaves.txt'));
+  fs.writeFileSync(path.join(dir, 'arrives.txt'), 'new');
+  const scoped = capture(dir, {
+    withBundle: false, suspects: [], previousUntracked: previousOf(full),
+  });
+  assert.equal(scoped.stateId, capture(dir, { withBundle: false }).stateId,
+    'git names the living; the previous list never resurrects the dead');
+  const paths = scoped.checkpoint.untracked.map((file) => file.path);
+  assert.ok(paths.includes('arrives.txt') && !paths.includes('leaves.txt'));
+  assert.ok(!scoped.checkpoint.untracked.find((file) => file.path === 'arrives.txt').reused,
+    'a path the previous state never held is read, scoped or not');
+});
+
+test('bundle captures never reuse: cloud cargo reads every byte', () => {
+  const dir = repo('bundle');
+  fs.writeFileSync(path.join(dir, 'file.txt'), 'bytes');
+  fs.writeFileSync(path.join(dir, 'seed.txt'), 'seed');
+  execFileSync('git', ['add', 'seed.txt'], { cwd: dir });
+  execFileSync('git', ['commit', '-qm', 'seed'], { cwd: dir });
+  const full = capture(dir, { withBundle: false });
+
+  const bundled = capture(dir, {
+    withBundle: true, suspects: [], previousUntracked: previousOf(full),
+  });
+  const entry = bundled.checkpoint.untracked.find((file) => file.path === 'file.txt');
+  assert.ok(!entry.reused && entry.content, 'withBundle ignores scope by contract');
+});
+
+test('the follower scopes doorbell-driven pairs and re-suspects everything on flush', async () => {
+  const dir = repo('follower');
+  fs.writeFileSync(path.join(dir, 'a.txt'), 'a');
+  fs.writeFileSync(path.join(dir, 'b.txt'), 'b');
+
+  const seen = [];
+  const follower = createFollower({
+    repoPath: dir,
+    settleMs: 10,
+    emit: () => {},
+    captureFn: (repo, { suspects } = {}) => {
+      seen.push(suspects);
+      return capture(repo, { withBundle: false, suspects });
+    },
+  });
+
+  await follower.start();
+  assert.equal(seen[0], null, 'birth suspects everything — rings before birth were nobody\'s');
+  assert.equal(seen[1], null, 'both halves of the pair read the same scope');
+
+  seen.length = 0;
+  fs.writeFileSync(path.join(dir, 'a.txt'), 'a2');
+  follower.ring('a.txt');
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [['a.txt'], ['a.txt']],
+    'a settled state narrows the next pair to exactly what rang');
+
+  seen.length = 0;
+  follower.ring('a.txt');
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [['a.txt'], ['a.txt']],
+    'consumed hints stay consumed: only the new ring is suspect');
+
+  seen.length = 0;
+  await follower.flush();
+  assert.deepEqual(seen, [null, null], 'flush exists to catch lost doorbells: it never trusts the scope');
+
+  follower.close();
+});
+
+test('a nameless ring makes everything suspect until a pair settles', async () => {
+  const dir = repo('nameless');
+  fs.writeFileSync(path.join(dir, 'x.txt'), 'x');
+  const seen = [];
+  const follower = createFollower({
+    repoPath: dir,
+    settleMs: 10,
+    emit: () => {},
+    captureFn: (repo, { suspects } = {}) => {
+      seen.push(suspects);
+      return capture(repo, { withBundle: false, suspects });
+    },
+  });
+  await follower.start();
+  seen.length = 0;
+
+  follower.ring(null);
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [null, null], 'null means anywhere: the whole ground is suspect');
+
+  seen.length = 0;
+  follower.ring('x.txt');
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [['x.txt'], ['x.txt']], 'and the settle consumed the nameless suspicion');
+  follower.close();
+});