@north-light/crouter 0.3.226 → 0.3.228

package/dist/core/substrate/on-read.d.ts

@@ -1,36 +1,33 @@
-import { type InjectedDocs } from './injected-store.js';
+import { type ExposureTarget } from './injected-store.js';
 import { type Rung, type SubstrateDoc } from './schema.js';
 import type { NodeConfigSubject } from './subject-fields.js';
-/** Render candidates at their matched rungs, gate-checked and deduped against
- *  the transcript set (higher rungs pierce lower; a delivery records at its
- *  rendered rung). A `null` subject means no node identity is available for
- *  gate evaluation: gated docs are skipped, ungated docs still deliver. */
-export declare function renderCandidateBlocks(subject: NodeConfigSubject | null, candidates: Array<{
+interface EventCandidate {
     doc: SubstrateDoc;
     rung: Rung;
-}>, seen: InjectedDocs): string[];
+}
+/** Render the selected candidates not already loaded at their matched rung. */
+export declare function renderCandidateBlocks(subject: NodeConfigSubject | null, candidates: EventCandidate[], target: ExposureTarget): string[];
 /** Surface docs whose `read` entries match a successfully read file, using
  * the caller-supplied daemon snapshot subject. */
-export declare function renderOnReadDocsForSubject(subject: NodeConfigSubject, readFilePath: string, seen?: InjectedDocs): string;
+export declare function renderOnReadDocsForSubject(subject: NodeConfigSubject, readFilePath: string, target?: ExposureTarget): string;
 /** Workspace boot docs using the snapshot's cwd/profile instead of a canvas
- * lookup. `seen` is the transcript-scoped dedup set shared with the on-read
- * hook, so a front door delivered here never re-delivers on a later read
- * beneath its store.
+ * lookup. The shared exposure target prevents a later read from repeating a
+ * document already loaded here.
  *
  * Each candidate's authored rung is clamped to its project's profile
- * relationship cap BEFORE the `none` filter, the ordering, the render, and the
- * seen-map recording — so a capped doc never renders above its cap, a `none`
- * project contributes nothing, and a later explicit `crtr memory read` can
- * still upgrade what workspace-open disclosed at a lower rung. */
-export declare function renderWorkspaceOpenDocsForSubject(subject: NodeConfigSubject, cwd: string, profileId: string | null, seen?: InjectedDocs): string;
+ * relationship cap BEFORE filtering, ordering, rendering, and exposure
+ * registration. A later explicit `crtr memory read` can still raise a document
+ * that workspace-open disclosed at a lower rung. */
+export declare function renderWorkspaceOpenDocsForSubject(subject: NodeConfigSubject, cwd: string, profileId: string | null, target?: ExposureTarget): string;
 /** Inner `<memory>` blocks for the memory-read event: docs whose
  * `memory-read` entries match the doc a `crtr memory read` just resolved
- * (known by `targetNames`; `excludeRealpath` keeps the resolved doc from
- * delivering itself). Returns unwrapped blocks — the read leaf composes one
- * `<auto-loaded-context>` envelope from these plus the directory listings. */
-export declare function memoryReadDocBlocks(subject: NodeConfigSubject | null, excludeRealpath: string, targetNames: string[], seen: InjectedDocs): string[];
-/** Surface docs whose `command` entries match an executed bash command
- * string. The corpus is the resolved cwd/profile set only — a command has no
- * file to walk enclosing stores from. `seen` is the same transcript-scoped
- * dedup set as the other channels. */
-export declare function renderOnCommandDocsForSubject(subject: NodeConfigSubject, command: string, seen?: InjectedDocs): string;
+ * (known by its exact canonical `name` — no mount-stripped or other alias;
+ * `excludeRealpath` keeps the resolved doc from delivering itself). Returns
+ * unwrapped blocks — the read leaf composes one `<auto-loaded-context>`
+ * envelope from these plus the directory listings. */
+export declare function memoryReadDocBlocks(subject: NodeConfigSubject | null, excludeRealpath: string, name: string, target: ExposureTarget): string[];
+/** Surface docs whose `command` entries match an executed bash command.
+ * The corpus is the resolved cwd/profile set; a command has no file from which
+ * to discover enclosing project stores. */
+export declare function renderOnCommandDocsForSubject(subject: NodeConfigSubject, command: string, target?: ExposureTarget): string;
+export {};

package/dist/core/substrate/on-read.js

@@ -22,24 +22,24 @@
 //   • `command` — a `bash` tool call evaluates the executed command string
 //     against every doc's `command` entries (string globs, `*` crossing `/`).
 //
