@north-light/crouter 0.3.318 → 0.3.319

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

@@ -1,644 +0,0 @@
-// 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 first four projects sit at none/name/preview/content in manifest order,
-// with the `preview` project as cwd, plus two more projects declaring ONE shared
-// namespace so a single canonical identity has two physical candidates split
-// across a `none` and a `content` relationship.
-//
-// 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, migrate, openDb } from '../canvas/db.js';
-import { resetScopeCache } from '../scope.js';
-import { createProfile } from '../profiles/manifest.js';
-import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
-import { spawnNode } from '../runtime/nodes.js';
-import { memoryDir } from '../runtime/memory.js';
-import { clearSessionCache } from '../substrate/session-cache.js';
-import { renderKnowledgeBlock } from '../substrate/render-node.js';
-import { renderKnowledgeForSubject, renderPreferencesForSubject } from '../substrate/render.js';
-import { assembleNodeSubject } from '../substrate/subject.js';
-import { renderWorkspaceOpenDocs } from '../substrate/on-read-node.js';
-import { renderWorkspaceOpenDocsForSubject } from '../substrate/on-read.js';
-import { documentExposedAtOrAbove, emptyContextExposureState, exposedAtOrAbove, exposureTarget, loadContextExposureState, saveContextExposureState, } from '../substrate/injected-store.js';
-import { readLeaf } from '../../commands/memory/read.js';
-import { listLeaf } from '../../commands/memory/list.js';
-import { findLeaf } from '../../commands/memory/find.js';
-import { assembleEventAccounting, docRow, effectivePlan, } from '../../commands/sys/context/resolve.js';
-import { planDelivery } from '../substrate/plan.js';
-import { PlanSet } from '../../commands/sys/context/admin/model.js';
-import { buildRows } from '../../commands/sys/context/admin/docs-panel.js';
-function freshTranscriptTarget() {
-    return exposureTarget(emptyContextExposureState(), 'transcript');
-}
-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',
-    dupNear: 'BODY-T9-DUP-FROM-NEAR',
-    dupFar: 'BODY-T9-DUP-FROM-FAR',
-    kindSplit: 'BODY-T9-KIND-SPLIT',
-    documentGateWins: 'BODY-T9-DOCUMENT-GATE-WINS',
-    codeCraftIndex: 'BODY-T9-CODE-CRAFT-INDEX',
-    companionSource: 'BODY-T9-COMPANION-SOURCE',
-    companionA: 'BODY-T9-COMPANION-A',
-    companionB: 'BODY-T9-COMPANION-B',
-    prefRouter: 'BODY-T9-PREF-ROUTER',
-    crossPartition: 'BODY-T9-CROSS-PARTITION',
-    outsideGuide: 'BODY-T9-OUTSIDE-GUIDE',
-    pnameNeighbour: 'BODY-T9-NEIGHBOUR-IN-PNAMEDIR',
-};
-let home;
-let canvasHome;
-let profileId;
-let prevHome;
-let prevCanvasHome;
-let prevProfile;
-let prevNode;
-let prevCwd;
-let cwdProject;
-let outsideProject;
-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;
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-    migrate(openDb());
-    // A project store answers only under the namespace its root INDEX.md
-    // declares; without that declaration the store does not mount at all.
-    const store = (slug, namespace) => {
-        const dir = join(home, slug, '.crouter', 'memory');
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(join(dir, 'INDEX.md'), [
-            '---',
-            'kind: knowledge',
-            `namespace: ${namespace}`,
-            `when-and-why-to-read: "When the ${slug} store is addressed"`,
-            '---',
-            '',
-            `STORE-ROOT-${slug.toUpperCase()}`,
-            '',
-        ].join('\n'));
-        return dir;
-    };
-    const pnone = store('pnone', 'pnone');
-    const pname = store('pname', 'pname');
-    const ppreview = store('ppreview', 'ppreview');
-    const pcontent = store('pcontent', 'pcontent');
-    // Two stores declaring ONE namespace — the only way two projects can hold the
-    // same canonical identity.
-    const pdupnear = store('pdupnear', 'shared');
-    const pdupfar = store('pdupfar', 'shared');
-    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));
-    // Equal-canonical collision: `shared/dup-doc` in both stores that declare
-    // `shared`, the `none`-capped one nearer in source order. The cap must apply
-    // BEFORE dedupe, so the capped nearer candidate yields to the farther one
-    // instead of suppressing it.
-    writeDoc(pdupnear, 'dup-doc', autoDoc('When the shared identity resolves', B.dupNear));
-    writeDoc(pdupfar, 'dup-doc', autoDoc('When the shared identity resolves', B.dupFar));
-    // Distinct identities that only LOOK like collisions: each project composes
-    // its own namespace, so a capped project cannot suppress another store's
-    // document that merely shares a local name.
-    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));
-    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));
-    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));
-    writeDoc(user, 't9-kind-split', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When the node needs this kind-specific guide"',
-        'surfaces:',
-        '  - {on: boot, gate: {kind: {in: [design, spec, plan, developer]}}, at: content}',
-        '  - {on: boot, gate: {kind: {in: [general, review, advisor]}}, at: preview}',
-        '---',
-        '',
-        B.kindSplit,
-        '',
-    ].join('\n'));
-    writeDoc(user, 'dev/code-craft/INDEX', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When planning code work, this knowledge should be read because it routes the applicable craft guidance"',
-        'surfaces:',
-        '  - {on: boot, gate: {kind: {in: [design, spec, plan, developer]}}, at: content}',
-        '---',
-        '',
-        B.codeCraftIndex,
-        '',
-    ].join('\n'));
-    for (let i = 1; i <= 10; i++) {
-        writeDoc(user, `dev/code-craft/member-${i}`, bootlessDoc(`When code-craft member ${i} applies`, `BODY-T9-CODE-CRAFT-MEMBER-${i}`));
-    }
-    // The ANCESTOR half of a content delivery's listings: a bootless sibling of
-    // the `dev/code-craft` directory, disclosed because `dev/` is the enclosing
-    // directory of the doc whose body delivered.
-    writeDoc(user, 'dev/sibling', bootlessDoc('When the dev sibling applies', 'BODY-T9-DEV-SIBLING'));
-    writeDoc(user, 't9-companion-source', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When companion delivery starts, this knowledge should be read because it proves content reads cascade"',
-        'surfaces:',
-        '  - {on: boot, at: content}',
-        '---',
-        '',
-        B.companionSource,
-        '',
-    ].join('\n'));
-    // A companion that FRONTS a directory: its content delivery discloses its own
-    // members exactly as the source doc's did, one level deeper in the fixpoint.
-    writeDoc(user, 't9-companion-a/INDEX', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When the source is read, this knowledge should be read because it proves the first companion route"',
-        'surfaces:',
-        '  - {on: memory-read, match: t9-companion-source, at: content}',
-        '---',
-        '',
-        B.companionA,
-        '',
-    ].join('\n'));
-    writeDoc(user, 't9-companion-a/member-1', bootlessDoc('When the companion member applies', 'BODY-T9-COMPANION-A-MEMBER-1'));
-    writeDoc(user, 't9-companion-b', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When the first companion is read, this knowledge should be read because it proves the route reaches a fixpoint"',
-        'surfaces:',
-        '  - {on: memory-read, match: t9-companion-a, at: content}',
-        '---',
-        '',
-        B.companionB,
-        '',
-    ].join('\n'));
-    writeDoc(user, 't9-document-gate-wins', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When document eligibility is tested"',
-        'gate: {kind: {ne: developer}}',
-        'surfaces:',
-        '  - {on: boot, gate: {kind: developer}, at: content}',
-        '---',
-        '',
-        B.documentGateWins,
-        '',
-    ].join('\n'));
-    // Cross-partition single emission: a preference body routes a KNOWLEDGE doc
-    // that carries boot content of its own. Both partitions render against one
-    // exposure state, so that body must be delivered exactly once.
-    writeDoc(user, 't9-pref-router', [
-        '---',
-        'kind: preference',
-        'when-and-why-to-read: "When the preference partition renders, this preference should be read because it routes a knowledge companion"',
-        'surfaces:',
-        '  - {on: boot, at: content}',
-        '---',
-        '',
-        B.prefRouter,
-        '',
-    ].join('\n'));
-    writeDoc(user, 't9-cross-partition', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When the preference routes here, this knowledge should be read because it proves one body crosses both partitions once"',
-        'surfaces:',
-        '  - {on: boot, at: content}',
-        '  - {on: memory-read, match: t9-pref-router, at: content}',
-        '---',
-        '',
-        B.crossPartition,
-        '',
-    ].join('\n'));
-    // Cap safety: a name-tree directory merges across stores, so this user doc
-    // sits in the SAME canonical directory as the name-capped project's docs. Its
-    // content delivery discloses that directory — and must not raise a capped
-    // neighbour above the bare name its relationship allows.
-    writeDoc(user, 'pname/user-guide', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When the merged directory renders, this knowledge should be read because it discloses that directory"',
-        'surfaces:',
-        '  - {on: boot, at: content}',
-        '---',
-        '',
-        B.pnameNeighbour,
-        '',
-    ].join('\n'));
-    // A project OUTSIDE the profile manifest: its store mounts only for a target
-    // whose cwd sits inside it, so a workspace-open render of it proves the
-    // listings answer from the opened workspace rather than the ambient one.
-    const poutside = store('poutside', 'poutside');
-    outsideProject = join(home, 'poutside');
-    writeDoc(poutside, 't9-ws-guide/INDEX', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When that workspace opens, this knowledge should be read because it fronts its guide directory"',
-        'surfaces:',
-        '  - {on: workspace-open, at: content}',
-        '---',
-        '',
-        B.outsideGuide,
-        '',
-    ].join('\n'));
-    writeDoc(poutside, 't9-ws-guide/member-1', bootlessDoc('When the outside guide member applies', 'BODY-T9-OUTSIDE-MEMBER-1'));
-    // Workspace-open plans project stores only, but a content delivery's
-    // read-equivalent attachments answer from the whole opened target.
-    writeDoc(user, 'poutside/listing-member', bootlessDoc('When the workspace listing member applies', 'BODY-T9-WORKSPACE-LISTING-MEMBER'));
-    writeDoc(user, 't9-workspace-companion', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When the workspace guide is read, this companion proves full-view accounting"',
-        'surfaces:',
-        '  - {on: memory-read, match: poutside/t9-ws-guide, at: content}',
-        '---',
-        '',
-        'BODY-T9-WORKSPACE-COMPANION',
-        '',
-    ].join('\n'));
-    // 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' },
-        { path: join(home, 'pdupnear'), memory: 'none' },
-        { path: join(home, 'pdupfar'), 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);
-});
-async function newNode(kind = 'general') {
-    return (await spawnNode({ kind, 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', async () => {
-    const boot = renderKnowledgeBlock(await newNode(), freshTranscriptTarget());
-    // 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 — including when a
-    // content delivery in the same merged directory (the user-store neighbour)
-    // discloses that directory's listing.
-    assert.ok(boot.includes(B.pnameNeighbour), `the merged directory's uncapped document delivers; got:\n${boot}`);
-    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('surface-entry gates select the rung by node kind while the document gate remains absolute', async () => {
-    for (const kind of ['design', 'spec', 'plan', 'developer']) {
-        const boot = renderKnowledgeBlock(await newNode(kind), freshTranscriptTarget());
-        assert.ok(boot.includes(B.kindSplit), `${kind} receives the content rung; got:\n${boot}`);
-    }
-    for (const kind of ['general', 'review', 'advisor']) {
-        const boot = renderKnowledgeBlock(await newNode(kind), freshTranscriptTarget());
-        assert.match(boot, /t9-kind-split {2}# read when: When the node needs this kind-specific guide\./, `${kind} receives the preview rung; got:\n${boot}`);
-        assert.ok(!boot.includes(B.kindSplit), `${kind} does not receive the body`);
-    }
-    for (const kind of ['explore', 'personal-assistant']) {
-        const boot = renderKnowledgeBlock(await newNode(kind), freshTranscriptTarget());
-        assert.ok(!boot.includes('t9-kind-split'), `${kind} receives no kind-split entry; got:\n${boot}`);
-        assert.ok(!boot.includes(B.kindSplit), `${kind} receives no kind-split body`);
-    }
-    const developer = renderKnowledgeBlock(await newNode('developer'), freshTranscriptTarget());
-    assert.ok(!developer.includes('t9-document-gate-wins'), `a failing document gate excludes every entry; got:\n${developer}`);
-    assert.ok(!developer.includes(B.documentGateWins), 'a failing document gate excludes its content');
-    assert.ok(developer.includes(B.codeCraftIndex), 'the directory document delivers its boot content');
-    for (let i = 1; i <= 10; i++) {
-        assert.match(developer, new RegExp(`member-${i} {2}# read when: When code-craft member ${i} applies`), `content delivery exposes code-craft member ${i} at preview; got:\n${developer}`);
-    }
-    // The ancestor listing, not just the doc's own directory.
-    assert.match(developer, /sibling {2}# read when: When the dev sibling applies\./, `content delivery exposes the enclosing directory's members too; got:\n${developer}`);
-});
-test('context docs accounting reports content attachment raises from the renderer', async () => {
-    const node = await newNode('developer');
-    const subject = assembleNodeSubject(node);
-    assert.ok(subject !== null, 'the fixture node assembles a subject');
-    const target = { cwd: cwdProject, profileId, nodeId: node };
-    const direct = planDelivery(subject, target, 'boot');
-    const rendered = assembleEventAccounting({ subject, target, nodeMissing: false }, 'boot', {});
-    const rows = effectivePlan(direct, rendered.accounting.deliveries).docs.map((record) => docRow(record, true, subject));
-    for (let i = 1; i <= 10; i++) {
-        const row = rows.find((candidate) => candidate.name === `dev/code-craft/member-${i}`);
-        assert.equal(row?.final_rung, 'preview', `member ${i} is raised to the listing preview rung`);
-        assert.equal(row?.delivery_cause, 'directory listing attached to content delivery');
-    }
-    const companion = rows.find((row) => row.name === 't9-companion-a');
-    assert.equal(companion?.final_rung, 'content', 'a memory-read companion reaches its rendered rung');
-    assert.equal(companion?.delivery_cause, 'memory-read companion of content delivery');
-    const plans = new PlanSet({
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        hasManager: true,
-        profileId,
-        cwd: cwdProject,
-        nodeId: node,
-        depth: 0,
-        event: 'boot',
-        file: '',
-        docName: '',
-        command: '',
-    });
-    plans.plan('boot');
-    const viewerMember = buildRows(plans, 'boot').find((row) => row.name === 'dev/code-craft/member-1');
-    const viewerRecord = viewerMember?.records.get('boot');
-    assert.equal(viewerRecord?.finalRung, 'preview', 'the admin row reads the renderer-raised rung');
-    assert.equal(viewerRecord?.deliveryCause, 'directory listing attached to content delivery');
-    plans.dispose();
-});
-test('context docs accounting adds full-view workspace content attachments', async () => {
-    const node = await newNode();
-    const subject = assembleNodeSubject(node);
-    assert.ok(subject !== null, 'the fixture node assembles a subject');
-    const target = { cwd: outsideProject, profileId, nodeId: node };
-    const direct = planDelivery(subject, target, 'workspace-open');
-    const rendered = assembleEventAccounting({ subject, target, nodeMissing: false }, 'workspace-open', {});
-    const rows = effectivePlan(direct, rendered.accounting.deliveries).docs.map((record) => docRow(record, true, subject));
-    const listing = rows.find((row) => row.name === 'poutside/listing-member');
-    assert.equal(listing?.final_rung, 'preview');
-    assert.equal(listing?.delivery_cause, 'directory listing attached to content delivery');
-    const companion = rows.find((row) => row.name === 't9-workspace-companion');
-    assert.equal(companion?.final_rung, 'content');
-    assert.equal(companion?.delivery_cause, 'memory-read companion of content delivery');
-});
-test('boot content triggers memory-read companions to a deduplicated fixpoint', async () => {
-    const boot = renderKnowledgeBlock(await newNode(), freshTranscriptTarget());
-    for (const body of [B.companionSource, B.companionA, B.companionB]) {
-        assert.equal(boot.split(body).length - 1, 1, `content companion ${body} delivers once; got:\n${boot}`);
-    }
-    // A companion is read-equivalent in its own right: the directory it fronts
-    // discloses its members exactly as the doc that routed to it did.
-    assert.match(boot, /member-1 {2}# read when: When the companion member applies\./, `a content companion exposes its own directory's members; got:\n${boot}`);
-});
-test('one body delivered across both boot partitions renders exactly once', async () => {
-    const node = await newNode();
-    const subject = assembleNodeSubject(node);
-    assert.ok(subject !== null, 'the fixture node assembles a subject');
-    const state = emptyContextExposureState();
-    // The live boot order: the knowledge block and the preference splice share
-    // ONE exposure state, so a knowledge body already delivered as a preference's
-    // companion must not render again as knowledge prose.
-    const preferences = renderPreferencesForSubject(subject, exposureTarget(state, 'system')).block;
-    const knowledge = renderKnowledgeForSubject(subject, node, exposureTarget(state, 'transcript'));
-    assert.ok(preferences.includes(B.prefRouter), `the routing preference delivers its body; got:\n${preferences}`);
-    assert.ok(preferences.includes(B.crossPartition), `its companion delivers with it; got:\n${preferences}`);
-    const occurrences = (preferences.split(B.crossPartition).length - 1) + (knowledge.split(B.crossPartition).length - 1);
-    assert.equal(occurrences, 1, `the companion body renders once across both partitions; got:\n${preferences}\n---\n${knowledge}`);
-});
-test('a node-local doc floors to name only without boot entries', async () => {
-    const node = await newNode('explore');
-    writeDoc(memoryDir(node), 't9-node-local-bootless', bootlessDoc('When the node-local fallback applies', 'BODY-T9-NODE-LOCAL-BOOTLESS'));
-    writeDoc(memoryDir(node), 't9-node-local-entry-gated', [
-        '---',
-        'kind: knowledge',
-        'when-and-why-to-read: "When the node-local entry gates are tested"',
-        'surfaces:',
-        '  - {on: boot, gate: {kind: developer}, at: content}',
-        '  - {on: boot, gate: {kind: review}, at: preview}',
-        '---',
-        '',
-        'BODY-T9-NODE-LOCAL-ENTRY-GATED',
-        '',
-    ].join('\n'));
-    const boot = renderKnowledgeBlock(node, freshTranscriptTarget());
-    assert.match(boot, /[├└]─ t9-node-local-bootless$/m, `a bootless node-local doc falls to name; got:\n${boot}`);
-    assert.ok(!boot.includes('BODY-T9-NODE-LOCAL-BOOTLESS'), 'the fallback discloses no body');
-    assert.ok(!boot.includes('t9-node-local-entry-gated'), `ineligible boot entries keep a node-local doc absent; got:\n${boot}`);
-    assert.ok(!boot.includes('BODY-T9-NODE-LOCAL-ENTRY-GATED'), 'ineligible boot entries disclose no body');
-});
-test('a `none` project contributes nothing to boot — no body, no name, no hidden count, no shadow', async () => {
-    const boot = renderKnowledgeBlock(await newNode(), freshTranscriptTarget());
-    assert.ok(!boot.includes(B.pnone), 'a none-capped body must not render');
-    assert.ok(!boot.includes('pnone'), 'a none-capped store must not appear as a name either — not even its namespace row');
-    // Hidden counts are disclosure too: the control project's namespace row proves
-    // a bootless doc does surface as a `[+N more]` count, so the none project's
-    // total absence is the cap and not a rendering quirk.
-    assert.match(boot, /pcontent\/\n[^\n]*\[\+\d+ more\]/, `the control project's row 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.
-    // A capped project cannot suppress a document it never shared an identity
-    // with: each store composes its own namespace, so these are distinct names.
-    assert.ok(boot.includes(B.sharedFromPcontent) && !boot.includes(B.sharedFromPnone), `pcontent/t9-shared-doc delivers while the none project contributes nothing; got:\n${boot}`);
-    assert.ok(boot.includes(B.userDupFromUser) && !boot.includes(B.userDupFromPnone), `the unqualified user identity delivers while the none project contributes nothing; got:\n${boot}`);
-});
-test('a capped nearer candidate yields the shared identity instead of suppressing it', async () => {
-    // Two project stores declare the SAME namespace, so `shared/dup-doc` has two
-    // physical candidates. Automatic delivery filters candidates by the profile
-    // cap BEFORE dedupe, so the `none`-capped nearer one drops out and the farther
-    // one delivers; a deliberate read stays winner-only on source order.
-    const boot = renderKnowledgeBlock(await newNode(), freshTranscriptTarget());
-    assert.ok(boot.includes(B.dupFar), `the farther uncapped candidate delivers the shared identity; got:\n${boot}`);
-    assert.ok(!boot.includes(B.dupNear), 'the none-capped nearer candidate delivers nothing');
-    const read = (await readLeaf.run({
-        name: 'shared/dup-doc',
-        kind: undefined,
-        frontmatter: false,
-        scope: undefined,
-        dir: undefined,
-    }));
-    assert.ok(read.content.includes(B.dupNear) && !read.content.includes(B.dupFar), `a deliberate read resolves the source-order winner; got:\n${read.content}`);
-});
-test('a non-none cap keeps its project precedence and discloses the duplicate at the capped rung', async () => {
-    const boot = renderKnowledgeBlock(await newNode(), freshTranscriptTarget());
-    assert.match(boot, /[├└]─ t9-namedup-doc$/m, `the name-capped project discloses its doc as a bare name; got:\n${boot}`);
-    assert.ok(!boot.includes(B.nameFromPname), 'a name-capped doc discloses at `name`, never its body');
-    assert.ok(boot.includes(B.nameFromPcontent), 'the content project delivers its own distinct identity in full');
-});
-test('workspace-open clamps each project store the same way boot does', async () => {
-    const opened = renderWorkspaceOpenDocs(await newNode(), freshTranscriptTarget());
-    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="ppreview\/t9-ppreview-doc" readWhen="When the cwd project delivers\./, `the cwd project delivers its preview line under its canonical name; got:\n${opened}`);
-    assert.match(opened, /name="pname\/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('workspace-open answers its listings from the workspace it opened, not the ambient one', async () => {
-    const node = await newNode();
-    const subject = assembleNodeSubject(node);
-    assert.ok(subject !== null, 'the fixture node assembles a subject');
-    // The process cwd is `ppreview`; this workspace is outside the profile
-    // manifest, so ONLY the opened target's corpus knows its store at all.
-    const opened = renderWorkspaceOpenDocsForSubject(subject, join(home, 'poutside'), profileId, freshTranscriptTarget());
-    assert.ok(opened.includes(B.outsideGuide), `the opened workspace's guide delivers its body; got:\n${opened}`);
-    assert.match(opened, /<memory-listing dir="poutside\/t9-ws-guide">/, `its directory listing renders from that workspace's corpus; got:\n${opened}`);
-    assert.match(opened, /\[\[poutside\/t9-ws-guide\/member-1\]\]: When the outside guide member applies\./, `the listing carries that directory's own members; got:\n${opened}`);
-});
-test('memory list and find record synthetic pages without crediting matched documents', async () => {
-    const node = await newNode();
-    process.env['CRTR_NODE_ID'] = node;
-    try {
-        const listed = await listLeaf.run({
-            kind: undefined,
-            scope: undefined,
-            dir: undefined,
-            paths: false,
-            limit: 50,
-            cursor: undefined,
-        });
-        const found = await findLeaf.run({
-            query: 'ppreview/t9-ppreview-doc',
-            kind: undefined,
-            scope: undefined,
-            dir: undefined,
-            grep: false,
-            body: false,
-            limit: 10,
-            cursor: undefined,
-            minScore: undefined,
-            paths: false,
-        });
-        assert.ok(listed.items.some((item) => item.name === 'ppreview/t9-ppreview-doc'), 'the inventory page listed the fixture document under its canonical name');
-        assert.ok(found.hits.some((hit) => hit.name === 'ppreview/t9-ppreview-doc'), 'the search page matched the fixture document under its canonical name');
-        const state = loadContextExposureState(node);
-        const listingKeys = [...state.exposures.keys()].filter((identity) => identity.startsWith('listing:memory-'));
-        assert.equal(listingKeys.length, 2, 'list and find each register their delivered page');
-        assert.ok(listingKeys.some((identity) => identity.startsWith('listing:memory-list:')));
-        assert.ok(listingKeys.some((identity) => identity.startsWith('listing:memory-find:')));
-        assert.ok(listingKeys.every((identity) => exposedAtOrAbove(state, identity, 'content')), 'each synthetic page is registered at its complete delivered representation');
-        assert.equal(documentExposedAtOrAbove(state, ppreviewDocPath, B.ppreview, 'name'), false, 'inventory metadata and matching lines never claim disclosure of the document itself');
-    }
-    finally {
-        delete process.env['CRTR_NODE_ID'];
-    }
-});
-test('an explicit read after boot content adds no duplicate directory attachments', async () => {
-    const node = await newNode('developer');
-    process.env['CRTR_NODE_ID'] = node;
-    try {
-        const state = loadContextExposureState(node);
-        renderKnowledgeBlock(node, exposureTarget(state, 'transcript'));
-        saveContextExposureState(node, state);
-        const result = (await readLeaf.run({
-            name: 'dev/code-craft',
-            kind: undefined,
-            frontmatter: false,
-            scope: undefined,
-            dir: undefined,
-        }));
-        assert.equal(result.content.trim(), B.codeCraftIndex, 'the repeated read returns its body without a new attachment block');
-        assert.equal(result.listing.length, 10, 'the deliberate directory read still returns its immediate members');
-        const afterRead = loadContextExposureState(node);
-        for (let i = 1; i <= 10; i++) {
-            assert.ok(documentExposedAtOrAbove(afterRead, join(home, '.crouter', 'memory', 'dev', 'code-craft', `member-${i}.md`), `BODY-T9-CODE-CRAFT-MEMBER-${i}`, 'preview'), `boot content registered member ${i} at preview before the explicit read`);
-        }
-    }
-    finally {
-        delete process.env['CRTR_NODE_ID'];
-    }
-});
-test('an explicit `crtr memory read` returns and records the full body a cap withheld', async () => {
-    const node = await newNode();
-    process.env['CRTR_NODE_ID'] = node;
-    const state = loadContextExposureState(node);
-    const transcript = exposureTarget(state, 'transcript');
-    const opened = renderWorkspaceOpenDocs(node, transcript);
-    assert.ok(!opened.includes(B.ppreview), 'workspace-open disclosed the capped doc at preview only');
-    saveContextExposureState(node, state);
-    const result = (await readLeaf.run({
-        name: 'ppreview/t9-ppreview-doc',
-        kind: undefined,
-        frontmatter: false,
-        scope: undefined,
-        dir: undefined,
-    }));
-    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 = loadContextExposureState(node);
-    assert.ok(documentExposedAtOrAbove(afterRead, ppreviewDocPath, B.ppreview, '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, exposureTarget(afterRead, 'transcript')), '', 'a later lower automatic event re-delivers nothing');
-    // A fresh ledger proves the renderer itself is still live.
-    assert.ok(renderWorkspaceOpenDocs(node, freshTranscriptTarget()).includes('ppreview/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

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