@north-light/crouter 0.3.352 → 0.3.354

package/dist/core/memory-resolver.d.ts

@@ -1,280 +0,0 @@
-import { type InstalledPlugin, type Scope } from '../types.js';
-import type { ProfileProjectMemory } from '../api/dto/profiles.js';
-import { type DocRepresentation } from './memory/identity.js';
-/**
- * Memory-document loading and resolution for the document substrate.
- *
- * Every document belongs to exactly one physical STORE. A store declares a
- * namespace — a project's `namespace:` on its root `INDEX.md`, an installed
- * plugin's mount prefix, or empty for user/profile/node/builtin — and every
- * document's CANONICAL name is that namespace composed with the document's
- * store-local name (see memory/identity.ts). The canonical name is the only
- * address: resolution compares the normalized query with canonical identities
- * and nothing else. There is no physical-path pass, no bare-leaf pass, no
- * scope-prefixed spelling, and no `<dir>/INDEX` address — a trailing `INDEX`
- * segment collapses, so a directory's own document answers at the directory
- * name and `memory find` is the discovery surface when the name is unknown.
- *
- * A project store whose repository root carries no valid `namespace:` does not mount: its
- * documents are absent from every target view, and its descriptor carries the
- * `crtr sys migrate --dir <repository root>` remedy. Exact-store inspection
- * (`openProjectMemoryStore` + `loadMemoryStoreView`) still loads it, which is
- * what lint and migration diagnose an unmounted store through.
- *
- * Two views exist over the same loader:
- *   - a TARGET view — the ordered source stack of one cwd/profile/node
- *     (node > project stores nearest-first > profile > user > builtin, native
- *     documents before enabled-plugin documents within each source). Alternate
- *     physical stores legitimately expose the same canonical identity (a linked
- *     worktree, a generated copy), so a name yields an ordered CANDIDATE set:
- *     source order picks the address winner, every later candidate stays
- *     inspectable.
- *   - an exact STORE view — one physical project store selected by owner
- *     directory, which still requires the full canonical query.
- *
- * Resolution never consults a project store's profile memory ceiling
- * (`projectMemory`); the full corpus resolves and lists regardless, and only
- * automatic delivery clamps against it.
- */
-/** The memory-only scope union: the global `Scope` (`user|project|builtin`)
- *  plus `profile` and `node`. Confined to the memory resolver/list/read/write/
- *  render paths — deliberately NOT folded into the global `Scope` union, because
- *  that would leak these into config, plugin, marketplace, and sys-config
- *  surfaces the spec does not extend. `node` is the this-node store
- *  (`nodes/<id>/context/memory/`), available only inside a running node
- *  (`CRTR_NODE_ID`), and it is the NEAREST scope — a node doc overrides a
- *  same-named doc at any wider scope. */
-export type MemoryScope = Scope | 'profile' | 'node';
-/** Whether a store contributes to target views.
- *  `absent` — no `memory/` dir on disk (silent, the ordinary case).
- *  `undeclared`/`invalid` — a project store the runtime refuses to mount until
- *  its namespace is declared; `diagnostic` carries the migration remedy. */
-export type MemoryStoreMountStatus = 'ready' | 'absent' | 'undeclared' | 'invalid';
-/** One physical memory store: where its documents live, what namespace their
- *  canonical names compose under, and whether it mounts. */
-export interface MemoryStoreDescriptor {
-    scope: MemoryScope;
-    /** App holding a profile store; absent for legacy local profiles. */
-    ownerApp?: string;
-    profileId?: string;
-    /** Absolute path of the physical `memory/` dir. Store identity (and the
-     *  dedup of one real store reached twice) uses its realpath. */
-    storeRoot: string;
-    /** The project directory containing `.crouter/`, for project stores only. */
-    ownerDir?: string;
-    /** Effective project prefix, repository-root namespace composed with the
-     *  owner-relative path; installed-plugin mount prefix, or `''`. */
-    namespace: string;
-    /** The repository-root `INDEX.md` a project namespace is declared on, when
-     *  association succeeds — present even for an undeclared/invalid store so
-     *  lint and migration can point at it. */
-    namespacePath?: string;
-    /** Absolute realpath of the associated repository root, for project stores. */
-    repositoryRoot?: string;
-    /** Linked-worktree/non-Git grouping key, for project stores. */
-    repositoryKey?: string;
-    /** Valid namespace read from the repository-root declaration. */
-    repositoryNamespace?: string;
-    /** Canonical owner path relative to the repository root, empty at the root. */
-    ownerRelativePath?: string;
-    /** Structured cause for a project store that does not mount. */
-    mountFailure?: 'association' | 'collision' | 'undeclared-root' | 'invalid-root' | 'symlink';
-    /** The owning plugin's name for a plugin-mounted store. Plugin docs surface
-     *  within a source scope but live under the plugins dir and are managed by
-     *  `crtr pkg`, so consumers that mutate the store gate on this. */
-    plugin?: string;
-    mountStatus: MemoryStoreMountStatus;
-    /** Why a non-`ready` store does not mount, with its actionable remedy. */
-    diagnostic?: string;
-    /** The selected profile relationship's ceiling for this store: the maximum
-     *  rung AUTOMATIC boot and workspace-open delivery may disclose it at.
-     *  Neutral (`content`) for every non-project store. */
-    projectMemory: ProfileProjectMemory;
-}
-export interface MemoryDoc {
-    /** Canonical identity — the store's namespace composed with `localName`, and
-     *  the only address resolution accepts. */
-    name: string;
-    /** Store-local identity: the explicit frontmatter `name` when present, else
-     *  derived from the store-relative path with ordering prefixes stripped and
-     *  one trailing `INDEX` collapsed. Empty for a store's root document. */
-    localName: string;
-    scope: MemoryScope;
-    /** Absolute path to the resolved .md file. */
-    path: string;
-    /** Absolute path of the `memory/` dir this doc loaded from — the store root
-     *  its physical path is relative to. Sidecar trees that mirror the doc tree
-     *  (the revision-history log) are derived from `path` relative to this. */
-    root: string;
-    /** Store-relative markdown path, kept exactly: placement, ordering, origin,
-     *  and history depend on the physical form, never on segment counts of the
-     *  canonical name. */
-    physicalRelativePath: string;
-    /** Which physical form owns this identity — `foo.md` or `foo/INDEX.md`. */
-    representation: DocRepresentation;
-    /** The canonical directory this doc's `./` memory-read entries match against:
-     *  its own name for a directory document, its parent for a leaf. */
-    routingAnchor: string;
-    store: MemoryStoreDescriptor;
-    /** Raw, uncoerced frontmatter record (null when the doc has no frontmatter). */
-    frontmatter: Record<string, unknown> | null;
-    /** Document body, with the frontmatter block stripped. */
-    body: string;
-    plugin?: string;
-    projectMemory: ProfileProjectMemory;
-}
-/** Every physical document sharing one canonical identity in a view, in source
- *  order. `winner` is the address a deliberate read resolves to; automatic
- *  delivery filters the ordered candidates for its own event eligibility. */
-export interface MemoryCandidateSet {
-    name: string;
-    winner: MemoryDoc;
-    candidates: readonly MemoryDoc[];
-}
-/** Restrict resolution to docs whose resolved kind matches. Threaded INTO
- *  candidate selection, not applied as a post-filter: a wrong-kind candidate is
- *  skipped so a nearer one cannot shadow a farther matching-kind document into
- *  a false not_found. */
-export interface MemoryCandidateOpts {
-    kind?: string;
-}
-export interface MemoryResolutionOpts extends MemoryCandidateOpts {
-    /** Restrict resolution to a single scope. Narrows the source stack only — the
-     *  query is still the full canonical name. */
-    scope?: MemoryScope;
-    /** Also consult `.crouter/memory` stores discovered BELOW the mounted
-     *  project roots (bounded discovery — see nested-stores.ts). Opt-in for the
-     *  addressing surfaces (`memory read/list/find/lint/delete/origin`); OFF for
-     *  boot render, on-read resolvedDocs, the slash-command snapshot, and
-     *  persona resolution, which stay on the flat ancestor+profile stack. */
-    includeDescendants?: boolean;
-    /** Report when bounded descendant discovery omits an owner. Defaults to the inverse of `quiet`, so callers can preserve quiet malformed-document handling while still making an incomplete corpus visible to their caller. */
-    reportDiscovery?: boolean;
-}
-/** A loaded corpus and the exact-identity queries over it. */
-export interface MemoryView {
-    /** Every store the view discovered, mounted or not, in precedence order. */
-    stores: readonly MemoryStoreDescriptor[];
-    /** Every document of every MOUNTED store, in source order — candidates
-     *  included, so a first-wins dedup by name yields the winners. */
-    docs: readonly MemoryDoc[];
-    /** The ordered candidate set for one exact canonical name, or null. */
-    candidates(name: string, opts?: MemoryCandidateOpts): MemoryCandidateSet | null;
-    /** One entry per canonical identity, sorted by name. */
-    candidateSets(opts?: MemoryCandidateOpts): MemoryCandidateSet[];
-    /** The address winner for one exact canonical name; throws not_found. */
-    resolve(name: string, opts?: MemoryCandidateOpts): MemoryDoc;
-}
-export interface MemoryTargetView extends MemoryView {
-    target: MemoryTarget;
-}
-export interface MemoryStoreView extends MemoryView {
-    store: MemoryStoreDescriptor;
-}
-/** Whose memory view is being resolved: the workspace dir, profile, and node
- *  id that decide which stores exist and in what order. Ambient resolution
- *  builds this from the process (`process.cwd()`, `CRTR_PROFILE_ID`,
- *  `CRTR_NODE_ID`); a TARGET-ADDRESSED caller passes another node's, which is
- *  what one process serving several nodes needs — crtrd resolving a link on
- *  behalf of a node, or a warm-spare claim building a node's first-message
- *  context. The same name can name different documents for different nodes, so
- *  every scope in the chain (node-local, project stack, profile, user, builtin)
- *  reads from the target rather than the host process. */
-export interface MemoryTarget {
-    /** The workspace dir the project-scope stack walks up from. */
-    cwd: string;
-    /** The selected profile id, or null when none. */
-    profileId: string | null;
-    /** The node whose `nodes/<id>/context/memory/` store is the nearest scope,
-     *  or null outside a node. */
-    nodeId: string | null;
-    /** App assignment from the selected node's row when outside its broker. */
-    grantee?: string;
-    /** Daemon authorization applied before exposing any candidate or store. */
-    allowsStore?: (store: MemoryStoreDescriptor, name?: string) => boolean;
-    /** Project roots whose repository is readable in the run's mount set. */
-    allowsProject?: (repositoryRoot: string) => boolean;
-}
-/** The target the ambient process describes: cwd + the two env seams every
- *  profile/node-aware memory path reads through (`CRTR_PROFILE_ID`,
- *  `CRTR_NODE_ID`). */
-export declare function ambientMemoryTarget(): MemoryTarget;
-/** The exact project store owned by `ownerDir` — the `--dir` selector's store,
- *  loaded whatever its mount status so lint and migration can inspect a store
- *  the runtime refuses to mount. */
-export declare function openProjectMemoryStore(ownerDir: string): MemoryStoreDescriptor;
-/** Every store a target sees, in precedence order: node, each project store
- *  nearest-first (its enabled plugins after it), then profile, user, builtin.
- *  One real store reached twice contributes once, at its first position. */
-export declare function memoryStoresInPrecedence(target: MemoryTarget, scope?: MemoryScope, includeDescendants?: boolean, reportDiscovery?: boolean): MemoryStoreDescriptor[];
-/** The native (non-plugin) MOUNTED store dirs in resolution precedence.
- *  Addresses a store directly when the document itself may be absent, which is
- *  how a DELETED doc's revision log is still found: history outlives the doc,
- *  so its lookup cannot go through document resolution. */
-export declare function nativeMemoryStoresInPrecedence(scope?: MemoryScope, includeDescendants?: boolean): {
-    scope: MemoryScope;
-    memoryDir: string;
-    store: MemoryStoreDescriptor;
-}[];
-/** Every document in one store, sorted by canonical identity. SKILL.md bundles
- *  are Agent Skills, not memory docs. Enumeration stops at a nested `.crouter/`:
- *  that is another store's mount point, never this store's content. */
-export declare function loadStoreMemoryDocs(store: MemoryStoreDescriptor, quiet?: boolean): MemoryDoc[];
-/** All of one plugin's substrate docs, mounted under the plugin's own name:
- *  each doc's store-local name (explicit or path-derived) composes under that
- *  mount prefix. */
-export declare function listPluginMemoryDocs(plugin: InstalledPlugin, scope: MemoryScope, quiet?: boolean, projectMemory?: ProfileProjectMemory): MemoryDoc[];
-/** Load one target's whole corpus: every mounted store's documents in source
- *  order. A project store that does not mount is reported once (unless quiet)
- *  with its migration remedy and contributes nothing. */
-export declare function loadMemoryTargetView(target: MemoryTarget, opts?: MemoryResolutionOpts & {
-    quiet?: boolean;
-}): MemoryTargetView;
-/** Load ONE exact physical store. An undeclared/invalid project store loads
- *  under the empty namespace so lint and migration can inspect what it holds;
- *  no target view ever sees those documents. */
-export declare function loadMemoryStoreView(store: MemoryStoreDescriptor, quiet?: boolean, target?: MemoryTarget): MemoryStoreView;
-/** All project-scoped docs visible from an explicit node workspace/profile — the
- *  project-only slice of a `MemoryTarget` view, used where only workspace docs
- *  are wanted (a workspace-open render). For a full-precedence target-addressed
- *  lookup, use `resolveMemoryDocForTarget`. */
-export declare function listProjectMemoryDocs(startDir?: string, profileId?: string | null, quiet?: boolean): MemoryDoc[];
-/** All memory docs across the resolved sources, in precedence order: each
- *  ancestor project `.crouter/` from nearest to farthest, then the selected
- *  profile's memory (if any), then user, then builtin. Within each source,
- *  native docs are emitted before enabled-plugin docs, and equal-canonical
- *  candidates stay in source order, so a caller's first-wins dedup yields the
- *  address winners. */
-export declare function listAllMemoryDocs(scope?: MemoryScope, quiet?: boolean, includeDescendants?: boolean): MemoryDoc[];
-export interface MemoryDocSnapshot {
-    /** Every document in default scope precedence order, loaded once. */
-    docs: readonly MemoryDoc[];
-    /** Resolve names against that source snapshot; failures are omitted so
-     * callers can retain their own per-document error behavior. */
-    resolve(names: readonly string[]): Map<string, MemoryDoc>;
-}
-export declare function createMemoryDocSnapshot(target?: MemoryTarget): MemoryDocSnapshot;
-/** Resolve several canonical names over one memory-source snapshot. Failed
- * names are omitted so callers can preserve their per-document error behavior. */
-export declare function resolveMemoryDocs(names: readonly string[]): Map<string, MemoryDoc>;
-/** The address winner for an exact canonical name in the ambient target. */
-export declare function resolveMemoryDoc(rawName: string, opts?: MemoryResolutionOpts): MemoryDoc;
-/** Resolve a memory document as ANOTHER node would see it — the same precedence
- *  chain (node-local > project stack > profile > user > builtin), read from the
- *  target's cwd/profile/node rather than the host process's. This is what crtrd
- *  resolves a `[[name]]` link through: the daemon's own cwd and env name no
- *  node, and the same name can be a different document for two nodes. */
-export declare function resolveMemoryDocForTarget(rawName: string, target: MemoryTarget, opts?: MemoryResolutionOpts): MemoryDoc;
-/** Every physical candidate for an exact canonical name in the ambient target,
- *  in source order — what path-aware inventory, diagnostics, and automatic
- *  event eligibility consume instead of the winner alone. */
-export declare function resolveMemoryCandidates(rawName: string, opts?: MemoryResolutionOpts): MemoryCandidateSet;
-export declare function resolveMemoryCandidatesForTarget(rawName: string, target: MemoryTarget, opts?: MemoryResolutionOpts): MemoryCandidateSet;
-/** The address winner for an exact canonical name inside ONE project store —
- *  the `--dir` selector's resolution. The query is still the full canonical
- *  name, including that store's namespace. */
-export declare function resolveMemoryDocInStore(rawName: string, store: MemoryStoreDescriptor, opts?: MemoryCandidateOpts): MemoryDoc;
-/** Resolve PHYSICAL path segments against a `.history` tree, which mirrors the
- *  doc tree segment for segment with `.jsonl` in place of `.md`. A log outlives
- *  its document, so this lookup cannot go through document resolution. */
-export declare function resolveHistoryLogPath(historyDir: string, segments: string[]): string | null;

