@north-light/crouter 0.3.353 → 0.3.355

package/dist/migrations/corpus.d.ts

@@ -1,75 +0,0 @@
-import type { NodeMemoryTarget } from '../core/canvas/types.js';
-import type { CorpusBlocker, CorpusDiscoveryRoot, CorpusIdentityRename, CorpusReferenceRewrite, CorpusRepositoryDecision, CorpusSnapshot, CorpusStore, CorpusStorePrefix, CorpusTarget, ProfileManifestSnapshot, StateMigration, StoreSnapshot } from './types.js';
-/** A store before its documents are read. */
-export type DiscoveredStore = Omit<CorpusStore, 'snapshot'>;
-export interface CorpusDiscovery {
-    /** Every place discovery looked, in the order it looked. */
-    roots: CorpusDiscoveryRoot[];
-    /** Deduped by realpath, in discovery order. Stores whose directory does not
-     *  exist are absent: there is nothing to migrate and nothing to point at. */
-    stores: DiscoveredStore[];
-    targets: CorpusTarget[];
-    /** Roots and targets discovery could not read. */
-    blockers: CorpusBlocker[];
-}
-export interface CorpusSkippedDoc {
-    storeRoot: string;
-    relPath: string;
-    error: string;
-}
-export interface CorpusRunResult {
-    /** Corpus migrations in the registry. Zero means the lane is inert. */
-    migrations: number;
-    /** True when blockers exist and a corpus migration was registered to gate. */
-    blocked: boolean;
-    blockers: CorpusBlocker[];
-    planned: {
-        migration: string;
-        consumers: string[];
-        identities: string[];
-    }[];
-    repositories: CorpusRepositoryDecision[];
-    storePrefixes: CorpusStorePrefix[];
-    renames: CorpusIdentityRename[];
-    references: CorpusReferenceRewrite[];
-    /** Files written, or under `--dry-run` the files that would be written. */
-    wrote: {
-        consumers: string[];
-        identities: string[];
-    };
-    /** True when the post-write rebuild ran every migration's `verify`. */
-    verified: boolean;
-}
-/** Discover the whole reachable corpus: every store, the targets that mount
- *  them, and the frontier searched to find them. `profiles` are the manifest
- *  lane's post-migration snapshots — a pre-migration manifest reads as corrupt,
- *  so discovery must run after that lane, not against `listProfiles()`. */
-export declare function discoverCorpus(opts: {
-    cwd?: string;
-    profiles: readonly ProfileManifestSnapshot[];
-    explicitDirs?: readonly string[];
-    nodes: readonly NodeMemoryTarget[];
-}): Promise<CorpusDiscovery>;
-/** Read every discovered store's documents. `preloaded` supplies the per-store
- *  convergent lane's FOLDED snapshots so the corpus plans against the bytes a
- *  write run leaves behind — identical under `--dry-run`, where the same fold
- *  ran and nothing was written. */
-export declare function loadCorpusSnapshots(discovery: CorpusDiscovery, opts?: {
-    preloaded?: ReadonlyMap<string, StoreSnapshot>;
-}): {
-    snapshots: Map<string, StoreSnapshot>;
-    skipped: CorpusSkippedDoc[];
-};
-export declare function parseFailureBlockers(skipped: readonly CorpusSkippedDoc[]): CorpusBlocker[];
-export declare function buildCorpusSnapshot(discovery: CorpusDiscovery, snapshots: ReadonlyMap<string, StoreSnapshot>): CorpusSnapshot;
-/** Plan every corpus migration over the whole corpus, then — only when the
- *  global plan is blocker-free — write every migration's consumer rewrites
- *  before any identity rewrite. `rebuild` re-reads the corpus from file truth
- *  for the post-write `verify` pass. */
-export declare function runCorpusMigrations(corpus: CorpusSnapshot, opts?: {
-    dryRun?: boolean;
-    migrations?: readonly StateMigration[];
-    /** Discovery and parse-failure blockers, gating identically to plan ones. */
-    blockers?: readonly CorpusBlocker[];
-    rebuild?: () => CorpusSnapshot;
-}): CorpusRunResult;

package/dist/migrations/corpus.js