-// All channels share one transcript-scoped (realpath → rung rank) dedup set,
-// so a doc delivered by one never re-delivers at the same or lower rung
-// through another. Each candidate renders at its matched rung — the highest
-// `at` over its matching entries for the event.
-import { createHash } from 'node:crypto';
+// All channels register through one context exposure target, so a document
+// already loaded at the same or a higher rung does not repeat. Each candidate
+// renders at the highest rung matched by that event.
+//
+// Equal-canonical candidates (the same identity in two physical stores) do not
+// each deliver: `selectEventCandidates` collapses them to the first one
+// ELIGIBLE for that event, in source order.
 import { homedir } from 'node:os';
-import { dirname, parse, relative, sep } from 'node:path';
-import { CRTR_DIR_NAME } from '../../types.js';
-import { pathExists, readText, walkFiles } from '../fs-utils.js';
+import { dirname, parse, sep } from 'node:path';
+import { readText, realpathOrSelf } from '../fs-utils.js';
 import { parseFrontmatterGeneric } from '../frontmatter.js';
-import { listAllMemoryDocs, listProjectMemoryDocs } from '../memory-resolver.js';
-import { NEUTRAL_PROJECT_MEMORY, userScopeRoot } from '../scope.js';
+import { listAllMemoryDocs, listProjectMemoryDocs, loadStoreMemoryDocs, openProjectMemoryStore } from '../memory-resolver.js';
+import { userScopeRoot } from '../scope.js';
 import { gatePasses } from './gate.js';
 import { commandDeliveryRung, memoryReadDeliveryRung, owningRootOf, readDeliveryRung, workspaceOpenRung } from './surface-match.js';