package/dist/core/memory-resolver.js

@@ -1,2 +0,0 @@
-var W=Object.defineProperty;var c=(e,o)=>W(e,"name",{value:o,configurable:!0});import{envGrantee as G,envNodeId as V,envProfileId as H}from"../shared/env.js";import{dirname as x,join as y,relative as J,sep as Q}from"node:path";import{readdirSync as U}from"node:fs";import{CRTR_DIR_NAME as F}from"../types.js";import{realpathOrSelf as $}from"./fs-utils.js";import{existsBeneath as X,isBeneathRefusal as Y,readFileBeneath as Z,readTextBeneathIfExists as ee,walkFilesBeneath as oe}from"./spaces/open-beneath.js";import{parseFrontmatterGeneric as k}from"./frontmatter.js";import{listInstalledPlugins as ne,listInstalledPluginsInRoot as te}from"./resolver.js";import{notFound as re,usage as N}from"./errors.js";import{warn as j}from"./output.js";import{NEUTRAL_PROJECT_MEMORY as h,pluginMemoryDir as ie,projectScopeRoots as ae,projectScopeRootsWithMemory as se,scopeMemoryDir as ce}from"./scope.js";import{effectiveDocKind as b}from"./substrate/schema.js";import{INDEX_SEGMENT as w,canonicalSegments as E,composeCanonicalName as T,localNameFromPath as ue,normalizeNameSegment as C,representationForPath as le,resolveLocalName as me,routingAnchorFor as de,validateNamespace as fe}from"./memory/identity.js";import{loadProfileManifest as A,profileMemoryDir as pe}from"./profiles/manifest.js";import{memoryDir as ye}from"./runtime/memory.js";import{descendantStoreRoots as he}from"./nested-stores.js";import{associateRepository as ge}from"./memory/repository-association.js";import{appSpace as we}from"./layout.js";function g(){return{cwd:process.cwd(),profileId:H()||null,nodeId:V()||null,grantee:G()||void 0}}c(g,"ambientMemoryTarget");function ve(){return g().profileId??""}c(ve,"selectedProfileId");function Se(e,o){if(o)return[o];const n=[];return e.nodeId&&n.push("node"),ae(e.cwd,e.profileId).length>0&&n.push("project"),e.profileId&&n.push("profile"),n.push("user"),n.push("builtin"),n}c(Se,"scopesInPrecedence");function L(e,o,n){const t={scope:"project",storeRoot:o,ownerDir:e,projectMemory:n},r=R(o);if(r.mountStatus!=="ready")return{...t,namespace:"",...r};const i=ge(e);if(!i.ok){const p=`run \`crtr sys migrate --dir ${e}\``;return i.code==="no-project-root"?{...t,namespace:"",mountStatus:"undeclared",mountFailure:"association",diagnostic:`project memory store at ${o} has no repository root declaring \`namespace:\` \u2014 ${p}`}:{...t,namespace:"",mountStatus:"invalid",mountFailure:"association",diagnostic:`project memory store at ${o} cannot be associated: ${i.reason} \u2014 ${p}`}}const{association:s}=i,u={namespacePath:s.declarationPath,repositoryRoot:s.repositoryRoot,repositoryKey:s.repositoryKey,ownerRelativePath:s.ownerRelativePath},m=s.declarationPath,a=s.ownerRelativePath!=="",l=`run \`crtr sys migrate --dir ${s.repositoryRoot}\``,f=a?`nested project memory store at ${o} takes its identity from ${m}, which is missing root ${w}.md declaring \`namespace:\` \u2014 ${l}`:`project memory store has no root ${w}.md declaring \`namespace:\` \u2014 ${l}`;let d;try{const p=ee(x(m),m);if(p===null)return{...t,...u,namespace:"",mountStatus:"undeclared",mountFailure:"undeclared-root",diagnostic:f};d=k(p).data?.namespace}catch(p){return{...t,...u,namespace:"",mountStatus:"invalid",mountFailure:"invalid-root",diagnostic:`project memory store's ${m} does not parse (${z(p)}) \u2014 ${l}`}}if(d==null||d===""){const p=a?`nested project memory store at ${o} takes its identity from ${m}, which declares no \`namespace:\` \u2014 ${l}`:`project memory store's ${m} declares no \`namespace:\` \u2014 ${l}`;return{...t,...u,namespace:"",mountStatus:"undeclared",mountFailure:"undeclared-root",diagnostic:p}}if(typeof d!="string")return{...t,...u,namespace:"",mountStatus:"invalid",mountFailure:"invalid-root",diagnostic:`project memory store declares a non-string \`namespace:\` (${JSON.stringify(d)}) \u2014 quote it in ${m}, or ${l}`};const v=fe(d);return v.ok?{...t,...u,repositoryNamespace:d,namespace:T(d,s.ownerRelativePath),mountStatus:"ready"}:{...t,...u,namespace:"",mountStatus:"invalid",mountFailure:"invalid-root",diagnostic:`project memory store declares an invalid namespace \`${d}\` (${v.reason}) \u2014 ${l}`}}c(L,"projectStoreDescriptor");function R(e){try{return{mountStatus:X(e,e)?"ready":"absent"}}catch(o){if(!Y(o))throw o;return{mountStatus:"invalid",mountFailure:"symlink",diagnostic:`memory store at ${e} is reached through a symlink, which never mounts`}}}c(R,"storeRootMount");function M(e,o){return o===null?{scope:e,storeRoot:"",namespace:"",mountStatus:"absent",projectMemory:h}:{scope:e,storeRoot:o,namespace:"",...R(o),projectMemory:h}}c(M,"plainStoreDescriptor");function I(e,o,n){const t=$(ie(e));return{scope:o,storeRoot:t,namespace:e.name,plugin:e.name,...R(t),projectMemory:n}}c(I,"pluginStoreDescriptor");function Ve(e){const o=$(e);return L(o,y(o,F,"memory"),h)}c(Ve,"openProjectMemoryStore");function q(e,o,n=!1,t=!0){const r=[],i=c((a,l)=>{r.push(L(x(a),y(a,"memory"),l));for(const f of te("project",a).filter(d=>d.enabled))r.push(I(f,"project",l))},"projectStores");for(const a of Se(e,o))if(a==="project"){const l=se(e.cwd,e.profileId);for(const{root:f,memory:d}of l)i(f,d);if(n)for(const f of he(l.map(({root:d})=>d),t))i(f,h)}else if(a==="profile"){const l=e.profileId??"";if(l!=="")try{const{profileId:f}=A(l),{manifest:d}=A(f),v=d.grantee?.startsWith("app:")?y(we(d.grantee).memory,"profiles",f):pe(f);r.push({...M("profile",v),profileId:f,ownerApp:d.grantee})}catch{}}else if(a==="node"){const l=e.nodeId??"";l!==""&&r.push({...M("node",ye(l,e.grantee)),ownerApp:e.grantee})}else{r.push(M(a,ce(a)));for(const l of ne(a).filter(f=>f.enabled))r.push(I(l,a,h))}const s=new Set,u=r.filter(a=>{if(a.storeRoot==="")return!1;const l=$(a.storeRoot);return s.has(l)?!1:(s.add(l),!0)}),m=new Map;for(const a of u){if(a.scope!=="project"||a.mountStatus!=="ready"||a.repositoryRoot===void 0||a.ownerRelativePath===void 0)continue;const l=`${a.repositoryRoot}\0${a.ownerRelativePath}`,f=m.get(l);f?f.push(a):m.set(l,[a])}return u.filter(a=>(a.scope!=="project"||a.repositoryRoot===void 0||e.allowsProject?.(a.repositoryRoot)!==!1)&&e.allowsStore?.(a)!==!1).map(a=>{if(a.scope!=="project"||a.mountStatus!=="ready"||a.repositoryRoot===void 0||a.ownerRelativePath===void 0)return a;const l=m.get(`${a.repositoryRoot}\0${a.ownerRelativePath}`);if(l===void 0||l.length<2)return a;const f=l.map(d=>d.ownerDir??d.storeRoot).join(", ");return{...a,mountStatus:"invalid",mountFailure:"collision",diagnostic:`project memory stores at ${f} normalize to the same effective prefix \`${a.namespace}\` \u2014 rename one owner directory`}})}c(q,"memoryStoresInPrecedence");function He(e,o=!1){return q(g(),e,o).filter(n=>n.mountStatus==="ready"&&n.scope!=="builtin"&&n.plugin===void 0).map(n=>({scope:n.scope,memoryDir:n.storeRoot,store:n}))}c(He,"nativeMemoryStoresInPrecedence");function z(e){return(e instanceof Error?e.message:String(e)).split(`
-`)[0]??""}c(z,"firstLine");function $e(e,o,n){const{data:t,body:r}=k(Z(e.storeRoot,o).toString("utf8")),i=ue(n),s=le(n),u=i===""?"":me(t,i),m=T(e.namespace,u);return m===""?null:{name:m,localName:u,scope:e.scope,path:o,root:e.storeRoot,physicalRelativePath:n,representation:s,routingAnchor:de(m,s),store:e,frontmatter:t,body:r,projectMemory:e.projectMemory,...e.plugin===void 0?{}:{plugin:e.plugin}}}c($e,"loadMemoryDoc");function je(e,o){const n=e.name.localeCompare(o.name);return n!==0?n:e.representation!==o.representation?e.representation==="directory-index"?-1:1:e.physicalRelativePath.localeCompare(o.physicalRelativePath)}c(je,"compareDocs");function P(e,o=!1){if(e.storeRoot===""||e.mountFailure==="symlink")return[];const n=[];for(const t of oe(e.storeRoot,e.storeRoot,r=>r.endsWith(".md")&&r!=="SKILL.md",r=>r===F)){const r=J(e.storeRoot,t).split(Q).join("/");try{const i=$e(e,t,r);if(i===null){o||j(`${t}: a root ${w}.md has no canonical name in a store without a namespace`);continue}n.push(i)}catch(i){o||j(`invalid frontmatter in ${t}: ${z(i)}`)}}return n.sort(je)}c(P,"loadStoreMemoryDocs");function Je(e,o,n=!1,t=h){return P(I(e,o,t),n)}c(Je,"listPluginMemoryDocs");function D(e){return E(e.trim()).join("/")}c(D,"normalizeQuery");function B(e,o,n){const t=E(o),r=t[t.length-1]===w;r&&t.pop();const i=t[t.length-1]??o,s=r?`A directory's own document answers at the directory name \u2014 drop the trailing /${w}. Run \`crtr memory find ${i}\` to find the canonical name.`:`Resolution takes the full canonical name (a project doc is <namespace>/<local name>). Run \`crtr memory find ${i}\` to find it.`;return re(`memory document not found: ${e}`,{memory:o,...n?{scope:n}:{},next:s})}c(B,"notFoundError");function _(e,o,n){const t=c((r,i)=>{const s=D(r);if(s==="")return null;const u=i?.kind,m=o.filter(a=>a.name===s&&(u===void 0||b(a)===u));return m.length===0?null:{name:s,winner:m[0],candidates:m}},"candidatesFor");return{stores:e,docs:o,candidates:t,candidateSets(r){const i=r?.kind,s=new Map;for(const u of o){if(i!==void 0&&b(u)!==i)continue;const m=s.get(u.name);m?m.push(u):s.set(u.name,[u])}return[...s.entries()].sort(([u],[m])=>u.localeCompare(m)).map(([u,m])=>({name:u,winner:m[0],candidates:m}))},resolve(r,i){const s=D(r);if(s==="")throw N("memory document name required");const u=t(s,i);if(u===null)throw B(r,s,n);return u.winner}}}c(_,"makeView");function S(e,o={}){const n=o.quiet??!1,t=q(e,o.scope,o.includeDescendants??!1,o.reportDiscovery??!n),r=[];for(const i of t)if(i.mountStatus!=="absent"){if(i.mountStatus!=="ready"){!n&&i.diagnostic!==void 0&&j(`memory store not mounted: ${i.diagnostic}`);continue}r.push(...P(i,n).filter(s=>e.allowsStore?.(i,s.name)!==!1))}return{target:e,..._(t,r,o.scope)}}c(S,"loadMemoryTargetView");function Re(e,o=!1,n){const t=P(e,o).filter(r=>n?.allowsStore?.(e,r.name)!==!1);return{store:e,..._([e],t)}}c(Re,"loadMemoryStoreView");function Qe(e=process.cwd(),o=ve()||null,n=!1){return[...S({cwd:e,profileId:o,nodeId:null},{scope:"project",quiet:n}).docs]}c(Qe,"listProjectMemoryDocs");function Ue(e,o=!1,n=!1){return[...S(g(),{...e?{scope:e}:{},quiet:o,includeDescendants:n}).docs]}c(Ue,"listAllMemoryDocs");function Me(e=g()){const o=S(e,{quiet:!0});return{docs:o.docs,resolve:c(n=>{const t=new Map;for(const r of n){const i=o.candidates(r);i!==null&&t.set(r,i.winner)}return t},"resolve")}}c(Me,"createMemoryDocSnapshot");function Xe(e){return Me().resolve(e)}c(Xe,"resolveMemoryDocs");function Ye(e,o={}){return Ie(e,g(),o)}c(Ye,"resolveMemoryDoc");function Ie(e,o,n={}){return K(e,o,n).winner}c(Ie,"resolveMemoryDocForTarget");function Ze(e,o={}){return K(e,g(),o)}c(Ze,"resolveMemoryCandidates");function K(e,o,n={}){const t=S(o,{...n,quiet:!0}),r=D(e);if(r==="")throw N("memory document name required");const i=t.candidates(r,n);if(i===null)throw B(e,r,n.scope);return i}c(K,"resolveMemoryCandidatesForTarget");function eo(e,o,n={}){return Re(o,!0).resolve(e,n)}c(eo,"resolveMemoryDocInStore");function O(e,o,n,t=".md"){let r;try{r=U(e,{withFileTypes:!0})}catch{return null}let i=null;for(const s of r)if(n==="dir"){if(!s.isDirectory())continue;if(s.name===o)return y(e,s.name);i===null&&C(s.name)===o&&(i=y(e,s.name))}else{if(!(s.isFile()&&s.name.endsWith(t)))continue;const u=s.name.slice(0,-t.length);if(u===o)return y(e,s.name);i===null&&C(u)===o&&(i=y(e,s.name))}return i}c(O,"matchNormalizedChild");function Pe(e,o,n){let t=e;for(let r=0;r<o.length-1;r++){const i=O(t,o[r],"dir",n);if(!i)return null;t=i}return O(t,o[o.length-1],"file",n)}c(Pe,"resolveNormalizedFile");function oo(e,o){return o.length===0?null:Pe(e,o,".jsonl")}c(oo,"resolveHistoryLogPath");export{g as ambientMemoryTarget,Me as createMemoryDocSnapshot,Ue as listAllMemoryDocs,Je as listPluginMemoryDocs,Qe as listProjectMemoryDocs,Re as loadMemoryStoreView,S as loadMemoryTargetView,P as loadStoreMemoryDocs,q as memoryStoresInPrecedence,He as nativeMemoryStoresInPrecedence,Ve as openProjectMemoryStore,oo as resolveHistoryLogPath,Ze as resolveMemoryCandidates,K as resolveMemoryCandidatesForTarget,Ye as resolveMemoryDoc,Ie as resolveMemoryDocForTarget,eo as resolveMemoryDocInStore,Xe as resolveMemoryDocs};