@@ -1,3 +0,0 @@
-var z=Object.defineProperty;var c=(t,n)=>z(t,"name",{value:n,configurable:!0});import{envProfileId as H}from"../shared/env.js";import{readdirSync as Q}from"node:fs";import{dirname as C,join as x}from"node:path";import{appsRoot as T,appSpace as V}from"../core/layout.js";import{atomicWriteText as L,listDirs as O,pathExists as v,realpathOrSelf as R,removePath as _,walkFiles as X}from"../core/fs-utils.js";import{memoryStoresInPrecedence as Z}from"../core/memory-resolver.js";import{descendantStoreRootsExhaustive as oo}from"../core/nested-stores.js";import{profileMemoryDir as eo}from"../core/profiles/manifest.js";import{memoryDir as to}from"../core/runtime/memory.js";import{listInstalledPlugins as so,listInstalledPluginsInRoot as no}from"../core/resolver.js";import{NEUTRAL_PROJECT_MEMORY as D,pluginMemoryDir as ro,projectScopeRoots as B,scopeRoot as io}from"../core/scope.js";import{CRTR_DIR_NAME as F}from"../types.js";import{foldDocChange as ao,loadStoreSnapshot as co}from"./convergent.js";import{STATE_MIGRATIONS as po}from"./registry.js";function fo(t){return(t instanceof Error?t.message:String(t)).split(`
-`)[0]??""}c(fo,"firstLine");function uo(t){return`${t.profileId??"-"}:${t.nodeId??"-"}:${R(t.cwd)}`}c(uo,"targetId");function lo(t){const n=ro(t);return{scope:t.scope,storeRoot:n,namespace:t.name,plugin:t.name,mountStatus:v(n)?"ready":"absent",projectMemory:D}}c(lo,"pluginStoreDescriptor");function mo(t){return{scope:"node",storeRoot:t,namespace:"",mountStatus:v(t)?"ready":"absent",projectMemory:D}}c(mo,"nodeStoreDescriptor");function ho(){const t=[];for(const n of O(T()))for(const r of O(x(T(),n,"memory","nodes"))){const i=x(T(),n,"memory","nodes",r);if(!v(i))continue;X(i,d=>d.endsWith(".md")&&d!=="SKILL.md",d=>d.startsWith(".")).length>0&&t.push({nodeId:r,storeRoot:i})}return t}c(ho,"nodeStoresWithDocs");async function Do(t){const n=R(t.cwd??process.cwd()),r=H()||null,i=t.explicitDirs??[],m=[],d=new Set,u=c(o=>{const e=`${o.reason}\0${R(o.root)}\0${o.detail??""}`;d.has(e)||(d.add(e),m.push(o))},"addRoot"),y=new Map,P=c((o,e,s)=>{const f=R(o);let p=y.get(f);p===void 0&&(p={root:o,reason:e,profileIds:[]},y.set(f,p)),p.profileIds.includes(s)||p.profileIds.push(s)},"addProjectRoot"),$=[{reason:"cwd-ancestor",profileId:r,roots:B(n,r)},...t.profiles.map(({profileId:o,manifest:e})=>({reason:"profile-project",profileId:o,detail:o,roots:[...new Set(e.projects.flatMap(s=>[x(s.path,F),...B(s.path,null)]))]})),...i.map(o=>({reason:"explicit-dir",profileId:r,detail:o,roots:[x(R(o),F)]}))],S=new Map,b=c(o=>{const e=o.map(f=>R(f)).sort().join(`
-`);let s=S.get(e);return s===void 0&&(s=oo([...o]),S.set(e,s)),s},"descendantsUnder"),j=c((o,e,s,f)=>{const p=f===void 0?{}:{detail:f};for(const h of o)u({reason:e,root:h,boundary:e==="explicit-dir"?"store":"ancestors",...p}),P(h,e,s);for(const h of b(o))u({reason:"descendant",root:h,boundary:"descendants",...p}),P(h,"descendant",s)},"expandRoots");for(const o of $)j(o.roots,o.reason,o.profileId,o.detail);const I=[],k=new Map,w=c((o,e,s)=>{const f=o.storeRoot;if(f===""||!v(f))return;const p=R(f);let h=k.get(p);if(h===void 0){h={key:p,descriptor:o,discovery:[],discoverySeen:new Set,targets:[],writable:o.scope!=="builtin"},k.set(p,h);try{Q(p)}catch(q){I.push({kind:"inaccessible-root",message:`memory store cannot be listed (${fo(q)}) \u2014 discovery cannot see its documents; fix the permissions and re-run`,storeRoot:p})}}const A=`${e.reason}\0${e.root}\0${e.targetId??""}`;h.discoverySeen.has(A)||(h.discoverySeen.add(A),h.discovery.push(e)),s!==void 0&&(h.targets.includes(s.id)||h.targets.push(s.id),s.storeKeys.includes(p)||s.storeKeys.push(p))},"register"),a=[],l=new Map,M=c((o,e,s)=>{const f=uo(s);if(l.has(f))return;const p={id:f,kind:o,origin:e,target:s,storeKeys:[]};l.set(f,p),a.push(p)},"addTarget");M("cwd",n,{cwd:n,profileId:r,nodeId:null});for(const{profileId:o,manifest:e}of t.profiles)M("profile",o,{cwd:e.projects[0]?.path??n,profileId:o,nodeId:null});const g=c(()=>{for(const{root:o,profileIds:e}of[...y.values()])for(const s of[...e])M("project",C(o),{cwd:C(o),profileId:s,nodeId:null})},"addProjectTargets"),Y=ho();v(T())&&u({reason:"node",root:T(),boundary:"nodes"});const G=new Map(t.nodes.map(o=>[o.nodeId,o]));for(const{nodeId:o,storeRoot:e}of Y){const s=G.get(o);if(s===void 0||s.cwd===""||to(o,s.grantee)!==e){const f=s===void 0?"no row":s.cwd===""?"empty cwd":"app assignment differs from folder";I.push({kind:"inaccessible-target",message:`node ${o} holds memory documents but canvas.db has no matching app assignment and usable row for it (${f}) \u2014 the corpus cannot resolve its project or profile`,storeRoot:R(e)}),w(mo(e),{reason:"node",root:e});continue}M("node",o,{cwd:s.cwd,profileId:s.profileId,nodeId:o,grantee:s.grantee})}const J=c(o=>{for(const e of Z(o.target)){if(e.plugin!==void 0){u({reason:"plugin",root:e.storeRoot,boundary:"store",detail:e.plugin}),w(e,{reason:"plugin",root:e.storeRoot,targetId:o.id},o);continue}if(e.scope==="project"){const f=C(e.storeRoot),p=y.get(R(f));p===void 0&&j([f],"cwd-ancestor",o.target.profileId,o.id),w(e,{reason:p?.reason??"cwd-ancestor",root:f,targetId:o.id},o);continue}const s=e.scope==="user"?"user":e.scope==="profile"?"profile":e.scope==="node"?"node":"builtin";u({reason:s,root:e.storeRoot,boundary:"store"}),w(e,{reason:s,root:e.storeRoot,targetId:o.id},o)}},"walkTarget"),E=new Set;for(;;){g();const o=a.filter(e=>!E.has(e.id));if(o.length===0)break;for(const e of o)E.add(e.id),J(e)}const K=io("user");K!==null&&u({reason:"plugin",root:K,boundary:"plugins"});const W=[...so("user")];for(const{root:o}of y.values())u({reason:"plugin",root:o,boundary:"plugins"}),W.push(...no("project",o));for(const o of W){const e=lo(o);u({reason:"plugin",root:e.storeRoot,boundary:"store",detail:o.name}),w(e,{reason:"plugin",root:e.storeRoot})}for(const{profileId:o,manifest:e}of t.profiles){const s=e.grantee?.startsWith("app:")?x(V(e.grantee).memory,"profiles",o):eo(o);u({reason:"profile",root:s,boundary:"store",detail:o}),w({scope:"profile",storeRoot:s,namespace:"",mountStatus:v(s)?"ready":"absent",projectMemory:D},{reason:"profile",root:s})}return{roots:m,stores:[...k.values()].map(o=>({key:o.key,descriptor:o.descriptor,discovery:o.discovery,targets:o.targets,writable:o.writable})),targets:a.map(o=>({id:o.id,kind:o.kind,origin:o.origin,target:o.target,storeKeys:o.storeKeys})),blockers:I}}c(Do,"discoverCorpus");function Eo(t,n={}){const r=new Map,i=[];for(const m of t.stores){const d=n.preloaded?.get(m.key);if(d!==void 0){r.set(m.key,d);continue}const u=co(m.descriptor.storeRoot);r.set(m.key,u.snapshot);for(const y of u.skipped)i.push({storeRoot:m.key,...y})}return{snapshots:r,skipped:i}}c(Eo,"loadCorpusSnapshots");function Ko(t){return t.map(n=>({kind:"parse-failure",message:`${n.relPath}: frontmatter is not valid YAML (${n.error}) \u2014 the document's identity cannot be read; fix the file and re-run`,storeRoot:n.storeRoot,path:x(n.storeRoot,n.relPath)}))}c(Ko,"parseFailureBlockers");function N(t,n,r){const i=new Map(t.map(d=>[d.key,d])),m=new Map(n.map(d=>[d.id,d]));return{stores:t,targets:n,roots:r,store:c(d=>i.get(d),"store"),storesForTarget:c(d=>(m.get(d)?.storeKeys??[]).map(u=>i.get(u)).filter(u=>u!==void 0),"storesForTarget")}}c(N,"makeCorpusSnapshot");function Wo(t,n){const r=t.stores.map(i=>({...i,snapshot:n.get(i.key)??{root:i.descriptor.storeRoot,docs:[]}}));return N(r,t.targets,t.roots)}c(Wo,"buildCorpusSnapshot");function go(t){const n=t.stores.map(r=>({...r,snapshot:{root:r.snapshot.root,docs:[...r.snapshot.docs]}}));return N(n,t.targets,t.roots)}c(go,"cloneCorpus");function U(t,n,r=new Set){let i;for(const m of t.stores)n.path.startsWith(`${m.snapshot.root}/`)&&(i===void 0||m.snapshot.root.length>i.snapshot.root.length)&&(i=m);if(i===void 0){if(r.has(n.path))return;throw new Error(`corpus migration: planned change outside every discovered store: ${n.path}`)}ao(i.snapshot,n)}c(U,"foldCorpusChange");function Ao(t,n={}){const r=(n.migrations??po).filter(a=>a.lane==="corpus"),i=[...n.blockers??[]],m=[],d=[],u=[],y=[],P=[],$=[],S=[],b=c((a,l)=>({migrations:r.length,blocked:i.length>0&&r.length>0,blockers:i,planned:m,repositories:d,storePrefixes:u,renames:y,references:P,wrote:l,verified:a}),"result"),j={consumers:[],identities:[]};if(r.length===0)return b(!1,j);const I=go(t);for(const a of r){const l=a.plan(I);i.push(...l.blockers),d.push(...l.repositories),u.push(...l.storePrefixes),y.push(...l.renames),P.push(...l.references);for(const g of l.consumers)U(I,g);const M=new Set(l.repositories.map(g=>g.declarationPath));for(const g of l.identities)U(I,g,M);$.push(...l.consumers),S.push(...l.identities),m.push({migration:a.description,consumers:l.consumers.map(g=>g.path),identities:l.identities.map(g=>g.path)})}const k={consumers:$.map(a=>a.path),identities:S.map(a=>a.path)};if(i.length>0)return b(!1,j);if(n.dryRun===!0)return b(!1,k);for(const a of $)a.after===null?_(a.path):L(a.path,a.after);for(const a of S)a.after===null?_(a.path):L(a.path,a.after);if(n.rebuild===void 0)return b(!1,k);const w=n.rebuild();for(const a of r)for(const l of a.verify?.(w)??[])i.push({...l,kind:"verification"});return b(!0,k)}c(Ao,"runCorpusMigrations");export{Wo as buildCorpusSnapshot,Do as discoverCorpus,Eo as loadCorpusSnapshots,Ko as parseFailureBlockers,Ao as runCorpusMigrations};

