@north-light/crouter 0.3.318 → 0.3.319

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

@@ -1,315 +1,9 @@
-// on-read.ts — the pure event-delivery renderers for the document substrate.
-// Each takes a caller-supplied subject; the canvas-db wrappers that resolve
-// one from a node id live in on-read-node.ts, so a consumer that already
-// holds a subject imports this module WITHOUT pulling subject.js's canvas-db
-// reach (the same split as render.ts / render-node.ts).
-//
-// A doc participates through its `surfaces` entries (surface-match.ts owns
-// the per-entry matchers; this module folds them per doc and renders):
-//
-//   • `read` — a successful read tool call evaluates the read file against
-//     every doc's `read` entries: path globs vs the absolute path and
-//     basename, `./`-anchored globs vs the path relative to the doc's store's
-//     owning repo dir (project stores only), `match-frontmatter` vs the read
-//     file's own YAML. Project stores encountered between the file and the
-//     filesystem root join the resolved cwd/profile corpus, so a nested
-//     workspace contributes guidance exactly when a file beneath it is read.
-//   • `workspace-open` — opening a workspace delivers docs carrying a
-//     `workspace-open` entry from every project store mounted by the cwd and
-//     selected profile, while the first-message bearings are assembled — so
-//     workspace-wide context arrives before the task rather than waiting for
-//     an arbitrary first file.
-//   • `command` — a `bash` tool call evaluates the executed command string
-//     against every doc's `command` entries (per shell segment, wildcards at
-//     token granularity — see surface-match.ts).
-//   • `pre-command` — a `bash` tool call ABOUT to run evaluates the same way
-//     against every doc's `pre-command` entries, and the call is held until
-//     the matching docs have been delivered. Because delivery registers
-//     exposure, the agent's re-issue of the same command finds nothing left to
-//     deliver and runs.
-//
-// 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: the plan collapses them to the first one ELIGIBLE for that
-// event, in corpus order.
-//
-// Every selection decision — discovery, gates, the profile cap, the rung fold,
-// the first-wins collapse — belongs to planDelivery (plan.ts). This module is
-// the plan→text adapter: it owns the `<memory>` envelope, the
-// `<auto-loaded-context>` wrapper, and the exposure ledger.
-import { sep } from 'node:path';
-import { realpathOrSelf } from '../fs-utils.js';
-import { ambientMemoryTarget, listAllMemoryDocs, loadMemoryTargetView, } from '../memory-resolver.js';
-import { commandEntryMatches, owningRootOf, preCommandEntryMatches } from './surface-match.js';
-import { demoteDocumentTranscriptExposure, documentExposedAtOrAbove, emptyContextExposureState, exposedAtOrAbove, exposureTarget, registerDocumentExposure, registerExposure, } from './injected-store.js';
-import { planDelivery } from './plan.js';
-import { parseSubstrateDoc, previewLine, rungRank } from './schema.js';
-import { dirDedupKey, docListingDirs, docsByName, isDirName, renderDirListing } from './listings.js';
-import { cachedEventCorpusInclusive } from './session-cache.js';
-function attr(s) {
-    return s
-        .replace(/&/g, '&amp;')
-        .replace(/"/g, '&quot;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
-}
-// 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 owns
-// node-local boot rendering); the active exposure state prevents a lower-rung
-// repeat here.
-function resolvedDocs() {
-    try {
-        return cachedEventCorpusInclusive(listAllMemoryDocs, parseSubstrateDoc);
-    }
-    catch {
-        return [];
-    }
-}
-// 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:
-// agents address memory by name through the command surface, and the explicit
-// read leaf already returns `path`.
-function renderDocEnvelope(doc, rung) {
-    if (rung === 'none')
-        return null;
-    let attrs = `kind="${attr(doc.kind)}" name="${attr(doc.name)}"`;
-    if (rung === 'content') {
-        const body = doc.body.trim();
-        if (body !== '')
-            return `<memory ${attrs}>\n${body}\n</memory>`;
-    }
-    else if (rung === 'preview') {
-        const pl = previewLine(doc);
-        if (pl !== '')
-            attrs += ` readWhen="${attr(pl)}"`;
-    }
-    return `<memory ${attrs} />`;
-}
-function planWinners(plan) {
-    return plan.docs.filter((r) => r.winner).map((r) => ({ doc: r.doc, rung: r.finalRung, source: r.source }));
-}
-/** The listing corpus for one event: every document the plan CONSIDERED, in
- *  the plan's own precedence order. Winners alone are not enough — a bootless
- *  sibling never wins anything, and a store discovered by the read walk is
- *  absent from the ambient corpus entirely, so both would drop out of the
- *  directory the delivered doc sits in. */
-function planListingCorpus(plan) {
-    return docsByName(plan.docs.map(({ source }) => source));
-}
-function listingBlock(dir, lines) {
-    return `<memory-listing dir="${attr(dir)}">\n${lines.join('\n')}\n</memory-listing>`;
-}
-export function deliveryAccounting() {
-    return { deliveries: new Map() };
-}
-export function accountDelivery(accounting, doc, rung, cause, source) {
-    if (accounting === undefined || rung === 'none')
-        return;
-    const key = realpathOrSelf(doc.path);
-    const held = accounting.deliveries.get(key);
-    if (held !== undefined && rungRank(held.rung) >= rungRank(rung))
-        return;
-    accounting.deliveries.set(key, {
-        rung,
-        ...(cause === undefined ? {} : { cause }),
-        ...(source === undefined ? {} : { source }),
-    });
-}
-/** The attachment semantics of a content delivery. Content is read-equivalent:
- * it exposes its own/enclosing directory listings and fires memory-read routes.
- * The exposure ledger makes this finite even when companion routes cycle. */
-export function contentReadAttachments(doc, opts) {
-    const { target, byName } = opts;
-    const dirs = docListingDirs(byName, doc.name);
-    const ownDir = dirs[0] === doc.name;
-    const blocks = [];
-    let listing;
-    for (const [index, dir] of dirs.entries()) {
-        // A directory absent from THIS corpus discloses nothing here, so claiming
-        // its `dir://` identity would tell the ledger a listing rendered that never
-        // did — and silence the channel that would have rendered it.
-        if (!isDirName(byName, dir))
-            continue;
-        const own = ownDir && index === 0;
-        if (!own && exposedAtOrAbove(target.state, dirDedupKey(dir), 'preview'))
-            continue;
-        if (opts.listings === 'tree') {
-            // The caller renders these members and registers the directory only for
-            // the rows it actually emits.
-            opts.dirs?.push(dir);
-            continue;
-        }
-        const explicitOwn = own && opts.explicit === true;
-        const lines = renderDirListing(byName, dir, target, !explicitOwn, (listed) => accountDelivery(opts.accounting, listed, 'preview', 'directory listing attached to content delivery', listed));
-        // An empty listing is not a listing: registering here would claim a render
-        // that produced no line and silence the next channel to reach this dir.
-        if (lines.length === 0)
-            continue;
-        registerExposure(target, dirDedupKey(dir), 'preview');
-        if (explicitOwn)
-            listing = lines;
-        else
-            blocks.push(listingBlock(dir, lines));
-    }
-    blocks.push(...memoryReadDocBlocks(realpathOrSelf(doc.path), doc.name, {
-        ...opts,
-        deliveryCause: 'memory-read companion of content delivery',
-    }));
-    return { blocks, ...(listing === undefined ? {} : { listing }) };
-}
-/** Render the plan's winners that are not already loaded at their matched rung. */
-function renderWinnerBlocks(winners, opts) {
-    const { target } = opts;
-    const rendered = [];
-    for (const { doc, rung, source } of winners) {
-        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);
-        accountDelivery(opts.accounting, doc, rung, opts.deliveryCause, source);
-        if (rung === 'content') {
-            rendered.push(...contentReadAttachments(doc, {
-                ...opts,
-                deliveryCause: 'memory-read companion of content delivery',
-            }).blocks);
-        }
-        rendered.push(block);
-    }
-    return rendered;
-}
-/** The attachment options for one event render: listings inline as blocks,
- *  answered from the event corpus ∪ this plan's own winners. */
-function eventAttachmentOptions(subject, target, plan, accounting) {
-    return { subject, target, byName: planListingCorpus(plan), listings: 'blocks', accounting };
-}
-function transientTranscriptTarget() {
-    return exposureTarget(emptyContextExposureState(), 'transcript');
-}
-function wrapAutoLoaded(blocks) {
-    return blocks.length === 0 ? '' : `<auto-loaded-context>\n${blocks.join('\n')}\n</auto-loaded-context>`;
-}
-/** The corpus-carrying plan for one event. Every renderer here passes the
- *  session-cached corpus so a hook never re-walks the filesystem. */
-function eventPlan(subject, event, payload, memoryTarget) {
-    // An explicit memory target names a workspace other than this process's, so
-    // its corpus is resolved for that target rather than taken from the ambient
-    // session cache.
-    return memoryTarget === undefined
-        ? planDelivery(subject, ambientMemoryTarget(), event, payload, resolvedDocs())
-        : planDelivery(subject, memoryTarget, event, payload);
-}
-/** Surface docs whose `read` entries match a successfully read file, using
- * the caller-supplied daemon snapshot subject. */
-export function renderOnReadDocsForSubject(subject, readFilePath, target = transientTranscriptTarget(), accounting) {
-    const plan = eventPlan(subject, 'read', { absoluteFile: readFilePath });
-    return wrapAutoLoaded(renderWinnerBlocks(planWinners(plan), eventAttachmentOptions(plan.subject, target, plan, accounting)));
-}
-/** Workspace boot docs using the snapshot's cwd/profile instead of a canvas
- * 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 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(), accounting) {
-    const workspaceTarget = { cwd, profileId, nodeId: null };
-    let winners;
-    let byName;
-    try {
-        winners = planWinners(planDelivery(subject, workspaceTarget, 'workspace-open'));
-        // Listings and companion routes answer from the workspace this event
-        // opened — the ambient cwd/profile of the process rendering it is a
-        // different corpus and would disclose another workspace's neighbourhood.
-        // The workspace-open plan considers project stores only, so the listing
-        // corpus is the target's full view rather than the plan's.
-        byName = docsByName(loadMemoryTargetView(workspaceTarget, { quiet: true }).docs);
-    }
-    catch {
-        return '';
-    }
-    // Selection ran on the corpus's PRECEDENCE order, so the nearest store won an
-    // equal-canonical tie; this sort is display order only — outermost workspace
-    // first, so context arrives general before specific.
-    winners.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 wrapAutoLoaded(renderWinnerBlocks(winners, {
-        subject,
-        target,
-        byName,
-        memoryTarget: workspaceTarget,
-        listings: 'blocks',
-        accounting,
-    }));
-}
-/** Inner `<memory>` blocks for the memory-read event: docs whose
- * `memory-read` entries match the doc a `crtr memory read` just resolved
- * (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(excludeRealpath, name, opts) {
-    const plan = eventPlan(opts.subject, 'memory-read', { resolvedCanonicalName: name, resolvedDocPath: excludeRealpath }, opts.memoryTarget);
-    // A caller with no corpus of its own (the `sys context resolve` simulation)
-    // gets this plan's; every nested companion arrives with its parent's corpus
-    // already resolved.
-    return renderWinnerBlocks(planWinners(plan), {
-        ...opts,
-        byName: opts.byName ?? planListingCorpus(plan),
-    });
-}
-/** 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(), accounting) {
-    const plan = eventPlan(subject, 'command', { command });
-    return wrapAutoLoaded(renderWinnerBlocks(planWinners(plan), eventAttachmentOptions(subject, target, plan, accounting)));
-}
-/** Surface docs whose `pre-command` entries match a bash command that has NOT
- * run yet. The exact twin of the post-execution renderer above, and its empty
- * string is load-bearing: `''` means every matching doc is already exposed at
- * its matching rung or above, which is the release — the caller lets the
- * command through. */
-export function renderPreCommandDocsForSubject(subject, command, target = transientTranscriptTarget(), accounting) {
-    const plan = eventPlan(subject, 'pre-command', { command });
-    return wrapAutoLoaded(renderWinnerBlocks(planWinners(plan), eventAttachmentOptions(subject, target, plan, accounting)));
-}
-function carriesPreCommandEntry(doc) {
-    return doc.surfaces.some((entry) => entry.on === 'pre-command');
-}
-function hasCommandSurfaceForCommand(command, event) {
-    const entryMatches = event === 'command' ? commandEntryMatches : preCommandEntryMatches;
-    return resolvedDocs().some(({ doc }) => doc.surfaces.some((entry) => entryMatches(entry, command)));
-}
-/** Whether this command matches a `command` surface before its node-config
- * gate is evaluated. A matching gate still requires a subject lookup. */
-export function corpusHasCommandSurfaceForCommand(command) {
-    return hasCommandSurfaceForCommand(command, 'command');
-}
-/** Whether this command matches a `pre-command` surface before its node-config
- * gate is evaluated. A matching gate still requires a subject lookup. */
-export function corpusHasPreCommandSurfaceForCommand(command) {
-    return hasCommandSurfaceForCommand(command, 'pre-command');
-}
-/** Forget the transcript exposure of every `pre-command` doc, re-arming their
- * holds. Compaction drops delivered guidance out of the transcript while the
- * ledger still claims it was delivered, so without this pass a doc could be
- * held once and then silently absent for the rest of the session. Lives here
- * rather than in the extension because the corpus accessor is private. */
-export function demotePreCommandExposures(state) {
-    for (const { doc } of resolvedDocs()) {
-        if (carriesPreCommandEntry(doc))
-            demoteDocumentTranscriptExposure(state, doc.path, doc.body);
-    }
-}
+var T=Object.defineProperty;var i=(e,n)=>T(e,"name",{value:n,configurable:!0});import{sep as k}from"node:path";import{realpathOrSelf as E}from"../fs-utils.js";import{ambientMemoryTarget as M,listAllMemoryDocs as B,loadMemoryTargetView as P}from"../memory-resolver.js";import{commandEntryMatches as L,owningRootOf as S,preCommandEntryMatches as j}from"./surface-match.js";import{demoteDocumentTranscriptExposure as W,documentExposedAtOrAbove as q,emptyContextExposureState as H,exposedAtOrAbove as I,exposureTarget as K,registerDocumentExposure as V,registerExposure as z}from"./injected-store.js";import{planDelivery as b}from"./plan.js";import{parseSubstrateDoc as G,previewLine as J,rungRank as A}from"./schema.js";import{dirDedupKey as O,docListingDirs as Q,docsByName as $,isDirName as U,renderDirListing as X}from"./listings.js";import{cachedEventCorpusInclusive as Y}from"./session-cache.js";function g(e){return e.replace(/&/g,"&amp;").replace(/"/g,"&quot;").replace(/</g,"&lt;").replace(/>/g,"&gt;")}i(g,"attr");function C(){try{return Y(B,G)}catch{return[]}}i(C,"resolvedDocs");function Z(e,n){if(n==="none")return null;let r=`kind="${g(e.kind)}" name="${g(e.name)}"`;if(n==="content"){const t=e.body.trim();if(t!=="")return`<memory ${r}>
+${t}
+</memory>`}else if(n==="preview"){const t=J(e);t!==""&&(r+=` readWhen="${g(t)}"`)}return`<memory ${r} />`}i(Z,"renderDocEnvelope");function l(e){return e.docs.filter(n=>n.winner).map(n=>({doc:n.doc,rung:n.finalRung,source:n.source}))}i(l,"planWinners");function F(e){return $(e.docs.map(({source:n})=>n))}i(F,"planListingCorpus");function _(e,n){return`<memory-listing dir="${g(e)}">
+${n.join(`
+`)}
+</memory-listing>`}i(_,"listingBlock");function pe(){return{deliveries:new Map}}i(pe,"deliveryAccounting");function N(e,n,r,t,o){if(e===void 0||r==="none")return;const c=E(n.path),a=e.deliveries.get(c);a!==void 0&&A(a.rung)>=A(r)||e.deliveries.set(c,{rung:r,...t===void 0?{}:{cause:t},...o===void 0?{}:{source:o}})}i(N,"accountDelivery");function ee(e,n){const{target:r,byName:t}=n,o=Q(t,e.name),c=o[0]===e.name,a=[];let s;for(const[f,u]of o.entries()){if(!U(t,u))continue;const m=c&&f===0;if(!m&&I(r.state,O(u),"preview"))continue;if(n.listings==="tree"){n.dirs?.push(u);continue}const d=m&&n.explicit===!0,y=X(t,u,r,!d,w=>N(n.accounting,w,"preview","directory listing attached to content delivery",w));y.length!==0&&(z(r,O(u),"preview"),d?s=y:a.push(_(u,y)))}return a.push(...ne(E(e.path),e.name,{...n,deliveryCause:"memory-read companion of content delivery"})),{blocks:a,...s===void 0?{}:{listing:s}}}i(ee,"contentReadAttachments");function p(e,n){const{target:r}=n,t=[];for(const{doc:o,rung:c,source:a}of e){if(q(r.state,o.path,o.body,c))continue;const s=Z(o,c);s!==null&&(V(r,o.path,o.body,c),N(n.accounting,o,c,n.deliveryCause,a),c==="content"&&t.push(...ee(o,{...n,deliveryCause:"memory-read companion of content delivery"}).blocks),t.push(s))}return t}i(p,"renderWinnerBlocks");function D(e,n,r,t){return{subject:e,target:n,byName:F(r),listings:"blocks",accounting:t}}i(D,"eventAttachmentOptions");function h(){return K(H(),"transcript")}i(h,"transientTranscriptTarget");function v(e){return e.length===0?"":`<auto-loaded-context>
+${e.join(`
+`)}
+</auto-loaded-context>`}i(v,"wrapAutoLoaded");function x(e,n,r,t){return t===void 0?b(e,M(),n,r,C()):b(e,t,n,r)}i(x,"eventPlan");function fe(e,n,r=h(),t){const o=x(e,"read",{absoluteFile:n});return v(p(l(o),D(o.subject,r,o,t)))}i(fe,"renderOnReadDocsForSubject");function ye(e,n,r,t=h(),o){const c={cwd:n,profileId:r,nodeId:null};let a,s;try{a=l(b(e,c,"workspace-open")),s=$(P(c,{quiet:!0}).docs)}catch{return""}return a.sort((f,u)=>{const m=S(f.doc)??"",d=S(u.doc)??"";return m.split(k).filter(Boolean).length-d.split(k).filter(Boolean).length||m.localeCompare(d)||f.doc.path.localeCompare(u.doc.path)}),v(p(a,{subject:e,target:t,byName:s,memoryTarget:c,listings:"blocks",accounting:o}))}i(ye,"renderWorkspaceOpenDocsForSubject");function ne(e,n,r){const t=x(r.subject,"memory-read",{resolvedCanonicalName:n,resolvedDocPath:e},r.memoryTarget);return p(l(t),{...r,byName:r.byName??F(t)})}i(ne,"memoryReadDocBlocks");function ge(e,n,r=h(),t){const o=x(e,"command",{command:n});return v(p(l(o),D(e,r,o,t)))}i(ge,"renderOnCommandDocsForSubject");function he(e,n,r=h(),t){const o=x(e,"pre-command",{command:n});return v(p(l(o),D(e,r,o,t)))}i(he,"renderPreCommandDocsForSubject");function re(e){return e.surfaces.some(n=>n.on==="pre-command")}i(re,"carriesPreCommandEntry");function R(e,n){const r=n==="command"?L:j;return C().some(({doc:t})=>t.surfaces.some(o=>r(o,e)))}i(R,"hasCommandSurfaceForCommand");function ve(e){return R(e,"command")}i(ve,"corpusHasCommandSurfaceForCommand");function xe(e){return R(e,"pre-command")}i(xe,"corpusHasPreCommandSurfaceForCommand");function be(e){for(const{doc:n}of C())re(n)&&W(e,n.path,n.body)}i(be,"demotePreCommandExposures");export{N as accountDelivery,ee as contentReadAttachments,ve as corpusHasCommandSurfaceForCommand,xe as corpusHasPreCommandSurfaceForCommand,pe as deliveryAccounting,be as demotePreCommandExposures,ne as memoryReadDocBlocks,ge as renderOnCommandDocsForSubject,fe as renderOnReadDocsForSubject,he as renderPreCommandDocsForSubject,ye as renderWorkspaceOpenDocsForSubject};

package/dist/core/substrate/plan.js

@@ -1,266 +1 @@
-// plan.ts — the pure delivery planner: for one (subject, target, event,
-// payload) tuple it computes the structured per-document delivery decision the
-// renderers turn into text and the inspection commands print as a table. It
-// renders nothing and touches no exposure state.
-//
-// The pipeline has two halves and this module is the UPSTREAM one:
-//
-//   planDelivery (subject,event -> decisions) -> exposure ledger dedup ->
-//   render -> registerDocumentExposure
-//
-// The ledger (injected-store.ts) records what a live context has ALREADY been
-// given; the planner computes what a state WOULD be given. Renderers own the
-// downstream half, so a plan can be computed for a hypothetical subject without
-// disturbing any node's real ledger.
-//
-// Two decisions are event-specific and deliberately so:
-//
-//   • THE PROFILE CAP reaches boot and workspace-open only. Every other event
-//     is reached by an explicit act (a read, a command) and delivers at the
-//     authored rung.
-//   • DEDUP PARTICIPATION differs. At boot every ELIGIBLE document participates
-//     — including one with no boot entry, because the boot catalog counts it
-//     into its directory's `[+N more]` — and the dedup runs per boot partition,
-//     since the boot render emits an independent block per partition. At every
-//     other event only a document that actually DELIVERS participates, so a
-//     nearer document that does not match never suppresses a farther one that
-//     does.
-import { homedir } from 'node:os';
-import { dirname, parse, sep } from 'node:path';
-import { parseFrontmatterGeneric } from '../frontmatter.js';
-import { readText, realpathOrSelf } from '../fs-utils.js';
-import { listProjectMemoryDocs, loadMemoryTargetView, loadStoreMemoryDocs, openProjectMemoryStore, } from '../memory-resolver.js';
-import { userScopeRoot } from '../scope.js';
-import { gatePasses, surfaceEntryGatePasses } from './gate.js';
-import { minRung, parseSubstrateDoc, rungAtLeast, } from './schema.js';
-import { matchingSurfaceEntry, surfaceEntryParticipates } from './surface-match.js';
-/** Which boot block a record belongs to. The node's own store is the catch-all
- *  this-node store and rides into the knowledge block whatever its kind, so a
- *  record's kind alone does not answer this. */
-export function bootPartitionOf(record) {
-    return record.nodeLocal ? 'knowledge' : record.kind;
-}
-/** Plan one event's delivery.
- *
- *  `corpus` is the already-loaded document set. The live renderers pass their
- *  session cache (the corpus is scanned and parsed once per session); an
- *  inspection caller omits it and the planner loads the event's corpus from
- *  `target`. Either way the planner writes nothing. */
-export function planDelivery(subject, target, event, payload = {}, corpus) {
-    const resolved = resolvePayload(event, payload);
-    const considered = considerFor(event, corpus ?? loadEventCorpus(target, event), resolved);
-    const docs = considered.map(({ doc, source }) => decide(doc, source, subject, event, resolved));
-    resolveWinners(event, docs);
-    return { event, subject, target, docs };
-}
-function resolvePayload(event, payload) {
-    if (event !== 'read' || payload.absoluteFile === undefined) {
-        return { ...payload, readFrontmatter: payload.readFrontmatter ?? {} };
-    }
-    const absoluteFile = realpathOrSelf(payload.absoluteFile);
-    return {
-        ...payload,
-        absoluteFile,
-        readFrontmatter: payload.readFrontmatter ?? readFileFrontmatter(absoluteFile),
-    };
-}
-function readFileFrontmatter(absReadFile) {
-    if (!/\.(md|mdx|markdown)$/i.test(absReadFile))
-        return {};
-    try {
-        return parseFrontmatterGeneric(readText(absReadFile)).data ?? {};
-    }
-    catch {
-        return {};
-    }
-}
-// The considered set — the corpus plus the event's own discovery and
-// self-exclusion rules.
-function considerFor(event, corpus, payload) {
-    if (event === 'read') {
-        const abs = payload.absoluteFile;
-        if (abs === undefined)
-            return [...corpus];
-        // Enclosing stores lead: a store discovered from the read file is the
-        // nearest source of an identity the mounted corpus may also carry.
-        return [...enclosingProjectDocs(abs), ...corpus].filter(({ doc }) => realpathOrSelf(doc.path) !== abs);
-    }
-    if (event === 'memory-read' && payload.resolvedDocPath !== undefined) {
-        const exclude = payload.resolvedDocPath;
-        return corpus.filter(({ doc }) => realpathOrSelf(doc.path) !== exclude);
-    }
-    return [...corpus];
-}
-const JUNK_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache', '.yalc']);
-function isJunkAncestor(dir) {
-    return dir.split(sep).some((segment) => JUNK_DIRS.has(segment));
-}
-/** 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 out = [];
-    const seen = new Set();
-    const home = realpathOrSelf(homedir());
-    const userRoot = realpathOrSelf(userScopeRoot());
-    const fsRoot = parse(absReadFile).root;
-    let dir = dirname(absReadFile);
-    while (true) {
-        if (dir !== home && dir !== userRoot && !isJunkAncestor(dir)) {
-            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)
-                        out.push({ doc, source });
-                }
-            }
-        }
-        if (dir === home || dir === fsRoot)
-            break;
-        const parent = dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return out;
-}
-/** The event's corpus for a target, for callers that hold no session cache.
- *  Boot orders node-local docs LAST so a resolver document keeps its identity
- *  against a same-named node-local one; workspace-open sees project stores
- *  only; every other event sees the whole mounted corpus. */
-function loadEventCorpus(target, event) {
-    const sources = event === 'workspace-open'
-        ? listProjectMemoryDocs(target.cwd, target.profileId)
-        : loadMemoryTargetView(target, { quiet: true }).docs;
-    const parsed = [];
-    for (const source of sources) {
-        const doc = parseSubstrateDoc(source);
-        if (doc !== null)
-            parsed.push({ doc, source });
-    }
-    if (event !== 'boot')
-        return parsed;
-    return [
-        ...parsed.filter((e) => e.doc.scope !== 'node'),
-        ...parsed.filter((e) => e.doc.scope === 'node'),
-    ];
-}
-// The per-document decision.
-function decide(doc, source, subject, event, payload) {
-    const match = {
-        absoluteFile: payload.absoluteFile,
-        readFrontmatter: payload.readFrontmatter,
-        resolvedCanonicalName: payload.resolvedCanonicalName,
-        routingAnchor: source.routingAnchor,
-        command: payload.command,
-    };
-    const docGate = documentGateOutcome(doc, subject);
-    const authoredEntries = doc.surfaces
-        .filter((entry) => entry.on === event)
-        .map((entry) => ({
-        entry,
-        matched: surfaceEntryParticipates(entry, doc, subject, event, match),
-        gate: entryGateOutcome(entry, subject),
-    }));
-    const matchedEntry = matchingSurfaceEntry(doc, subject, event, match);
-    const authoredRung = matchedEntry?.at ?? 'none';
-    const nodeLocal = doc.scope === 'node';
-    const capped = event === 'boot' || event === 'workspace-open';
-    const projectMemoryCap = capped && !nodeLocal ? doc.projectMemory : null;
-    const cappedRung = projectMemoryCap === null ? authoredRung : minRung(authoredRung, projectMemoryCap);
-    let finalRung = docGate.pass ? cappedRung : 'none';
-    // The one rung FLOOR, scoped to the node store at boot: a node-local doc with
-    // no boot entry still shows its bare name rather than collapsing into its
-    // directory's hidden count. A node-local doc whose boot entries all fail
-    // stays absent.
-    if (event === 'boot' &&
-        nodeLocal &&
-        docGate.pass &&
-        !rungAtLeast(finalRung, 'name') &&
-        !doc.surfaces.some((entry) => entry.on === 'boot')) {
-        finalRung = 'name';
-    }
-    return {
-        name: doc.name,
-        kind: doc.kind,
-        scope: doc.scope,
-        storePath: doc.path,
-        nodeLocal,
-        authoredEntries,
-        matchedEntry,
-        authoredRung,
-        projectMemoryCap,
-        cappedRung,
-        docGate,
-        entryGate: recordEntryGate(authoredEntries, matchedEntry),
-        finalRung,
-        winner: false,
-        shadowedBy: null,
-        doc,
-        source,
-    };
-}
-/** A missing subject cannot satisfy a gate, so a gated document is skipped and
- *  an ungated one still delivers. A predicate that throws excludes only its own
- *  document — never the whole render. */
-function documentGateOutcome(doc, subject) {
-    if (doc.gate === undefined)
-        return { pass: true };
-    if (subject === null)
-        return { pass: false, reason: 'gated document with no node config to match' };
-    try {
-        return gatePasses(doc, subject)
-            ? { pass: true }
-            : { pass: false, reason: 'document gate does not match this node config' };
-    }
-    catch (err) {
-        return { pass: false, reason: `document gate failed to evaluate: ${String(err)}` };
-    }
-}
-function entryGateOutcome(entry, subject) {
-    if (entry.gate === undefined)
-        return { pass: true };
-    return surfaceEntryGatePasses(entry, subject)
-        ? { pass: true }
-        : { pass: false, reason: 'entry gate does not match this node config' };
-}
-function recordEntryGate(entries, matched) {
-    if (entries.length === 0)
-        return null;
-    if (matched !== null)
-        return { pass: true };
-    const gatedOut = entries.find((e) => !e.gate.pass);
-    return gatedOut === undefined ? { pass: true } : gatedOut.gate;
-}
-// Winner resolution — first-win by canonical name over the corpus's precedence
-// order, within the event's participating set.
-function participates(record, event) {
-    if (!record.docGate.pass)
-        return false;
-    // Boot counts an eligible document even when it delivers nothing, because the
-    // catalog tree still counts it. A `none` cap removes the document from the
-    // corpus entirely, so it cannot shadow a wider-scope document either.
-    if (event === 'boot')
-        return record.projectMemoryCap !== 'none';
-    return rungAtLeast(record.finalRung, 'name');
-}
-function resolveWinners(event, docs) {
-    const winners = new Map();
-    for (const record of docs) {
-        if (!participates(record, event))
-            continue;
-        const key = event === 'boot' ? `${bootPartitionOf(record)}:${record.name}` : record.name;
-        const held = winners.get(key);
-        if (held === undefined) {
-            winners.set(key, record);
-            record.winner = true;
-            continue;
-        }
-        record.shadowedBy = { name: held.name, scope: held.scope, path: held.storePath };
-    }
-}
+var P=Object.defineProperty;var a=(e,t)=>P(e,"name",{value:t,configurable:!0});import{homedir as b}from"node:os";import{dirname as w,parse as k,sep as S}from"node:path";import{parseFrontmatterGeneric as R}from"../frontmatter.js";import{readText as D,realpathOrSelf as l}from"../fs-utils.js";import{listProjectMemoryDocs as G,loadMemoryTargetView as M,loadStoreMemoryDocs as E,openProjectMemoryStore as x}from"../memory-resolver.js";import{userScopeRoot as C}from"../scope.js";import{gatePasses as O,surfaceEntryGatePasses as A}from"./gate.js";import{minRung as $,parseSubstrateDoc as F,rungAtLeast as y}from"./schema.js";import{matchingSurfaceEntry as L,surfaceEntryParticipates as N}from"./surface-match.js";function B(e){return e.nodeLocal?"knowledge":e.kind}a(B,"bootPartitionOf");function ie(e,t,n,o={},r){const s=I(n,o),u=T(n,r??K(t,n),s).map(({doc:c,source:f})=>U(c,f,e,n,s));return Q(n,u),{event:n,subject:e,target:t,docs:u}}a(ie,"planDelivery");function I(e,t){if(e!=="read"||t.absoluteFile===void 0)return{...t,readFrontmatter:t.readFrontmatter??{}};const n=l(t.absoluteFile);return{...t,absoluteFile:n,readFrontmatter:t.readFrontmatter??J(n)}}a(I,"resolvePayload");function J(e){if(!/\.(md|mdx|markdown)$/i.test(e))return{};try{return R(D(e)).data??{}}catch{return{}}}a(J,"readFileFrontmatter");function T(e,t,n){if(e==="read"){const o=n.absoluteFile;return o===void 0?[...t]:[...q(o),...t].filter(({doc:r})=>l(r.path)!==o)}if(e==="memory-read"&&n.resolvedDocPath!==void 0){const o=n.resolvedDocPath;return t.filter(({doc:r})=>l(r.path)!==o)}return[...t]}a(T,"considerFor");const _=new Set(["node_modules",".git","dist","build",".next",".cache",".yalc"]);function j(e){return e.split(S).some(t=>_.has(t))}a(j,"isJunkAncestor");function q(e){const t=[],n=new Set,o=l(b()),r=l(C()),s=k(e).root;let i=w(e);for(;;){if(i!==o&&i!==r&&!j(i)){const c=x(i);if(c.mountStatus==="ready"&&!n.has(c.storeRoot)){n.add(c.storeRoot);for(const f of E(c,!0)){const m=F(f);m!==null&&t.push({doc:m,source:f})}}}if(i===o||i===s)break;const u=w(i);if(u===i)break;i=u}return t}a(q,"enclosingProjectDocs");function K(e,t){const n=t==="workspace-open"?G(e.cwd,e.profileId):M(e,{quiet:!0}).docs,o=[];for(const r of n){const s=F(r);s!==null&&o.push({doc:s,source:r})}return t!=="boot"?o:[...o.filter(r=>r.doc.scope!=="node"),...o.filter(r=>r.doc.scope==="node")]}a(K,"loadEventCorpus");function U(e,t,n,o,r){const s={absoluteFile:r.absoluteFile,readFrontmatter:r.readFrontmatter,resolvedCanonicalName:r.resolvedCanonicalName,routingAnchor:t.routingAnchor,command:r.command},i=V(e,n),u=e.surfaces.filter(d=>d.on===o).map(d=>({entry:d,matched:N(d,e,n,o,s),gate:W(d,n)})),c=L(e,n,o,s),f=c?.at??"none",m=e.scope==="node",p=(o==="boot"||o==="workspace-open")&&!m?e.projectMemory:null,g=p===null?f:$(f,p);let h=i.pass?g:"none";return o==="boot"&&m&&i.pass&&!y(h,"name")&&!e.surfaces.some(d=>d.on==="boot")&&(h="name"),{name:e.name,kind:e.kind,scope:e.scope,storePath:e.path,nodeLocal:m,authoredEntries:u,matchedEntry:c,authoredRung:f,projectMemoryCap:p,cappedRung:g,docGate:i,entryGate:z(u,c),finalRung:h,winner:!1,shadowedBy:null,doc:e,source:t}}a(U,"decide");function V(e,t){if(e.gate===void 0)return{pass:!0};if(t===null)return{pass:!1,reason:"gated document with no node config to match"};try{return O(e,t)?{pass:!0}:{pass:!1,reason:"document gate does not match this node config"}}catch(n){return{pass:!1,reason:`document gate failed to evaluate: ${String(n)}`}}}a(V,"documentGateOutcome");function W(e,t){return e.gate===void 0?{pass:!0}:A(e,t)?{pass:!0}:{pass:!1,reason:"entry gate does not match this node config"}}a(W,"entryGateOutcome");function z(e,t){if(e.length===0)return null;if(t!==null)return{pass:!0};const n=e.find(o=>!o.gate.pass);return n===void 0?{pass:!0}:n.gate}a(z,"recordEntryGate");function H(e,t){return e.docGate.pass?t==="boot"?e.projectMemoryCap!=="none":y(e.finalRung,"name"):!1}a(H,"participates");function Q(e,t){const n=new Map;for(const o of t){if(!H(o,e))continue;const r=e==="boot"?`${B(o)}:${o.name}`:o.name,s=n.get(r);if(s===void 0){n.set(r,o),o.winner=!0;continue}o.shadowedBy={name:s.name,scope:s.scope,path:s.storePath}}}a(Q,"resolveWinners");export{B as bootPartitionOf,ie as planDelivery};

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

@@ -1,30 +1 @@
-// render-node.ts — the CANVAS-DB wrappers over the pure boot-render functions.
-// `renderPreferencesSection` and `renderKnowledgeBlock` take a node id, assemble
-// its subject from the canvas-db (assembleNodeSubject), then delegate to the
-// pure render fns in render.ts. Split out of render.ts so a CLI consumer that
-// only needs the pure `*ForSubject` fns imports render.js WITHOUT pulling
-// subject.js's canvas-db reach. Broker/daemon-side callers (bearings.ts,
-// 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
- *  the node's subject from the canvas-db, render the pure splice, then swap the
- *  literal `$CRTR_CONTEXT_DIR` env-var token for the node's real absolute path
- *  so agents don't paste it into the non-expanding Write tool (see
- *  interpolateNodePaths). A null subject (unknown id) still renders the
- *  always-present memory-usage guidance frame. */
-export function renderPreferencesSection(nodeId) {
-    const subject = assembleNodeSubject(nodeId);
-    return interpolateNodePaths(renderPreferencesForSubject(subject).block, nodeId);
-}
-/** 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, target);
-}
+var c=Object.defineProperty;var t=(e,r)=>c(e,"name",{value:r,configurable:!0});import{interpolateNodePaths as u}from"../canvas/paths.js";import{assembleNodeSubject as n}from"./subject.js";import{emptyContextExposureState as s,exposureTarget as p}from"./injected-store.js";import{renderPreferencesForSubject as i,renderKnowledgeForSubject as m}from"./render.js";function x(e){const r=n(e);return u(i(r).block,e)}t(x,"renderPreferencesSection");function S(e,r=p(s(),"transcript")){const o=n(e);return o===null?"":m(o,e,r)}t(S,"renderKnowledgeBlock");export{S as renderKnowledgeBlock,x as renderPreferencesSection};