package/dist/core/nested-stores.d.ts

@@ -1,18 +0,0 @@
-export declare function descendantStoreDiscoveryWarnings(ancestorRoots: string[]): string[];
-/**
- * Every `.crouter` store root strictly BELOW the given ancestor roots' owning
- * dirs, in owner order then discovery order. Takes the `projectScopeRoots()`
- * entries themselves (`.crouter` dir paths) and derives owner dirs internally.
- *
- * Any discovered root whose realpath matches an INPUT root is excluded here,
- * inside the function: a profile can manage both `/a` and `/a/b`, making
- * `/a/b/.crouter` simultaneously an ancestor root and a descendant of `/a` —
- * excluding centrally gives the resolver and lint the identical call with no
- * duplicated dedupe logic.
- */
-export declare function descendantStoreRoots(ancestorRoots: string[], reportBudgetExceeded?: boolean, warnings?: string[]): string[];
-/** Complete descendant-store discovery for state migrations. Unlike the
- *  interactive addressing lane, this filesystem walk has no time or depth
- *  budget, crosses embedded repositories, admits plugin-only `.crouter` roots,
- *  and does not cache. */
-export declare function descendantStoreRootsExhaustive(ancestorRoots: string[]): string[];

package/dist/core/nested-stores.js

@@ -1 +0,0 @@
-var D=Object.defineProperty;var a=(t,r)=>D(t,"name",{value:r,configurable:!0});import{readdirSync as E}from"node:fs";import{dirname as x,join as f,sep as R}from"node:path";import{CRTR_DIR_NAME as l}from"../types.js";import{pathExists as p,realpathOrSelf as m}from"./fs-utils.js";import{gitSync as _}from"./git.js";import{warn as v}from"./output.js";const O=new Set(["node_modules",".git","dist","build",".next",".cache",".yalc",".venv"]),T=6,h=500;function C(t){const r=[];return b(t,!1,r),r}a(C,"descendantStoreDiscoveryWarnings");function b(t,r=!0,o=[]){const i=new Set(t.map(s=>m(s))),c=[],d=new Set;for(const s of t){const u=x(s),y=m(u);d.has(y)||(d.add(y),c.push(u))}const e=a(s=>{const u=`memory: nested-store discovery under ${s} exceeded its ${h}ms budget \u2014 this result may omit nested stores. To read a document from a known nested store, pass its owner as \`--dir <owner>\`; that exact-store read bypasses discovery.`;o.push(u),r&&v(u)},"tripBudget"),n=[],w=new Set,S=a(s=>{const u=m(s);w.has(u)||i.has(u)||(w.add(u),n.push(s))},"add");for(const s of c)p(f(s,".git"))?k(s,S,h,()=>e(s)):M(s,S,Date.now()+h,()=>e(s));return n}a(b,"descendantStoreRoots");function k(t,r,o,i){const c=`/${l}/memory/`,d=_(["-C",t,"ls-files","-z","-co","--exclude-standard","--",`*/${l}/memory/*`],void 0,void 0,{timeoutMs:o});if(d.timedOut===!0){i();return}if(d.status===0)for(const e of d.stdout.split("\0")){if(e==="")continue;const n=e.indexOf(c);n<=0||r(f(t,e.slice(0,n).split("/").join(R),l))}}a(k,"collectGitStores");function M(t,r,o,i){g(t,r,{deadline:o,maxDepth:T,trip:i})}a(M,"collectWalkStores");function g(t,r,o={}){const i=[{dir:t,depth:0}];for(;i.length>0;){if(o.deadline!==void 0&&Date.now()>o.deadline){o.trip?.();return}const{dir:c,depth:d}=i.pop();if(c!==t){if(o.crossEmbeddedRepos!==!0&&p(f(c,".git")))continue;const n=f(c,l);p(o.includePluginOnly===!0?n:f(n,"memory"))&&r(n)}if(o.maxDepth!==void 0&&d>=o.maxDepth)continue;let e;try{e=E(c,{withFileTypes:!0})}catch{continue}for(const n of e)n.isDirectory()&&(O.has(n.name)||n.name===l||i.push({dir:f(c,n.name),depth:d+1}))}}a(g,"collectWalkStoresFromOwner");function F(t){const r=new Set(t.map(e=>m(e))),o=[],i=new Set,c=a(e=>{const n=m(e);i.has(n)||r.has(n)||(i.add(n),o.push(e))},"add"),d=new Set(t.map(e=>m(x(e))));for(const e of d)g(e,c,{includePluginOnly:!0,crossEmbeddedRepos:!0});return o}a(F,"descendantStoreRootsExhaustive");export{C as descendantStoreDiscoveryWarnings,b as descendantStoreRoots,F as descendantStoreRootsExhaustive};