package/dist/migrations/frontmatter-splice.d.ts

@@ -1,15 +0,0 @@
-/** Split a complete document into its raw frontmatter YAML and byte-preserved body. */
-export declare function splitDocSource(source: string, docPath: string): {
-    rawYaml: string;
-    body: string;
-};
-/** Remove complete top-level mapping-key lines, including multiline values. */
-export declare function dropTopLevelKeys(rawYaml: string, keys: readonly string[], docPath: string): string;
-/** Remove selected items from a top-level block sequence without re-rendering retained bytes. */
-export declare function dropSequenceItems(rawYaml: string, key: string, drop: (item: unknown) => boolean, docPath: string): string;
-/** Append a rendered top-level mapping pair while retaining existing YAML bytes. */
-export declare function appendRenderedKey(rawYaml: string, key: string, value: unknown, docPath: string): string;
-/** Prove that a transformed YAML block parses to exactly the expected mapping. */
-export declare function proveFrontmatterRoundTrip(after: string, expected: Record<string, unknown>, docPath: string): void;
-/** Replace only the YAML block in a complete document; the body remains byte-for-byte unchanged. */
-export declare function rebuildDocSource(source: string, newYaml: string, docPath: string): string;

package/dist/migrations/frontmatter-splice.js

@@ -1,8 +0,0 @@
-var A=Object.defineProperty;var p=(e,t)=>A(e,"name",{value:t,configurable:!0});import{isMap as q,isSeq as v,parse as x,parseDocument as k,stringify as O}from"yaml";import{parseFrontmatterGeneric as R}from"../core/frontmatter.js";function w(e,t){if(e===t)return!0;if(Array.isArray(e)||Array.isArray(t))return!Array.isArray(e)||!Array.isArray(t)||e.length!==t.length?!1:e.every((r,n)=>w(r,t[n]));if(e!==null&&t!==null&&typeof e=="object"&&typeof t=="object"){const r=Object.keys(e),n=Object.keys(t);return r.length!==n.length?!1:r.every(c=>w(e[c],t[c]))}return!1}p(w,"deepEqual");function $(e,t){if(e.trim()==="")return[];const r=k(e);if(r.errors.length>0||!q(r.contents))throw new Error(`frontmatter splice: unparseable frontmatter in ${t}`);return r.contents.items}p($,"yamlMap");function j(e,t,r){const n=t.key?.range,c=t.value?.range;if(n===void 0)throw new Error(`frontmatter splice: rangeless key in ${r}`);const f=e.lastIndexOf(`
-`,n[0]-1)+1;let o=c?.[2]??n[2];if(!(o>0&&e[o-1]===`
-`)){for(;o<e.length&&(e[o]===" "||e[o]==="	"||e[o]==="\r");)o++;e[o]===`
-`&&o++}return[f,o]}p(j,"keyLineSpan");function h(e,t){$(e,t);let r;try{r=x(e)}catch{throw new Error(`frontmatter splice: unparseable frontmatter in ${t}`)}if(r===null||typeof r!="object"||Array.isArray(r))throw new Error(`frontmatter splice: frontmatter is not a mapping in ${t}`);return r}p(h,"parseRecord");function D(e,t){let r;try{r=R(e)}catch(n){throw new Error(`frontmatter splice: unparseable frontmatter in ${t}`,{cause:n})}if(r.raw===""&&r.body===e)throw new Error(`frontmatter splice: cannot locate frontmatter block in ${t}`);return{rawYaml:r.raw,body:r.body}}p(D,"splitDocSource");function I(e,t,r){const n=$(e,r),c=new Set(t),f=n.filter(i=>c.has(String(i.key))).map(i=>j(e,i,r)).sort((i,u)=>u[0]-i[0]);let o=e;for(const[i,u]of f)o=o.slice(0,i)+o.slice(u);const l=h(e,r);for(const i of t)delete l[i];return g(o,l,r),o}p(I,"dropTopLevelKeys");function M(e,t,r,n){const f=$(e,n).find(s=>String(s.key)===t);if(f===void 0)return e;if(!v(f.value))throw new Error(`frontmatter splice: ${t} is not a sequence in ${n}`);const o=f.value.items,l=o.map(s=>r(s.toJSON?.()));if(!l.some(Boolean))return e;const i=h(e,n),u=i[t];if(!Array.isArray(u))throw new Error(`frontmatter splice: ${t} is not a sequence in ${n}`);const E=u.filter((s,a)=>!l[a]);if(E.length===0){delete i[t];const s=I(e,[t],n);return g(s,i,n),s}const b=f.value.range;if(b===void 0)throw new Error(`frontmatter splice: rangeless sequence in ${n}`);const y=o.map(s=>{const a=s.range;if(a===void 0)throw new Error(`frontmatter splice: rangeless sequence item in ${n}`);return e.lastIndexOf(`
-`,a[0]-1)+1});if(new Set(y).size!==y.length)throw new Error(`frontmatter splice: flow sequence cannot be spliced byte-precisely in ${n}`);const m=[];for(let s=0;s<o.length;s++){if(!l[s])continue;const a=y[s],S=y[s+1]??b[2];m.push([a,S])}m.sort((s,a)=>a[0]-s[0]);let d=e;for(const[s,a]of m)d=d.slice(0,s)+d.slice(a);return i[t]=E,g(d,i,n),d}p(M,"dropSequenceItems");function N(e,t,r,n){const c=h(e,n);c[t]=r;const f=O({[t]:r},{lineWidth:0});let o=e===""?f:(e.endsWith(`
-`)?e:e+`
-`)+f;return o=o.replace(/\r?\n$/,""),g(o,c,n),o}p(N,"appendRenderedKey");function g(e,t,r){let n;try{n=x(e===""?"{}":e)}catch(c){throw new Error(`frontmatter splice: transformed frontmatter does not parse in ${r}`,{cause:c})}if(!w(n??{},t))throw new Error(`frontmatter splice: spliced frontmatter does not round-trip in ${r}`)}p(g,"proveFrontmatterRoundTrip");function T(e,t,r){const{rawYaml:n,body:c}=D(e,r),f=e.length-c.length,o=e.indexOf(`
-`),l=o<0?-1:o+1,i=l<0?-1:l+n.length;if(n===""&&f===e.length)throw new Error(`frontmatter splice: cannot locate frontmatter block in ${r}`);if(l<0||i>f)throw new Error(`frontmatter splice: cannot locate frontmatter block in ${r}`);return e.slice(0,l)+t+e.slice(i)}p(T,"rebuildDocSource");export{N as appendRenderedKey,M as dropSequenceItems,I as dropTopLevelKeys,g as proveFrontmatterRoundTrip,T as rebuildDocSource,D as splitDocSource};

