@north-light/crouter 0.3.227 → 0.3.228

package/dist/core/substrate/injected-store.js

@@ -1,121 +1,225 @@
-// injected-store.ts — durable per-node dedup map for substrate doc delivery.
-//
-// Delivery channels (boot render seeding, workspace-open, on-read, memory-read
-// listings and events, command events) dedup so a given doc surfaces at most
-// once per conversation AT A GIVEN DISCLOSURE. The map keys on realpath and
-// carries the highest rung rank delivered so far; higher rungs pierce lower —
-// a listing line (preview rank) must not block a later explicit content
-// delivery, while a content delivery silences everything after it. Directory
-// listings participate under the directory's own realpath (a directory never
-// collides with a file's realpath).
-//
-// The map USED to live only in the pi process heap, cleared on session_start.
-// But a node's logical session — the .jsonl transcript — spans MULTIPLE pi
-// processes: a dormancy → revive(resume) cycle exits the old process and
-// launches a fresh `pi --session` that REUSES the same transcript. This module
-// persists the map to `nodes/<id>/injected-docs.json` so the resumed process
-// rehydrates it and skips docs already present in the transcript. The one
-// launch path that begins a FRESH transcript (reviveNode with resume=false, in
-// runtime/revive.ts) calls clearInjectedDocs(), so a new conversation starts
-// empty. CLI processes (the `memory read` leaf) load/save the same file.
-//
-// Disk format: `{"v":2,"docs":{"<realpath>":<rank 1|2|3>}}` (rank =
-// rungRank of the delivered rung). A legacy v1 string-array rehydrates at
-// content rank — its entries were recorded under never-re-deliver semantics.
-//
-// All ops are best-effort: a failed read/write degrades to a possible
-// re-inject, never a crash — a dedup miss must never break a read or a revive.
-import { readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { injectedDocsPath } from '../canvas/paths.js';
+import { atomicWriteJson, realpathOrSelf } from '../fs-utils.js';
 import { rungRank } from './schema.js';
-/** Already delivered at `rung` or above? — the skip test every channel runs
- *  before rendering a doc (or a listing line, at preview) again. */
-export function deliveredAtOrAbove(seen, realpath, rung) {
-    const have = seen.get(realpath);
-    return have !== undefined && have >= rungRank(rung);
-}
-/** Record a delivery at `rung`, keeping the highest rank seen. */
-export function recordDelivery(seen, realpath, rung) {
+const CONTENT_RANK = rungRank('content');
+const cache = new Map();
+export function emptyContextExposureState() {
+    return { preferenceSnapshot: null, exposures: new Map() };
+}
+export function exposureTarget(state, source) {
+    return { state, source };
+}
+function validRank(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= CONTENT_RANK;
+}
+function activeRank(ranks) {
+    return Math.max(ranks?.system ?? 0, ranks?.transcript ?? 0);
+}
+export function exposedAtOrAbove(state, identity, rung) {
+    return activeRank(state.exposures.get(identity)) >= rungRank(rung);
+}
+/** The sole delivery mutation: max-fold one loaded identity into its source rank. */
+export function registerExposure(target, identity, rung) {
     const rank = rungRank(rung);
-    const have = seen.get(realpath);
-    if (have === undefined || have < rank)
-        seen.set(realpath, rank);
-}
-/** Max-merge `source` into `target` — used to fold an out-of-process delivery
- *  (the daemon's warm-spare bearings push) into a live process's shared map. */
-export function mergeInjectedDocs(target, source) {
-    for (const [real, rank] of source) {
-        const have = target.get(real);
-        if (have === undefined || have < rank)
-            target.set(real, rank);
+    if (rank === 0)
+        return;
+    const current = target.state.exposures.get(identity) ?? {};
+    if ((current[target.source] ?? 0) >= rank)
+        return;
+    target.state.exposures.set(identity, { ...current, [target.source]: rank });
+}
+export function contentExposureIdentity(body) {
+    const canonical = body.trim();
+    return canonical === ''
+        ? null
+        : `content-sha256:${createHash('sha256').update(canonical).digest('hex')}`;
+}
+export function documentExposedAtOrAbove(state, path, body, rung) {
+    if (exposedAtOrAbove(state, realpathOrSelf(path), rung))
+        return true;
+    const contentIdentity = contentExposureIdentity(body);
+    return contentIdentity !== null && exposedAtOrAbove(state, contentIdentity, rung);
+}
+/** Register both the physical document and its non-empty content alias. */
+export function registerDocumentExposure(target, path, body, rung) {
+    registerExposure(target, realpathOrSelf(path), rung);
+    const contentIdentity = contentExposureIdentity(body);
+    if (contentIdentity !== null)
+        registerExposure(target, contentIdentity, rung);
+}
+export function freezePreferenceSnapshot(state, rendered) {
+    if (state.preferenceSnapshot === null)
+        state.preferenceSnapshot = rendered;
+    return state.preferenceSnapshot;
+}
+export function cloneContextExposureState(source) {
+    return {
+        preferenceSnapshot: source.preferenceSnapshot,
+        exposures: new Map([...source.exposures].map(([identity, ranks]) => [identity, { ...ranks }])),
+    };
+}
+export function hasTranscriptExposure(state) {
+    return [...state.exposures.values()].some((ranks) => validRank(ranks.transcript));
+}
+/** The context copied into a fork excludes the source's system snapshot. */
+export function cloneTranscriptExposureState(source) {
+    const clone = emptyContextExposureState();
+    const transcript = exposureTarget(clone, 'transcript');
+    for (const [identity, ranks] of source.exposures) {
+        const rank = ranks.transcript;
+        if (!validRank(rank))
+            continue;
+        registerExposure(transcript, identity, rank === 1 ? 'name' : rank === 2 ? 'preview' : 'content');
     }
+    return clone;
 }
-/** Per-process cache behind `sharedInjectedDocs`: one Map instance per node,
- *  shared by every extension in the pi process (context-intro's workspace-open
- *  render and doc-substrate's on-read hook), so a doc delivered by one hook is
- *  already in the map the other dedups against. */
-const cache = new Map();
-/** The process-shared dedup map for a node: loaded from disk once, then the
- *  SAME Map instance on every call, so all hooks in this pi process grow and
- *  consult one map. Daemon-side deliveries (a warm-spare claim) write the disk
- *  file from another process; consumers that must see those merge the plain
- *  `loadInjectedDocs` result in before rendering. */
-export function sharedInjectedDocs(nodeId) {
-    let seen = cache.get(nodeId);
-    if (seen === undefined) {
-        seen = loadInjectedDocs(nodeId);
-        cache.set(nodeId, seen);
+export function replaceContextExposureState(target, source) {
+    target.preferenceSnapshot = source.preferenceSnapshot;
+    target.exposures.clear();
+    for (const [identity, ranks] of source.exposures) {
+        target.exposures.set(identity, { ...ranks });
     }
-    return seen;
 }
-const CONTENT_RANK = rungRank('content');
-/** Rehydrate a node's dedup map from disk. Returns an empty map when the file
- *  is absent, unreadable, or malformed (a fresh transcript, or a node that has
- *  not yet surfaced any doc). */
-export function loadInjectedDocs(nodeId) {
+export function contextExposureStatesEqual(left, right) {
+    if (left.preferenceSnapshot !== right.preferenceSnapshot || left.exposures.size !== right.exposures.size)
+        return false;
+    for (const [identity, ranks] of left.exposures) {
+        const other = right.exposures.get(identity);
+        if (ranks.system !== other?.system || ranks.transcript !== other?.transcript)
+            return false;
+    }
+    return true;
+}
+/** Fold state written by another process into the live context state. */
+export function mergeContextExposureState(target, source) {
+    if (target.preferenceSnapshot !== null &&
+        source.preferenceSnapshot !== null &&
+        target.preferenceSnapshot !== source.preferenceSnapshot) {
+        throw new Error('context exposure state contains conflicting preference snapshots');
+    }
+    if (target.preferenceSnapshot === null && source.preferenceSnapshot !== null) {
+        target.preferenceSnapshot = source.preferenceSnapshot;
+    }
+    for (const [identity, ranks] of source.exposures) {
+        const current = target.exposures.get(identity) ?? {};
+        const system = Math.max(current.system ?? 0, ranks.system ?? 0);
+        const transcript = Math.max(current.transcript ?? 0, ranks.transcript ?? 0);
+        target.exposures.set(identity, {
+            ...(system > 0 ? { system } : {}),
+            ...(transcript > 0 ? { transcript } : {}),
+        });
+    }
+}
+export function sharedContextExposureState(nodeId) {
+    let state = cache.get(nodeId);
+    if (state === undefined) {
+        state = loadContextExposureState(nodeId);
+        cache.set(nodeId, state);
+    }
+    return state;
+}
+/** v1/v2 ranks predate provenance and conservatively become transcript exposure. */
+export function loadContextExposureState(nodeId) {
+    const path = injectedDocsPath(nodeId);
+    let raw;
     try {
-        const raw = JSON.parse(readFileSync(injectedDocsPath(nodeId), 'utf8'));
-        const out = new Map();
-        if (Array.isArray(raw)) {
-            // legacy v1: bare realpath array, never-re-deliver semantics
-            for (const x of raw)
-                if (typeof x === 'string')
-                    out.set(x, CONTENT_RANK);
-            return out;
+        raw = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return emptyContextExposureState();
+        throw new Error(`failed to read context exposure state at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const state = emptyContextExposureState();
+    const transcript = exposureTarget(state, 'transcript');
+    if (Array.isArray(raw)) {
+        for (const identity of raw) {
+            if (typeof identity !== 'string')
+                throw new Error(`invalid v1 context exposure state at ${path}`);
+            registerExposure(transcript, identity, 'content');
+        }
+        return state;
+    }
+    if (raw === null || typeof raw !== 'object') {
+        throw new Error(`invalid context exposure state at ${path}`);
+    }
+    const record = raw;
+    if (record['v'] === 3) {
+        const preferenceSnapshot = record['preferenceSnapshot'];
+        const exposures = record['exposures'];
+        if ((preferenceSnapshot !== null && typeof preferenceSnapshot !== 'string') ||
+            exposures === null ||
+            typeof exposures !== 'object' ||
+            Array.isArray(exposures)) {
+            throw new Error(`invalid v3 context exposure state at ${path}`);
         }
-        if (raw !== null && typeof raw === 'object') {
-            const docs = raw.docs;
-            if (docs !== null && typeof docs === 'object' && !Array.isArray(docs)) {
-                for (const [real, rank] of Object.entries(docs)) {
-                    if (typeof rank === 'number' && rank >= 1 && rank <= CONTENT_RANK)
-                        out.set(real, rank);
-                }
+        state.preferenceSnapshot = preferenceSnapshot;
+        for (const [identity, value] of Object.entries(exposures)) {
+            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+                throw new Error(`invalid v3 exposure entry '${identity}' at ${path}`);
+            }
+            const ranks = value;
+            const system = ranks['system'];
+            const transcriptRank = ranks['transcript'];
+            if ((system !== undefined && !validRank(system)) ||
+                (transcriptRank !== undefined && !validRank(transcriptRank)) ||
+                (system === undefined && transcriptRank === undefined)) {
+                throw new Error(`invalid v3 exposure ranks for '${identity}' at ${path}`);
             }
+            state.exposures.set(identity, {
+                ...(validRank(system) ? { system } : {}),
+                ...(validRank(transcriptRank) ? { transcript: transcriptRank } : {}),
+            });
         }
-        return out;
-    }
-    catch {
-        return new Map();
+        return state;
     }
-}
-/** Persist a node's dedup map. Called after each delivery that grew it, so
- *  the grown map survives a later dormancy. */
-export function saveInjectedDocs(nodeId, seen) {
-    try {
-        writeFileSync(injectedDocsPath(nodeId), JSON.stringify({ v: 2, docs: Object.fromEntries(seen) }));
+    if (record['v'] !== 2)
+        throw new Error(`unsupported context exposure state at ${path}`);
+    const docs = record['docs'];
+    if (docs === null || typeof docs !== 'object' || Array.isArray(docs)) {
+        throw new Error(`invalid v2 context exposure state at ${path}`);
     }
-    catch {
-        // best-effort — a failed persist only risks a re-inject, never a crash
+    for (const [identity, rank] of Object.entries(docs)) {
+        if (!validRank(rank))
+            throw new Error(`invalid v2 exposure rank for '${identity}' at ${path}`);
+        registerExposure(transcript, identity, rank === 1 ? 'name' : rank === 2 ? 'preview' : 'content');
     }
+    return state;
 }
-/** Drop a node's persisted dedup map. Called by the launch paths that start a
- *  FRESH transcript, so the new conversation surfaces docs from scratch. */
-export function clearInjectedDocs(nodeId) {
-    cache.delete(nodeId);
-    try {
-        rmSync(injectedDocsPath(nodeId), { force: true });
-    }
-    catch {
-        // ignore — absence is the desired state anyway
+export function saveContextExposureState(nodeId, state) {
+    atomicWriteJson(injectedDocsPath(nodeId), {
+        v: 3,
+        preferenceSnapshot: state.preferenceSnapshot,
+        exposures: Object.fromEntries(state.exposures),
+    });
+}
+/** Clear in place so every extension closure observes the new context boundary. */
+export function clearContextExposureState(nodeId) {
+    const live = cache.get(nodeId);
+    if (live !== undefined)
+        replaceContextExposureState(live, emptyContextExposureState());
+    rmSync(injectedDocsPath(nodeId), { force: true });
+}
+/** Seed a fork with only context copied in the source transcript. */
+export function initializeForkContextExposure(destinationNodeId, sourceNodeId) {
+    if (existsSync(injectedDocsPath(destinationNodeId))) {
+        const existing = loadContextExposureState(destinationNodeId);
+        const live = cache.get(destinationNodeId);
+        if (live === undefined)
+            cache.set(destinationNodeId, existing);
+        else
+            replaceContextExposureState(live, existing);
+        return;
     }
+    const destination = sourceNodeId === null
+        ? emptyContextExposureState()
+        : cloneTranscriptExposureState(loadContextExposureState(sourceNodeId));
+    const live = cache.get(destinationNodeId);
+    if (live === undefined)
+        cache.set(destinationNodeId, destination);
+    else
+        replaceContextExposureState(live, destination);
+    saveContextExposureState(destinationNodeId, destination);
 }

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

@@ -1,21 +1,28 @@
 import type { MemoryDoc } from '../memory-resolver.js';
-import { type InjectedDocs } from './injected-store.js';
-/** Dedup key for a whole directory's listing. Realpath keys start with `/`,
- *  so the scheme prefix never collides with a doc entry. */
+import { type ExposureTarget } from './injected-store.js';
+/** Exposure identity for a whole directory listing. Realpath identities start
+ *  with `/`, so the scheme prefix never collides with a document. */
 export declare function dirDedupKey(dir: string): string;
 /** First-occurrence-wins name map over a precedence-ordered corpus: the doc
  *  that renders a name's line is the doc a read of that name would return. */
 export declare function docsByName(corpus: readonly MemoryDoc[]): Map<string, MemoryDoc>;
-/** Is `name` a directory in the merged name tree — i.e. does any doc live
- *  beneath it? The corpus root ('') is never a directory here: store roots
- *  merge into the whole catalog, which `memory list` owns. */
+/** Is `name` a directory in the merged name tree — i.e. does it have members?
+ *  A doc that fronts a directory answers true here and still returns its own
+ *  body, because one node carries both. The corpus root ('') is never a
+ *  directory here: store roots merge into the whole catalog, which
+ *  `memory list` owns. */
 export declare function isDirName(byName: ReadonlyMap<string, MemoryDoc>, name: string): boolean;
 /** The dirs a doc read discloses: the doc's own directory, then each ancestor
  *  walking up, the root excluded. `a/b/c` → `['a/b', 'a']`. */
 export declare function ancestorDirsOf(name: string): string[];
-/** Render one directory's listing lines: `[[name]]: <when-and-why>` per
- *  member doc (bare `[[name]]` when the doc carries no routing line), a bare
- *  `[[name]]` per subdirectory. `unlisted` members are omitted always;
- *  `filterDelivered` additionally drops members already delivered at preview
- *  rank or higher. Rendered members record at preview rank into `seen`. */
-export declare function renderDirListing(byName: ReadonlyMap<string, MemoryDoc>, dir: string, seen: InjectedDocs | null, filterDelivered: boolean): string[];
+/** The listings a read of `name` discloses, in render order: the node's own
+ *  listing first when it has members (a directory document's members belong
+ *  with its body), then each ancestor walking up. */
+export declare function docListingDirs(byName: ReadonlyMap<string, MemoryDoc>, name: string): string[];
+/** Render one directory's listing lines: `[[name]]: <when-and-why>` per member
+ *  (bare `[[name]]` when it carries no routing line), childless members first
+ *  and subdirectories after. `unlisted` members are omitted always;
+ *  `filterDelivered` additionally drops members already exposed at preview rank
+ *  or higher. A subdirectory always keeps its row — it advertises a subtree, so
+ *  an omitted preview leaves the bare name. */
+export declare function renderDirListing(byName: ReadonlyMap<string, MemoryDoc>, dir: string, target: ExposureTarget | null, filterDelivered: boolean): string[];

package/dist/core/substrate/listings.js

@@ -1,24 +1,26 @@
-// listings.ts — system-owned directory listings over the merged name tree.
+// listings.ts — system-owned directory listings over the canonical tree.
 //
 // Reading a doc discloses where it sits: `ls` semantics over the corpus
 // namespace (directories merge across stores), consulting no frontmatter
-// except `unlisted`. A listing renders one when-and-why line per member doc
-// and one bare name per subdirectory — never recursive contents, never gates.
+// except `unlisted`. A listing renders one when-and-why line per member,
+// including a subdirectory that carries its own document — never recursive
+// contents, never gates. Structure comes from `memory/tree.ts`, so a directory
+// document and its members are one row rather than two.
 //
 // Two render modes share one function. An EXPLICIT directory read (`crtr
 // memory read <dir>`) is a deliberate act, so every line renders (unlisted
 // excluded) — mirroring how an explicit doc read always returns content. The
 // AUTOMATIC neighborhood listings a doc read prepends are unsolicited, so
-// each member line dedup-filters against the transcript set and whole
-// directories dedup under a synthetic `dir://<name>` key (a name-tree
+// each member line filters against the active exposure ledger and each whole
+// directory registers a synthetic `dir://<name>` identity (a name-tree
 // directory spans stores, so no single physical realpath identifies it).
-// Either mode records rendered member docs at preview rank — a listing line
-// IS a preview-rank render — when a dedup map is supplied.
-import { realpathOrSelf } from '../fs-utils.js';
+// Either mode registers rendered member docs at preview rank when a target is
+// supplied, because a listing line is a preview-rank render.
+import { buildMemoryTree } from '../memory/tree.js';
 import { parseSubstrateDoc, previewLine } from './schema.js';
-import { deliveredAtOrAbove, recordDelivery } from './injected-store.js';
-/** Dedup key for a whole directory's listing. Realpath keys start with `/`,
- *  so the scheme prefix never collides with a doc entry. */
+import { documentExposedAtOrAbove, registerDocumentExposure, } from './injected-store.js';
+/** Exposure identity for a whole directory listing. Realpath identities start
+ *  with `/`, so the scheme prefix never collides with a document. */
 export function dirDedupKey(dir) {
     return `dir://${dir}`;
 }
@@ -31,17 +33,25 @@ export function docsByName(corpus) {
             byName.set(d.name, d);
     return byName;
 }
-/** Is `name` a directory in the merged name tree — i.e. does any doc live
- *  beneath it? The corpus root ('') is never a directory here: store roots
- *  merge into the whole catalog, which `memory list` owns. */
+/** One tree per winner map. A single read asks about its own directory, each
+ *  ancestor, and every `[[link]]` in its body; rebuilding the tree per question
+ *  would walk the whole corpus each time. */
+const trees = new WeakMap();
+function treeFor(byName) {
+    const cached = trees.get(byName);
+    if (cached !== undefined)
+        return cached;
+    const tree = buildMemoryTree([...byName.values()]);
+    trees.set(byName, tree);
+    return tree;
+}
+/** Is `name` a directory in the merged name tree — i.e. does it have members?
+ *  A doc that fronts a directory answers true here and still returns its own
+ *  body, because one node carries both. The corpus root ('') is never a
+ *  directory here: store roots merge into the whole catalog, which
+ *  `memory list` owns. */
 export function isDirName(byName, name) {
-    if (name === '')
-        return false;
-    const prefix = name + '/';
-    for (const n of byName.keys())
-        if (n.startsWith(prefix))
-            return true;
-    return false;
+    return name !== '' && treeFor(byName).isDirectory(name);
 }
 /** The dirs a doc read discloses: the doc's own directory, then each ancestor
  *  walking up, the root excluded. `a/b/c` → `['a/b', 'a']`. */
@@ -52,37 +62,50 @@ export function ancestorDirsOf(name) {
         dirs.push(segs.slice(0, i).join('/'));
     return dirs;
 }
-/** Render one directory's listing lines: `[[name]]: <when-and-why>` per
- *  member doc (bare `[[name]]` when the doc carries no routing line), a bare
- *  `[[name]]` per subdirectory. `unlisted` members are omitted always;
- *  `filterDelivered` additionally drops members already delivered at preview
- *  rank or higher. Rendered members record at preview rank into `seen`. */
-export function renderDirListing(byName, dir, seen, filterDelivered) {
-    const prefix = dir + '/';
-    const memberLines = new Map();
-    const subdirs = new Set();
-    for (const [name, doc] of byName) {
-        if (!name.startsWith(prefix))
-            continue;
-        const rest = name.slice(prefix.length);
-        const slash = rest.indexOf('/');
-        if (slash >= 0) {
-            subdirs.add(rest.slice(0, slash));
-            continue;
-        }
-        const sub = parseSubstrateDoc(doc);
-        if (sub?.unlisted)
-            continue;
-        const real = realpathOrSelf(doc.path);
-        if (filterDelivered && seen !== null && deliveredAtOrAbove(seen, real, 'preview'))
+/** The listings a read of `name` discloses, in render order: the node's own
+ *  listing first when it has members (a directory document's members belong
+ *  with its body), then each ancestor walking up. */
+export function docListingDirs(byName, name) {
+    return [...(isDirName(byName, name) ? [name] : []), ...ancestorDirsOf(name)];
+}
+/** The when-and-why suffix a doc contributes to its line, or null when it must
+ *  not preview here: `unlisted` always, and under `filterDelivered` a doc
+ *  already in this context at preview rank or higher. A rendered preview IS a
+ *  preview-rank delivery, so it registers. */
+function previewSuffix(doc, target, filterDelivered) {
+    const sub = parseSubstrateDoc(doc);
+    if (sub?.unlisted)
+        return null;
+    if (filterDelivered &&
+        target !== null &&
+        documentExposedAtOrAbove(target.state, doc.path, doc.body, 'preview'))
+        return null;
+    if (target !== null)
+        registerDocumentExposure(target, doc.path, doc.body, 'preview');
+    return sub === null ? '' : previewLine(sub);
+}
+function line(name, suffix) {
+    return suffix === null || suffix === '' ? `[[${name}]]` : `[[${name}]]: ${suffix}`;
+}
+/** Render one directory's listing lines: `[[name]]: <when-and-why>` per member
+ *  (bare `[[name]]` when it carries no routing line), childless members first
+ *  and subdirectories after. `unlisted` members are omitted always;
+ *  `filterDelivered` additionally drops members already exposed at preview rank
+ *  or higher. A subdirectory always keeps its row — it advertises a subtree, so
+ *  an omitted preview leaves the bare name. */
+export function renderDirListing(byName, dir, target, filterDelivered) {
+    const node = treeFor(byName).node(dir);
+    if (node === null)
+        return [];
+    const lines = [];
+    for (const member of node.childDocuments) {
+        const suffix = previewSuffix(member.document, target, filterDelivered);
+        if (suffix === null)
             continue;
-        const line = sub === null ? '' : previewLine(sub);
-        memberLines.set(rest, line === '' ? `[[${name}]]` : `[[${name}]]: ${line}`);
-        if (seen !== null)
-            recordDelivery(seen, real, 'preview');
+        lines.push(line(member.name, suffix));
+    }
+    for (const sub of node.childDirectories) {
+        lines.push(line(sub.name, sub.document === null ? null : previewSuffix(sub.document, target, filterDelivered)));
     }
-    return [
-        ...[...memberLines.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([, l]) => l),
-        ...[...subdirs].sort((a, b) => a.localeCompare(b)).map((s) => `[[${prefix}${s}]]`),
-    ];
+    return lines;
 }

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

@@ -1,9 +1,6 @@
-import type { InjectedDocs } from './injected-store.js';
+import { type ExposureTarget } from './injected-store.js';
 /** Surface docs matched by a successful read tool call. An unknown node id or
  *  an unreadable canvas renders nothing. */
-export declare function renderOnReadDocs(nodeId: string, readFilePath: string, seen?: InjectedDocs): string;
-/** Surface workspace-wide docs during first-message assembly, using the node's
- *  recorded cwd and selected profile: docs in mounted project stores carrying
- *  a `workspace-open` surfaces entry deliver here. `seen` is the
- *  transcript-scoped dedup set shared with the on-read hook. */
-export declare function renderWorkspaceOpenDocs(nodeId: string, seen?: InjectedDocs): string;
+export declare function renderOnReadDocs(nodeId: string, readFilePath: string, target?: ExposureTarget): string;
+/** Surface matching workspace-open docs from the node's mounted project stores. */
+export declare function renderWorkspaceOpenDocs(nodeId: string, target?: ExposureTarget): string;

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

@@ -4,11 +4,12 @@
 // that already holds a subject imports on-read.js without subject.js's
 // canvas-db reach.
 import { getNode } from '../canvas/index.js';
+import { emptyContextExposureState, exposureTarget, } from './injected-store.js';
 import { assembleNodeSubject } from './subject.js';
 import { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject } from './on-read.js';
 /** Surface docs matched by a successful read tool call. An unknown node id or
  *  an unreadable canvas renders nothing. */
-export function renderOnReadDocs(nodeId, readFilePath, seen = new Map()) {
+export function renderOnReadDocs(nodeId, readFilePath, target = exposureTarget(emptyContextExposureState(), 'transcript')) {
     let subject;
     try {
         subject = assembleNodeSubject(nodeId);
@@ -18,19 +19,16 @@ export function renderOnReadDocs(nodeId, readFilePath, seen = new Map()) {
     }
     if (subject === null)
         return '';
-    return renderOnReadDocsForSubject(subject, readFilePath, seen);
+    return renderOnReadDocsForSubject(subject, readFilePath, target);
 }
-/** Surface workspace-wide docs during first-message assembly, using the node's
- *  recorded cwd and selected profile: docs in mounted project stores carrying
- *  a `workspace-open` surfaces entry deliver here. `seen` is the
- *  transcript-scoped dedup set shared with the on-read hook. */
-export function renderWorkspaceOpenDocs(nodeId, seen = new Map()) {
+/** Surface matching workspace-open docs from the node's mounted project stores. */
+export function renderWorkspaceOpenDocs(nodeId, target = exposureTarget(emptyContextExposureState(), 'transcript')) {
     try {
         const subject = assembleNodeSubject(nodeId);
         const node = getNode(nodeId);
         if (subject === null || node === null)
             return '';
-        return renderWorkspaceOpenDocsForSubject(subject, node.cwd, node.profile_id ?? null, seen);
+        return renderWorkspaceOpenDocsForSubject(subject, node.cwd, node.profile_id ?? null, target);
     }
     catch {
         return '';