package/dist/core/runtime/memory.d.ts

@@ -1,3 +0,0 @@
-/** The node-local memory directory in a node's context dir — holds substrate
- *  docs (.md files with kind/when/why frontmatter). */
-export declare function memoryDir(nodeId: string, grantee?: string): string;

package/dist/core/runtime/memory.js

@@ -1 +0,0 @@
-var e=Object.defineProperty;var m=(r,o)=>e(r,"name",{value:o,configurable:!0});import{join as p}from"node:path";import{appSpace as i}from"../layout.js";function a(r,o){if(!o)throw new Error(`memory store for ${r} requires an app`);return p(i(o).memory,"nodes",r)}m(a,"memoryDir");export{a as memoryDir};

package/dist/core/substrate/frontmatter-validation.d.ts

@@ -1,11 +0,0 @@
-import { type SurfaceEntry } from './schema.js';
-export declare const SUPPRESSIBLE_RULES: readonly string[];
-/** Strict validation of one raw routing entry. Runtime parsing deliberately
- * tolerates malformed docs; this authoring/preflight contract does not. */
-export declare function lintSubstrateSurfaces(value: unknown): string | null;
-/** Strict substrate frontmatter checker shared by lint and package preflight. */
-export declare function lintSubstrateFrontmatter(fm: Record<string, unknown> | null): string | null;
-/** Compatibility name for consumers that adopted lint's former export. */
-export declare const lintSubstrateSchema: typeof lintSubstrateFrontmatter;
-/** Parsed routing entries for checks that run after strict validation. */
-export declare function parsedSubstrateSurfaces(fm: Record<string, unknown>): SurfaceEntry[];

