@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/runtime/__tests__/spawn-env.test.js

@@ -1,259 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/runtime/__tests__/spawn-env.test.ts
-//
-// Regression lock for the C-1 spawn-env boundary (`../spawn-env.ts`): the
-// broker child env is CONSTRUCTED from a default-deny allowlist, never
-// inherited via `{ ...process.env }`. Each case below reproduces one clause of
-// the contract so a future edit that re-opens the leak (or re-admits `GIT_*`
-// / a credentialed proxy, or resolves `spawnEnv.allow` from the wrong scope)
-// fails loud here instead of silently in prod.
-import { test, before, after, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, realpathSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { resetScopeCache } from '../../scope.js';
-import { readMergedLaunchConfig, writeRawConfig, updateConfigAtRoot } from '../../config.js';
-import { createProfile, profileRoot } from '../../profiles/manifest.js';
-import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
-import { buildOperationalEnvBase, buildBrokerEnv } from '../spawn-env.js';
-const LEAK_CLASS_HOST_ENV = {
-    HOME: '/Users/tester',
-    PATH: '/usr/bin:/bin',
-    LANG: 'en_US.UTF-8',
-    XDG_CONFIG_HOME: '/Users/tester/.config',
-    PI_CODING_AGENT_DIR: '/Users/tester/.pi',
-    // The C-1 leak class: ambient third-party credentials that must never cross.
-    MISTRAL_API_KEY: 'fake-m',
-    GOOGLE_GENERATIVE_AI_API_KEY: 'fake-g',
-    GITHUB_TOKEN: 'fake-gh',
-    AWS_ACCESS_KEY_ID: 'fake-aws-id',
-    AWS_SECRET_ACCESS_KEY: 'fake-aws-secret',
-    // The GIT_* injection surface.
-    GIT_CONFIG_KEY_0: 'http.https://x.insteadof',
-    GIT_ASKPASS: '/tmp/fake-askpass',
-    // Proxy: one credentialed (must drop), one plain (must keep).
-    HTTP_PROXY: 'http://baduser:badpass@proxy.corp:3128',
-    HTTPS_PROXY: 'http://proxy.corp:3128',
-    NO_PROXY: 'localhost,127.0.0.1',
-    // Configured model-provider keys (source B).
-    ANTHROPIC_API_KEY: 'fake-anthropic',
-    OPENAI_API_KEY: 'fake-openai',
-};
-/** Ambient-scope helper: most cases below don't care about `spawnEnv.allow`
- *  scoping (source C), so they resolve against whatever cwd/profile is live
- *  when they run (an isolated empty scope by construction of `beforeEach`
- *  below) rather than repeating `{ targetCwd, targetProfileId }` at each
- *  call site. */
-function base(host) {
-    return buildOperationalEnvBase({ targetCwd: process.cwd(), targetProfileId: null, host });
-}
-// --- every case needs an isolated scope root so the repo's own
-// .crouter/config.json (which declares no spawnEnv) never masks a test, and
-// so `spawnEnv.allow` config can be planted per-test without cross-talk.
-let isolatedHome;
-let isolatedCwd;
-let prevHome;
-let prevCwd;
-before(() => {
-    prevHome = process.env.HOME;
-    prevCwd = process.cwd();
-});
-beforeEach(() => {
-    isolatedHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-spawn-env-home-')));
-    isolatedCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-spawn-env-cwd-')));
-    process.env.HOME = isolatedHome;
-    process.chdir(isolatedCwd);
-    initializeFreshScopedStore({ kind: 'user', root: join(isolatedHome, '.crouter') });
-    resetScopeCache();
-});
-afterEach(() => {
-    rmSync(isolatedHome, { recursive: true, force: true });
-    rmSync(isolatedCwd, { recursive: true, force: true });
-});
-after(() => {
-    process.chdir(prevCwd);
-    if (prevHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = prevHome;
-    resetScopeCache();
-});
-test('A1: literal operational names and non-secret prefixes cross verbatim', () => {
-    const env = base(LEAK_CLASS_HOST_ENV);
-    assert.equal(env.HOME, '/Users/tester');
-    assert.equal(env.PATH, '/usr/bin:/bin');
-    assert.equal(env.LANG, 'en_US.UTF-8');
-    assert.equal(env.XDG_CONFIG_HOME, '/Users/tester/.config');
-    assert.equal(env.PI_CODING_AGENT_DIR, '/Users/tester/.pi');
-});
-test('leak-class ambient credentials are dropped', () => {
-    const env = base(LEAK_CLASS_HOST_ENV);
-    assert.equal(env.MISTRAL_API_KEY, undefined);
-    assert.equal(env.GOOGLE_GENERATIVE_AI_API_KEY, undefined);
-    assert.equal(env.GITHUB_TOKEN, undefined);
-    assert.equal(env.AWS_ACCESS_KEY_ID, undefined);
-    assert.equal(env.AWS_SECRET_ACCESS_KEY, undefined);
-});
-test('GIT_* is dropped in full — no default admits any GIT_ variable', () => {
-    const env = base(LEAK_CLASS_HOST_ENV);
-    assert.equal(env.GIT_CONFIG_KEY_0, undefined);
-    assert.equal(env.GIT_ASKPASS, undefined);
-    assert.equal(Object.keys(env).some((k) => k.startsWith('GIT_')), false);
-});
-test('B: configured model-provider keys cross by exact name', () => {
-    const env = base(LEAK_CLASS_HOST_ENV);
-    assert.equal(env.ANTHROPIC_API_KEY, 'fake-anthropic');
-    assert.equal(env.OPENAI_API_KEY, 'fake-openai');
-});
-// A2 — proxy userinfo guard (Major 1 fix): must reject username-only,
-// password-only, and scheme-less userinfo, for BOTH uppercase and lowercase
-// var names; must keep a plain proxy URL, for both cases; NO_PROXY always
-// keeps.
-test('A2: a credentialed proxy URL is dropped, a plain one crosses (uppercase)', () => {
-    const env = base(LEAK_CLASS_HOST_ENV);
-    assert.equal(env.HTTP_PROXY, undefined, 'userinfo-bearing proxy must not cross');
-    assert.equal(env.HTTPS_PROXY, 'http://proxy.corp:3128', 'plain proxy crosses untouched');
-    assert.equal(env.NO_PROXY, 'localhost,127.0.0.1');
-});
-test('A2: password-only proxy authority is dropped (http://:pass@host)', () => {
-    const env = base({ HTTP_PROXY: 'http://:badpass@proxy.corp:3128' });
-    assert.equal(env.HTTP_PROXY, undefined, 'a naive `username === \'\'` check would wrongly admit this');
-});
-test('A2: username-only proxy authority is dropped (http://user@host)', () => {
-    const env = base({ HTTP_PROXY: 'http://baduser@proxy.corp:3128' });
-    assert.equal(env.HTTP_PROXY, undefined);
-});
-test('A2: scheme-less userinfo is dropped, not silently normalized then admitted', () => {
-    // `new URL('user:pass@proxy.corp:3128')` parses "user" as a CUSTOM scheme
-    // with empty username/password — the exact hole the naive check missed.
-    const env = base({ HTTP_PROXY: 'user:pass@proxy.corp:3128' });
-    assert.equal(env.HTTP_PROXY, undefined);
-});
-test('A2: lowercase proxy vars get the same guard — credentialed drops, plain keeps', () => {
-    const env = base({
-        http_proxy: 'http://baduser:badpass@proxy.corp:3128',
-        https_proxy: 'http://proxy.corp:3128',
-        no_proxy: 'localhost',
-    });
-    assert.equal(env.http_proxy, undefined, 'lowercase credentialed proxy must not cross');
-    assert.equal(env.https_proxy, 'http://proxy.corp:3128', 'lowercase plain proxy crosses');
-    assert.equal(env.no_proxy, 'localhost');
-});
-test('A2: a non-http(s) scheme or hostless value is dropped, never admitted', () => {
-    const env = base({ HTTP_PROXY: 'not a url at all' });
-    assert.equal(env.HTTP_PROXY, undefined);
-});
-// buildBrokerEnv: overlay + drop the leak class through the real process.env
-// path.
-test('buildBrokerEnv overlays inv.env + FRONT_DOOR_ENV on top of the sanitized base, and drops the leak class', () => {
-    const inv = {
-        argv: [],
-        env: { CRTR_NODE_ID: 'n1', CRTR_CONTEXT_DIR: '/ctx', CRTR_NODE_CWD: isolatedCwd, CRTR_PROFILE_ID: '' },
-    };
-    // Mutate individual keys and delete them back out afterward — NEVER
-    // reassign `process.env` wholesale (`process.env = {...}`), which detaches
-    // it from the real OS environment binding (e.g. breaks `os.homedir()` for
-    // every test that runs after it in this same process).
-    try {
-        process.env.MISTRAL_API_KEY = 'fake-m';
-        process.env.GIT_ASKPASS = '/tmp/fake-askpass';
-        const env = buildBrokerEnv(inv);
-        assert.equal(env.CRTR_NODE_ID, 'n1', 'trusted inv.env overlay present');
-        assert.equal(env.CRTR_CONTEXT_DIR, '/ctx');
-        assert.equal(env.CRTR_FRONT_DOOR, '1', 'fork-bomb recursion guard set');
-        assert.equal(env.MISTRAL_API_KEY, undefined, 'ambient leak class still absent through the real process.env path');
-        assert.equal(env.GIT_ASKPASS, undefined, 'GIT_* still absent through the real process.env path');
-    }
-    finally {
-        delete process.env.MISTRAL_API_KEY;
-        delete process.env.GIT_ASKPASS;
-    }
-});
-// C — explicit spawnEnv.allow escape hatch: literal names + globs.
-test('C: an explicit spawnEnv.allow literal name admits a var that would otherwise be dropped', () => {
-    writeRawConfig('user', { spawnEnv: { allow: ['GOOGLE_GENERATIVE_AI_API_KEY'] } });
-    resetScopeCache();
-    const env = base(LEAK_CLASS_HOST_ENV);
-    assert.equal(env.GOOGLE_GENERATIVE_AI_API_KEY, 'fake-g', 'explicitly allowlisted name now crosses');
-    assert.equal(env.MISTRAL_API_KEY, undefined, 'every other leak-class name stays absent — the hatch is scoped, not a blanket reopen');
-    assert.equal(env.GIT_ASKPASS, undefined);
-});
-test('C (glob, Minor fix): AWS_* admits only AWS_-prefixed names, nothing else', () => {
-    writeRawConfig('user', { spawnEnv: { allow: ['AWS_*'] } });
-    resetScopeCache();
-    const env = base(LEAK_CLASS_HOST_ENV);
-    assert.equal(env.AWS_ACCESS_KEY_ID, 'fake-aws-id', 'AWS_-prefixed name admitted by the glob');
-    assert.equal(env.AWS_SECRET_ACCESS_KEY, 'fake-aws-secret', 'a second AWS_-prefixed name is also admitted');
-    assert.equal(env.MISTRAL_API_KEY, undefined, 'the glob must not admit unrelated names');
-    assert.equal(env.GIT_ASKPASS, undefined);
-});
-test('C (glob, Minor fix): a bare "*" (inherit-all) is rejected loud at config read, not silently accepted or dropped', () => {
-    mkdirSync(join(isolatedCwd, '.crouter'), { recursive: true });
-    writeFileSync(join(isolatedCwd, '.crouter', 'config.json'), JSON.stringify({ spawnEnv: { allow: ['*'] } }));
-    resetScopeCache();
-    assert.throws(() => readMergedLaunchConfig(isolatedCwd, null), /matches every env var name/, 'a bare "*" must fail loud at config read, per cto-rejects-fallback-hedges — never silently literal, never silently dropped');
-});
-// Major 2 fix — spawnEnv.allow resolves from the TARGET's own cwd/profile,
-// never the calling/launcher process's ambient scope.
-test('target-scope: spawnEnv.allow is read from the TARGET cwd, not process.cwd() (the ambient/launcher cwd)', () => {
-    const launcherCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-spawn-env-launcher-')));
-    const targetCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-spawn-env-target-')));
-    try {
-        // The LAUNCHER's own cwd declares an allowlist entry — this must NOT leak
-        // into a target with a different cwd (the verified C-1 follow-up leak:
-        // "a broker for target cwd B admitted AWS_ACCESS_KEY_ID solely because
-        // the launcher cwd A had it in spawnEnv.allow").
-        mkdirSync(join(launcherCwd, '.crouter'), { recursive: true });
-        writeFileSync(join(launcherCwd, '.crouter', 'config.json'), JSON.stringify({ spawnEnv: { allow: ['AWS_ACCESS_KEY_ID'] } }));
-        process.chdir(launcherCwd); // simulate: ambient process.cwd() is the LAUNCHER's, not the target's
-        resetScopeCache();
-        const envAgainstUnrelatedTarget = buildOperationalEnvBase({ targetCwd, targetProfileId: null, host: LEAK_CLASS_HOST_ENV });
-        assert.equal(envAgainstUnrelatedTarget.AWS_ACCESS_KEY_ID, undefined, "the launcher's own cwd allowlist must not admit into an unrelated target");
-        // Now give the TARGET's own cwd the allow entry instead (ambient
-        // process.cwd() is STILL the launcher's — unchanged) and confirm it takes
-        // effect purely because it is the passed target scope.
-        mkdirSync(join(targetCwd, '.crouter'), { recursive: true });
-        writeFileSync(join(targetCwd, '.crouter', 'config.json'), JSON.stringify({ spawnEnv: { allow: ['AWS_ACCESS_KEY_ID'] } }));
-        resetScopeCache();
-        const envAgainstOwnTarget = buildOperationalEnvBase({ targetCwd, targetProfileId: null, host: LEAK_CLASS_HOST_ENV });
-        assert.equal(envAgainstOwnTarget.AWS_ACCESS_KEY_ID, 'fake-aws-id', "the TARGET's own cwd allowlist takes effect regardless of the ambient/launcher cwd");
-    }
-    finally {
-        rmSync(launcherCwd, { recursive: true, force: true });
-        rmSync(targetCwd, { recursive: true, force: true });
-        resetScopeCache();
-    }
-});
-test('target-scope: buildBrokerEnv resolves spawnEnv.allow from inv.env.CRTR_NODE_CWD (the revive/spawn target), not this process\'s ambient cwd', () => {
-    const launcherCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-spawn-env-launcher2-')));
-    const targetCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-spawn-env-target2-')));
-    try {
-        mkdirSync(join(targetCwd, '.crouter'), { recursive: true });
-        writeFileSync(join(targetCwd, '.crouter', 'config.json'), JSON.stringify({ spawnEnv: { allow: ['MISTRAL_API_KEY'] } }));
-        process.chdir(launcherCwd); // this process's ambient cwd is unrelated to the target — mirrors the daemon reviving a node from its OWN cwd
-        resetScopeCache();
-        process.env.MISTRAL_API_KEY = 'fake-m';
-        try {
-            const inv = { argv: [], env: { CRTR_NODE_ID: 'n2', CRTR_NODE_CWD: targetCwd, CRTR_PROFILE_ID: '' } };
-            const env = buildBrokerEnv(inv);
-            assert.equal(env.MISTRAL_API_KEY, 'fake-m', "the TARGET node's own cwd allowlist (from inv.env.CRTR_NODE_CWD) takes effect on a broker launch — this is what revive/cron-launched spawn goes through");
-        }
-        finally {
-            delete process.env.MISTRAL_API_KEY;
-        }
-    }
-    finally {
-        rmSync(launcherCwd, { recursive: true, force: true });
-        rmSync(targetCwd, { recursive: true, force: true });
-        resetScopeCache();
-    }
-});
-test('target-scope: spawnEnv.allow is read from the TARGET profile id, not this process\'s ambient CRTR_PROFILE_ID', () => {
-    const { profileId } = createProfile('test profile');
-    updateConfigAtRoot(profileRoot(profileId), (config) => { config.spawnEnv = { allow: ['AWS_ACCESS_KEY_ID'] }; });
-    resetScopeCache();
-    const withoutTargetProfile = buildOperationalEnvBase({ targetCwd: isolatedCwd, targetProfileId: null, host: LEAK_CLASS_HOST_ENV });
-    assert.equal(withoutTargetProfile.AWS_ACCESS_KEY_ID, undefined, 'no profile passed — the profile-scoped allow must not apply');
-    const withTargetProfile = buildOperationalEnvBase({ targetCwd: isolatedCwd, targetProfileId: profileId, host: LEAK_CLASS_HOST_ENV });
-    assert.equal(withTargetProfile.AWS_ACCESS_KEY_ID, 'fake-aws-id', "passing the TARGET's own profile id resolves that profile's allowlist");
-});

package/dist/core/substrate/__tests__/surface-match-command.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/substrate/__tests__/surface-match-command.test.js

@@ -1,89 +0,0 @@
-// Deliberate, user-approved exception to crouter's standing policy of not using unit tests: glob matching is pure string logic with a large space of near-miss inputs, where a table of real cases is the only economical way to pin behavior, and where BOTH false negatives and false positives are defects.
-//
-// Run: node --conditions=crtr-src --import tsx/esm --test src/core/substrate/__tests__/surface-match-command.test.ts
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { commandDeliveryRung, matchesCommandEntry } from '../surface-match.js';
-const subject = {
-    kind: 'developer',
-    mode: 'base',
-    lifecycle: 'terminal',
-    hasManager: false,
-    cwd: '/tmp/project',
-    scope: 'project',
-    orchestration: { depth: 0 },
-    profile: null,
-};
-function entry(match, on = 'command', at = 'preview') {
-    return { on, at, match };
-}
-test('real command globs match the direct invocation they describe', () => {
-    const cases = [
-        { name: 'linear issues', glob: 'linear *', command: 'linear issues list', expected: true },
-        { name: 'capture screenshot', glob: '*capture *', command: 'capture screenshot --url https://example.com', expected: true },
-        { name: 'grove status', glob: '*grove*', command: 'grove status', expected: true },
-        { name: 'crtr human send', glob: '*crtr human *', command: 'crtr human send --message "Approve this change"', expected: true },
-        { name: 'git commit', glob: '*git commit*', command: 'git commit -m "ship fix"', expected: true },
-        { name: 'git push', glob: '*git push*', command: 'git push origin main', expected: true },
-        { name: 'npm publish', glob: '*npm publish*', command: 'npm publish --access public', expected: true },
-        { name: 'pnpm publish', glob: '*pnpm publish*', command: 'pnpm publish --access public', expected: true },
-        { name: 'termrender doc check', glob: '*termrender*', command: 'termrender doc check ./README.md', expected: true },
-        { name: 'single-character question mark', glob: '*git p?sh*', command: 'git push origin main', expected: true },
-        { name: 'trailing star permits bare tool', glob: 'linear *', command: 'linear', expected: true },
-        { name: 'literal glob is an exact command', glob: 'git status', command: 'git status', expected: true },
-        { name: 'literal glob does not imply arguments', glob: 'git status', command: 'git status --short', expected: false },
-    ];
-    for (const testCase of cases) {
-        assert.equal(matchesCommandEntry(entry([testCase.glob]), subject, testCase.command), testCase.expected, testCase.name);
-    }
-});
-test('a command is found after ordinary shell composition and whitespace variation', () => {
-    const cases = [
-        { name: 'after directory change', glob: 'linear *', command: 'cd apps/core && linear issues list', expected: true },
-        { name: 'after semicolon', glob: '*grove*', command: 'printf ready; grove status', expected: true },
-        { name: 'after or-list', glob: '*crtr human *', command: 'test -f answer.txt || crtr human send --message "Choose one"', expected: true },
-        { name: 'leading environment assignment', glob: 'linear *', command: 'CI=1 linear issues list', expected: true },
-        { name: 'tool inside a pipeline', glob: '*termrender*', command: 'termrender doc check README.md | grep -q error', expected: true },
-        { name: 'tool on the right side of a pipe', glob: '*termrender*', command: 'cat README.md | termrender', expected: true },
-        { name: 'two spaces between tokens', glob: 'linear *', command: 'linear  issues list', expected: true },
-        { name: 'tab between tokens', glob: 'linear *', command: 'linear\tissues list', expected: true },
-        { name: 'trailing newline', glob: 'linear *', command: 'linear issues list\n', expected: true },
-    ];
-    for (const testCase of cases) {
-        assert.equal(matchesCommandEntry(entry([testCase.glob]), subject, testCase.command), testCase.expected, testCase.name);
-    }
-});
-test('command text and token near-misses do not wake a surface', () => {
-    const cases = [
-        { name: 'linear only appears in quoted text', glob: 'linear *', command: 'echo "linear issues list"', expected: false },
-        { name: 'capture only appears in quoted text', glob: '*capture *', command: 'echo "capture screenshot"', expected: false },
-        { name: 'git push only appears in a commit message', glob: '*git push*', command: 'git commit -m "please git push later"', expected: false },
-        { name: 'grove is part of a longer word', glob: '*grove*', command: 'echo grover', expected: false },
-        { name: 'capture is part of a longer word', glob: '*capture *', command: 'printf "%s\\n" mycapture', expected: false },
-        { name: 'linear is part of a filename', glob: 'linear *', command: 'python linear-regression.py', expected: false },
-        { name: 'git commit is a sibling subcommand', glob: '*git commit*', command: 'git commit-tree -m "ship fix"', expected: false },
-        { name: 'termrender only appears in quoted text', glob: '*termrender*', command: 'echo "termrender"', expected: false },
-        // A path mention is not an invocation: an unrelated listing should not wake the grove doc.
-        { name: 'grove only appears in an unrelated path', glob: '*grove*', command: 'ls /tmp/grove/config', expected: false },
-    ];
-    for (const testCase of cases) {
-        assert.equal(matchesCommandEntry(entry([testCase.glob]), subject, testCase.command), testCase.expected, testCase.name);
-    }
-});
-test('entry and match-list composition stays within the command event', () => {
-    const anyGlobCases = [
-        { name: 'second glob satisfies the list', globs: ['*npm publish*', '*pnpm publish*'], command: 'pnpm publish --access public', expected: true },
-        { name: 'no glob satisfies the list', globs: ['*npm publish*', '*pnpm publish*'], command: 'yarn publish', expected: false },
-    ];
-    for (const testCase of anyGlobCases) {
-        assert.equal(matchesCommandEntry(entry(testCase.globs), subject, testCase.command), testCase.expected, testCase.name);
-    }
-    assert.equal(commandDeliveryRung({ surfaces: [entry(['*npm publish*'], 'command', 'name'), entry(['*pnpm publish*'], 'command', 'content')] }, subject, 'pnpm publish --access public'), 'content', 'matching command entries OR together and retain the highest matching rung');
-    const otherEventCases = [
-        { name: 'read entry never fires for a command', on: 'read' },
-        { name: 'memory-read entry never fires for a command', on: 'memory-read' },
-    ];
-    for (const testCase of otherEventCases) {
-        assert.equal(matchesCommandEntry(entry(['linear *'], testCase.on), subject, 'linear issues list'), false, testCase.name);
-    }
-});

package/dist/core/substrate/__tests__/surface-match-memory-read.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/substrate/__tests__/surface-match-memory-read.test.js

@@ -1,28 +0,0 @@
-// Regression: memory-read matching must consume ONLY the resolved doc's
-// exact canonical name — the hard-cut identity rule forbids a mount-stripped
-// alias (or any other alias) from firing an unrelated carrier's route.
-//
-// Run: node --conditions=crtr-src --import tsx/esm --test src/core/substrate/__tests__/surface-match-memory-read.test.ts
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { matchesMemoryReadEntry } from '../surface-match.js';
-function entry(match) {
-    return { on: 'memory-read', at: 'preview', match };
-}
-test('a carrier routed at the mount-stripped local name does not fire for the plugin-qualified canonical read', () => {
-    // Authored for an unrelated ordinary doc named "topic" — must not fire
-    // when the resolved doc is actually the plugin doc "plug/topic".
-    assert.equal(matchesMemoryReadEntry(entry(['topic']), '', null, 'plug/topic'), false);
-});
-test('a carrier routed at the plugin-qualified canonical name still fires for that exact read', () => {
-    assert.equal(matchesMemoryReadEntry(entry(['plug/topic']), '', null, 'plug/topic'), true);
-});
-test('a carrier routed at the canonical name still fires for an ordinary (non-plugin) read', () => {
-    assert.equal(matchesMemoryReadEntry(entry(['topic']), '', null, 'topic'), true);
-});
-test('a directory-relative `./` route still anchors to the routing anchor of the canonical name', () => {
-    // Legitimate routing anchor / directory semantics preserved: a carrier
-    // fronting `plug/dir` still matches its own member by relative glob.
-    assert.equal(matchesMemoryReadEntry(entry(['./member']), 'plug/dir', null, 'plug/dir/member'), true);
-    assert.equal(matchesMemoryReadEntry(entry(['./member']), 'plug/dir', null, 'member'), false);
-});

package/dist/core/substrate/__tests__/surface-match-pre-command.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/substrate/__tests__/surface-match-pre-command.test.js

@@ -1,92 +0,0 @@
-// Regression: `pre-command` matching holds a command BEFORE it runs, so it
-// costs the agent a whole turn when it fires. Two ways it can be wrong:
-//
-//   • It fires on a mention rather than an invocation. A doc-writing command
-//     whose heredoc body merely quotes a matched invocation must run untouched
-//     — only the heredoc's opening line is a real command.
-//   • It ignores the entry's own `gate`. A doc whose entry excludes this node
-//     must never hold that node's commands.
-//
-// It also pins the shared-routing invariant: the pre-command matcher is the
-// post-execution `command` matcher plus heredoc stripping, and nothing else.
-// One command-glob semantics, not two.
-//
-// Run: node --conditions=crtr-src --import tsx/esm --test src/core/substrate/__tests__/surface-match-pre-command.test.ts
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { matchesCommandEntry, matchesPreCommandEntry, preCommandDeliveryRung } from '../surface-match.js';
-const SUBJECT = {
-    kind: 'developer',
-    mode: 'base',
-    lifecycle: 'terminal',
-    hasManager: true,
-    cwd: '/tmp/project',
-    scope: 'project',
-    orchestration: { depth: 1 },
-    profile: 'northlight',
-};
-function entry(match, gate) {
-    return { on: 'pre-command', at: 'content', match, ...(gate !== undefined ? { gate } : {}) };
-}
-// the behaviour this event adds
-test('a matched invocation inside a heredoc BODY does not hold the command', () => {
-    const command = [
-        "crtr memory write approvals --body <<'EOF'",
-        'Before you run `crtr integration run --action send`, get approval.',
-        'EOF',
-    ].join('\n');
-    assert.equal(matchesPreCommandEntry(entry(['crtr integration run*']), SUBJECT, command), false);
-});
-test('the same invocation on the heredoc OPENING line still holds the command', () => {
-    const command = ["crtr integration run --action send --body <<'EOF'", 'hello', 'EOF'].join('\n');
-    assert.equal(matchesPreCommandEntry(entry(['crtr integration run*']), SUBJECT, command), true);
-});
-test('a `<<-` heredoc body is stripped too, tabs and all', () => {
-    const command = ['cat <<-EOF', '\tcrtr integration run --action send', '\tEOF'].join('\n');
-    assert.equal(matchesPreCommandEntry(entry(['crtr integration run*']), SUBJECT, command), false);
-});
-test('an unterminated heredoc drops its body rather than leaking it back in', () => {
-    const command = ["crtr memory write d --body <<'EOF'", 'crtr integration run --action send'].join('\n');
-    assert.equal(matchesPreCommandEntry(entry(['crtr integration run*']), SUBJECT, command), false);
-});
-test('an entry whose gate excludes the subject never holds a command', () => {
-    const excluded = entry(['crtr integration run*'], { lifecycle: 'resident' });
-    assert.equal(matchesPreCommandEntry(excluded, SUBJECT, 'crtr integration run --action send'), false);
-    const included = entry(['crtr integration run*'], { lifecycle: 'terminal' });
-    assert.equal(matchesPreCommandEntry(included, SUBJECT, 'crtr integration run --action send'), true);
-});
-test('a `command` entry is never consumed by the pre-command matcher, nor the reverse', () => {
-    const post = { on: 'command', at: 'content', match: ['crtr integration run*'] };
-    assert.equal(matchesPreCommandEntry(post, SUBJECT, 'crtr integration run --action send'), false);
-    assert.equal(matchesCommandEntry(entry(['crtr integration run*']), SUBJECT, 'crtr integration run --action send'), false);
-});
-// the rung fold
-test('the rung fold returns the highest `at` across matching entries, and none when nothing matches', () => {
-    const doc = {
-        surfaces: [
-            entry(['crtr crustdata person search*']),
-            entry(['crtr integration run*']),
-            { on: 'command', at: 'content', match: ['*'] },
-        ],
-    };
-    assert.equal(preCommandDeliveryRung(doc, SUBJECT, 'crtr integration run --action send'), 'content');
-    assert.equal(preCommandDeliveryRung(doc, SUBJECT, 'ls -la'), 'none');
-});
-// shared routing: one command-glob semantics, not two
-test('outside a heredoc, pre-command matching is exactly the `command` matcher', () => {
-    // The guard against a second command tokenizer drifting away from the first.
-    // Whatever `command` globs mean today, `pre-command` means the same thing —
-    // so a sharpening of command-position matching reaches both events at once.
-    const glob = 'crtr integration run*';
-    for (const command of [
-        'crtr integration run --action send',
-        'cd /tmp && crtr integration run --action send',
-        'echo hi\ncrtr integration run --action send',
-        'NL_ENV=1 crtr integration run --action send',
-        'crtr integration list',
-        'ls -la',
-        'echo "crtr integration run --action send"',
-    ]) {
-        assert.equal(matchesPreCommandEntry(entry([glob]), SUBJECT, command), matchesCommandEntry({ on: 'command', at: 'content', match: [glob] }, SUBJECT, command), `pre-command and command disagreed on: ${JSON.stringify(command)}`);
-    }
-});

package/dist/daemon/__tests__/autostart-storm.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/daemon/__tests__/autostart-storm.test.js

@@ -1,128 +0,0 @@
-import { test, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ensureDaemon, resetDaemonAutostart, } from '../manage.js';
-import { withExclusiveDirectoryLockAsync } from '../../core/exclusive-lock.js';
-// REGRESSION (daemon respawn storm): a daemon whose startup hit a STANDING
-// condition — a blocked on-disk migration — exited, its attach clients saw a
-// cold socket, autostarted a replacement, and that replacement hit the same
-// wall. Nothing tracked the repeat and nothing reaped the losers, so failed
-// starts accumulated into a pile that pegged the machine. Three properties keep
-// that from recurring: the terminal exit is TYPED, a typed failure SUPPRESSES
-// further autostarts, and an ordinary failure at least BACKS OFF.
-const settle = async () => { await new Promise((resolve) => setImmediate(resolve)); };
-// The test lane exports CRTR_NO_DAEMON_AUTOSTART=1 so no suite ever spawns a
-// real daemon. These tests drive ensureDaemon through injected deps — nothing
-// is spawned — so the guard has to come off for the gate under test to be
-// reachable at all.
-const autostartEnv = process.env['CRTR_NO_DAEMON_AUTOSTART'];
-beforeEach(() => {
-    delete process.env['CRTR_NO_DAEMON_AUTOSTART'];
-    resetDaemonAutostart();
-});
-after(() => {
-    if (autostartEnv === undefined)
-        delete process.env['CRTR_NO_DAEMON_AUTOSTART'];
-    else
-        process.env['CRTR_NO_DAEMON_AUTOSTART'] = autostartEnv;
-    resetDaemonAutostart();
-});
-test('an ordinary spawn failure backs off, then retries once the window passes', async () => {
-    let spawns = 0;
-    let now = 1_000_000;
-    const deps = {
-        isDaemonRunning: () => false,
-        now: () => now,
-        spawnDaemon: async () => {
-            spawns += 1;
-            throw new Error('dist/daemon/crtrd-cli.js missing');
-        },
-    };
-    ensureDaemon(deps);
-    await settle();
-    assert.equal(spawns, 1);
-    for (let i = 0; i < 20; i++)
-        ensureDaemon(deps);
-    await settle();
-    assert.equal(spawns, 1, 'retries inside the backoff window must be dropped');
-    now += 5_000;
-    ensureDaemon(deps);
-    await settle();
-    assert.equal(spawns, 2, 'the window expiring re-opens exactly one attempt');
-    // Backoff grows, so the second failure buys a longer quiet period than the first.
-    now += 5_000;
-    ensureDaemon(deps);
-    await settle();
-    assert.equal(spawns, 2, 'the second failure must back off further than the first');
-});
-test('a spawn already in flight blocks a concurrent autostart', async () => {
-    let spawns = 0;
-    let release = () => { };
-    const gate = new Promise((resolve) => { release = resolve; });
-    const deps = {
-        isDaemonRunning: () => false,
-        spawnDaemon: async () => {
-            spawns += 1;
-            await gate;
-            return { started: true, pid: 1 };
-        },
-    };
-    ensureDaemon(deps);
-    for (let i = 0; i < 10; i++)
-        ensureDaemon(deps);
-    await settle();
-    assert.equal(spawns, 1, 'concurrent callers must not each spawn a daemon');
-    release();
-    await settle();
-});
-test('a success clears the backoff so the next cold socket starts immediately', async () => {
-    let spawns = 0;
-    let fail = true;
-    let now = 1_000_000;
-    const deps = {
-        isDaemonRunning: () => false,
-        now: () => now,
-        spawnDaemon: async () => {
-            spawns += 1;
-            if (fail)
-                throw new Error('transient');
-            return { started: true, pid: 1 };
-        },
-    };
-    ensureDaemon(deps);
-    await settle();
-    fail = false;
-    now += 5_000;
-    ensureDaemon(deps);
-    await settle();
-    assert.equal(spawns, 2);
-    ensureDaemon(deps);
-    await settle();
-    assert.equal(spawns, 3, 'a healthy start must not leave a backoff behind');
-});
-// The pile pegged the machine because each waiter re-probed the lock every 10ms
-// with no backoff. Backing off must not make an uncontended hand-off sluggish.
-test('a contended lock waiter still acquires promptly once the holder releases', async () => {
-    const home = mkdtempSync(join(tmpdir(), 'crtr-lock-backoff-'));
-    const lockPath = join(home, 'contended.lock');
-    try {
-        let released = 0;
-        const holder = withExclusiveDirectoryLockAsync(lockPath, async () => {
-            await new Promise((resolve) => setTimeout(resolve, 300));
-            released = Date.now();
-        }, { timeoutMs: 5_000 });
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        let acquired = 0;
-        const waiter = withExclusiveDirectoryLockAsync(lockPath, async () => {
-            acquired = Date.now();
-        }, { timeoutMs: 5_000 });
-        await Promise.all([holder, waiter]);
-        assert.ok(acquired >= released, 'the waiter must not enter before the holder leaves');
-        assert.ok(acquired - released < 1_000, `hand-off took ${acquired - released}ms — backoff ceiling is too coarse`);
-    }
-    finally {
-        rmSync(home, { recursive: true, force: true });
-    }
-});

package/dist/daemon/__tests__/broker-ownership.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/daemon/__tests__/broker-ownership.test.js

@@ -1,25 +0,0 @@
-// Regression (2026-07-22 cross-canvas broker slaughter): the orphan reaper
-// matched every broker-cli.js process on the machine, so a test-fixture
-// daemon in a temp CRTR_HOME SIGTERMed the real fleet each test iteration
-// while the real daemon reaped the fixture's brk-* brokers. Ownership is now
-// DECLARED at spawn — `broker-cli.js --canvas-home <home> <nodeId>` — and
-// the census/reap match exactly the daemon's own canvas home; untagged or
-// foreign-home brokers are invisible to both.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { brokerCommandDeclaresCanvasHome } from '../crtrd.js';
-const HOME = '/Users/u/.crouter/canvas';
-const CMD = `1234 /Users/u/.crouter/host/crouter /Users/u/.crouter/runtime/generations/abc/dist/core/runtime/broker-cli.js --canvas-home ${HOME} mrnode01-aabbccdd`;
-test('matches a broker declaring this canvas home', () => {
-    assert.equal(brokerCommandDeclaresCanvasHome(CMD, HOME), true);
-});
-test('rejects a broker declaring a different canvas home', () => {
-    assert.equal(brokerCommandDeclaresCanvasHome(CMD, '/tmp/crtr-test-xyz/canvas'), false);
-});
-test('rejects an untagged (pre-tag or harness-spawned) broker', () => {
-    const untagged = '1234 node /repo/dist/core/runtime/broker-cli.js brk-99-0';
-    assert.equal(brokerCommandDeclaresCanvasHome(untagged, HOME), false);
-});
-test('rejects a home that is a prefix of the declared home', () => {
-    assert.equal(brokerCommandDeclaresCanvasHome(CMD, '/Users/u/.crouter'), false);
-});

package/dist/daemon/__tests__/daemon-ownership.test.d.ts

@@ -1 +0,0 @@
-export {};