package/dist/migrations/profile-manifests.d.ts

@@ -1,30 +0,0 @@
-import type { ProfileManifestSnapshot, StateMigration } from './types.js';
-export interface ProfileManifestRunResult {
-    /** Profile manifests found under the profiles root. */
-    profiles: number;
-    /** One row per migration that rewrote a manifest, in registry order. */
-    applied: {
-        profileId: string;
-        path: string;
-        migration: string;
-    }[];
-    /** Post-migration manifest per readable profile, in scan order — coherent
-     *  under `dryRun`, where the same fold ran but nothing was written. */
-    snapshots: ProfileManifestSnapshot[];
-    /** Manifests left untouched because they are not valid JSON. Unreadable
-     *  bytes are not a structure this lane can convert, and failing the run over
-     *  one would block every other profile's convergence. */
-    skipped: {
-        profileId: string;
-        path: string;
-        error: string;
-    }[];
-}
-export declare function runProfileManifestMigrations(profilesRoot: string, opts: {
-    /** Held for the whole re-read/fold/write of one manifest — the same lock
-     *  add/remove take, so a concurrent mutation either lands before the
-     *  re-read or serializes after the write, never under it. */
-    withLock: <T>(profileId: string, fn: () => T) => T;
-    dryRun?: boolean;
-    migrations?: readonly StateMigration[];
-}): ProfileManifestRunResult;

package/dist/migrations/profile-manifests.js

@@ -1,2 +0,0 @@
-var d=Object.defineProperty;var l=(n,o)=>d(n,"name",{value:o,configurable:!0});import{existsSync as u,readFileSync as h,readdirSync as y}from"node:fs";import{join as S}from"node:path";import{atomicWriteJson as g}from"../core/fs-utils.js";import{STATE_MIGRATIONS as w}from"./registry.js";const A=/^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/;function x(n,o){const m=(o.migrations??w).filter(s=>s.lane==="profile-manifest"),e={profiles:0,applied:[],snapshots:[],skipped:[]};if(!u(n))return e;for(const s of y(n,{withFileTypes:!0})){if(!s.isDirectory())continue;const t=s.name;if(!A.test(t))continue;const i=S(n,t,"profile.json");u(i)&&(e.profiles+=1,o.withLock(t,()=>{let f;try{const r=JSON.parse(h(i,"utf8"));if(typeof r!="object"||r===null||Array.isArray(r))throw new Error("manifest is not a JSON object");f=r}catch(r){e.skipped.push({profileId:t,path:i,error:(r instanceof Error?r.message:String(r)).split(`
-`)[0]});return}let a=f,c=!1;for(const r of m){const p=r.apply({profileId:t,path:i,raw:a});p!==null&&(a=p,c=!0,e.applied.push({profileId:t,path:i,migration:r.description}))}c&&o.dryRun!==!0&&g(i,a),e.snapshots.push({profileId:t,path:i,manifest:a})}))}return e}l(x,"runProfileManifestMigrations");export{x as runProfileManifestMigrations};