package/dist/core/substrate/frontmatter-validation.js

@@ -1 +0,0 @@
-var g=Object.defineProperty;var s=(e,n)=>g(e,"name",{value:n,configurable:!0});import{isDocKind as m,parseSubstrateFrontmatter as b,PRIVACY_LEVELS as y,SURFACE_EVENTS as f,SURFACE_RUNGS as h}from"./schema.js";const S=["system-prompt-visibility","file-read-visibility","applies-to","read-when"],v=["on","match","match-frontmatter","gate","at"],p=["length","broad-memory-read","orphan"];function $(e){if(e===void 0)return null;if(!Array.isArray(e))return`invalid surfaces: ${JSON.stringify(e)} (expected a list of {on, at, match?, match-frontmatter?, gate?} entries)`;for(const n of e){if(n===null||typeof n!="object"||Array.isArray(n))return`invalid surfaces entry: ${JSON.stringify(n)} (expected an {on, at, match?, match-frontmatter?, gate?} object)`;const r=n;for(const i of Object.keys(r))if(!v.includes(i))return`invalid surfaces entry: unknown key \`${i}\` (an entry carries only on, match, match-frontmatter, gate, at)`;const t=r.on;if(typeof t!="string"||!f.includes(t))return`invalid surfaces entry \`on\`: ${JSON.stringify(t)} (expected ${f.join("|")})`;const c=r.at;if(typeof c!="string"||!h.includes(c))return`invalid surfaces entry \`at\`: ${JSON.stringify(c)} (expected ${h.join("|")})`;let u=!1;if(r.match!==void 0){if(t==="boot"||t==="workspace-open")return`invalid surfaces entry: \`match\` is meaningless on \`${t}\` \u2014 the entry's presence is the match; drop it`;const i=r.match,d=typeof i=="string"?[i]:Array.isArray(i)&&i.every(l=>typeof l=="string")?i:null;if(d===null||d.length===0||d.some(l=>l.trim()===""))return`invalid surfaces entry \`match\`: ${JSON.stringify(i)} (expected a non-empty glob or non-empty glob list)`;u=!0}const a=r["match-frontmatter"];if(a!==void 0){if(t!=="read")return"invalid surfaces entry: `match-frontmatter` is a `read`-event predicate only";if(a===null||typeof a!="object"||Array.isArray(a))return`invalid surfaces entry \`match-frontmatter\`: ${JSON.stringify(a)} (expected a field\u2192matcher object)`}if((t==="read"||t==="memory-read"||t==="command"||t==="pre-command")&&!u&&a===void 0)return`invalid surfaces entry: a \`${t}\` entry requires \`match\`${t==="read"?" or `match-frontmatter`":""}`;const o=r.gate;if(o!==void 0&&(o===null||typeof o!="object"||Array.isArray(o)))return`invalid surfaces entry \`gate\`: ${JSON.stringify(o)} (expected a field\u2192matcher object)`}return null}s($,"lintSubstrateSurfaces");function w(e){if(e===null)return"missing frontmatter: a memory store doc requires `kind: knowledge|preference`";if(!m(e.kind))return`invalid kind: ${JSON.stringify(e.kind)} (expected knowledge|preference)`;if("when"in e||"why"in e)return'retired `when`/`why` keys: merge them into one `when-and-why-to-read` line \u2014 "When <circumstance>, this <kind> should be read because <broader downstream payoff>." WHY is the benefit unlocked by reading, not the document summary, rule, or obedience rationale.';if(typeof e["when-and-why-to-read"]!="string"||e["when-and-why-to-read"].trim()==="")return'missing `when-and-why-to-read`: one routing line \u2014 "When <circumstance>, this <kind> should be read because <broader downstream payoff>." WHY is the benefit unlocked by reading, not the document summary, rule, or obedience rationale.';for(const r of S)if(r in e)return`retired \`${r}\` key: the visibility axes were replaced by \`surfaces\` event routing \u2014 run \`crtr sys migrate\` to convert old-format docs, or author \`surfaces\` entries by hand (\`crtr memory write -h\`)`;if("privacy"in e&&!y.includes(e.privacy))return`invalid privacy: ${JSON.stringify(e.privacy)} (expected ${y.join("|")})`;if(e.unlisted!==void 0&&typeof e.unlisted!="boolean")return`invalid unlisted: ${JSON.stringify(e.unlisted)} (expected a boolean)`;const n=$(e.surfaces);if(n!==null)return n;if(e.gate!==void 0&&(e.gate===null||typeof e.gate!="object"||Array.isArray(e.gate)))return`invalid gate: ${JSON.stringify(e.gate)} (expected a field\u2192matcher object)`;if(e.slash!==void 0&&typeof e.slash!="boolean")return`invalid slash: ${JSON.stringify(e.slash)} (expected a boolean)`;if(e.rationale!==void 0&&typeof e.rationale!="string")return`invalid rationale: ${JSON.stringify(e.rationale)} (expected a string)`;if(e["lint-ignore"]!==void 0){const r=Array.isArray(e["lint-ignore"])?e["lint-ignore"]:[e["lint-ignore"]];if(r.length===0||!r.every(t=>typeof t=="string"&&p.includes(t)))return`invalid lint-ignore: ${JSON.stringify(e["lint-ignore"])} (suppressible rules: ${p.map(t=>`\`${t}\``).join(", ")})`}return null}s(w,"lintSubstrateFrontmatter");const k=w;function N(e){return b(e)?.surfaces??[]}s(N,"parsedSubstrateSurfaces");export{p as SUPPRESSIBLE_RULES,w as lintSubstrateFrontmatter,k as lintSubstrateSchema,$ as lintSubstrateSurfaces,N as parsedSubstrateSurfaces};

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

@@ -1,16 +0,0 @@
-import type { SubstrateDoc, SurfaceEntry } from './schema.js';
-import type { NodeConfigSubject } from './subject-fields.js';
-/** Does `doc` pass its gate for `subject`?
- *
- *  - No gate (field absent) ⇒ `true`: always eligible (the common case).
- *  - A gate present ⇒ the matcher engine's verdict. An empty `gate: {}` is inert
- *    and returns `false` (never matches) per design §4 — so an author cannot
- *    write an always-eligible-via-empty-predicate doc.
- *
- *  Eligibility only. A failing gate excludes the doc from BOTH automatic hooks
- *  for this node; it remains findable by `crtr memory find` (search ignores
- *  gate + rung). */
-export declare function gatePasses(doc: SubstrateDoc, subject: NodeConfigSubject): boolean;
-/** Does a surface entry participate for `subject`? A missing subject cannot
- * satisfy an entry gate; entries without one remain eligible. */
-export declare function surfaceEntryGatePasses(entry: Pick<SurfaceEntry, 'gate'>, subject: NodeConfigSubject | null): boolean;

package/dist/core/substrate/gate.js

@@ -1 +0,0 @@
-var a=Object.defineProperty;var n=(e,t)=>a(e,"name",{value:t,configurable:!0});import{evalCondition as r}from"../predicate.js";function f(e,t){return e.gate===void 0?!0:r(e.gate,t)}n(f,"gatePasses");function o(e,t){return e.gate===void 0||t!==null&&r(e.gate,t)}n(o,"surfaceEntryGatePasses");export{f as gatePasses,o as surfaceEntryGatePasses};

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

@@ -1,18 +0,0 @@
-export { KINDS, isDocKind, RUNGS, rungRank, rungAtLeast, SURFACE_EVENTS, SURFACE_RUNGS, parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, normalizeNameSegment, normalizeDocName, resolveDocName, } from './schema.js';
-export type { DocKind, Rung, GatePredicate, SubstrateSchema, SubstrateDoc, SurfaceEntry, SurfaceEvent, SurfaceRung } from './schema.js';
-export { lintSubstrateFrontmatter, lintSubstrateSchema, lintSubstrateSurfaces, parsedSubstrateSurfaces } from './frontmatter-validation.js';
-export { matchesReadEntry, matchesMemoryReadEntry, matchesCommandEntry, readDeliveryRung, workspaceOpenRung, memoryReadDeliveryRung, commandDeliveryRung, matchingSurfaceEntry, surfaceEntryParticipates, owningRootOf, underOwningRoot } from './surface-match.js';
-export type { SurfaceMatchPayload } from './surface-match.js';
-export { planDelivery, bootPartitionOf } from './plan.js';
-export type { DeliveryPlan, DeliveryRecord, DeliveryPayload, EntryDecision, GateOutcome } from './plan.js';
-export { dirDedupKey, docsByName, isDirName, ancestorDirsOf, renderDirListing } from './listings.js';
-export { clearContextExposureState, cloneContextExposureState, cloneTranscriptExposureState, contentExposureIdentity, contextExposureStatesEqual, documentExposedAtOrAbove, emptyContextExposureState, exposedAtOrAbove, exposureTarget, freezePreferenceSnapshot, hasTranscriptExposure, initializeForkContextExposure, loadContextExposureState, mergeContextExposureState, registerDocumentExposure, registerExposure, replaceContextExposureState, saveContextExposureState, sharedContextExposureState, } from './injected-store.js';
-export type { ContextExposureState, ExposureSource, ExposureTarget } from './injected-store.js';
-export { scopeForCwd, profileNameFor } from './subject-fields.js';
-export type { NodeConfigSubject } from './subject-fields.js';
-export { spineDepth, assembleNodeSubject } from './subject.js';
-export { gatePasses } from './gate.js';
-export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
-export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject, renderOnCommandDocsForSubject, memoryReadDocBlocks } from './on-read.js';
-export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read-node.js';

package/dist/core/substrate/index.js

@@ -1 +0,0 @@
-import{KINDS as t,isDocKind as o,RUNGS as n,rungRank as a,rungAtLeast as s,SURFACE_EVENTS as p,SURFACE_RUNGS as c,parseSubstrateFrontmatter as m,parseSubstrateDoc as u,previewLine as x,normalizeNameSegment as i,normalizeDocName as d,resolveDocName as S}from"./schema.js";import{lintSubstrateFrontmatter as f,lintSubstrateSchema as l,lintSubstrateSurfaces as D,parsedSubstrateSurfaces as g}from"./frontmatter-validation.js";import{matchesReadEntry as b,matchesMemoryReadEntry as y,matchesCommandEntry as C,readDeliveryRung as F,workspaceOpenRung as O,memoryReadDeliveryRung as N,commandDeliveryRung as h,matchingSurfaceEntry as v,surfaceEntryParticipates as k,owningRootOf as w,underOwningRoot as A}from"./surface-match.js";import{planDelivery as P,bootPartitionOf as K}from"./plan.js";import{dirDedupKey as T,docsByName as U,isDirName as B,ancestorDirsOf as L,renderDirListing as G}from"./listings.js";import{clearContextExposureState as W,cloneContextExposureState as _,cloneTranscriptExposureState as q,contentExposureIdentity as M,contextExposureStatesEqual as V,documentExposedAtOrAbove as H,emptyContextExposureState as J,exposedAtOrAbove as Q,exposureTarget as X,freezePreferenceSnapshot as Y,hasTranscriptExposure as Z,initializeForkContextExposure as $,loadContextExposureState as ee,mergeContextExposureState as re,registerDocumentExposure as te,registerExposure as oe,replaceContextExposureState as ne,saveContextExposureState as ae,sharedContextExposureState as se}from"./injected-store.js";import{scopeForCwd as ce,profileNameFor as me}from"./subject-fields.js";import{spineDepth as xe,assembleNodeSubject as ie}from"./subject.js";import{gatePasses as Se}from"./gate.js";import{renderPreferencesForSubject as fe,renderKnowledgeForSubject as le}from"./render.js";import{renderPreferencesSection as ge,renderKnowledgeBlock as Re}from"./render-node.js";import{renderOnReadDocsForSubject as ye,renderWorkspaceOpenDocsForSubject as Ce,renderOnCommandDocsForSubject as Fe,memoryReadDocBlocks as Oe}from"./on-read.js";import{renderOnReadDocs as he,renderWorkspaceOpenDocs as ve}from"./on-read-node.js";export{t as KINDS,n as RUNGS,p as SURFACE_EVENTS,c as SURFACE_RUNGS,L as ancestorDirsOf,ie as assembleNodeSubject,K as bootPartitionOf,W as clearContextExposureState,_ as cloneContextExposureState,q as cloneTranscriptExposureState,h as commandDeliveryRung,M as contentExposureIdentity,V as contextExposureStatesEqual,T as dirDedupKey,U as docsByName,H as documentExposedAtOrAbove,J as emptyContextExposureState,Q as exposedAtOrAbove,X as exposureTarget,Y as freezePreferenceSnapshot,Se as gatePasses,Z as hasTranscriptExposure,$ as initializeForkContextExposure,B as isDirName,o as isDocKind,f as lintSubstrateFrontmatter,l as lintSubstrateSchema,D as lintSubstrateSurfaces,ee as loadContextExposureState,C as matchesCommandEntry,y as matchesMemoryReadEntry,b as matchesReadEntry,v as matchingSurfaceEntry,N as memoryReadDeliveryRung,Oe as memoryReadDocBlocks,re as mergeContextExposureState,d as normalizeDocName,i as normalizeNameSegment,w as owningRootOf,u as parseSubstrateDoc,m as parseSubstrateFrontmatter,g as parsedSubstrateSurfaces,P as planDelivery,x as previewLine,me as profileNameFor,F as readDeliveryRung,te as registerDocumentExposure,oe as registerExposure,G as renderDirListing,Re as renderKnowledgeBlock,le as renderKnowledgeForSubject,Fe as renderOnCommandDocsForSubject,he as renderOnReadDocs,ye as renderOnReadDocsForSubject,fe as renderPreferencesForSubject,ge as renderPreferencesSection,ve as renderWorkspaceOpenDocs,Ce as renderWorkspaceOpenDocsForSubject,ne as replaceContextExposureState,S as resolveDocName,s as rungAtLeast,a as rungRank,ae as saveContextExposureState,ce as scopeForCwd,se as sharedContextExposureState,xe as spineDepth,k as surfaceEntryParticipates,A as underOwningRoot,O as workspaceOpenRung};

package/dist/core/substrate/injected-store.d.ts

@@ -1,75 +0,0 @@
-import { type Rung } from './schema.js';
-export type ExposureSource = 'system' | 'transcript';
-interface ExposureRanks {
-    system?: number;
-    transcript?: number;
-}
-/** Memory visible to the currently loaded LLM context. */
-export interface ContextExposureState {
-    /** Byte-stable preference splice for this context. */
-    preferenceSnapshot: string | null;
-    /** Canonical identity → ranks loaded from the system and transcript snapshots. */
-    exposures: Map<string, ExposureRanks>;
-}
-/** One full document body that entered a context — the analytics memory log's
- *  `loaded` event, before it is timestamped and sent. */
-export interface MemoryLoad {
-    name: string;
-    scope: string;
-}
-export interface ExposureTarget {
-    state: ContextExposureState;
-    source: ExposureSource;
-    /** Present only at real delivery sites; diagnostic renders pass none. */
-    loads?: MemoryLoad[];
-}
-/** JSON form exchanged with the daemon after Pi has materialized a baseline. */
-export interface ContextExposureSnapshot {
-    preferenceSnapshot: string | null;
-    exposures: Record<string, {
-        system?: number;
-        transcript?: number;
-    }>;
-}
-export declare function snapshotContextExposure(state: ContextExposureState): ContextExposureSnapshot;
-export declare function restoreContextExposure(value: ContextExposureSnapshot): ContextExposureState;
-export declare function emptyContextExposureState(): ContextExposureState;
-export declare function exposureTarget(state: ContextExposureState, source: ExposureSource, loads?: MemoryLoad[]): ExposureTarget;
-export declare function exposedAtOrAbove(state: ContextExposureState, identity: string, rung: Rung): boolean;
-/** The sole delivery mutation: max-fold one loaded identity into its source rank. */
-export declare function registerExposure(target: ExposureTarget, identity: string, rung: Rung): void;
-export declare function contentExposureIdentity(body: string): string | null;
-export declare function documentExposedAtOrAbove(state: ContextExposureState, path: string, body: string, rung: Rung): boolean;
-/** Register both the physical document and its non-empty content alias. A
- *  `content` registration of a body the context did not already hold is a full
- *  body entering the context, so it lands in the target's collector. */
-export declare function registerDocumentExposure(target: ExposureTarget, doc: {
-    path: string;
-    body: string;
-    name: string;
-    scope: string;
-}, rung: Rung): void;
-/** Forget that a document was delivered into the TRANSCRIPT — both its physical
- *  identity and its content alias — while leaving any `system` rank intact,
- *  because the system prompt is rebuilt on every agent run and survives
- *  compaction. This is what re-arms a `pre-command` hold for guidance that
- *  compaction dropped out of the transcript. */
-export declare function demoteDocumentTranscriptExposure(state: ContextExposureState, path: string, body: string): void;
-export declare function freezePreferenceSnapshot(state: ContextExposureState, rendered: string): string;
-export declare function cloneContextExposureState(source: ContextExposureState): ContextExposureState;
-export declare function hasTranscriptExposure(state: ContextExposureState): boolean;
-/** The context copied into a fork excludes the source's system snapshot. */
-export declare function cloneTranscriptExposureState(source: ContextExposureState): ContextExposureState;
-export declare function replaceContextExposureState(target: ContextExposureState, source: ContextExposureState): void;
-export declare function contextExposureStatesEqual(left: ContextExposureState, right: ContextExposureState): boolean;
-/** Fold state written by another process into the live context state. */
-export declare function mergeContextExposureState(target: ContextExposureState, source: ContextExposureState): void;
-export declare function sharedContextExposureState(nodeId: string): ContextExposureState;
-/** v1/v2 ranks predate provenance and conservatively become transcript exposure. */
-export declare function loadContextExposureState(nodeId: string): ContextExposureState;
-export declare function saveContextExposureState(nodeId: string, state: ContextExposureState): void;
-/** Clear in place so every extension closure observes the new context boundary. */
-export declare function clearContextExposureState(nodeId: string): void;
-/** Seed a fork with only context copied in the source transcript. */
-export declare function initializeForkContextExposure(destinationNodeId: string, sourceNodeId: string | null): void;
-export {};

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

@@ -1,2 +0,0 @@
-var T=Object.defineProperty;var s=(e,t)=>T(e,"name",{value:t,configurable:!0});import{createHash as M}from"node:crypto";import{injectedDocsPath as S,nodeRunDir as d}from"../canvas/paths.js";import{realpathOrSelf as w}from"../fs-utils.js";import{existsBeneath as g,readFileBeneath as B,setModeBeneath as R,statBeneath as z,unlinkBeneath as D,writeFileBeneath as N}from"../spaces/open-beneath.js";import{rungRank as v}from"./schema.js";function V(e){return{preferenceSnapshot:e.preferenceSnapshot,exposures:Object.fromEntries(e.exposures)}}s(V,"snapshotContextExposure");function W(e){if(e===null||typeof e!="object"||e.preferenceSnapshot!==null&&typeof e.preferenceSnapshot!="string"||e.exposures===null||typeof e.exposures!="object"||Array.isArray(e.exposures))throw new Error("invalid context exposure snapshot");const t=x();t.preferenceSnapshot=e.preferenceSnapshot;for(const[r,n]of Object.entries(e.exposures)){if(n===null||typeof n!="object"||Array.isArray(n)||n.system===void 0&&n.transcript===void 0||n.system!==void 0&&!u(n.system)||n.transcript!==void 0&&!u(n.transcript))throw new Error(`invalid context exposure ranks for '${r}'`);t.exposures.set(r,{...n})}return t}s(W,"restoreContextExposure");const F=v("content"),a=new Map;function x(){return{preferenceSnapshot:null,exposures:new Map}}s(x,"emptyContextExposureState");function $(e,t,r){return r===void 0?{state:e,source:t}:{state:e,source:t,loads:r}}s($,"exposureTarget");function u(e){return typeof e=="number"&&Number.isInteger(e)&&e>=1&&e<=F}s(u,"validRank");function J(e){return Math.max(e?.system??0,e?.transcript??0)}s(J,"activeRank");function O(e,t,r){return J(e.exposures.get(t))>=v(r)}s(O,"exposedAtOrAbove");function y(e,t,r){const n=v(r);if(n===0)return;const o=e.state.exposures.get(t)??{};(o[e.source]??0)>=n||e.state.exposures.set(t,{...o,[e.source]:n})}s(y,"registerExposure");function b(e){const t=e.trim();return t===""?null:`content-sha256:${M("sha256").update(t).digest("hex")}`}s(b,"contentExposureIdentity");function P(e,t,r,n){if(O(e,w(t),n))return!0;const o=b(r);return o!==null&&O(e,o,n)}s(P,"documentExposedAtOrAbove");function X(e,t,r){const{path:n,body:o}=t;r==="content"&&e.loads!==void 0&&!P(e.state,n,o,"content")&&e.loads.push({name:t.name,scope:t.scope}),y(e,w(n),r);const p=b(o);p!==null&&y(e,p,r)}s(X,"registerDocumentExposure");function j(e,t){const r=e.exposures.get(t);r!==void 0&&(u(r.system)?e.exposures.set(t,{system:r.system}):e.exposures.delete(t))}s(j,"dropTranscriptExposure");function Y(e,t,r){j(e,w(t));const n=b(r);n!==null&&j(e,n)}s(Y,"demoteDocumentTranscriptExposure");function Z(e,t){return e.preferenceSnapshot===null&&(e.preferenceSnapshot=t),e.preferenceSnapshot}s(Z,"freezePreferenceSnapshot");function I(e){return{preferenceSnapshot:e.preferenceSnapshot,exposures:new Map([...e.exposures].map(([t,r])=>[t,{...r}]))}}s(I,"cloneContextExposureState");function ee(e){return[...e.exposures.values()].some(t=>u(t.transcript))}s(ee,"hasTranscriptExposure");function q(e){const t=x(),r=$(t,"transcript");for(const[n,o]of e.exposures){const p=o.transcript;u(p)&&y(r,n,p===1?"name":p===2?"preview":"content")}return t}s(q,"cloneTranscriptExposureState");function k(e,t){e.preferenceSnapshot=t.preferenceSnapshot,e.exposures.clear();for(const[r,n]of t.exposures)e.exposures.set(r,{...n})}s(k,"replaceContextExposureState");function te(e,t){if(e.preferenceSnapshot!==t.preferenceSnapshot||e.exposures.size!==t.exposures.size)return!1;for(const[r,n]of e.exposures){const o=t.exposures.get(r);if(n.system!==o?.system||n.transcript!==o?.transcript)return!1}return!0}s(te,"contextExposureStatesEqual");function re(e,t){if(e.preferenceSnapshot!==null&&t.preferenceSnapshot!==null&&e.preferenceSnapshot!==t.preferenceSnapshot)throw new Error("context exposure state contains conflicting preference snapshots");e.preferenceSnapshot===null&&t.preferenceSnapshot!==null&&(e.preferenceSnapshot=t.preferenceSnapshot);for(const[r,n]of t.exposures){const o=e.exposures.get(r)??{},p=Math.max(o.system??0,n.system??0),i=Math.max(o.transcript??0,n.transcript??0);e.exposures.set(r,{...p>0?{system:p}:{},...i>0?{transcript:i}:{}})}}s(re,"mergeContextExposureState");function ne(e){let t=a.get(e);return t===void 0&&(t=x(),a.set(e,t)),t}s(ne,"sharedContextExposureState");function C(e){const t=S(e);let r;try{r=JSON.parse(B(d(e),t).toString("utf8"))}catch(c){if(c.code==="ENOENT")return x();throw new Error(`failed to read context exposure state at ${t}: ${c instanceof Error?c.message:String(c)}`)}const n=x(),o=$(n,"transcript");if(Array.isArray(r)){for(const c of r){if(typeof c!="string")throw new Error(`invalid v1 context exposure state at ${t}`);y(o,c,"content")}return n}if(r===null||typeof r!="object")throw new Error(`invalid context exposure state at ${t}`);const p=r;if(p.v===3){const c=p.preferenceSnapshot,f=p.exposures;if(c!==null&&typeof c!="string"||f===null||typeof f!="object"||Array.isArray(f))throw new Error(`invalid v3 context exposure state at ${t}`);n.preferenceSnapshot=c;for(const[E,m]of Object.entries(f)){if(m===null||typeof m!="object"||Array.isArray(m))throw new Error(`invalid v3 exposure entry '${E}' at ${t}`);const A=m,h=A.system,l=A.transcript;if(h!==void 0&&!u(h)||l!==void 0&&!u(l)||h===void 0&&l===void 0)throw new Error(`invalid v3 exposure ranks for '${E}' at ${t}`);n.exposures.set(E,{...u(h)?{system:h}:{},...u(l)?{transcript:l}:{}})}return n}if(p.v!==2)throw new Error(`unsupported context exposure state at ${t}`);const i=p.docs;if(i===null||typeof i!="object"||Array.isArray(i))throw new Error(`invalid v2 context exposure state at ${t}`);for(const[c,f]of Object.entries(i)){if(!u(f))throw new Error(`invalid v2 exposure rank for '${c}' at ${t}`);y(o,c,f===1?"name":f===2?"preview":"content")}return n}s(C,"loadContextExposureState");function H(e,t){const r=d(e),n=S(e);let o=384;try{o=z(r,n).mode&511}catch(i){if(i.code!=="ENOENT")throw i}const p=`${JSON.stringify({v:3,preferenceSnapshot:t.preferenceSnapshot,exposures:Object.fromEntries(t.exposures)},null,2)}
-`;N(r,n,p,{atomic:!0,mode:o}),R(r,n,o)}s(H,"saveContextExposureState");function oe(e){const t=a.get(e);t!==void 0&&k(t,x());try{D(d(e),S(e))}catch(r){if(r.code!=="ENOENT")throw r}}s(oe,"clearContextExposureState");function se(e,t){if(g(d(e),S(e))){const o=C(e),p=a.get(e);p===void 0?a.set(e,o):k(p,o);return}const r=t===null?x():q(C(t)),n=a.get(e);n===void 0?a.set(e,r):k(n,r),H(e,r)}s(se,"initializeForkContextExposure");export{oe as clearContextExposureState,I as cloneContextExposureState,q as cloneTranscriptExposureState,b as contentExposureIdentity,te as contextExposureStatesEqual,Y as demoteDocumentTranscriptExposure,P as documentExposedAtOrAbove,x as emptyContextExposureState,O as exposedAtOrAbove,$ as exposureTarget,Z as freezePreferenceSnapshot,ee as hasTranscriptExposure,se as initializeForkContextExposure,C as loadContextExposureState,re as mergeContextExposureState,X as registerDocumentExposure,y as registerExposure,k as replaceContextExposureState,W as restoreContextExposure,H as saveContextExposureState,ne as sharedContextExposureState,V as snapshotContextExposure};

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

@@ -1,28 +0,0 @@
-import type { MemoryDoc } from '../memory-resolver.js';
-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 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[];
-/** 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, onPreview?: (doc: MemoryDoc) => void): string[];

package/dist/core/substrate/listings.js

@@ -1 +0,0 @@
-var h=Object.defineProperty;var o=(e,n)=>h(e,"name",{value:n,configurable:!0});import{buildMemoryTree as x}from"../memory/tree.js";import{parseSubstrateDoc as D,previewLine as a}from"./schema.js";import{documentExposedAtOrAbove as b,registerDocumentExposure as w}from"./injected-store.js";function A(e){return`dir://${e}`}o(A,"dirDedupKey");function E(e){const n=new Map;for(const t of e)n.has(t.name)||n.set(t.name,t);return n}o(E,"docsByName");const f=new WeakMap;function p(e){const n=f.get(e);if(n!==void 0)return n;const t=x([...e.values()]);return f.set(e,t),t}o(p,"treeFor");function v(e,n){return n!==""&&p(e).isDirectory(n)}o(v,"isDirName");function y(e){const n=[],t=e.split("/");for(let r=t.length-1;r>=1;r--)n.push(t.slice(0,r).join("/"));return n}o(y,"ancestorDirsOf");function O(e,n){return[...v(e,n)?[n]:[],...y(n)]}o(O,"docListingDirs");function d(e,n,t){const r=D(e);return r?.unlisted||t&&n!==null&&b(n.state,e.path,e.body,"preview")?null:(n!==null&&w(n,e,"preview"),r===null?"":a(r))}o(d,"previewSuffix");function m(e,n){return n===null||n===""?`[[${e}]]`:`[[${e}]]: ${n}`}o(m,"line");function S(e,n,t,r,l){const s=p(e).node(n);if(s===null)return[];const c=[];for(const u of s.childDocuments){const i=d(u.document,t,r);i!==null&&(l?.(u.document),c.push(m(u.name,i)))}for(const u of s.childDirectories){const i=u.document===null?null:d(u.document,t,r);u.document!==null&&i!==null&&l?.(u.document),c.push(m(u.name,i))}return c}o(S,"renderDirListing");export{y as ancestorDirsOf,A as dirDedupKey,O as docListingDirs,E as docsByName,v as isDirName,S as renderDirListing};

