@north-light/crouter 0.3.220 → 0.3.222

package/dist/core/__tests__/inline-memory-refs.test.js

@@ -14,6 +14,7 @@ import { resetScopeCache } from '../scope.js';
 import { clearSessionCache } from '../substrate/session-cache.js';
 import { memoryDir as nodeMemoryDir } from '../runtime/memory.js';
 import { buildRefInventory } from '../memory/inline-ref-inventory.js';
+import { gatewayMemoryRows } from '../runtime/chat-inventory-rows.js';
 // ---------------------------------------------------------------------------
 // Wave C4 — buildRefInventory: the authoritative corpus builder. Fixture-
 // backed (node/project/user scope docs on disk), since precedence dedup,
@@ -47,6 +48,21 @@ describe('buildRefInventory (fixture-backed corpus)', () => {
     function nodeScopeMemoryDir() {
         return nodeMemoryDir(NODE_ID);
     }
+    function plantNorthlightVisibilityExtension() {
+        const manifestDir = join(userHome, '.crouter', 'plugins', 'northlight', '.crouter-plugin');
+        mkdirSync(manifestDir, { recursive: true });
+        writeFileSync(join(manifestDir, 'plugin.json'), JSON.stringify({
+            name: 'northlight',
+            memory_extensions: {
+                visibility: {
+                    type: 'boolean',
+                    default: true,
+                    write_help: 'Control chat visibility.',
+                    edit_help: 'Control chat visibility.',
+                },
+            },
+        }));
+    }
     before(() => {
         prevCanvasHome = process.env['CRTR_HOME'];
         prevUserHome = process.env['HOME'];
@@ -148,12 +164,30 @@ describe('buildRefInventory (fixture-backed corpus)', () => {
         // A sibling doc in the same corpus is unaffected.
         assert.ok(names.has('crtr-inline-ref-fixture-sibling'));
     });
-    test('refs are metadata-only: exactly {name, kind, scope, shortForm}, no body/path', () => {
+    test('refs are metadata-only: exactly {name, kind, scope, shortForm, gatewayVisible}, no body/path', () => {
         writeDoc(projectMemoryDir(), 'crtr-inline-ref-fixture-meta.md', "kind: knowledge\nshort-form: 'hook'");
         const { refs } = buildRefInventory();
         const ref = refs.find((r) => r.name === 'crtr-inline-ref-fixture-meta');
         assert.ok(ref);
-        assert.deepEqual(Object.keys(ref).sort(), ['kind', 'name', 'scope', 'shortForm']);
+        assert.deepEqual(Object.keys(ref).sort(), ['gatewayVisible', 'kind', 'name', 'scope', 'shortForm']);
+    });
+    test('Gateway eligibility excludes builtins and effective Northlight-hidden refs without changing resolution', () => {
+        plantNorthlightVisibilityExtension();
+        writeDoc(projectMemoryDir(), 'crtr-inline-ref-fixture-hidden.md', 'kind: knowledge\nextensions:\n  northlight:\n    visibility: false');
+        writeDoc(projectMemoryDir(), 'crtr-inline-ref-fixture-visible.md', 'kind: knowledge');
+        const { refs, names } = buildRefInventory();
+        const hidden = refs.find((ref) => ref.name === 'crtr-inline-ref-fixture-hidden');
+        const visible = refs.find((ref) => ref.name === 'crtr-inline-ref-fixture-visible');
+        assert.equal(hidden?.gatewayVisible, false);
+        assert.equal(visible?.gatewayVisible, true);
+        assert.ok(names.has('crtr-inline-ref-fixture-hidden'));
+        assert.ok(names.has('crtr-inline-ref-fixture-visible'));
+        assert.ok(refs.some((ref) => ref.scope === 'builtin'));
+        assert.ok(refs.filter((ref) => ref.scope === 'builtin').every((ref) => !ref.gatewayVisible));
+        const chatRows = gatewayMemoryRows(refs);
+        assert.ok(!chatRows.some((ref) => ref.name === 'crtr-inline-ref-fixture-hidden'));
+        assert.ok(chatRows.some((ref) => ref.name === 'crtr-inline-ref-fixture-visible'));
+        assert.ok(!chatRows.some((ref) => ref.scope === 'builtin'));
     });
     test('a malformed doc (no valid kind) is omitted from the inventory', () => {
         writeDoc(projectMemoryDir(), 'crtr-inline-ref-fixture-malformed.md', "short-form: 'no kind here'");

package/dist/core/__tests__/profile-project-memory-delivery.test.d.ts

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

package/dist/core/__tests__/profile-project-memory-delivery.test.js

@@ -0,0 +1,217 @@
+// A selected profile's project relationship caps AUTOMATIC delivery — boot and
+// workspace-open — and nothing else. The reported failure this suite exists for:
+// a profile project that is also the node's cwd rendered its authored rung, as
+// if the relationship applied only to projects reached through the manifest.
+//
+// One real fixture drives the real scope resolver, the real boot renderer, the
+// real workspace-open renderer, and the real `crtr memory read` leaf: a profile
+// whose four projects sit at none/name/preview/content in manifest order, with
+// the `preview` project as cwd and canonical-name collisions across projects and
+// against the wider user scope.
+//
+// Migration convergence is NOT here — it lives in migration.test.ts.
+//
+// Run: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/profile-project-memory-delivery.test.ts
+import { test, before, beforeEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { closeDb } from '../canvas/db.js';
+import { resetScopeCache } from '../scope.js';
+import { createProfile } from '../profiles/manifest.js';
+import { spawnNode } from '../runtime/nodes.js';
+import { clearSessionCache } from '../substrate/session-cache.js';
+import { renderKnowledgeBlock } from '../substrate/render-node.js';
+import { renderWorkspaceOpenDocs } from '../substrate/on-read-node.js';
+import { deliveredAtOrAbove, loadInjectedDocs, saveInjectedDocs, } from '../substrate/injected-store.js';
+import { readLeaf } from '../../commands/memory/read.js';
+const B = {
+    pnone: 'BODY-T9-PNONE',
+    pname: 'BODY-T9-PNAME',
+    ppreview: 'BODY-T9-PPREVIEW',
+    pcontent: 'BODY-T9-PCONTENT',
+    sharedFromPnone: 'BODY-T9-SHARED-FROM-PNONE',
+    sharedFromPcontent: 'BODY-T9-SHARED-FROM-PCONTENT',
+    nameFromPname: 'BODY-T9-NAMEDUP-FROM-PNAME',
+    nameFromPcontent: 'BODY-T9-NAMEDUP-FROM-PCONTENT',
+    userDupFromPnone: 'BODY-T9-USERDUP-FROM-PNONE',
+    userDupFromUser: 'BODY-T9-USERDUP-FROM-USER',
+};
+let home;
+let canvasHome;
+let profileId;
+let prevHome;
+let prevCanvasHome;
+let prevProfile;
+let prevNode;
+let prevCwd;
+let cwdProject;
+let ppreviewDocPath;
+/** A doc delivered automatically at the top rung by both automatic channels —
+ *  every cap observed below is the relationship's, never the author's. */
+function autoDoc(when, body) {
+    return [
+        '---',
+        'kind: knowledge',
+        `when-and-why-to-read: "${when}"`,
+        'surfaces:',
+        '  - {on: boot, at: content}',
+        '  - {on: workspace-open, at: content}',
+        '---',
+        '',
+        body,
+        '',
+    ].join('\n');
+}
+/** No surfaces at all: invisible at boot, counted into its dir's `[+N more]`. */
+function bootlessDoc(when, body) {
+    return ['---', 'kind: knowledge', `when-and-why-to-read: "${when}"`, '---', '', body, ''].join('\n');
+}
+function writeDoc(storeDir, relName, contents) {
+    const path = join(storeDir, `${relName}.md`);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents);
+    return path;
+}
+before(() => {
+    prevHome = process.env['HOME'];
+    prevCanvasHome = process.env['CRTR_HOME'];
+    prevProfile = process.env['CRTR_PROFILE_ID'];
+    prevNode = process.env['CRTR_NODE_ID'];
+    prevCwd = process.cwd();
+    // realpath: the manifest owner persists realpath-resolved project paths. A raw
+    // /var/folders path on macOS makes the cwd ancestor walk and the profile
+    // pointer name two different roots, and the cwd project then reads as uncapped
+    // for the wrong reason.
+    home = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-ppm-home-')));
+    canvasHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-ppm-canvas-')));
+    process.env['HOME'] = home;
+    process.env['CRTR_HOME'] = canvasHome;
+    const store = (slug) => {
+        const dir = join(home, slug, '.crouter', 'memory');
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    };
+    const pnone = store('pnone');
+    const pname = store('pname');
+    const ppreview = store('ppreview');
+    const pcontent = store('pcontent');
+    const user = join(home, '.crouter', 'memory');
+    mkdirSync(user, { recursive: true });
+    writeDoc(pnone, 't9-pnone-doc', autoDoc('When the none project delivers', B.pnone));
+    writeDoc(pname, 't9-pname-doc', autoDoc('When the name project delivers', B.pname));
+    ppreviewDocPath = writeDoc(ppreview, 't9-ppreview-doc', autoDoc('When the cwd project delivers', B.ppreview));
+    writeDoc(pcontent, 't9-pcontent-doc', autoDoc('When the content project delivers', B.pcontent));
+    // Collision one: `none` (earlier in manifest order) vs `content`. The cap must
+    // apply before name dedupe, so the dropped entry cannot shadow the winner.
+    writeDoc(pnone, 't9-shared-doc', autoDoc('When the shared name resolves', B.sharedFromPnone));
+    writeDoc(pcontent, 't9-shared-doc', autoDoc('When the shared name resolves', B.sharedFromPcontent));
+    // Collision two: `name` vs `content`. A non-none cap keeps its project's
+    // precedence and discloses at the capped rung — it does not step aside.
+    writeDoc(pname, 't9-namedup-doc', autoDoc('When the name-capped duplicate resolves', B.nameFromPname));
+    writeDoc(pcontent, 't9-namedup-doc', autoDoc('When the name-capped duplicate resolves', B.nameFromPcontent));
+    // Collision three: `none` vs the wider user scope, which project precedence
+    // would otherwise beat.
+    writeDoc(pnone, 't9-userdup-doc', autoDoc('When the user duplicate resolves', B.userDupFromPnone));
+    writeDoc(user, 't9-userdup-doc', autoDoc('When the user duplicate resolves', B.userDupFromUser));
+    // Hidden-count pair: a top-level dir always renders, so a dir holding only a
+    // bootless doc shows as `<dir>/` + `[+1 more]` — unless its project is `none`.
+    writeDoc(pnone, join('t9-none-hidden', 'probe'), bootlessDoc('When counted', 'HIDDEN-NONE'));
+    writeDoc(pcontent, join('t9-hidden-control', 'probe'), bootlessDoc('When counted', 'HIDDEN-CONTROL'));
+    profileId = createProfile('t9', [
+        { path: join(home, 'pnone'), memory: 'none' },
+        { path: join(home, 'pname'), memory: 'name' },
+        { path: join(home, 'ppreview'), memory: 'preview' },
+        { path: join(home, 'pcontent'), memory: 'content' },
+    ]).profileId;
+    process.env['CRTR_PROFILE_ID'] = profileId;
+    // The node works INSIDE a capped project: the reported failure.
+    cwdProject = join(home, 'ppreview');
+    process.chdir(cwdProject);
+});
+beforeEach(() => {
+    resetScopeCache();
+    clearSessionCache();
+});
+after(() => {
+    closeDb();
+    resetScopeCache();
+    clearSessionCache();
+    process.chdir(prevCwd);
+    rmSync(home, { recursive: true, force: true });
+    rmSync(canvasHome, { recursive: true, force: true });
+    const restore = (key, value) => {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    };
+    restore('HOME', prevHome);
+    restore('CRTR_HOME', prevCanvasHome);
+    restore('CRTR_PROFILE_ID', prevProfile);
+    restore('CRTR_NODE_ID', prevNode);
+});
+function newNode() {
+    return spawnNode({ kind: 'general', cwd: cwdProject, parent: null, profile_id: profileId }).node_id;
+}
+test('boot delivery caps every profile project at its relationship, including the one used as cwd', () => {
+    const boot = renderKnowledgeBlock(newNode(), new Map());
+    // The control: an uncapped relationship still renders its authored content.
+    assert.ok(boot.includes(B.pcontent), `the content-capped project renders its body; got:\n${boot}`);
+    // The reported failure. cwd reaches this root before the manifest pointer
+    // does, and the relationship still decides the ceiling.
+    assert.ok(!boot.includes(B.ppreview), `the cwd project is capped at preview — its body must not render; got:\n${boot}`);
+    assert.match(boot, /t9-ppreview-doc {2}# read when: When the cwd project delivers\./, `the cwd project's doc discloses at preview; got:\n${boot}`);
+    // `name` discloses the bare identifier and nothing else.
+    assert.ok(!boot.includes(B.pname), 'a name-capped project must not render a body');
+    assert.match(boot, /[├└]─ t9-pname-doc$/m, `the name-capped doc discloses as a bare name; got:\n${boot}`);
+    assert.ok(!boot.includes('When the name project delivers'), 'a name-capped doc discloses no preview line');
+});
+test('a `none` project contributes nothing to boot — no body, no name, no hidden count, no shadow', () => {
+    const boot = renderKnowledgeBlock(newNode(), new Map());
+    assert.ok(!boot.includes(B.pnone), 'a none-capped body must not render');
+    assert.ok(!boot.includes('t9-pnone-doc'), 'a none-capped doc must not appear as a name either');
+    // Hidden counts are disclosure too: the control dir proves a bootless doc
+    // does surface as a `[+N more]` count, so the none project's absence is the cap.
+    assert.match(boot, /t9-hidden-control\/\n.*\[\+1 more\]/, `the control dir shows its hidden count; got:\n${boot}`);
+    assert.ok(!boot.includes('t9-none-hidden'), 'a none-capped project contributes no `[+N more]` count');
+    // Shadowing: `none` wins name dedupe on precedence, so a cap applied after
+    // dedupe would silently delete the winner instead of deferring to it.
+    assert.ok(boot.includes(B.sharedFromPcontent) && !boot.includes(B.sharedFromPnone), `the content project wins the collision the none project would have taken; got:\n${boot}`);
+    assert.ok(boot.includes(B.userDupFromUser) && !boot.includes(B.userDupFromPnone), `a none project does not shadow the wider user-scope winner; got:\n${boot}`);
+});
+test('a non-none cap keeps its project precedence and discloses the duplicate at the capped rung', () => {
+    const boot = renderKnowledgeBlock(newNode(), new Map());
+    assert.match(boot, /[├└]─ t9-namedup-doc$/m, `the name-capped duplicate wins dedupe; got:\n${boot}`);
+    assert.ok(!boot.includes(B.nameFromPname), 'the winner discloses at `name`, never its body');
+    assert.ok(!boot.includes(B.nameFromPcontent), 'the content project does not take a collision the name project already won');
+});
+test('workspace-open clamps each project store the same way boot does', () => {
+    const opened = renderWorkspaceOpenDocs(newNode(), new Map());
+    assert.ok(opened.includes(B.pcontent), `the content-capped project delivers its body; got:\n${opened}`);
+    assert.ok(!opened.includes(B.ppreview), `the cwd project must not deliver its body; got:\n${opened}`);
+    assert.match(opened, /name="t9-ppreview-doc" readWhen="When the cwd project delivers\./, `the cwd project delivers its preview line; got:\n${opened}`);
+    assert.match(opened, /name="t9-pname-doc"[^>]*\/>/, `the name-capped doc delivers name-only; got:\n${opened}`);
+    assert.ok(!opened.includes('t9-pnone-doc'), 'the none-capped project delivers nothing at workspace-open');
+    assert.ok(!opened.includes(B.sharedFromPnone), 'nor its side of a name collision');
+});
+test('an explicit `crtr memory read` returns and records the full body a cap withheld', async () => {
+    const node = newNode();
+    process.env['CRTR_NODE_ID'] = node;
+    const seen = loadInjectedDocs(node);
+    const opened = renderWorkspaceOpenDocs(node, seen);
+    assert.ok(!opened.includes(B.ppreview), 'workspace-open disclosed the capped doc at preview only');
+    saveInjectedDocs(node, seen);
+    const result = (await readLeaf.run({ name: 't9-ppreview-doc', frontmatter: false }));
+    assert.equal(result.path, ppreviewDocPath, 'the read resolved the cwd project doc');
+    assert.ok(result.content.includes(B.ppreview), `an explicit read is uncapped and returns the full body; got:\n${result.content}`);
+    const afterRead = loadInjectedDocs(node);
+    assert.ok(deliveredAtOrAbove(afterRead, ppreviewDocPath, 'content'), 'the explicit read records a content delivery, upgrading the preview disclosure');
+    // A later automatic event runs at the capped rung, which is now below what the
+    // transcript holds, so it re-delivers nothing.
+    assert.equal(renderWorkspaceOpenDocs(node, afterRead), '', 'a later lower automatic event re-delivers nothing');
+    // ...and the emptiness is the dedup set, not a dead render.
+    assert.ok(renderWorkspaceOpenDocs(node, new Map()).includes('t9-ppreview-doc'), 'the same call against a fresh transcript still delivers');
+    delete process.env['CRTR_NODE_ID'];
+});

package/dist/core/__tests__/prospective-inventory-capability-parity.test.d.ts

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

package/dist/core/__tests__/prospective-inventory-capability-parity.test.js

@@ -0,0 +1,91 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DefaultResourceLoader, ExtensionRunner, } from '@earendil-works/pi-coding-agent';
+import { captureChatCapabilities, registrationChatSurface } from '../runtime/command-surface.js';
+test('startup capability capture preserves same-name lifecycle replacements and excludes new lifecycle registrations', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-prospective-capability-'));
+    const agentDir = join(root, '.pi');
+    const invoked = join(root, 'late-invoked');
+    mkdirSync(agentDir);
+    const first = join(root, 'first.js');
+    const second = join(root, 'second.js');
+    writeFileSync(first, `
+import { writeFileSync } from 'node:fs';
+export default function (pi) {
+  pi.registerCommand('collision', {
+    description: 'first factory command',
+    gateway: true,
+    argumentHint: '<first>',
+    handler: async () => {},
+  });
+  pi.on('session_start', () => {
+    pi.registerCommand('collision', {
+      description: 'lifecycle replacement',
+      argumentHint: '<replacement>',
+      handler: async () => {},
+    });
+    pi.registerCommand('late', {
+      description: 'lifecycle command',
+      gateway: true,
+      handler: async () => writeFileSync(${JSON.stringify(invoked)}, 'yes'),
+    });
+  });
+}
+`);
+    writeFileSync(second, `
+export default function (pi) {
+  pi.registerCommand('collision', {
+    description: 'second factory command',
+    gateway: true,
+    argumentHint: '<second>',
+    handler: async () => {},
+  });
+}
+`);
+    try {
+        const loader = new DefaultResourceLoader({
+            cwd: root,
+            agentDir,
+            additionalExtensionPaths: [first, second],
+            noContextFiles: true,
+        });
+        await loader.reload();
+        const loaded = loader.getExtensions();
+        assert.deepEqual(loaded.errors, []);
+        const runner = new ExtensionRunner(loaded.extensions, loaded.runtime, root, undefined, undefined);
+        const startupCommands = runner.getRegisteredCommands();
+        captureChatCapabilities({ commands: startupCommands, templates: [] });
+        const startupRows = startupCommands.map((command) => ({
+            name: command.invocationName,
+            ...registrationChatSurface(command),
+        }));
+        assert.deepEqual(startupRows, [
+            { name: 'collision:1', gatewayCapable: true, argumentHint: '<first>' },
+            { name: 'collision:2', gatewayCapable: true, argumentHint: '<second>' },
+        ]);
+        for (const extension of loaded.extensions) {
+            for (const handler of extension.handlers.get('session_start') ?? []) {
+                await handler({ type: 'session_start' }, {});
+            }
+        }
+        const reloadedRows = runner.getRegisteredCommands().map((command) => ({
+            name: command.invocationName,
+            ...registrationChatSurface(command),
+        }));
+        assert.deepEqual(reloadedRows, [
+            { name: 'collision:1', gatewayCapable: true, argumentHint: '<replacement>' },
+            { name: 'late', gatewayCapable: false },
+            { name: 'collision:2', gatewayCapable: true, argumentHint: '<second>' },
+        ]);
+        const late = runner.getCommand('late');
+        assert.ok(late, 'the lifecycle command remains registered and addressable');
+        await late.handler('', {});
+        assert.equal(existsSync(invoked), true, 'the lifecycle command remains invokable');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/core/__tests__/seam/memory-slash-node-relative-inventory.test.d.ts

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

package/dist/core/__tests__/seam/memory-slash-node-relative-inventory.test.js

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { test } from 'node:test';
+import { loadedCommandPreview } from '../../../clients/attach/slash/prompt-preview.js';
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '../../../..');
+const EXTENSION = join(ROOT, 'dist/builtin-pi-packages/pi-crtr-extensions/extensions/memory-slash-commands.ts');
+const LIVE_PROBE = join(ROOT, 'dist/core/__tests__/fixtures/memory-slash-live-probe.js');
+const COMMAND_NAMES = ['acceptance-context-token', 'acceptance-node-token', 'acceptance-independent'];
+function writeSlashDoc(memoryDir, name, description, body) {
+    writeFileSync(join(memoryDir, `${name}.md`), `---\nkind: knowledge\nwhen-and-why-to-read: Acceptance fixture.\nshort-form: ${description}\nslash: true\n---\n${body}`);
+}
+function liveProbe(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [LIVE_PROBE, EXTENSION, JSON.stringify(input.invocations)], {
+            cwd: input.cwd,
+            env: {
+                ...process.env,
+                CRTR_HOME: input.home,
+                CRTR_NODE_ID: input.nodeId,
+                CRTR_PROFILE_ID: '',
+                PI_CODING_AGENT_DIR: join(input.cwd, '.pi'),
+            },
+            stdio: ['ignore', 'pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let response = '';
+        const stdoutStream = child.stdout;
+        const stderrStream = child.stderr;
+        const responseStream = child.stdio[3];
+        if (stdoutStream === null || stderrStream === null || responseStream === null) {
+            child.kill('SIGKILL');
+            reject(new Error('live probe response channel unavailable'));
+            return;
+        }
+        stdoutStream.setEncoding('utf8');
+        stderrStream.setEncoding('utf8');
+        responseStream.setEncoding('utf8');
+        stdoutStream.on('data', (chunk) => { stdout += chunk; });
+        stderrStream.on('data', (chunk) => { stderr += chunk; });
+        responseStream.on('data', (chunk) => { response += chunk; });
+        child.on('error', reject);
+        child.on('close', (code, signal) => {
+            if (code !== 0) {
+                reject(new Error(`live probe exited ${code ?? signal ?? 'unknown'}: ${stderr}${stdout}`));
+                return;
+            }
+            resolve(JSON.parse(response));
+        });
+    });
+}
+function fixtureRows(rows) {
+    return COMMAND_NAMES.map((name) => {
+        const row = rows.find((candidate) => candidate.name === name);
+        assert.ok(row, `Gateway advertises /${name}`);
+        return row;
+    });
+}
+test('node-relative memory slash commands omit preview metadata without changing live sends', async () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'crtr-memory-slash-inventory-'));
+    const home = join(cwd, 'canvas');
+    const memoryDir = join(cwd, '.crouter', 'memory');
+    const nodeId = 'acceptance-live-node';
+    mkdirSync(memoryDir, { recursive: true });
+    writeSlashDoc(memoryDir, COMMAND_NAMES[0], 'Context-relative fixture.', 'Store $ARGUMENTS in $CRTR_CONTEXT_DIR/result.md.\n');
+    writeSlashDoc(memoryDir, COMMAND_NAMES[1], 'Node-relative fixture.', 'Node $CRTR_NODE_ID received $ARGUMENTS.\n');
+    writeSlashDoc(memoryDir, COMMAND_NAMES[2], 'Node-independent fixture.', 'Independent payload: $ARGUMENTS.\n');
+    try {
+        const live = await liveProbe({
+            cwd,
+            home,
+            nodeId,
+            invocations: COMMAND_NAMES.map((name) => ({ name, args: 'evidence' })),
+        });
+        assert.equal(live.stateBeforeProspective, false);
+        assert.equal(live.stateAfterProspective, false);
+        assert.deepEqual(live.commands, live.prospective.commands);
+        assert.deepEqual(live.memoryRefs, live.prospective.memory_refs);
+        const prospectiveRows = fixtureRows(live.prospective.commands);
+        const liveRows = fixtureRows(live.commands);
+        assert.deepEqual(liveRows, prospectiveRows);
+        assert.deepEqual(prospectiveRows, [
+            { name: COMMAND_NAMES[0], description: 'Context-relative fixture.', source: 'command' },
+            { name: COMMAND_NAMES[1], description: 'Node-relative fixture.', source: 'command' },
+            {
+                name: COMMAND_NAMES[2],
+                description: 'Node-independent fixture.',
+                source: 'command',
+                expansion: {
+                    kind: 'memory-slash',
+                    commandName: COMMAND_NAMES[2],
+                    body: 'Independent payload: $ARGUMENTS.\n',
+                },
+            },
+        ]);
+        const insightsInit = live.commands.find((row) => row.name === 'insights:init');
+        assert.ok(insightsInit, 'Gateway completion includes /insights:init');
+        assert.equal(insightsInit.expansion, undefined);
+        assert.equal(loadedCommandPreview('/insights:init agent-facing CLI', live.commands), undefined);
+        assert.equal(loadedCommandPreview('/acceptance-independent first evidence', live.commands)?.content, 'Independent payload: first evidence.\n');
+        assert.equal(loadedCommandPreview('/acceptance-independent changed evidence', live.commands)?.content, 'Independent payload: changed evidence.\n');
+        assert.deepEqual(live.notifications, []);
+        const sentContent = Object.fromEntries(live.sent.map((send) => [send.name, send.message.content]));
+        assert.deepEqual(sentContent, {
+            [COMMAND_NAMES[0]]: `Store evidence in ${join(home, 'nodes', nodeId, 'context', 'result.md')}.\n`,
+            [COMMAND_NAMES[1]]: `Node ${nodeId} received evidence.\n`,
+            [COMMAND_NAMES[2]]: 'Independent payload: evidence.\n',
+        });
+        for (const send of live.sent) {
+            assert.deepEqual(send.message, {
+                customType: 'memory-slash-command',
+                content: sentContent[send.name],
+                display: true,
+            });
+            assert.deepEqual(send.options, { triggerTurn: true });
+        }
+        assert.doesNotMatch(sentContent[COMMAND_NAMES[0]], /\$CRTR_CONTEXT_DIR|\$CRTR_NODE_ID/);
+        assert.doesNotMatch(sentContent[COMMAND_NAMES[1]], /\$CRTR_CONTEXT_DIR|\$CRTR_NODE_ID/);
+    }
+    finally {
+        rmSync(cwd, { recursive: true, force: true });
+    }
+});

package/dist/core/__tests__/seam/prospective-inventory-stdout.test.d.ts

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

package/dist/core/__tests__/seam/prospective-inventory-stdout.test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { runProspectiveInventory } from '../../runtime/prospective-inventory.js';
+test('prospective preflight keeps package stdout out of its response channel', async () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'crtr-prospective-stdout-'));
+    const extension = join(cwd, 'loud-extension.mjs');
+    writeFileSync(extension, `
+export default function (pi) {
+  console.log('harmless package diagnostic');
+  pi.registerCommand('stdout-probe', {
+    description: 'survives package stdout',
+    gateway: true,
+    handler: async () => {},
+  });
+}
+`);
+    try {
+        const rows = await runProspectiveInventory({ cwd, profileId: null, extensions: [extension] });
+        assert.deepEqual(rows.commands.find((row) => row.name === 'stdout-probe'), {
+            name: 'stdout-probe',
+            description: 'survives package stdout',
+            source: 'command',
+        });
+    }
+    finally {
+        rmSync(cwd, { recursive: true, force: true });
+    }
+});