package/dist/migrations/registry.d.ts

@@ -1,7 +0,0 @@
-import type { OnDiskMigrationLane, StateMigration } from './types.js';
-export declare const STATE_MIGRATIONS: readonly StateMigration[];
-export interface OnDiskMigrationIdentity {
-    readonly id: string;
-    readonly lane: OnDiskMigrationLane;
-}
-export declare function onDiskMigrationIdentity(): readonly OnDiskMigrationIdentity[];

package/dist/migrations/registry.js

@@ -1 +0,0 @@
-var i=Object.defineProperty;var t=(o,r)=>i(o,"name",{value:r,configurable:!0});import{surfacesFrontmatterMigration as e}from"./001-surfaces-frontmatter.js";import{profileProjectMemoryMigration as n}from"./002-profile-project-memory.js";import{repositoryRootMemoryIdentityMigration as m}from"./003-repository-root-memory-identity/index.js";const a=[e,n,m];function y(){return a.filter(o=>o.lane!=="journaled").map(({id:o,lane:r})=>({id:o,lane:r}))}t(y,"onDiskMigrationIdentity");export{a as STATE_MIGRATIONS,y as onDiskMigrationIdentity};

package/dist/migrations/runner.d.ts

@@ -1,43 +0,0 @@
-import type { NodeMemoryTarget } from '../core/canvas/types.js';
-import { type CorpusDiscovery } from './corpus.js';
-import type { CorpusBlocker, CorpusIdentityRename, CorpusRepositoryDecision, CorpusStorePrefix, CorpusReferenceRewrite, OnDiskMigrationLane, StoreSnapshot } from './types.js';
-export type OnDiskMigrationPhase = 'not-started' | 'planned' | 'written';
-export interface OnDiskMigrationApplied {
-    store: string;
-    lane: OnDiskMigrationLane;
-    migration: string;
-    files: string[];
-}
-export interface OnDiskMigrationSkipped {
-    store: string;
-    relPath: string;
-    error: string;
-}
-export interface OnDiskMigrationRunResult {
-    profiles: number;
-    discovery: CorpusDiscovery;
-    snapshots: ReadonlyMap<string, StoreSnapshot>;
-    changed: number;
-    applied: OnDiskMigrationApplied[];
-    skipped: OnDiskMigrationSkipped[];
-    blocked: boolean;
-    blockers: CorpusBlocker[];
-    corpusPhase: OnDiskMigrationPhase;
-    wrote: {
-        profileManifests: string[];
-        documents: string[];
-        corpusConsumers: string[];
-        corpusIdentities: string[];
-    };
-    repositories: CorpusRepositoryDecision[];
-    storePrefixes: CorpusStorePrefix[];
-    renames: CorpusIdentityRename[];
-    references: CorpusReferenceRewrite[];
-    finalVerificationSucceeded: boolean;
-    dryRun: boolean;
-}
-export declare function runOnDiskMigrations(opts: {
-    dryRun?: boolean;
-    explicitDirs?: readonly string[];
-    nodes: readonly NodeMemoryTarget[];
-}): Promise<OnDiskMigrationRunResult>;

package/dist/migrations/runner.js

@@ -1 +0,0 @@
-var b=Object.defineProperty;var l=(n,t)=>b(n,"name",{value:t,configurable:!0});import{profileSpace as y}from"../core/layout.js";import{listStoredProfiles as C}from"../core/scoped-state/profiles.js";import{resetScopeCache as R,userScopeRoot as S}from"../core/scope.js";import{buildCorpusSnapshot as g,discoverCorpus as v,loadCorpusSnapshots as k,parseFailureBlockers as M,runCorpusMigrations as P}from"./corpus.js";import{runConvergentMigrations as x}from"./convergent.js";async function j(n){const t=n.dryRun===!0,i=[],u=[],f=C(S()).map(({profileId:e,manifest:r})=>({profileId:e,manifest:r,path:y(r.grantee??"app:terminal",e).memory}));R();const s=await v({profiles:f,explicitDirs:n.explicitDirs,nodes:n.nodes}),p=[],d=new Map;for(const e of s.stores){if(!e.writable)continue;const r=x(e.descriptor.storeRoot,{dryRun:t});d.set(e.key,r.snapshot);for(const c of r.applied)i.push({store:e.key,lane:"convergent",migration:c.migration,files:c.files});for(const c of r.skipped)p.push({storeRoot:e.key,...c})}const a=k(s,{preloaded:d});p.push(...a.skipped);for(const e of p)u.push({store:e.storeRoot,relPath:e.relPath,error:e.error});const o=P(g(s,a.snapshots),{dryRun:t,blockers:[...s.blockers,...M(p)],rebuild:l(()=>g(s,k(s).snapshots),"rebuild")}),m=o.wrote.consumers.length>0||o.wrote.identities.length>0;if(m)for(const e of o.planned){const r=[...e.consumers,...e.identities];r.length>0&&i.push({store:"corpus",lane:"corpus",migration:e.migration,files:r})}const w=t?"planned":m?"written":"not-started",h=o.blocked;return{profiles:f.length,discovery:s,snapshots:a.snapshots,changed:i.reduce((e,r)=>e+r.files.length,0),applied:i,skipped:u,blocked:h,blockers:o.blockers,corpusPhase:w,wrote:{profileManifests:[],documents:i.filter(e=>e.lane==="convergent").flatMap(e=>e.files),corpusConsumers:o.wrote.consumers,corpusIdentities:o.wrote.identities},repositories:o.repositories,storePrefixes:o.storePrefixes,renames:o.renames,references:o.references,finalVerificationSucceeded:o.verified&&!h,dryRun:t}}l(j,"runOnDiskMigrations");export{j as runOnDiskMigrations};

package/dist/migrations/types.d.ts

