@crouton-kit/crouter 0.3.36 → 0.3.38

package/dist/core/scope.js

@@ -4,7 +4,19 @@ import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { CRTR_DIR_NAME } from '../types.js';
 import { usage } from './errors.js';
-let cachedProjectRoot;
+import { loadProfileManifest } from './profiles/manifest.js';
+// Cache of resolved project-scope-root STACKS, keyed by (resolved cwd, profile
+// id). A profile widens the pointer set beyond the bare cwd (see
+// findProjectScopeRoots below), so the cache key must carry both — the same
+// cwd resolves to a different stack under a different (or no) profile.
+// `resetScopeCache()` (called by every profile mutation in
+// src/core/profiles/manifest.ts) clears the whole cache; there is no
+// per-entry invalidation because a profile edit can change which pointer set
+// any cached cwd belongs to.
+const scopeRootsCache = new Map();
+function scopeRootsCacheKey(resolvedStartDir, profileId) {
+    return `${resolvedStartDir}\u0000${profileId ?? ''}`;
+}
 export function builtinViewsRoot() {
     // Resolved relative to this file: dist/core/scope.js → dist/builtin-views/
     // (src/ at dev time).
@@ -47,20 +59,13 @@ function isProjectScopeDir(candidate, userRoot) {
     }
 }
 export function findProjectScopeRoot(startDir = process.cwd()) {
-    if (cachedProjectRoot !== undefined)
-        return cachedProjectRoot;
-    const roots = findProjectScopeRoots(startDir);
-    cachedProjectRoot = roots[0] ?? null;
-    return cachedProjectRoot;
-}
-/** Every project scope root visible from `startDir`, nearest first. Each
- *  ancestor directory with a `.crouter/` contributes memory/preferences to the
- *  current workspace; the nearest root still wins for writes and duplicate doc
- *  names. The user-global `~/.crouter/` is excluded because it is the separate
- *  user scope, not a project ancestor. */
-export function findProjectScopeRoots(startDir = process.cwd()) {
+    return findProjectScopeRoots(startDir)[0] ?? null;
+}
+/** Walk `startDir` upward to the filesystem root, collecting every ancestor
+ *  `.crouter/` dir (nearest first). The user-global `~/.crouter/` is excluded
+ *  because it is the separate user scope, not a project ancestor. */
+function collectAncestorScopeRoots(startDir, userRoot) {
     const roots = [];
-    const userRoot = userScopeRoot();
     let dir = resolve(startDir);
     while (true) {
         const candidate = join(dir, CRTR_DIR_NAME);
@@ -72,11 +77,55 @@ export function findProjectScopeRoots(startDir = process.cwd()) {
         dir = parent;
     }
 }
+/** Every project scope root visible from `startDir`, nearest first — now a
+ *  PROFILE-AWARE pointer walk, not a single-pointer ancestor walk. Pointers are
+ *  `[startDir]` plus, when `profileId` resolves to a manifest, each of its
+ *  `projects` in manifest order; each pointer independently walks upward
+ *  collecting every ancestor `.crouter/` dir, the pointers' contributions
+ *  concatenate in pointer order, and the combined list dedupes to first
+ *  occurrence — so a `.crouter/` shared by two pointers contributes once, at
+ *  whichever pointer reached it first. `profileId` defaults to the process's
+ *  selected profile (`CRTR_PROFILE_ID`); a null/unresolvable profile collapses
+ *  to the single `[startDir]` pointer, reproducing today's behavior exactly.
+ *  Results are cached per (resolved startDir, profileId) — `resetScopeCache()`
+ *  invalidates on any profile mutation that can change project dirs or names. */
+export function findProjectScopeRoots(startDir = process.cwd(), profileId = process.env['CRTR_PROFILE_ID'] || null) {
+    const resolvedStart = resolve(startDir);
+    const key = scopeRootsCacheKey(resolvedStart, profileId);
+    const cached = scopeRootsCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const userRoot = userScopeRoot();
+    const pointers = [resolvedStart];
+    if (profileId !== null && profileId !== '') {
+        try {
+            const { manifest } = loadProfileManifest(profileId);
+            pointers.push(...manifest.projects);
+        }
+        catch {
+            // Missing/deleted/invalid profile: this is a hot path every memory and
+            // launch-config resolve runs through, so fall back to the bare
+            // `[startDir]` pointer rather than throwing.
+        }
+    }
+    const seen = new Set();
+    const roots = [];
+    for (const pointer of pointers) {
+        for (const root of collectAncestorScopeRoots(pointer, userRoot)) {
+            if (seen.has(root))
+                continue;
+            seen.add(root);
+            roots.push(root);
+        }
+    }
+    scopeRootsCache.set(key, roots);
+    return roots;
+}
 export function projectScopeRoot(startDir) {
     return findProjectScopeRoot(startDir);
 }
-export function projectScopeRoots(startDir) {
-    return findProjectScopeRoots(startDir);
+export function projectScopeRoots(startDir, profileId) {
+    return findProjectScopeRoots(startDir, profileId);
 }
 export function scopeRoot(scope) {
     // The builtin scope has no scope-root dir: its only content is memory
@@ -96,9 +145,16 @@ export function ensureProjectScopeRoot(startDir = process.cwd()) {
     const found = findProjectScopeRoot(startDir);
     if (found)
         return found;
-    // Initialize new project scope at startDir
-    const root = join(resolve(startDir), CRTR_DIR_NAME);
-    cachedProjectRoot = root;
+    // Initialize new project scope at startDir. `found` was falsy, which means
+    // the (resolvedStart, profileId) cache key above resolved to an EMPTY stack
+    // (no pointer had an existing `.crouter/` yet) — seed that same cache entry
+    // with the about-to-exist root so a caller that immediately writes under it
+    // (without an intervening disk rescan) sees it without a stale empty-array
+    // cache hit.
+    const resolvedStart = resolve(startDir);
+    const root = join(resolvedStart, CRTR_DIR_NAME);
+    const profileId = process.env['CRTR_PROFILE_ID'] || null;
+    scopeRootsCache.set(scopeRootsCacheKey(resolvedStart, profileId), [root]);
     return root;
 }
 export function pluginsDir(scope) {
@@ -154,5 +210,5 @@ export function listScopes(scopeArg) {
     return [v];
 }
 export function resetScopeCache() {
-    cachedProjectRoot = undefined;
+    scopeRootsCache.clear();
 }

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

@@ -1,9 +1,9 @@
-export { KINDS, isDocKind, RUNGS, rungRank, rungAtLeast, FALLBACK_RUNG, parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, } from './schema.js';
+export { KINDS, isDocKind, RUNGS, rungRank, rungAtLeast, FALLBACK_RUNG, parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, normalizeNameSegment, normalizeDocName, } from './schema.js';
 export type { DocKind, Rung, GatePredicate, SubstrateSchema, SubstrateDoc } from './schema.js';
-export { scopeForCwd, spineDepth, assembleNodeSubject } from './subject.js';
+export { scopeForCwd, spineDepth, assembleNodeSubject, profileNameFor } from './subject.js';
 export type { NodeConfigSubject } from './subject.js';
 export { gatePasses } from './gate.js';
 export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveRung, } from './ceiling.js';
 export type { Surface } from './ceiling.js';
-export { renderPreferencesSection, renderKnowledgeBlock, } from './render.js';
+export { renderPreferencesSection, renderKnowledgeBlock, renderPreferencesForSubject, } from './render.js';
 export { renderOnReadDocs } from './on-read.js';

package/dist/core/substrate/index.js

@@ -11,9 +11,11 @@ RUNGS, rungRank, rungAtLeast,
 // fallback floor
 FALLBACK_RUNG, 
 // parse + render-shared helpers
-parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, } from './schema.js';
-export { scopeForCwd, spineDepth, assembleNodeSubject } from './subject.js';
+parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, 
+// display-name normalization
+normalizeNameSegment, normalizeDocName, } from './schema.js';
+export { scopeForCwd, spineDepth, assembleNodeSubject, profileNameFor } from './subject.js';
 export { gatePasses } from './gate.js';
 export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveRung, } from './ceiling.js';