package/dist/core/substrate/memory-events.d.ts

@@ -1,6 +0,0 @@
-import type { MemoryReadEventDTO } from '../../api/dto/analytics.js';
-import type { MemoryLoad } from './injected-store.js';
-export declare function memoryEvents(loads: readonly MemoryLoad[], type: MemoryReadEventDTO['type'], at?: string): MemoryReadEventDTO[];
-/** One POST for all of `events`; resolves (never rejects) whether or not crtrd
- *  recorded them. Sends nothing when there is nothing to record. */
-export declare function sendMemoryEvents(nodeId: string, events: MemoryReadEventDTO[]): Promise<void>;

package/dist/core/substrate/memory-events.js

@@ -1 +0,0 @@
-var i=Object.defineProperty;var r=(o,t)=>i(o,"name",{value:t,configurable:!0});import{localClient as c}from"../../api/node-transport.js";function s(o,t,e=new Date().toISOString()){return o.map(({name:n,scope:a})=>({name:n,scope:a,at:e,type:t}))}r(s,"memoryEvents");async function u(o,t){if(t.length!==0)try{await c({autostart:!1,coldStartPollWindowMs:0,timeoutMs:500}).recordMemoryReads(o,{events:t})}catch{}}r(u,"sendMemoryEvents");export{s as memoryEvents,u as sendMemoryEvents};

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

@@ -1,6 +0,0 @@
-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, 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

@@ -1 +0,0 @@
-var i=Object.defineProperty;var n=(e,t)=>i(e,"name",{value:t,configurable:!0});import{getNode as m}from"../canvas/index.js";import{appForNode as s}from"../canvas/node-agent-paths.js";import{automaticMemoryTarget as a}from"../spaces/permissions.js";import{emptyContextExposureState as c,exposureTarget as p}from"./injected-store.js";import{assembleNodeSubject as u}from"./subject.js";import{renderOnReadDocsForSubject as f,renderWorkspaceOpenDocsForSubject as l}from"./on-read.js";function S(e,t,o=p(c(),"transcript")){let r;try{r=u(e)}catch{return""}return r===null?"":f(r,t,o)}n(S,"renderOnReadDocs");function y(e,t=p(c(),"transcript")){const o=u(e),r=m(e);return o===null||r===null?"":l(o,r.cwd,r.profile_id??null,t,void 0,a({...r,grantee:s(e)}))}n(y,"renderWorkspaceOpenDocs");export{S as renderOnReadDocs,y as renderWorkspaceOpenDocs};