@@ -1,211 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite';
-import type { MemoryStoreDescriptor, MemoryTarget } from '../core/memory-resolver.js';
-import type { ProjectNamespaceSource } from '../core/memory/project-namespace.js';
-import type { ProfileManifest } from '../types.js';
-export interface JournaledMigration {
-    lane: 'journaled';
-    description: string;
-    /** Runs inside the canvas-db migration transaction. Filesystem work under
-     *  `canvasHome` is OUTSIDE that transaction — it must be crash-resumable
-     *  (a re-run after a partial application completes rather than corrupts). */
-    apply(db: DatabaseSync, canvasHome: string): void;
-}
-export interface ConvergentMigration {
-    readonly id: string;
-    lane: 'convergent';
-    description: string;
-    /** Pure planning: return the full new text of each doc to rewrite. The
-     *  runner filters no-op changes and performs the writes. */
-    apply(store: StoreSnapshot): DocChange[];
-}
-/** One stored `profile.json` handed to the profile-manifest lane. */
-export interface ProfileManifestInput {
-    /** The immediate directory name under the profiles root. The only root
-     *  classifier a migration may key on — a manifest `name` is mutable. */
-    profileId: string;
-    /** Absolute path to the `profile.json`. */
-    path: string;
-    /** Parsed JSON exactly as stored, historical shapes included. */
-    raw: Record<string, unknown>;
-}
-export interface ProfileManifestMigration {
-    readonly id: string;
-    lane: 'profile-manifest';
-    description: string;
-    /** Pure planning: the full replacement record, or null when this manifest is
-     *  already current. A structure the migration cannot convert THROWS — the
-     *  run fails rather than persisting a guessed value. */
-    apply(input: ProfileManifestInput): Record<string, unknown> | null;
-}
-export type OnDiskMigration = ConvergentMigration | ProfileManifestMigration | CorpusMigration;
-export type OnDiskMigrationLane = OnDiskMigration['lane'];
-export type StateMigration = JournaledMigration | OnDiskMigration;
-/** One profile's manifest after every profile-manifest migration folded —
- *  the bytes on disk after a write run, and the bytes a write run WOULD have
- *  produced under `--dry-run`. */
-export interface ProfileManifestSnapshot {
-    profileId: string;
-    path: string;
-    manifest: ProfileManifest;
-}
-/** One parsed markdown doc in a store snapshot. */
-export interface StoreDoc {
-    /** Absolute file path. */
-    path: string;
-    /** Path relative to the store root, `/`-separated. */
-    relPath: string;
-    /** Full file text as read from disk. */
-    source: string;
-    /** Parsed frontmatter record (null when the file has no frontmatter block). */
-    frontmatter: Record<string, unknown> | null;
-    body: string;
-}
-/** Every parseable `.md` doc under one memory-store root. */
-export interface StoreSnapshot {
-    root: string;
-    docs: StoreDoc[];
-}
-/** One planned rewrite: the full new file text for `path`. */
-export interface DocChange {
-    path: string;
-    /** Complete replacement text for the file, or null to delete it. */
-    after: string | null;
-}
-/** Why a root or store entered the corpus. `cwd-ancestor` is the walk up from
- *  the invoking directory, `profile-project` a project a profile manifest names,
- *  `descendant` the exhaustive nested-store walk below either, `explicit-dir` a
- *  `--dir` argument. */
-export type CorpusDiscoveryReason = 'user' | 'profile' | 'profile-project' | 'cwd-ancestor' | 'descendant' | 'node' | 'plugin' | 'builtin' | 'explicit-dir';
-/** How far discovery searched from one root: the root's own store only, the
- *  ancestor walk above it, the exhaustive descendant walk below it, its
- *  installed plugins, or the canvas node stores. */
-export type CorpusDiscoveryBoundary = 'store' | 'ancestors' | 'descendants' | 'plugins' | 'nodes';
-/** One place discovery looked, reported whether or not it yielded a store —
- *  the frontier an operator reads to see what a run could NOT have seen. */
-export interface CorpusDiscoveryRoot {
-    reason: CorpusDiscoveryReason;
-    /** The directory searched: a `.crouter` root, a store dir, or a scan root. */
-    root: string;
-    boundary: CorpusDiscoveryBoundary;
-    /** Profile id, node id, or the `--dir` argument that produced this root. */
-    detail?: string;
-}
-/** One reason a store is in the corpus. A store reached several ways keeps
- *  every reason — deduping physical stores must not erase why they matter. */
-export interface CorpusStoreDiscovery {
-    reason: CorpusDiscoveryReason;
-    root: string;
-    targetId?: string;
-}
-export interface CorpusStore {
-    /** Realpath of the memory dir: the dedup key, and the id every report row and
-     *  blocker cites this store by. */
-    key: string;
-    descriptor: MemoryStoreDescriptor;
-    /** Documents after the per-store convergent lane folded, so the corpus lane
-     *  plans against exactly the bytes a write run leaves on disk. */
-    snapshot: StoreSnapshot;
-    discovery: readonly CorpusStoreDiscovery[];
-    /** Ids of every target that mounts this store. Empty for a store no target
-     *  reaches — a disabled plugin, a node store whose metadata is unreadable. */
-    targets: readonly string[];
-    /** False for builtin: package-owned, regenerated on install, corpus INPUT
-     *  only (link resolution and lint validation), never written. */
-    writable: boolean;
-}
-export interface CorpusTarget {
-    /** `${profileId ?? '-'}:${nodeId ?? '-'}:${realCwd}`. */
-    id: string;
-    kind: 'cwd' | 'profile' | 'project' | 'node';
-    /** Profile id, node id, or the directory this target speaks for. */
-    origin: string;
-    target: MemoryTarget;
-    /** Store keys in this target's source precedence order. */
-    storeKeys: readonly string[];
-}
-export interface CorpusSnapshot {
-    stores: readonly CorpusStore[];
-    targets: readonly CorpusTarget[];
-    roots: readonly CorpusDiscoveryRoot[];
-    store(key: string): CorpusStore | undefined;
-    /** The target's stores in precedence order; empty for an unknown target. */
-    storesForTarget(targetId: string): CorpusStore[];
-}
-/** Why a corpus run may not write. `inaccessible-root`/`inaccessible-target`
- *  mean discovery could not see all of the corpus; `package-owned-corpus` is a
- *  store the run may only read (builtin, or a package handed in read-only)
- *  whose documents still need an identity rewrite; `verification` is raised
- *  after both write phases, against a corpus rebuilt from file truth. */
-export type CorpusBlockerKind = 'inaccessible-root' | 'inaccessible-target' | 'parse-failure' | 'namespace' | 'association' | 'front-door' | 'divergent-reference' | 'unsafe-route' | 'collision' | 'package-owned-corpus' | 'verification';
-export interface CorpusBlocker {
-    kind: CorpusBlockerKind;
-    /** What is wrong and what the operator does about it. */
-    message: string;
-    storeRoot?: string;
-    targetId?: string;
-    /** The one file at fault. */
-    path?: string;
-    /** The canonical name or namespace at fault. */
-    name?: string;
-    /** Every file at fault when the finding is a relationship between them. */
-    paths?: string[];
-}
-export interface CorpusRepositoryDecision {
-    repositoryRoot: string;
-    repositoryKey: string;
-    declarationPath: string;
-    namespace: string;
-    source: 'declared' | ProjectNamespaceSource;
-    action: 'kept' | 'created' | 'filled-linked-root';
-}
-export type FrontDoorAction = 'none' | 'kept-root' | 'created-root' | `transferred-from:${string}`;
-export interface CorpusStorePrefix {
-    storeRoot: string;
-    ownerDir: string;
-    repositoryRoot: string;
-    ownerRelativePath: string;
-    oldPrefix: string;
-    oldRule: 'pre-003' | 'per-store-declaration';
-    effectivePrefix: string;
-    nestedDeclarationAction: 'none' | 'removed' | 'synthetic-index-removed';
-    /** Only the repository-root store reports the repository's front-door action. */
-    frontDoorAction: FrontDoorAction;
-}
-export interface CorpusIdentityRename {
-    storeRoot: string;
-    path: string;
-    from: string;
-    to: string;
-}
-export interface CorpusReferenceRewrite {
-    storeRoot: string;
-    path: string;
-    kind: 'link' | 'memory-read';
-    from: string;
-    to: string;
-}
-export interface CorpusPlan {
-    /** A blocker anywhere stops the whole lane: nothing is written in any store. */
-    blockers: CorpusBlocker[];
-    /** Phase 1 — rewrites of authored links and routes that POINT AT an identity. */
-    consumers: DocChange[];
-    /** Phase 2 — rewrites that change a document's own identity. A non-null
-     *  `after` is the file's complete final text INCLUDING that same file's
-     *  phase-1 consumer rewrites: phase 2 writes last and would otherwise revert
-     *  them. A null `after` deletes an obsolete synthetic identity document. */
-    identities: DocChange[];
-    repositories: CorpusRepositoryDecision[];
-    storePrefixes: CorpusStorePrefix[];
-    renames: CorpusIdentityRename[];
-    references: CorpusReferenceRewrite[];
-}
-export interface CorpusMigration {
-    readonly id: string;
-    lane: 'corpus';
-    description: string;
-    /** Pure planning over every discovered store at once. */
-    plan(corpus: CorpusSnapshot): CorpusPlan;
-    /** Re-checked against a corpus rebuilt from file truth AFTER both write
-     *  phases; findings surface as `verification` blockers. */
-    verify?(corpus: CorpusSnapshot): CorpusBlocker[];
-}