-export { renderPreferencesSection, renderKnowledgeBlock, } from './render.js';
+export { renderPreferencesSection, renderKnowledgeBlock, renderPreferencesForSubject, } from './render.js';
 export { renderOnReadDocs } from './on-read.js';

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

@@ -56,7 +56,7 @@ import { pathExists, readText, walkFiles } from '../fs-utils.js';
 import { parseFrontmatterGeneric } from '../frontmatter.js';
 import { evalCondition } from '../predicate.js';
 import { listAllMemoryDocs } from '../memory-resolver.js';
-import { assembleNodeSubject, buildCeilingIndex, displayName, effectiveRung, gatePasses, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, } from './index.js';
+import { assembleNodeSubject, buildCeilingIndex, displayName, effectiveRung, gatePasses, normalizeDocName, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, } from './index.js';
 import { cachedSubstrateDocs } from './session-cache.js';
 // Ancestor dirs we never look inside for a `.crouter/memory/` store (the read
 // file may live under a build/dependency tree; `.crouter` is NOT junk here — it
@@ -113,10 +113,11 @@ function isJunkAncestor(dir) {
  *  (gate eval keys off the NODE subject, render off name/body/rung). */
 function loadPositionalDoc(file, memDir, scope) {
     try {
-        const name = relative(memDir, file)
+        const raw = relative(memDir, file)
             .replace(/\.md$/i, '')
             .split(sep)
             .join('/');
+        const name = normalizeDocName(raw);
         if (name === '')
             return null;
         const { data, body } = parseFrontmatterGeneric(readText(file));

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

@@ -1,16 +1,21 @@
-/** The system-prompt memory block: the always-present memory-usage guidance,
- *  then (when any are eligible) the `kind: preference` docs in one tree at their
- *  effective rung (the preference default rung is `preview` → the routing line).
- *  ALWAYS returns a non-empty `<memory kind="preference">` block — the guidance
- *  frame is unconditional, so the system-prompt splice is never empty even when
- *  no preference is eligible. */
+import { type NodeConfigSubject, type SubstrateDoc } from './index.js';
 export declare function renderPreferencesSection(nodeId: string): string;
+export declare function renderPreferencesForSubject(subject: NodeConfigSubject): {
+    block: string;
+    contentDocs: SubstrateDoc[];
+    tree: string;
+};
 /** The `<memory kind="knowledge">` block embedded in the session_start bearings
  *  message (bearings.ts pushes it as a SIBLING of `<crtr-bearings>`, or drops it
  *  when ''). The consultable catalog: every eligible `kind: knowledge` resolver
- *  doc at its effective rung (most surface only as `[+N more]` counts unless
- *  author-promoted) PLUS the node-local memory docs (any kind), the latter
- *  floored to `name` so a `none`-rung node-local doc still shows its name rather
- *  than collapsing into a count. Procedural guidance and factual references both
- *  live here as `knowledge`. Returns '' when nothing is eligible. */
+ *  doc PLUS the node-local memory docs (any kind) — resolver docs win
+ *  first-wins dedup over a same-named node-local doc. GROUPED by rung exactly
+ *  like the preference block: content prose first (general→specific,
+ *  node-local last), then the preview/name catalog tree. Node-local docs are
+ *  floored HERE — a rung-none node-local doc's effective rung is bumped to
+ *  `name` before grouping, so it still surfaces as a bare-name tree entry
+ *  rather than collapsing into a `[+N more]` count (its body still never
+ *  renders: floored docs never reach the `content` rung). Procedural guidance
+ *  and factual references both live here as `knowledge`. Returns '' when
+ *  nothing is eligible. */
 export declare function renderKnowledgeBlock(nodeId: string): string;