@north-light/crouter 0.3.318 → 0.3.319

package/dist/pi-extensions/__tests__/canvas-structured-output.test.js

@@ -1,88 +0,0 @@
-// Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-structured-output.test.ts
-//
-// The extension injects a pending structured-output request at the END of the
-// system prompt each agent run; submission itself is `crtr push result`
-// (server-side). These cases pin the injection contract: terminal vs one-off
-// wording, no injection for absent/invalid requests, and per-run re-reads.
-import { after, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { outputSchemaPath, removeOutputSchema, writeOutputSchema } from '../../core/runtime/structured-output.js';
-import registerCanvasStructuredOutput from '../canvas-structured-output.js';
-const NODE = 'structured-output-test';
-const PROMPT = 'BASE SYSTEM PROMPT';
-const previous = {
-    home: process.env['CRTR_HOME'],
-    nodeId: process.env['CRTR_NODE_ID'],
-};
-let home;
-before(() => {
-    // macOS limits Unix-socket paths to 104 bytes; keep the home short.
-    home = mkdtempSync('/tmp/crtr-so-');
-    process.env['CRTR_HOME'] = home;
-    process.env['CRTR_NODE_ID'] = NODE;
-});
-beforeEach(() => {
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (previous.home === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = previous.home;
-    if (previous.nodeId === undefined)
-        delete process.env['CRTR_NODE_ID'];
-    else
-        process.env['CRTR_NODE_ID'] = previous.nodeId;
-});
-/** Register the extension against a stub pi and return a run(): the prompt the
- *  model would see for one agent run. */
-function harness() {
-    let handler;
-    registerCanvasStructuredOutput({
-        on: (_event, h) => { handler = h; },
-    });
-    assert.ok(handler, 'extension registered a before_agent_start handler');
-    return (prompt = PROMPT) => handler({ systemPrompt: prompt })?.systemPrompt ?? prompt;
-}
-test('terminal request appends schema, push result, and a final-push prohibition at the end', () => {
-    const run = harness();
-    writeOutputSchema(NODE, 'terminal', { type: 'object', properties: { verdict: { type: 'string' } } });
-    const prompt = run();
-    assert.ok(prompt.startsWith(PROMPT), 'base prompt preserved');
-    const block = prompt.slice(PROMPT.length);
-    assert.match(block, /crtr push result/);
-    assert.match(block, /"verdict"/);
-    assert.match(block, /do NOT call `crtr push final`/i);
-    assert.ok(prompt.trimEnd().endsWith('</structured-output-request>'), 'block sits at the end of the prompt');
-});
-test('one-off request appends continue-after-success wording', () => {
-    const run = harness();
-    writeOutputSchema(NODE, 'oneoff', { type: 'object' });
-    const prompt = run();
-    const block = prompt.slice(PROMPT.length);
-    assert.match(block, /crtr push result/);
-    assert.match(block, /continue working/);
-    assert.doesNotMatch(block, /push final/);
-});
-test('absent request leaves the prompt untouched', () => {
-    const run = harness();
-    assert.equal(run(), PROMPT);
-});
-test('invalid request file leaves the prompt untouched (stop guard owns the error)', () => {
-    const run = harness();
-    const path = outputSchemaPath(NODE);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, 'not json', 'utf8');
-    assert.equal(run(), PROMPT);
-});
-test('request state is re-read every run, never cached', () => {
-    const run = harness();
-    assert.equal(run(), PROMPT);
-    writeOutputSchema(NODE, 'oneoff', { type: 'object' });
-    assert.match(run(), /crtr push result/);
-    removeOutputSchema(NODE);
-    assert.equal(run(), PROMPT);
-});

package/dist/pi-extensions/__tests__/canvas-tool-guide.test.d.ts

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

package/dist/pi-extensions/__tests__/canvas-tool-guide.test.js

@@ -1,96 +0,0 @@
-// Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-tool-guide.test.ts
-//
-// Regression: canvas brokers must load and inject the root crtr guide themselves;
-// optional pi packages are not part of the canvas runtime contract.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { delimiter, join } from 'node:path';
-import { CANVAS_EXTENSIONS, CANVAS_TOOL_GUIDE_PATH } from '../../core/runtime/canvas-extensions.js';
-import registerCanvasToolGuide from '../canvas-tool-guide.js';
-function fakePi() {
-    return {
-        on(event, handler) {
-            if (event === 'before_agent_start')
-                this.beforeAgentStart = handler;
-            if (event === 'session_start')
-                this.sessionStart = handler;
-        },
-    };
-}
-test('canvas nodes load the cwd-specific root guide, share its boot cache, and never capture during a turn', async () => {
-    assert.ok(CANVAS_EXTENSIONS.includes(CANVAS_TOOL_GUIDE_PATH), 'the guide is a mandatory canvas extension');
-    const root = mkdtempSync(join(tmpdir(), 'crtr-tool-guide-'));
-    const bin = join(root, 'bin');
-    const cwd = join(root, 'configured-project');
-    const countFile = join(root, 'capture-count');
-    const capturedCwdFile = join(root, 'capture-cwd');
-    const previous = {
-        cwd: process.cwd(),
-        home: process.env['HOME'],
-        nodeId: process.env['CRTR_NODE_ID'],
-        path: process.env['PATH'],
-    };
-    try {
-        mkdirSync(bin);
-        mkdirSync(cwd);
-        const command = join(bin, 'crtr');
-        writeFileSync(command, `#!/bin/sh
-count=0
-if [ -f "$CAPTURE_COUNT" ]; then count=$(cat "$CAPTURE_COUNT"); fi
-printf '%s' "$((count + 1))" > "$CAPTURE_COUNT"
-printf '%s' "$PWD" > "$CAPTURE_CWD"
-printf '%s\\n' 'configured root guide'
-`);
-        chmodSync(command, 0o755);
-        process.chdir(cwd);
-        process.env['HOME'] = root;
-        process.env['CRTR_NODE_ID'] = 'canvas-tool-guide-test';
-        process.env['PATH'] = `${bin}${delimiter}${previous.path ?? ''}`;
-        process.env['CAPTURE_COUNT'] = countFile;
-        process.env['CAPTURE_CWD'] = capturedCwdFile;
-        const first = fakePi();
-        registerCanvasToolGuide(first);
-        const firstSessionStart = first.sessionStart;
-        assert.ok(firstSessionStart, 'session-start capture is registered');
-        await firstSessionStart();
-        const second = fakePi();
-        registerCanvasToolGuide(second);
-        const secondSessionStart = second.sessionStart;
-        assert.ok(secondSessionStart, 'session-start capture is registered for every broker');
-        await secondSessionStart();
-        assert.equal(readFileSync(countFile, 'utf8'), '1', 'a sibling broker uses the 15-second disk cache');
-        assert.equal(readFileSync(capturedCwdFile, 'utf8'), realpathSync(cwd), 'root help discovers commands from the node cwd');
-        const beforeAgentStart = second.beforeAgentStart;
-        assert.ok(beforeAgentStart, 'turn-time guide injection is registered');
-        const prompt = 'Available tools\n\nGuidelines:\nUse the available tools.';
-        assert.equal(beforeAgentStart({ systemPrompt: prompt })?.systemPrompt, 'Available tools\n\n<crtr-tool-guide>\nconfigured root guide\n</crtr-tool-guide>\n\nGuidelines:\nUse the available tools.', 'the captured guide sits in the tool-selection frame');
-        rmSync(join(root, '.crouter'), { recursive: true, force: true });
-        const unbooted = fakePi();
-        registerCanvasToolGuide(unbooted);
-        const unbootedBeforeAgentStart = unbooted.beforeAgentStart;
-        assert.ok(unbootedBeforeAgentStart, 'turn-time guide injection is registered before boot capture');
-        assert.equal(unbootedBeforeAgentStart({ systemPrompt: prompt }), undefined, 'a node without a boot capture starts without a guide');
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        assert.equal(readFileSync(countFile, 'utf8'), '1', 'a turn never starts a root-help subprocess');
-    }
-    finally {
-        process.chdir(previous.cwd);
-        if (previous.home === undefined)
-            delete process.env['HOME'];
-        else
-            process.env['HOME'] = previous.home;
-        if (previous.nodeId === undefined)
-            delete process.env['CRTR_NODE_ID'];
-        else
-            process.env['CRTR_NODE_ID'] = previous.nodeId;
-        if (previous.path === undefined)
-            delete process.env['PATH'];
-        else
-            process.env['PATH'] = previous.path;
-        delete process.env['CAPTURE_COUNT'];
-        delete process.env['CAPTURE_CWD'];
-        rmSync(root, { recursive: true, force: true });
-    }
-});

package/dist/pi-extensions/__tests__/integration/canvas-bash-valve.test.d.ts

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

package/dist/pi-extensions/__tests__/integration/canvas-bash-valve.test.js

@@ -1,133 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import { backgroundRunningBashJobs, bashJobsDir, bashJobPaths, readJobPgid, stopBackgroundBashJob } from '../../../core/bash-jobs.js';
-import { capturePidIdentities, isPidAlive } from '../../../core/canvas/pid.js';
-import { BACKGROUND_BASH_LOG_TRUNCATION_MARKER, MAX_BACKGROUND_BASH_LOG_BYTES, createValveOperations } from '../../canvas-bash-valve.js';
-const POLL_MS = 20;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function waitFor(condition, message) {
-    const deadline = Date.now() + 4_000;
-    while (Date.now() < deadline) {
-        if (condition())
-            return;
-        await sleep(POLL_MS);
-    }
-    throw new Error(message);
-}
-async function backgroundOneJob(contextDir) {
-    await waitFor(() => backgroundRunningBashJobs(contextDir).length === 1, 'bash job did not start');
-    await waitFor(() => {
-        try {
-            return readdirSync(bashJobsDir(contextDir)).length === 1;
-        }
-        catch {
-            return false;
-        }
-    }, 'background job directory was not created');
-    return readdirSync(bashJobsDir(contextDir))[0];
-}
-function killOwnedProcess(pid) {
-    if (pid === undefined)
-        return;
-    try {
-        process.kill(pid, 'SIGKILL');
-    }
-    catch {
-        // The test already stopped this exact process.
-    }
-}
-test('background cancellation reaches a descendant that changed process groups', { timeout: 10_000 }, async () => {
-    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-tree-'));
-    const contextDir = join(root, 'context');
-    const escapedPidPath = join(root, 'escaped.pid');
-    let escapedPid;
-    try {
-        const python = [
-            'import os, pathlib, time',
-            'os.setpgrp()',
-            `pathlib.Path(${JSON.stringify(escapedPidPath)}).write_text(f"{os.getpid()} {os.getpgrp()}")`,
-            'time.sleep(30)',
-        ].join('; ');
-        const run = createValveOperations('test-node', contextDir).exec(`python3 -c ${JSON.stringify(python)}`, root, { onData: () => { } });
-        const jobId = await backgroundOneJob(contextDir);
-        await run;
-        await waitFor(() => existsSync(escapedPidPath), 'escaped descendant did not start');
-        const [pidText, pgidText] = readFileSync(escapedPidPath, 'utf8').split(' ');
-        escapedPid = Number(pidText);
-        const escapedPgid = Number(pgidText);
-        assert.ok(Number.isInteger(escapedPid) && escapedPid > 1);
-        assert.notEqual(escapedPgid, readJobPgid(contextDir, jobId));
-        const stopped = await stopBackgroundBashJob(contextDir, jobId);
-        assert.equal(stopped.kind, 'stopped');
-        assert.equal(stopped.signaled, true);
-        await waitFor(() => {
-            try {
-                process.kill(escapedPid, 0);
-                return false;
-            }
-            catch {
-                return true;
-            }
-        }, 'escaped descendant survived background cancellation');
-    }
-    finally {
-        killOwnedProcess(escapedPid);
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('stale background metadata never signals a reused supervisor PID', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-stale-pid-'));
-    const contextDir = join(root, 'context');
-    const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 30_000)']);
-    try {
-        assert.notEqual(child.pid, undefined);
-        const actualIdentity = capturePidIdentities([child.pid])?.get(child.pid);
-        assert.notEqual(actualIdentity, undefined);
-        const paths = bashJobPaths(contextDir, '1234567890-stale');
-        mkdirSync(paths.dir, { recursive: true });
-        writeFileSync(paths.jobBg, '');
-        writeFileSync(paths.jobPgid, String(child.pid));
-        writeFileSync(paths.jobPgidIdentity, 'stale-supervisor');
-        const stopped = await stopBackgroundBashJob(contextDir, paths.jobId);
-        assert.deepEqual(stopped, { kind: 'stopped', signaled: false, pgid: child.pid, logPath: paths.jobLog });
-        assert.equal(isPidAlive(child.pid), true, 'a process with a reused supervisor PID was signaled');
-    }
-    finally {
-        child.kill('SIGKILL');
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('background log retains a capped prefix, truncation marker, and does not grow afterward', { timeout: 10_000 }, async () => {
-    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-log-'));
-    const contextDir = join(root, 'context');
-    try {
-        const writer = [
-            'const chunk = Buffer.alloc(1024 * 1024, 120)',
-            'setTimeout(() => {',
-            '  for (let i = 0; i < 11; i += 1) process.stdout.write(chunk)',
-            '  setTimeout(() => process.stdout.write("after-cap"), 200)',
-            '}, 200)',
-            'setTimeout(() => {}, 1_000)',
-        ].join('; ');
-        const run = createValveOperations('test-node', contextDir).exec(`${process.execPath} -e ${JSON.stringify(writer)}`, root, { onData: () => { } });
-        const jobId = await backgroundOneJob(contextDir);
-        await run;
-        const { jobExit, jobLog } = bashJobPaths(contextDir, jobId);
-        await waitFor(() => existsSync(jobLog) && readFileSync(jobLog, 'utf8').includes(BACKGROUND_BASH_LOG_TRUNCATION_MARKER), 'log did not record truncation');
-        const sizeAtCap = statSync(jobLog).size;
-        assert.ok(sizeAtCap <= MAX_BACKGROUND_BASH_LOG_BYTES);
-        await sleep(500);
-        assert.equal(statSync(jobLog).size, sizeAtCap, 'discarded output continued growing the log');
-        await waitFor(() => existsSync(jobExit), 'writer did not finish');
-        assert.equal(readFileSync(jobExit, 'utf8').trim(), '0', 'collector changed the writer exit status');
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});

package/dist/pi-extensions/__tests__/pre-command-gate.test.d.ts

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

package/dist/pi-extensions/__tests__/pre-command-gate.test.js

@@ -1,232 +0,0 @@
-// Regression: the `pre-command` gate holds a bash command BEFORE it runs and
-// releases it once its memory is in the transcript. The release is not a stored
-// decision — it is the exposure ledger, and that is exactly what makes it
-// fragile:
-//
-//   • Compaction drops the delivered guidance out of the transcript while the
-//     ledger still claims it was delivered. Without the demotion pass the doc is
-//     held once and then silently absent for the rest of the session. Worse, a
-//     demotion that left a rankless entry behind would crash the node's whole
-//     substrate on its next load — so the ledger is reloaded FROM DISK here.
-//   • pi preflights the siblings of one assistant message sequentially and then
-//     executes them concurrently, so without a per-turn flag the second sibling
-//     would find the doc already exposed and slip past the hold its sibling just
-//     raised.
-//   • A command that matches no `pre-command` doc must never pay a daemon
-//     round-trip, even when another document gates a different command. Proven
-//     against an unavailable test API socket: a lookup fails loudly.
-//
-// The gate runs against the real canvas api server, so the subject the matcher
-// gates on is the one crtrd actually serves.
-//
-// Run: node --conditions=crtr-src --import tsx/esm --test src/pi-extensions/__tests__/pre-command-gate.test.ts
-import { test, before, beforeEach, afterEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { registerCanvasDocSubstrate } from '../canvas-doc-substrate.js';
-import { createNode } from '../../core/canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../../core/canvas/db.js';
-import { beginExecution } from '../../core/canvas/executions.js';
-import { apiSocketPath } from '../../core/canvas/paths.js';
-import { resetScopeCache } from '../../core/scope.js';
-import { initializeFreshScopedStore } from '../../core/scoped-state/migrate.js';
-import { loadContextExposureState } from '../../core/substrate/injected-store.js';
-import { clearSessionCache } from '../../core/substrate/session-cache.js';
-import { createApiServer } from '../../daemon/api/server.js';
-const DOCTRINE_BODY = 'PRE-COMMAND-DOCTRINE-BODY';
-let home;
-let cwd;
-let server = null;
-let origCwd;
-let origHome;
-let origNode;
-let origExecution;
-let origProfile;
-async function waitForSocket(path) {
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(path))
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    throw new Error(`api socket never bound at ${path}`);
-}
-async function closeServer() {
-    const running = server;
-    server = null;
-    if (running !== null)
-        await running.close();
-}
-/** A user-scope doc that holds every `deploy …` invocation until it is read. */
-function writeDoctrineDoc(event) {
-    const store = join(home, 'user', '.crouter', 'memory');
-    mkdirSync(store, { recursive: true });
-    const path = join(store, 'deploy-doctrine.md');
-    writeFileSync(path, '---\nkind: knowledge\n' +
-        'when-and-why-to-read: When deploying, this knowledge should be read because it carries the approval boundary.\n' +
-        `surfaces:\n  - {on: ${event}, at: content, match: "deploy*"}\n---\n` +
-        `${DOCTRINE_BODY}\n`);
-    clearSessionCache();
-    return realpathSync(path);
-}
-/** A canvas node the api server can assemble a subject for, selected as the
- *  session's node. Each test uses its own id: the extension's exposure state is
- *  a per-node process singleton. */
-function seedNode(id) {
-    createNode({
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd,
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-    });
-    mkdirSync(join(home, 'nodes', id), { recursive: true });
-    process.env['CRTR_NODE_ID'] = id;
-    process.env['CRTR_EXECUTION_ID'] = beginExecution(id, { daemonEpoch: null });
-}
-/** The registered extension, driven through the pi events it actually binds. */
-function registerSubstrate() {
-    const handlers = new Map();
-    registerCanvasDocSubstrate({
-        on(event, handler) {
-            const bound = handlers.get(event) ?? [];
-            bound.push(handler);
-            handlers.set(event, bound);
-        },
-    });
-    async function fire(event, payload) {
-        const bound = handlers.get(event) ?? [];
-        assert.equal(bound.length, 1, `the substrate binds exactly one ${event} handler`);
-        return await bound[0](payload, {});
-    }
-    return {
-        toolCall: (toolName, input) => fire('tool_call', { toolName, input }),
-        bash: (command) => fire('tool_call', { toolName: 'bash', input: { command } }),
-        endTurn: async () => void (await fire('turn_end', {})),
-        compact: async () => void (await fire('session_compact', {})),
-        toolResult: (toolName, input) => fire('tool_result', { toolName, input, content: [] }),
-    };
-}
-function assertHeld(result, what) {
-    assert.ok(result !== undefined, `${what} is held`);
-    assert.equal(result.block, true);
-    assert.ok(result.reason.startsWith('HELD — nothing ran.'), `the held result opens with the notice; got: ${result.reason}`);
-    return result;
-}
-before(() => {
-    origCwd = process.cwd();
-    origHome = process.env['HOME'];
-    origNode = process.env['CRTR_NODE_ID'];
-    origExecution = process.env['CRTR_EXECUTION_ID'];
-    origProfile = process.env['CRTR_PROFILE_ID'];
-});
-beforeEach(async () => {
-    closeDb();
-    if (home)
-        rmSync(home, { recursive: true, force: true });
-    home = mkdtempSync(join(tmpdir(), 'crtr-pre-command-'));
-    cwd = join(home, 'user', 'work');
-    mkdirSync(cwd, { recursive: true });
-    process.chdir(cwd);
-    process.env['HOME'] = join(home, 'user');
-    process.env['CRTR_HOME'] = home;
-    delete process.env['CRTR_NODE_ID'];
-    delete process.env['CRTR_EXECUTION_ID'];
-    delete process.env['CRTR_PROFILE_ID'];
-    resetScopeCache();
-    clearSessionCache();
-    initializeFreshScopedStore({ kind: 'user', root: join(home, 'user', '.crouter') });
-    migrate(openDb());
-    server = createApiServer();
-    await waitForSocket(apiSocketPath());
-});
-afterEach(async () => {
-    try {
-        await closeServer();
-    }
-    finally {
-        process.chdir(origCwd);
-    }
-});
-after(() => {
-    process.chdir(origCwd);
-    closeDb();
-    if (home)
-        rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-    clearSessionCache();
-    delete process.env['CRTR_HOME'];
-    if (origHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = origHome;
-    if (origNode === undefined)
-        delete process.env['CRTR_NODE_ID'];
-    else
-        process.env['CRTR_NODE_ID'] = origNode;
-    if (origExecution === undefined)
-        delete process.env['CRTR_EXECUTION_ID'];
-    else
-        process.env['CRTR_EXECUTION_ID'] = origExecution;
-    if (origProfile === undefined)
-        delete process.env['CRTR_PROFILE_ID'];
-    else
-        process.env['CRTR_PROFILE_ID'] = origProfile;
-});
-test('a matching command is held with its doc, every sibling in the message with it, and the re-issue runs', async () => {
-    const docPath = writeDoctrineDoc('pre-command');
-    seedNode('gate-hold');
-    const pi = registerSubstrate();
-    const held = assertHeld(await pi.bash('deploy prod'), 'the first matching command');
-    assert.ok(held.reason.includes(DOCTRINE_BODY), `the doc rides back as the blocked call's result; got: ${held.reason}`);
-    assert.match(held.reason, /re-issue your WHOLE command/, 'the copy steers a whole-command re-issue, never one clause');
-    // Exposure is registered AT BLOCK TIME — physical identity and content alias
-    // both — and that single fact is what releases the re-issue below.
-    const afterBlock = loadContextExposureState('gate-hold');
-    assert.deepEqual(afterBlock.exposures.get(docPath), { transcript: 3 }, 'the held doc is recorded as delivered');
-    assert.equal(afterBlock.exposures.size, 4, 'the content alias and the read-equivalent memory-read companion are recorded alongside the held doc');
-    // Siblings of the same assistant message. The doc is already exposed, so
-    // without the per-turn flag the render would come back empty and let them
-    // through. The flag covers the whole message, matching or not: every command
-    // in it was authored under the worldview this doc just corrected.
-    const sibling = assertHeld(await pi.bash('deploy staging'), 'a matching sibling');
-    assert.match(sibling.reason, /Another command in this same message/);
-    assertHeld(await pi.bash('ls -la'), 'a non-matching sibling of a held command');
-    await pi.endTurn();
-    // The release: the doc is in the transcript, so there is nothing left to
-    // deliver and nothing left to hold.
-    assert.equal(await pi.bash('deploy prod'), undefined, 'the identical command re-issued in a later turn runs');
-    assert.equal(await pi.bash('ls -la'), undefined, 'a command matching nothing is untouched');
-});
-test('compaction re-arms the hold and leaves an exposure ledger that reloads', async () => {
-    const docPath = writeDoctrineDoc('pre-command');
-    seedNode('gate-compact');
-    const pi = registerSubstrate();
-    assertHeld(await pi.bash('deploy prod'), 'the first matching command');
-    await pi.endTurn();
-    assert.equal(await pi.bash('deploy prod'), undefined, 'the doc is in the transcript, so the command runs');
-    await pi.endTurn();
-    await pi.compact();
-    // Reloaded from disk: the demotion must DELETE the rankless entry rather than
-    // leave `{}` behind, which the v3 loader rejects outright — this call is the
-    // proof it did.
-    const afterCompact = loadContextExposureState('gate-compact');
-    assert.equal(afterCompact.exposures.has(docPath), false, 'compaction forgets the delivery that compaction dropped');
-    assert.equal(afterCompact.exposures.size, 2, 'the held doc and its alias are forgotten while its read-equivalent companion remains, with no rankless entry');
-    const reheld = assertHeld(await pi.bash('deploy prod'), 'the same command after compaction');
-    assert.ok(reheld.reason.includes(DOCTRINE_BODY), 'guidance the transcript no longer carries is delivered again');
-});
-test('a command that matches no gate never reaches the daemon', async () => {
-    writeDoctrineDoc('pre-command');
-    seedNode('gate-quiet');
-    const pi = registerSubstrate();
-    // The test API socket is unavailable. Both hooks must return before their
-    // subject lookup; one that does not fails loud with `daemon_unavailable`.
-    await closeServer();
-    assert.equal(await pi.bash('git status'), undefined, 'the pre-call hook ignores an unrelated pre-command document');
-    assert.equal(await pi.toolResult('bash', { command: 'git status' }), undefined, 'the post-result hook ignores an unrelated pre-command document');
-});

package/dist/shared/__tests__/env-boundary.test.d.ts

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

package/dist/shared/__tests__/env-boundary.test.js

@@ -1,95 +0,0 @@
-// `shared/env.ts` is the reader-side surface for the env vars listed below —
-// every one of them was migrated off a scattered `process.env` read onto a
-// named accessor there. This grep-enforces that boundary: outside the owner
-// module itself, a read of any migrated var may live only in an explicitly
-// documented exemption — a distinct, non-read use of the SAME var. Exemptions
-// are itemized below so a new stray read fails loud instead of silently
-// reintroducing the var outside its accessor.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, resolve, relative } from 'node:path';
-const SRC_ROOT = resolve(process.cwd(), 'src');
-// Every var migrated onto an accessor in `shared/env.ts`. Complete: every
-// forbidden-file sweep has landed, so this is the full migrated set.
-const MIGRATED_VARS = [
-    'CRTR_NODE_ID',
-    'CRTR_PROFILE_ID',
-    'CRTR_NODE_CWD',
-    'CRTR_MODEL_INTENT',
-    'CRTR_MODEL_EXACT',
-    'CRTR_HOME',
-    'CRTR_STREAM_WATCHDOG_MS',
-    'CRTR_WATCHER_TICK_MS',
-    'CRTR_WATCHER_DEBOUNCE_MS',
-    'CRTR_RECAP_IDLE_MS',
-    'CRTR_RECAP_MODEL',
-    'CRTR_BASH_VALVE_MS',
-    'CRTR_PIDFILE',
-    'CRTR_BROKER_ENGINE',
-    'CRTR_PI_BINARY',
-    'CRTR_NO_DAEMON_AUTOSTART',
-    'CRTRD_TCP',
-    'CRTR_NO_EXPORTS',
-    'CRTR_DEBUG',
-    'CRTR_MAX_LIVE_BROKERS',
-    'CRTR_WARN_LIVE_BROKERS',
-    'CRTR_TEST_UNATTENDED_PARK_MS',
-    'CRTR_TEST_PARK_SUMMARY_GRACE_MS',
-    'CRTR_UNATTENDED_PARK_MS',
-];
-// Matches `process.env['VAR']`, `process.env.VAR`, or `process.env[\`VAR\`]`
-// for exactly one of MIGRATED_VARS — not a longer name that merely starts
-// with it (e.g. `CRTR_DEBUG_PID_LIVENESS` must NOT match `CRTR_DEBUG`).
-const VAR_PATTERN = MIGRATED_VARS.join('|');
-const READ_RE = new RegExp(String.raw `process\.env(?:\.(?:${VAR_PATTERN})\b|\[['"\`](?:${VAR_PATTERN})['"\`]\])`);
-// Relative to src/, forward-slash form. Each entry is a genuinely distinct
-// use of the SAME var name that the migration deliberately leaves in place —
-// not an unmigrated read.
-const EXEMPTIONS = new Map([
-    [
-        'core/canvas/paths.ts',
-        'crtrHome() is the canonical resolved-path accessor for CRTR_HOME; ' +
-            'envHomeOverride() in shared/env.ts is for callers that want the raw ' +
-            'override itself (see the header comment there).',
-    ],
-    [
-        'core/runtime/broker.ts',
-        "clears CRTR_MODEL_INTENT and sets CRTR_MODEL_EXACT via process.env — mutations, " +
-            'not reads, so they stay here per shared/env.ts\'s header comment.',
-    ],
-]);
-function tsFilesUnder(dir) {
-    const out = [];
-    for (const entry of readdirSync(dir)) {
-        const path = join(dir, entry);
-        const stat = statSync(path);
-        if (stat.isDirectory()) {
-            if (entry === '__tests__')
-                continue;
-            out.push(...tsFilesUnder(path));
-        }
-        else if (entry.endsWith('.ts') && !entry.endsWith('.test.ts')) {
-            out.push(path);
-        }
-    }
-    return out;
-}
-test('every migrated env var is read only through shared/env.ts or an explicit exemption', () => {
-    const offenders = [];
-    for (const file of tsFilesUnder(SRC_ROOT)) {
-        const relPath = relative(SRC_ROOT, file).split('\\').join('/');
-        if (relPath === 'shared/env.ts')
-            continue;
-        if (EXEMPTIONS.has(relPath))
-            continue;
-        const source = readFileSync(file, 'utf8');
-        const lines = source.split('\n');
-        lines.forEach((line, index) => {
-            if (READ_RE.test(line)) {
-                offenders.push(`${relPath}:${index + 1}: ${line.trim()}`);
-            }
-        });
-    }
-    assert.deepEqual(offenders, [], `migrated env var read(s) outside shared/env.ts and its exemptions:\n${offenders.join('\n')}`);
-});

package/dist/shared/__tests__/generated-context-grammar.test.d.ts

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