package/dist/shared/birth-announcement.d.ts

@@ -1,12 +0,0 @@
-/** The entry marker keeps delivery-time rendering exclusive to birth notices. */
-export declare const BIRTH_ANNOUNCEMENT_MARKER = "crtr.birth-announcement.v1";
-export declare const BIRTH_ANNOUNCEMENT_AGE_TOKEN = "[[CRTR_BIRTH_ANNOUNCEMENT_AGE]]";
-export declare function birthAnnouncementBody(child: {
-    name: string;
-    nodeId: string;
-    kind: string;
-    creator: string;
-}): string;
-export declare function birthAnnouncementAge(createdAt: string, now?: number): string;
-/** Return a birth notice's body rendered at delivery, or null for every other entry. */
-export declare function renderBirthAnnouncementBody(data: Record<string, unknown> | undefined, createdAt: string, now?: number): string | null;

package/dist/shared/birth-announcement.js

@@ -1 +0,0 @@
-var i=Object.defineProperty;var t=(n,o)=>i(n,"name",{value:o,configurable:!0});const c="crtr.birth-announcement.v1",a="[[CRTR_BIRTH_ANNOUNCEMENT_AGE]]";function _(n){return`${n.name} (${n.nodeId}, ${n.kind}) was created under you by ${n.creator} ${a} ago. For your awareness only \u2014 no response or action is needed, and no need to mention it unless asked. Treat its future reports as background you already know about; investigate only if something genuinely needs you.`}t(_,"birthAnnouncementBody");function d(n,o=Date.now()){const e=Math.max(0,o-Date.parse(n));if(e<6e4)return"moments";const r=Math.floor(e/6e4);if(r<60)return`${r} minute${r===1?"":"s"}`;const s=Math.floor(e/36e5);if(s<48)return`${s} hour${s===1?"":"s"}`;const u=Math.floor(e/864e5);return`${u} day${u===1?"":"s"}`}t(d,"birthAnnouncementAge");function f(n,o,e=Date.now()){return n?.birth_announcement!==c||typeof n.body!="string"?null:n.body.replace(a,d(o,e))}t(f,"renderBirthAnnouncementBody");export{a as BIRTH_ANNOUNCEMENT_AGE_TOKEN,c as BIRTH_ANNOUNCEMENT_MARKER,d as birthAnnouncementAge,_ as birthAnnouncementBody,f as renderBirthAnnouncementBody};

package/docs/sdk/guides/app-memory.md

@@ -1,22 +0,0 @@
----
-title: Application memory
-description: When an application's agents need shared durable knowledge, read this because a profile store gives runs one owned memory location and scopes can allow reading without writing.
----
-
-# Application memory
-
-Use this recipe when several runs need the same application guidance. Run `npx tsx examples/guides/app-memory.ts /path/to/repo`; it ensures a profile, creates a profile-owned knowledge document if it does not already exist, then starts a run allowed to read but not write memory.
-
-<include lang="ts">../../../examples/guides/app-memory.ts</include>
-
-A profile is the application's durable identity: it names the memory store and the projects whose context the profile can reach. The routing line is part of the document, not decoration. State both the moment the agent should read it and the reason it matters; a document with a vague routing line will not surface when the agent needs it.
-
-The `boot`/`preview` surface exposes the document's routing line when this profile's agent starts. The task asks for a release note without naming `release/voice`; in the local run the agent read that document before producing the note. Without a surface entry, a memory document appears only in its directory listing and its routing line cannot select it at boot. The run passes `scopes: ['memory:read']`. That is an allow-list: node-targeted memory reads are allowed and writes are refused because `memory:write` is absent. The application itself is not narrowed by those node scopes, so keep application credentials and its memory mutation policy separate from the agent's capabilities.
-
-Observed against the local daemon with `APP_PROFILE=release-notes-app-guide-boot-preview GUIDE_MODEL=openai-codex/gpt-6-sol:high`:
-
-```text
-You can now download your invoices as a CSV from account settings.
-```
-
-Use profile memory for knowledge shared across the application's related projects. Put facts that belong to one repository in project memory instead, and temporary run notes in node memory. See [memory](../../concepts/memory.md) for the ownership tiers and [profiles, kinds, and modes](../../concepts/profiles-kinds-and-modes.md) for what a profile changes.