-import { deliveredAtOrAbove, recordDelivery } from './injected-store.js';
-import { minRung, normalizeDocName, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, resolveDocName } from './schema.js';
-import { cachedSubstrateDocsInclusive } from './session-cache.js';
-import { realpathOrSelf } from '../fs-utils.js';
+import { documentExposedAtOrAbove, emptyContextExposureState, exposureTarget, registerDocumentExposure, } from './injected-store.js';
+import { minRung, parseSubstrateDoc, previewLine } from './schema.js';
+import { cachedEventCorpusInclusive } from './session-cache.js';
 const JUNK_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache', '.yalc']);
 function attr(s) {
     return s
@@ -51,46 +51,14 @@ function attr(s) {
 function isJunkAncestor(dir) {
     return dir.split(sep).some((segment) => JUNK_DIRS.has(segment));
 }
-function loadProjectDoc(file, memoryDir) {
-    try {
-        const raw = relative(memoryDir, file)
-            .replace(/\.md$/i, '')
-            .split(sep)
-            .join('/');
-        const fallbackName = normalizeDocName(raw);
-        if (fallbackName === '')
-            return null;
-        const { data, body } = parseFrontmatterGeneric(readText(file));
-        const schema = parseSubstrateFrontmatter(data);
-        if (schema === null)
-            return null;
-        return {
-            ...schema,
-            name: resolveDocName(data, fallbackName),
-            scope: 'project',
-            path: file,
-            body,
-            // The read event is uncapped by design: this walk is reached only by an
-            // explicit file read, never by automatic boot/workspace-open delivery.
-            projectMemory: NEUTRAL_PROJECT_MEMORY,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function safeWalkMarkdown(dir) {
-    try {
-        return walkFiles(dir, (name) => name.toLowerCase().endsWith('.md'));
-    }
-    catch {
-        return [];
-    }
-}
-/** Project docs from every workspace store enclosing the read file. This is a
- * discovery walk only: each returned doc must still match an explicit trigger. */
+/** Project docs from every workspace store enclosing the read file, nearest
+ * first. This is a discovery walk only: each returned doc must still match an
+ * explicit trigger. A store that declares no namespace does not mount here
+ * either — an unmounted store has no canonical identities to deliver under.
+ * The stores carry the neutral ceiling: the read event is uncapped by design,
+ * reached only by an explicit file read. */
 function enclosingProjectDocs(absReadFile) {
-    const docs = [];
+    const out = [];
     const seen = new Set();
     const home = realpathOrSelf(homedir());
     const userRoot = realpathOrSelf(userScopeRoot());
@@ -98,16 +66,13 @@ function enclosingProjectDocs(absReadFile) {
     let dir = dirname(absReadFile);
     while (true) {
         if (dir !== home && dir !== userRoot && !isJunkAncestor(dir)) {
-            const memoryDir = `${dir}${sep}${CRTR_DIR_NAME}${sep}memory`;
-            if (pathExists(memoryDir)) {
-                for (const file of safeWalkMarkdown(memoryDir)) {
-                    const real = realpathOrSelf(file);
-                    if (seen.has(real))
-                        continue;
-                    seen.add(real);
-                    const doc = loadProjectDoc(file, memoryDir);
+            const store = openProjectMemoryStore(dir);
+            if (store.mountStatus === 'ready' && !seen.has(store.storeRoot)) {
+                seen.add(store.storeRoot);
+                for (const source of loadStoreMemoryDocs(store, true)) {
+                    const doc = parseSubstrateDoc(source);
                     if (doc !== null)
-                        docs.push(doc);
+                        out.push({ doc, source });
                 }
             }
         }
@@ -118,33 +83,21 @@ function enclosingProjectDocs(absReadFile) {
             break;
         dir = parent;
     }
-    return docs;
+    return out;
 }
 // The event corpus INCLUDES node-scope docs: surfaces entries are explicit
 // authored routing, so a node-local doc's read/memory-read/command entry
 // fires like any other store's. Only boot excludes node scope (render.ts's
-// nodeLocalDocs owns node-local boot rendering); the shared dedup set keeps
-// a boot-rendered doc from re-delivering below its rung here.
+// nodeLocalDocs owns node-local boot rendering); the active exposure state
+// prevents a lower-rung repeat here.
 function resolvedDocs() {
     try {
-        return cachedSubstrateDocsInclusive(listAllMemoryDocs, parseSubstrateDoc);
+        return cachedEventCorpusInclusive(listAllMemoryDocs, parseSubstrateDoc);
     }
     catch {
         return [];
     }
 }
-function dedupeByPhysicalPath(docs) {
-    const seen = new Set();
-    const out = [];
-    for (const doc of docs) {
-        const real = realpathOrSelf(doc.path);
-        if (seen.has(real))
-            continue;
-        seen.add(real);
-        out.push(doc);
-    }
-    return out;
-}
 function readFileFrontmatter(absReadFile) {
     if (!/\.(md|mdx|markdown)$/i.test(absReadFile))
         return {};
@@ -155,14 +108,6 @@ function readFileFrontmatter(absReadFile) {
         return {};
     }
 }
-/** Content-identity dedup key, or null for an empty body (name-only docs
- *  must not collide with each other). */
-function docContentKey(doc) {
-    const body = doc.body.trim();
-    if (body === '')
-        return null;
-    return `content-sha256:${createHash('sha256').update(body).digest('hex')}`;
-}
 // Two shapes: element-with-body means the content is here; self-closing means
 // it is not — a preview carries its routing line as `readWhen` metadata so the
 // one-liner can never be mistaken for the document's content. No disk path:
@@ -184,66 +129,77 @@ function renderDocEnvelope(doc, rung) {
     }
     return `<memory ${attrs} />`;
 }
-/** Render candidates at their matched rungs, gate-checked and deduped against
- *  the transcript set (higher rungs pierce lower; a delivery records at its
- *  rendered rung). A `null` subject means no node identity is available for
- *  gate evaluation: gated docs are skipped, ungated docs still deliver. */
-export function renderCandidateBlocks(subject, candidates, seen) {
-    const rendered = [];
-    for (const { doc, rung } of candidates) {
-        const real = realpathOrSelf(doc.path);
-        // Byte-identical bodies at different paths (a cloned repo's store) inform
-        // once; the content key shares the realpath map and its rung semantics.
-        const contentKey = docContentKey(doc);
-        if (deliveredAtOrAbove(seen, real, rung))
-            continue;
-        if (contentKey !== null && deliveredAtOrAbove(seen, contentKey, rung))
+/** The eligible candidate per canonical identity, in the caller's SOURCE order.
+ * Kind and mount are settled by the loader and the profile cap by the caller's
+ * rung fold, so what remains is the document gate over candidates the event
+ * already gave a delivering rung. A nearer candidate that is gated off or does
+ * not deliver never suppresses a farther one — the filter runs before the
+ * first-wins collapse, not after it.
+ *
+ * A `null` subject skips gated documents and still delivers ungated ones. */
+function selectEventCandidates(subject, candidates) {
+    const selected = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const { doc, rung } = candidate;
+        if (rung === 'none' || seen.has(doc.name))
             continue;
         try {
             if (subject === null ? doc.gate !== undefined : !gatePasses(doc, subject))
                 continue;
-            const block = renderDocEnvelope(doc, rung);
-            if (block === null)
-                continue;
-            recordDelivery(seen, real, rung);
-            if (contentKey !== null)
-                recordDelivery(seen, contentKey, rung);
-            rendered.push(block);
         }
         catch {
             continue;
         }
+        seen.add(doc.name);
+        selected.push(candidate);
+    }
+    return selected;
+}
+/** Render the selected candidates not already loaded at their matched rung. */
+export function renderCandidateBlocks(subject, candidates, target) {
+    const rendered = [];
+    for (const { doc, rung } of selectEventCandidates(subject, candidates)) {
+        if (documentExposedAtOrAbove(target.state, doc.path, doc.body, rung))
+            continue;
+        const block = renderDocEnvelope(doc, rung);
+        if (block === null)
+            continue;
+        registerDocumentExposure(target, doc.path, doc.body, rung);
+        rendered.push(block);
     }
     return rendered;
 }
-function renderCandidates(subject, candidates, seen) {
-    const rendered = renderCandidateBlocks(subject, candidates, seen);
+function transientTranscriptTarget() {
+    return exposureTarget(emptyContextExposureState(), 'transcript');
+}
+function renderCandidates(subject, candidates, target) {
+    const rendered = renderCandidateBlocks(subject, candidates, target);
     return rendered.length === 0
         ? ''
         : `<auto-loaded-context>\n${rendered.join('\n')}\n</auto-loaded-context>`;
 }
 /** Surface docs whose `read` entries match a successfully read file, using
  * the caller-supplied daemon snapshot subject. */
-export function renderOnReadDocsForSubject(subject, readFilePath, seen = new Map()) {
+export function renderOnReadDocsForSubject(subject, readFilePath, target = transientTranscriptTarget()) {
     const absReadFile = realpathOrSelf(readFilePath);
     const readFrontmatter = readFileFrontmatter(absReadFile);
-    const candidates = dedupeByPhysicalPath([...enclosingProjectDocs(absReadFile), ...resolvedDocs()])
-        .filter((doc) => realpathOrSelf(doc.path) !== absReadFile)
-        .map((doc) => ({ doc, rung: readDeliveryRung(doc, subject, absReadFile, readFrontmatter) }))
-        .filter(({ rung }) => rung !== 'none');
-    return renderCandidates(subject, candidates, seen);
+    // Enclosing stores lead: a store discovered from the read file is the nearest
+    // source of an identity the mounted corpus may also carry.
+    const candidates = [...enclosingProjectDocs(absReadFile), ...resolvedDocs()]
+        .filter(({ doc }) => realpathOrSelf(doc.path) !== absReadFile)
+        .map(({ doc }) => ({ doc, rung: readDeliveryRung(doc, subject, absReadFile, readFrontmatter) }));
+    return renderCandidates(subject, candidates, target);
 }
 /** Workspace boot docs using the snapshot's cwd/profile instead of a canvas
- * lookup. `seen` is the transcript-scoped dedup set shared with the on-read
- * hook, so a front door delivered here never re-delivers on a later read
- * beneath its store.
+ * lookup. The shared exposure target prevents a later read from repeating a
+ * document already loaded here.
  *
  * Each candidate's authored rung is clamped to its project's profile
- * relationship cap BEFORE the `none` filter, the ordering, the render, and the
- * seen-map recording — so a capped doc never renders above its cap, a `none`
- * project contributes nothing, and a later explicit `crtr memory read` can
- * still upgrade what workspace-open disclosed at a lower rung. */
-export function renderWorkspaceOpenDocsForSubject(subject, cwd, profileId, seen = new Map()) {
+ * relationship cap BEFORE filtering, ordering, rendering, and exposure
+ * registration. A later explicit `crtr memory read` can still raise a document
+ * that workspace-open disclosed at a lower rung. */
+export function renderWorkspaceOpenDocsForSubject(subject, cwd, profileId, target = transientTranscriptTarget()) {
     let docs;
     try {
         docs = listProjectMemoryDocs(cwd, profileId)
@@ -253,36 +209,36 @@ export function renderWorkspaceOpenDocsForSubject(subject, cwd, profileId, seen
     catch {
         return '';
     }
-    const candidates = dedupeByPhysicalPath(docs)
-        .map((doc) => ({ doc, rung: minRung(workspaceOpenRung(doc, subject), doc.projectMemory) }))
-        .filter(({ rung }) => rung !== 'none')
-        .sort((a, b) => {
+    // Selection runs on the corpus's SOURCE order, so the nearest store wins an
+    // equal-canonical tie; the sort below is display order only — outermost
+    // workspace first, so context arrives general before specific.
+    const ordered = selectEventCandidates(subject, docs.map((doc) => ({ doc, rung: minRung(workspaceOpenRung(doc, subject), doc.projectMemory) }))).sort((a, b) => {
         const aRoot = owningRootOf(a.doc) ?? '';
         const bRoot = owningRootOf(b.doc) ?? '';
         const depth = aRoot.split(sep).filter(Boolean).length - bRoot.split(sep).filter(Boolean).length;
         return depth || aRoot.localeCompare(bRoot) || a.doc.path.localeCompare(b.doc.path);
     });
-    return renderCandidates(subject, candidates, seen);
+    return renderCandidates(subject, ordered, target);
 }
 /** Inner `<memory>` blocks for the memory-read event: docs whose
  * `memory-read` entries match the doc a `crtr memory read` just resolved
- * (known by `targetNames`; `excludeRealpath` keeps the resolved doc from
- * delivering itself). Returns unwrapped blocks — the read leaf composes one
- * `<auto-loaded-context>` envelope from these plus the directory listings. */
-export function memoryReadDocBlocks(subject, excludeRealpath, targetNames, seen) {
-    const candidates = dedupeByPhysicalPath(resolvedDocs())
-        .filter((doc) => realpathOrSelf(doc.path) !== excludeRealpath)
-        .map((doc) => ({ doc, rung: memoryReadDeliveryRung(doc, subject, targetNames) }))
-        .filter(({ rung }) => rung !== 'none');
-    return renderCandidateBlocks(subject, candidates, seen);
-}
-/** Surface docs whose `command` entries match an executed bash command
- * string. The corpus is the resolved cwd/profile set only — a command has no
- * file to walk enclosing stores from. `seen` is the same transcript-scoped
- * dedup set as the other channels. */
-export function renderOnCommandDocsForSubject(subject, command, seen = new Map()) {
-    const candidates = dedupeByPhysicalPath(resolvedDocs())
-        .map((doc) => ({ doc, rung: commandDeliveryRung(doc, subject, command) }))
-        .filter(({ rung }) => rung !== 'none');
-    return renderCandidates(subject, candidates, seen);
+ * (known by its exact canonical `name` — no mount-stripped or other alias;
+ * `excludeRealpath` keeps the resolved doc from delivering itself). Returns
+ * unwrapped blocks — the read leaf composes one `<auto-loaded-context>`
+ * envelope from these plus the directory listings. */
+export function memoryReadDocBlocks(subject, excludeRealpath, name, target) {
+    const candidates = resolvedDocs()
+        .filter(({ doc }) => realpathOrSelf(doc.path) !== excludeRealpath)
+        .map(({ doc, source }) => ({
+        doc,
+        rung: memoryReadDeliveryRung(doc, source.routingAnchor, subject, name),
+    }));
+    return renderCandidateBlocks(subject, candidates, target);
+}
+/** Surface docs whose `command` entries match an executed bash command.
+ * The corpus is the resolved cwd/profile set; a command has no file from which
+ * to discover enclosing project stores. */
+export function renderOnCommandDocsForSubject(subject, command, target = transientTranscriptTarget()) {
+    const candidates = resolvedDocs().map(({ doc }) => ({ doc, rung: commandDeliveryRung(doc, subject, command) }));
+    return renderCandidates(subject, candidates, target);
 }

package/dist/core/substrate/render-node.d.ts

@@ -1,4 +1,4 @@
-import type { InjectedDocs } from './injected-store.js';
+import { type ExposureTarget } from './injected-store.js';
 /** The system-prompt substrate splice for `nodeId` — shipped-layer protocol
  *  prose followed by the `<memory kind="preference">` block: assemble
  *  the node's subject from the canvas-db, render the pure splice, then swap the
@@ -7,9 +7,6 @@ import type { InjectedDocs } from './injected-store.js';
  *  interpolateNodePaths). A null subject (unknown id) still renders the
  *  always-present memory-usage guidance frame. */
 export declare function renderPreferencesSection(nodeId: string): string;
-/** The first-message `<memory kind="knowledge">` block for `nodeId`: assemble
- *  the node's subject from the canvas-db and render the consultable catalog.
- *  Returns '' for an unknown id or when nothing is eligible. `seen` (optional,
- *  write-only) receives each rendered doc at its displayed rung — boot
- *  delivery seeding for the transcript dedup map. */
-export declare function renderKnowledgeBlock(nodeId: string, seen?: InjectedDocs): string;
+/** The first-message `<memory kind="knowledge">` block for `nodeId`. Rendered
+ * documents register at their displayed rung through `target`. */
+export declare function renderKnowledgeBlock(nodeId: string, target?: ExposureTarget): string;

package/dist/core/substrate/render-node.js

@@ -7,6 +7,7 @@
 // canvas-doc-substrate.ts) import these — the canvas-db read is fine there.
 import { interpolateNodePaths } from '../canvas/paths.js';
 import { assembleNodeSubject } from './subject.js';
+import { emptyContextExposureState, exposureTarget, } from './injected-store.js';
 import { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
 /** The system-prompt substrate splice for `nodeId` — shipped-layer protocol
  *  prose followed by the `<memory kind="preference">` block: assemble
@@ -19,14 +20,11 @@ export function renderPreferencesSection(nodeId) {
     const subject = assembleNodeSubject(nodeId);
     return interpolateNodePaths(renderPreferencesForSubject(subject).block, nodeId);
 }
-/** The first-message `<memory kind="knowledge">` block for `nodeId`: assemble
- *  the node's subject from the canvas-db and render the consultable catalog.
- *  Returns '' for an unknown id or when nothing is eligible. `seen` (optional,
- *  write-only) receives each rendered doc at its displayed rung — boot
- *  delivery seeding for the transcript dedup map. */
-export function renderKnowledgeBlock(nodeId, seen) {
+/** The first-message `<memory kind="knowledge">` block for `nodeId`. Rendered
+ * documents register at their displayed rung through `target`. */
+export function renderKnowledgeBlock(nodeId, target = exposureTarget(emptyContextExposureState(), 'transcript')) {
     const subject = assembleNodeSubject(nodeId);
     if (subject === null)
         return '';
-    return renderKnowledgeForSubject(subject, nodeId, seen);
+    return renderKnowledgeForSubject(subject, nodeId, target);
 }

package/dist/core/substrate/render.d.ts

@@ -1,7 +1,15 @@
-import { type InjectedDocs } from './injected-store.js';
+import { type ExposureTarget } from './injected-store.js';
 import { type SubstrateDoc } from './schema.js';
 import type { NodeConfigSubject } from './subject-fields.js';
-export declare function renderPreferencesForSubject(subject: NodeConfigSubject | null, seen?: InjectedDocs): {
+/** The computed "sub-personas you may spawn" menu for a subject's kind — the
+ *  live restoration of the old `personas/resolve.ts` static menu, now derived
+ *  at render time from the merged kind registry (`subKindsAvailableTo`) so it
+ *  can never drift from `sys prompt-review --list`'s `subPersonas` metadata.
+ *  Returns '' when the kind has zero available sub-kinds (no dangling empty
+ *  header). Emitted for BOTH base and orchestrator modes per the CTO's ruling —
+ *  mode is irrelevant to which sub-kinds are spawnable. */
+export declare function buildSubPersonaMenu(kind: string): string;
+export declare function renderPreferencesForSubject(subject: NodeConfigSubject | null, target?: ExposureTarget): {
     block: string;
     contentDocs: SubstrateDoc[];
     tree: string;
@@ -19,4 +27,14 @@ export declare function renderPreferencesForSubject(subject: NodeConfigSubject |
  *  docs never reach the `content` rung). Procedural guidance and factual
  *  references both live here as `knowledge`. Returns '' when nothing is
  *  eligible. */
-export declare function renderKnowledgeForSubject(subject: NodeConfigSubject, nodeId: string, seen?: InjectedDocs): string;
+export declare function renderKnowledgeForSubject(subject: NodeConfigSubject, nodeId: string, target?: ExposureTarget): string;
+/** What a node's configuration change newly exposes, rendered as up to three
+ *  blocks in one string: the shipped protocol prose, a `<memory kind="preference">`
+ *  block, and a `<memory kind="knowledge">` block — each dropped when empty, ''
+ *  when the change exposes nothing.
+ *
+ *  Both kinds use the current subject's ordinary winner assembly, then compare
+ *  against the active exposure maximum. A lower rung or removal yields nothing
+ *  because content already loaded into this context cannot be withdrawn.
+ *  Rendered deltas register as transcript exposure through `target`. */
+export declare function renderConfigChangeDelta(subject: NodeConfigSubject, nodeId: string, target: ExposureTarget): string;