package/docs/sdk/memory.md

@@ -1,85 +0,0 @@
----
-title: Memory
-description: Read and write memory documents with an explicit target for every request.
----
-
-# `client.memory`
-
-Phase 3. `client.memory` reads and writes the memory documents that shape an agent run. Every call names its target; the daemon never uses its own working directory or environment to select memory.
-
-```ts
-const page = await client.memory.list({ node: nodeId, kind: 'knowledge', limit: 50 });
-const document = await client.memory.retrieve('insights/capture', { node: nodeId, frontmatter: true });
-```
-
-## Target
-
-```ts
-type MemoryScope = {
-  node?: string;
-  cwd?: string;
-  profile?: string;
-  store?: 'node' | 'project' | 'profile' | 'user' | 'builtin';
-};
-```
-
-Pass `node` to use that node's working directory and profile. Do not combine it with `cwd` or `profile`. With no target, only user and builtin memory are searched. `store` restricts the request to one memory tier; `store: 'node'` requires `node`, and `store: 'profile'` requires a profile target. `create` defaults to the nearest project store when one is available, otherwise the user store. `update`, `delete`, and `move` resolve the existing document through normal scope precedence when `store` is omitted. `builtin` is read-only.
-
-When a request supplies `node`, its node row must hold `memory:read` for `list`, `retrieve`, `search`, `history`, and `resolve`, or `memory:write` for `create`, `update`, `delete`, and `move`. Calls without `node` are external application calls and are not narrowed by a node scope list.
-
-## Methods
-
-Every method accepts `RequestOptions` as its final optional argument (`signal`, `timeout`, `maxRetries`, and `headers`). A document name can contain `/`; the SDK encodes it as one path segment.
-
-| Method | Parameters | Result |
-|---|---|---|
-| `memory.list(query?, options?)` | `MemoryScope & { kind?, limit?, after? }`; `limit` is 1–100 (default 100) | `MemoryPage<MemoryDocSummaryDTO>` |
-| `memory.retrieve(name, query?, options?)` | `name`; `MemoryScope & { frontmatter? }` | `MemoryDocDTO` |
-| `memory.create(params, options?)` | `MemoryDocCreateRequest` | `MemoryDocDTO` |
-| `memory.update(name, params, options?)` | `name`; `MemoryDocUpdateRequest` | `MemoryDocDTO` |
-| `memory.delete(name, scope?, options?)` | `name`; `MemoryScope` | `MemoryDocDeletedDTO` |
-| `memory.move(name, params, options?)` | `name`; `MemoryDocMoveRequest` | `MemoryDocMovedDTO` |
-| `memory.search(params, options?)` | `MemorySearchRequest` | `MemoryPage<MemorySearchHitDTO>` |
-| `memory.history(name, query?, options?)` | `name`; `MemoryHistoryQuery` | `MemoryHistoryDTO` |
-| `memory.resolve(name, scope?, options?)` | `name`; `MemoryScope` | `MemoryDocRefDTO` |
-
-`MemoryDocCreateRequest` requires `name`, `kind`, `when_and_why_to_read`, and `body`; it also accepts `frontmatter`, `extensions`, and the scope fields. `frontmatter.privacy` accepts `public`, `friends`, or `private`; creation defaults to persisted `public`. `MemoryDocUpdateRequest` requires `rationale`, which is stored in revision history rather than document text, and optionally accepts `body`, `frontmatter`, `extensions`, `unset`, and the scope fields. Set `frontmatter.privacy` to change the level; it cannot be unset. A legacy document without the field reads as `private`. `MemoryDocMoveRequest` requires `to` and accepts the scope fields.
-
-`retrieve` returns the body by default. With `frontmatter: true`, its `body` is the complete document source with the effective privacy level included for older documents. `MemoryDocDTO` also contains `privacy`, `frontmatter`, `representation` (`'leaf-file'` or `'directory-index'`), `links`, and any lint `findings`; document DTOs include their canonical name, kind, scope, extensions, path, store root, physical relative path, and any competing candidates. `resolve` returns the winning document's location and optional plugin name without reading its body.
-
-```ts
-await client.memory.create({
-  name: 'billing/refund-policy',
-  kind: 'knowledge',
-  when_and_why_to_read: 'When handling a refund request, read this because the eligibility window is not in the order record.',
-  body: 'Refunds are available for 60 days.',
-  profile: 'my-app',
-});
-
-await client.memory.update('billing/refund-policy', {
-  rationale: 'The eligibility window changed on 2026-01-04.',
-  body: 'Refunds are available for 90 days.',
-  profile: 'my-app',
-});
-```
-
-The daemon returns document text without expanding shell blocks. Builtin and plugin documents are read-only. `kind`, `when-and-why-to-read`, `origin`, and `last-updated` cannot be set or removed directly. Each mutation writes a complete before/after history record; delete leaves a tombstone. `retrieve` and `resolve` return `NotFoundError` with status 404 and code `memory_document_not_found` for a deleted document or an unknown name. Concurrent writes are last-write-wins.
-
-`search` uses ranked search by default. Set `body: true` to include document bodies in ranking, or `grep: true` for regular-expression line matches; `grep` and `body` cannot be combined, and `min_score` is only available in ranked search. Ranked hits contain `kind`, `score`, and `short_form`; grep hits contain `line` and `text`.
-
-`history` returns newest-first revision summaries, optionally with `diff`, or the full before/after record for one `revision`. A delete leaves history available through its tombstone.
-
-## Pages
-
-`list` and `search` return `{ object: 'list', data, has_more }` as a `MemoryPage`. A page has `hasNextPage()`, `getNextPage()`, and is async iterable across every page. The list cursor is the final document's canonical name. Ranked search uses the final hit's name; grep uses an opaque cursor that includes the match location, which the SDK handles.
-
-```ts
-const page = await client.memory.search({ query: 'refund window', node: nodeId });
-for (const hit of page.data) console.log(hit.name);
-
-if (page.hasNextPage()) {
-  const next = await page.getNextPage();
-}
-
-for await (const hit of page) console.log(hit.name);
-```