@crouton-kit/crouter 0.3.21 → 0.3.23

package/dist/core/scope.js

@@ -5,16 +5,9 @@ import { fileURLToPath } from 'node:url';
 import { CRTR_DIR_NAME } from '../types.js';
 import { usage } from './errors.js';
 let cachedProjectRoot;
-export function builtinSkillsRoot() {
-    // Resolve relative to this file: src/core/scope.ts → src/builtin-skills/ OR dist/core/scope.js → dist/builtin-skills/
-    const thisFile = fileURLToPath(import.meta.url);
-    const coreDir = dirname(thisFile);
-    const pkgDir = dirname(coreDir); // src/ or dist/
-    return join(pkgDir, 'builtin-skills');
-}
 export function builtinViewsRoot() {
-    // Resolved relative to this file exactly like builtinSkillsRoot — sibling of
-    // builtin-skills: dist/core/scope.js → dist/builtin-views/ (src/ at dev time).
+    // Resolved relative to this file: dist/core/scope.js → dist/builtin-views/
+    // (src/ at dev time).
     const thisFile = fileURLToPath(import.meta.url);
     const coreDir = dirname(thisFile);
     const pkgDir = dirname(coreDir); // src/ or dist/
@@ -22,11 +15,10 @@ export function builtinViewsRoot() {
 }
 export function builtinMemoryRoot() {
     // The substrate's shipped built-in documents live in their OWN package dir,
-    // a sibling of builtin-skills — resolved relative to this file exactly like
-    // builtinSkillsRoot/builtinViewsRoot: dist/core/scope.js → dist/builtin-memory/
+    // resolved relative to this file: dist/core/scope.js → dist/builtin-memory/
     // (src/ at dev time). This is a HARD special case (design verdict m2): builtin
-    // memory is NOT scopeRoot('builtin')/memory, which would land under
-    // builtin-skills/ — builtin's scopeRoot is builtinSkillsRoot().
+    // memory is the only content the builtin scope carries — the scope has no
+    // scopeRoot (scopeRoot('builtin') is null).
     const thisFile = fileURLToPath(import.meta.url);
     const coreDir = dirname(thisFile);
     const pkgDir = dirname(coreDir); // src/ or dist/
@@ -65,8 +57,10 @@ export function projectScopeRoot(startDir) {
     return findProjectScopeRoot(startDir);
 }
 export function scopeRoot(scope) {
+    // The builtin scope has no scope-root dir: its only content is memory
+    // (builtinMemoryRoot) and views (builtinViewsRoot), both hard special cases.
     if (scope === 'builtin')
-        return builtinSkillsRoot();
+        return null;
     return scope === 'user' ? userScopeRoot() : projectScopeRoot();
 }
 export function requireScopeRoot(scope) {
@@ -98,15 +92,20 @@ export function scopeSkillsDir(scope) {
     return root ? join(root, 'skills') : null;
 }
 /** Where substrate memory documents live per scope. Builtin memory is the
- *  special case — its own package dir (builtinMemoryRoot, a sibling of
- *  builtin-skills), NOT scopeRoot('builtin')/memory — mirroring viewsDir's
- *  builtin handling. User and project memory live at scopeRoot(scope)/memory. */
+ *  special case — its own package dir (builtinMemoryRoot), since the builtin
+ *  scope has no scopeRoot — mirroring viewsDir's builtin handling. User and
+ *  project memory live at scopeRoot(scope)/memory. */
 export function scopeMemoryDir(scope) {
     if (scope === 'builtin')
         return builtinMemoryRoot();
     const root = scope === 'user' ? userScopeRoot() : projectScopeRoot();
     return root ? join(root, 'memory') : null;
 }
+/** Where a plugin's substrate memory documents live: `<plugin.root>/memory`.
+ *  The resolver mounts these under the virtual `<pluginName>/` namespace. */
+export function pluginMemoryDir(plugin) {
+    return join(plugin.root, 'memory');
+}
 /** Where view definition dirs live per scope. Builtin views sit directly under
  *  builtinViewsRoot() (no `views/` segment — they ARE the builtin views dir),
  *  matching the loader's `<root>/<name>/view.mjs` resolution. */

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

@@ -0,0 +1,28 @@
+import { type Rung, type SubstrateDoc } from './schema.js';
+/** The reserved basename (no extension) that marks a directory's index doc. */
+export declare const INDEX_NAME = "INDEX";
+/** Does this path-derived name denote a directory INDEX (`taste/INDEX`, or a
+ *  top-level `INDEX`)? */
+export declare function isIndexName(name: string): boolean;
+/** The directory an INDEX doc represents: `taste/INDEX` → `taste`, `INDEX` → ''. */
+export declare function indexDirOf(name: string): string;
+/** The name a doc renders under in agent-facing surfaces: an INDEX doc renders
+ *  under its directory name (the dir entry); every other doc keeps its name. */
+export declare function displayName(name: string): string;
+/** The two visibility surfaces an INDEX can cap. */
+export type Surface = 'systemPromptVisibility' | 'fileReadVisibility';
+/** Build the dir → governing-INDEX map. Precedence is first-occurrence-wins, so
+ *  callers MUST pass docs precedence-ordered (project > user > builtin) — the
+ *  highest-precedence INDEX governs a dir, mirroring the memory resolver. */
+export declare function buildCeilingIndex(docs: SubstrateDoc[]): Map<string, SubstrateDoc>;
+/** A doc's effective rung on `surface` after applying every ancestor INDEX
+ *  ceiling: min(own rung, each ancestor INDEX's rung). A `none` ancestor INDEX
+ *  hides the whole subtree (min with none = none). */
+export declare function effectiveRung(doc: SubstrateDoc, ceil: Map<string, SubstrateDoc>, surface: Surface): Rung;
+/** Apply ceilings to a doc list for a surface: each doc gets its effective rung
+ *  on `surface` written back into that field, and INDEX docs are renamed to
+ *  their dir entry. Returns NEW objects only where something changed (cheap,
+ *  preserves identity for untouched docs). Does NOT drop `none`-rung docs — the
+ *  caller filters per surface (boot drops them; node-local intentionally keeps
+ *  them). */
+export declare function applyCeilings(docs: SubstrateDoc[], surface: Surface): SubstrateDoc[];

package/dist/core/substrate/ceiling.js

@@ -0,0 +1,87 @@
+// ceiling.ts — INDEX.md dir-level entries and the subtree rung ceiling.
+//
+// A directory under a memory store may carry an `INDEX.md` with the SAME
+// substrate frontmatter as any doc. That file makes the directory a first-class
+// substrate entry: it renders as ONE entry at dir level (headed by the dir
+// name, not `…/INDEX`), and its rung is a CEILING for everything in its subtree.
+//
+//   effective rung of a descendant = min(own rung, every ancestor INDEX's rung)
+//
+// So a dir's INDEX at `preview` lets its files surface at most at `preview`; an
+// INDEX at `none` hides the whole subtree. This is the single, explicit
+// mechanism for collapsing a directory in agent-facing surfaces (boot render +
+// on-read) — there is no parallel auto-hiding heuristic. See design taste:
+// `crtr memory read taste/document-substrate`.
+import { rungRank } from './schema.js';
+/** The reserved basename (no extension) that marks a directory's index doc. */
+export const INDEX_NAME = 'INDEX';
+/** Does this path-derived name denote a directory INDEX (`taste/INDEX`, or a
+ *  top-level `INDEX`)? */
+export function isIndexName(name) {
+    return name === INDEX_NAME || name.endsWith('/' + INDEX_NAME);
+}
+/** The directory an INDEX doc represents: `taste/INDEX` → `taste`, `INDEX` → ''. */
+export function indexDirOf(name) {
+    return name === INDEX_NAME ? '' : name.slice(0, name.length - INDEX_NAME.length - 1);
+}
+/** The name a doc renders under in agent-facing surfaces: an INDEX doc renders
+ *  under its directory name (the dir entry); every other doc keeps its name. */
+export function displayName(name) {
+    return isIndexName(name) ? indexDirOf(name) : name;
+}
+/** Build the dir → governing-INDEX map. Precedence is first-occurrence-wins, so
+ *  callers MUST pass docs precedence-ordered (project > user > builtin) — the
+ *  highest-precedence INDEX governs a dir, mirroring the memory resolver. */
+export function buildCeilingIndex(docs) {
+    const m = new Map();
+    for (const d of docs) {
+        if (!isIndexName(d.name))
+            continue;
+        const dir = indexDirOf(d.name);
+        if (!m.has(dir))
+            m.set(dir, d);
+    }
+    return m;
+}
+function minRung(a, b) {
+    return rungRank(a) <= rungRank(b) ? a : b;
+}
+/** Ancestor directory names of a doc, nearest-last: `a/b/c` → [`a/b`, `a`];
+ *  `a` → []. An INDEX doc's OWN dir is included (a self-cap is a no-op), so a
+ *  nested INDEX still inherits its parents' ceilings. */
+function ancestorDirs(name) {
+    const parts = name.split('/');
+    parts.pop(); // drop the leaf
+    const out = [];
+    for (let i = parts.length; i > 0; i--)
+        out.push(parts.slice(0, i).join('/'));
+    return out;
+}
+/** A doc's effective rung on `surface` after applying every ancestor INDEX
+ *  ceiling: min(own rung, each ancestor INDEX's rung). A `none` ancestor INDEX
+ *  hides the whole subtree (min with none = none). */
+export function effectiveRung(doc, ceil, surface) {
+    let rung = doc[surface];
+    for (const dir of ancestorDirs(doc.name)) {
+        const idx = ceil.get(dir);
+        if (idx)
+            rung = minRung(rung, idx[surface]);
+    }
+    return rung;
+}
+/** Apply ceilings to a doc list for a surface: each doc gets its effective rung
+ *  on `surface` written back into that field, and INDEX docs are renamed to
+ *  their dir entry. Returns NEW objects only where something changed (cheap,
+ *  preserves identity for untouched docs). Does NOT drop `none`-rung docs — the
+ *  caller filters per surface (boot drops them; node-local intentionally keeps
+ *  them). */
+export function applyCeilings(docs, surface) {
+    const ceil = buildCeilingIndex(docs);
+    return docs.map((d) => {
+        const rung = effectiveRung(d, ceil, surface);
+        const name = displayName(d.name);
+        if (rung === d[surface] && name === d.name)
+            return d;
+        return { ...d, [surface]: rung, name };
+    });
+}

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

@@ -3,5 +3,7 @@ export type { DocKind, Rung, GatePredicate, SubstrateSchema, SubstrateDoc } from
 export { scopeForCwd, spineDepth, assembleNodeSubject } from './subject.js';
 export type { NodeConfigSubject } from './subject.js';
 export { gatePasses } from './gate.js';
+export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveRung, applyCeilings, } from './ceiling.js';
+export type { Surface } from './ceiling.js';
 export { renderSkillsSection, renderPreferencesSection, renderReferencesBlock } from './render.js';
 export { renderOnReadDocs } from './on-read.js';

package/dist/core/substrate/index.js

@@ -14,5 +14,6 @@ KIND_DEFAULT_RUNGS,
 parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, } from './schema.js';
 export { scopeForCwd, spineDepth, assembleNodeSubject } from './subject.js';
 export { gatePasses } from './gate.js';
+export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveRung, applyCeilings, } from './ceiling.js';
 export { renderSkillsSection, renderPreferencesSection, renderReferencesBlock } from './render.js';
 export { renderOnReadDocs } from './on-read.js';

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

@@ -36,7 +36,7 @@ import { CRTR_DIR_NAME } from '../../types.js';
 import { pathExists, readText, walkFiles } from '../fs-utils.js';
 import { parseFrontmatterGeneric } from '../frontmatter.js';
 import { listAllMemoryDocs } from '../memory-resolver.js';
-import { assembleNodeSubject, gatePasses, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, } from './index.js';
+import { assembleNodeSubject, buildCeilingIndex, displayName, effectiveRung, gatePasses, 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
@@ -264,6 +264,18 @@ export function renderOnReadDocs(nodeId, readFilePath, seen = new Set()) {
     // Outermost-first: the nearest/most-specific doc reads last — closest to the
     // file content that follows it (the applies-to set, order -1, trails).
     candidates.sort((a, b) => b.order - a.order);
+    // INDEX ceiling: build the dir → governing-INDEX map over the whole resolved
+    // corpus PLUS the candidate docs, so a dir's INDEX caps (or `none`-hides) its
+    // subtree on-read exactly as it does at boot. The candidate's own
+    // fileReadVisibility and name are overridden by the effective rung / dir entry.
+    let ceil;
+    try {
+        const resolved = cachedSubstrateDocs(listAllMemoryDocs, parseSubstrateDoc);
+        ceil = buildCeilingIndex([...resolved, ...candidates.map((c) => c.doc)]);
+    }
+    catch {
+        ceil = buildCeilingIndex(candidates.map((c) => c.doc));
+    }
     const rendered = [];
     for (const c of candidates) {
         // Never re-surface the doc the agent is literally reading.
@@ -276,7 +288,11 @@ export function renderOnReadDocs(nodeId, readFilePath, seen = new Set()) {
         try {
             if (!gatePasses(c.doc, subject))
                 continue; // gated out for this node
-            block = renderDocEnvelope(c.doc, absReadFile);
+            const rung = effectiveRung(c.doc, ceil, 'fileReadVisibility');
+            const doc = rung === c.doc.fileReadVisibility && displayName(c.doc.name) === c.doc.name
+                ? c.doc
+                : { ...c.doc, fileReadVisibility: rung, name: displayName(c.doc.name) };
+            block = renderDocEnvelope(doc, absReadFile);
         }
         catch {
             continue; // a single bad doc never breaks the read

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

@@ -1,8 +1,7 @@
 /** The `## Skills` system-prompt section: every eligible `kind: skill` doc,
  *  rendered at its `system-prompt-visibility`. `name`-rung skills collapse into
- *  one compact catalog (group-collapsed, unioned with plugin/marketplace
- *  skills); `preview`/`content`-rung skills each get a `###` sub-section.
- *  Returns '' when nothing is eligible. */
+ *  one compact, plugin-grouped catalog; `preview`/`content`-rung skills each get
+ *  a `###` sub-section. Returns '' when nothing is eligible. */
 export declare function renderSkillsSection(nodeId: string): string;
 /** The `## Preferences` system-prompt section: every eligible `kind: preference`
  *  doc as its own `###` sub-section, at its `system-prompt-visibility` (the

package/dist/core/substrate/render.js

@@ -18,14 +18,13 @@
 // null for a non-substrate doc and is `.filter()`ed out; per-file loads are
 // wrapped so one bad file is skipped, not fatal.
 import { relative, sep } from 'node:path';
-import { SCOPE_SKILL_PLUGIN } from '../../types.js';
-import { listAllPlugins, listAllSkills } from '../resolver.js';
+import { listAllPlugins } from '../resolver.js';
 import { renderCatalogSection } from '../../commands/skill/shared.js';
 import { listAllMemoryDocs } from '../memory-resolver.js';
 import { parseFrontmatterGeneric } from '../frontmatter.js';
 import { pathExists, readText, walkFiles } from '../fs-utils.js';
 import { memoryDir } from '../runtime/memory.js';
-import { assembleNodeSubject, gatePasses, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, } from './index.js';
+import { applyCeilings, assembleNodeSubject, gatePasses, isIndexName, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, } from './index.js';
 import { cachedAllPlugins, cachedNodeSubject, cachedSubstrateDocs, } from './session-cache.js';
 // ---------------------------------------------------------------------------
 // The shared per-doc pipeline.
@@ -35,7 +34,12 @@ import { cachedAllPlugins, cachedNodeSubject, cachedSubstrateDocs, } from './ses
  *  system-prompt rung above `none`. Resolver = user + project + builtin scopes
  *  (precedence-ordered); node-local is loaded separately (see nodeLocalDocs).
  *  Uses the per-session cache so the full corpus is scanned+parsed at most once
- *  per session across the three boot-render calls. */
+ *  per session across the three boot-render calls.
+ *
+ *  Ceilings are applied over the WHOLE corpus (cross-kind) BEFORE the kind
+ *  filter: an INDEX.md renders as its dir entry (`taste`, not `taste/INDEX`) at
+ *  its own rung, and every descendant's rung is capped by its ancestor INDEX
+ *  rungs — a `none` dir hides its whole subtree. */
 function resolverDocs(subject, kind) {
     let docs;
     try {
@@ -44,10 +48,17 @@ function resolverDocs(subject, kind) {
     catch {
         return [];
     }
-    return docs
+    return applyCeilings(docs, 'systemPromptVisibility')
         .filter((d) => d.kind === kind)
         .filter((d) => gatePasses(d, subject))
-        .filter((d) => d.systemPromptVisibility !== 'none');
+        .filter((d) => d.systemPromptVisibility !== 'none')
+        // Re-sort after the INDEX rename (taste/INDEX → taste) so a dir entry sorts
+        // immediately BEFORE its children, keeping scope precedence (project > user
+        // > builtin) intact.
+        .sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope) || a.name.localeCompare(b.name));
+}
+function scopeRank(scope) {
+    return scope === 'project' ? 0 : scope === 'user' ? 1 : 2;
 }
 /** The node-local memory docs eligible at boot. Node-local memory lives in the
  *  canvas home (`nodes/<id>/context/memory/`) and is OUTSIDE the scope resolver,
@@ -114,50 +125,49 @@ function renderSubSection(d) {
 // ---------------------------------------------------------------------------
 // 1. Skills section — `## Skills` (system prompt).
 // ---------------------------------------------------------------------------
-/** The compact, group-collapsed `name`-rung catalog: the UNION of name-rung
- *  substrate `skill` docs (the migrated scope-local + builtin skills, rendered
- *  as scope-local `_` entries) WITH plugin/marketplace skills (which stay
- *  resolver-provided, NOT migrated — named-plugin skills at user/project scope;
- *  the SCOPE_SKILL_PLUGIN sentinel and builtin scope are EXCLUDED because they
- *  become substrate docs). Reuses skill/shared.ts's renderCatalogSection
- *  group-collapse for a compact, source-grouped catalog. Returns '' when nothing
- *  is in the catalog. */
-function renderSkillCatalog(nameRungSkillDocs) {
-    let pluginSkills;
-    try {
-        pluginSkills = listAllSkills().filter((s) => s.enabled && s.plugin !== SCOPE_SKILL_PLUGIN && s.scope !== 'builtin');
-    }
-    catch {
-        pluginSkills = [];
-    }
-    const entries = [
-        ...pluginSkills.map((s) => ({ scope: s.scope, plugin: s.plugin, name: s.name })),
-        ...nameRungSkillDocs.map((d) => ({ scope: d.scope, plugin: SCOPE_SKILL_PLUGIN, name: d.name })),
-    ];
-    if (entries.length === 0)
-        return '';
-    // Group by scope+plugin → forest-root names (drop nested children) so each
-    // source contributes only its top-level skills.
+/** The compact, group-collapsed `name`-rung catalog of substrate `skill` docs.
+ *  Every leaf is a migrated/generated substrate doc (native, builtin, or a
+ *  plugin's `<pluginName>/` subtree) — there is no second, resolver-provided
+ *  skill corpus. Each doc self-groups by its top-dir segment: a name with a
+ *  slash sources to its top segment (the plugin name); a bare name sources to
+ *  '' (a scope-local native/builtin skill). A plugin whose INDEX is elevated to
+ *  preview/content renders as its own `### <plugin>` subsection, so its catalog
+ *  group is dropped here (via `elevatedSources`) to avoid a double render.
+ *  Reuses skill/shared.ts's renderCatalogSection group-collapse. Returns ''
+ *  when nothing is in the catalog. */
+function renderSkillCatalog(nameRungSkillDocs, elevatedSources) {
     const bySource = new Map();
-    for (const e of entries) {
-        const key = `${e.scope}\t${e.plugin}`;
-        const arr = bySource.get(key);
-        if (arr)
-            arr.push(e);
+    for (const d of nameRungSkillDocs) {
+        // INDEX docs are structural ceilings (already renamed to their dir entry by
+        // applyCeilings), never catalog leaves — drop defensively.
+        if (isIndexName(d.name))
+            continue;
+        const slash = d.name.indexOf('/');
+        const plugin = slash === -1 ? '' : d.name.slice(0, slash);
+        const leaf = slash === -1 ? d.name : d.name.slice(slash + 1);
+        // A plugin represented by its own elevated ### subsection is dropped from the
+        // catalog so it is not rendered twice.
+        if (plugin !== '' && elevatedSources.has(plugin))
+            continue;
+        const key = `${d.scope}\t${plugin}`;
+        const src = bySource.get(key);
+        if (src)
+            src.roots.push(leaf);
         else
-            bySource.set(key, [e]);
+            bySource.set(key, { scope: d.scope, plugin, roots: [leaf] });
     }
+    if (bySource.size === 0)
+        return '';
     const projectSources = [];
     const userSources = [];
-    for (const [key, group] of bySource) {
-        const [scope, plugin] = key.split('\t');
-        const names = group.map((g) => g.name);
-        const roots = names
-            .filter((n) => !names.some((m) => m !== n && n.startsWith(m + '/')))
+    for (const { scope, plugin, roots } of bySource.values()) {
+        // Drop nested children so each source contributes only its top-level skills.
+        const top = roots
+            .filter((n) => !roots.some((m) => m !== n && n.startsWith(m + '/')))
             .sort();
-        if (roots.length === 0)
+        if (top.length === 0)
             continue;
-        (scope === 'project' ? projectSources : userSources).push({ plugin, roots });
+        (scope === 'project' ? projectSources : userSources).push({ plugin, roots: top });
     }
     const descriptions = new Map();
     try {
@@ -180,19 +190,21 @@ function renderSkillCatalog(nameRungSkillDocs) {
 }
 /** The `## Skills` system-prompt section: every eligible `kind: skill` doc,
  *  rendered at its `system-prompt-visibility`. `name`-rung skills collapse into
- *  one compact catalog (group-collapsed, unioned with plugin/marketplace
- *  skills); `preview`/`content`-rung skills each get a `###` sub-section.
- *  Returns '' when nothing is eligible. */
+ *  one compact, plugin-grouped catalog; `preview`/`content`-rung skills each get
+ *  a `###` sub-section. Returns '' when nothing is eligible. */
 export function renderSkillsSection(nodeId) {
     const subject = cachedNodeSubject(nodeId, assembleNodeSubject);
     if (subject === null)
         return '';
     const skills = resolverDocs(subject, 'skill');
-    const catalog = renderSkillCatalog(skills.filter((d) => d.systemPromptVisibility === 'name'));
-    const elevated = skills
-        .filter((d) => d.systemPromptVisibility !== 'name')
-        .map(renderSubSection);
-    const blocks = [catalog, ...elevated].filter((s) => s !== '');
+    const elevated = skills.filter((d) => d.systemPromptVisibility !== 'name');
+    // A plugin whose INDEX is elevated surfaces as its own `### <plugin>`
+    // subsection (its display name is the plugin/dir name after ceiling rename);
+    // the catalog drops that plugin's group so it is not rendered twice.
+    const elevatedSources = new Set(elevated.map((d) => d.name));
+    const catalog = renderSkillCatalog(skills.filter((d) => d.systemPromptVisibility === 'name'), elevatedSources);
+    const elevatedBlocks = elevated.map(renderSubSection);
+    const blocks = [catalog, ...elevatedBlocks].filter((s) => s !== '');
     if (blocks.length === 0)
         return '';
     return `## Skills\n\n${blocks.join('\n\n')}`;

package/dist/pi-extensions/canvas-inbox-watcher.js

@@ -43,8 +43,24 @@ import { getNode } from '../core/canvas/index.js';
 // one watcher is live. Pattern copied verbatim from agent-inbox-watcher.ts.
 // ---------------------------------------------------------------------------
 let liveTimer;
-const TICK_MS = 800; // polling cadence
-const DEBOUNCE_MS = 1000; // flush once the burst has been quiet for this long
+const DEFAULT_TICK_MS = 800; // polling cadence
+const DEFAULT_DEBOUNCE_MS = 1000; // flush once the burst has been quiet for this long
+// Testability seam: a test can inject a much shorter cadence so it doesn't have
+// to sleep against the real ~800ms/1000ms wall-clock timing. Read per-registration
+// (not as an import-time module const) so each registerCanvasInboxWatcher() call
+// picks up the env current at that moment. Unset → production defaults.
+function resolveCadence() {
+    const parse = (raw, fallback) => {
+        if (raw === undefined)
+            return fallback;
+        const n = Number(raw);
+        return Number.isFinite(n) && n > 0 ? n : fallback;
+    };
+    return {
+        tickMs: parse(process.env['CRTR_WATCHER_TICK_MS'], DEFAULT_TICK_MS),
+        debounceMs: parse(process.env['CRTR_WATCHER_DEBOUNCE_MS'], DEFAULT_DEBOUNCE_MS),
+    };
+}
 // ---------------------------------------------------------------------------
 // Extension
 // ---------------------------------------------------------------------------
@@ -56,6 +72,7 @@ const DEBOUNCE_MS = 1000; // flush once the burst has been quiet for this long
  * the module-level liveTimer guard is the actual stacking prevention.
  */
 export function registerCanvasInboxWatcher(pi) {
+    const { tickMs: TICK_MS, debounceMs: DEBOUNCE_MS } = resolveCadence();
     // Capture the latest event context so isIdle() is readable inside the timer
     // callback, which has no ctx of its own.
     let lastCtx;

package/dist/types.d.ts

@@ -20,6 +20,7 @@ export interface PluginManifest {
     source?: string;
     owner?: OwnerRef;
     kinds?: string[];
+    generator?: 'claude-bridge';
 }
 export interface MarketplacePluginEntry {
     name: string;
@@ -44,9 +45,6 @@ export interface ConfigPluginEntry {
     source_marketplace?: string;
     version?: string;
 }
-export interface ConfigSkillEntry {
-    enabled: boolean;
-}
 export type AutoUpdateMode = 'notify' | 'apply' | false;
 export interface AutoUpdateConfig {
     crtr: AutoUpdateMode;
@@ -79,7 +77,6 @@ export interface ScopeConfig {
     schema_version: number;
     marketplaces: Record<string, ConfigMarketplaceEntry>;
     plugins: Record<string, ConfigPluginEntry>;
-    skills: Record<string, ConfigSkillEntry>;
     auto_update: AutoUpdateConfig;
     max_panes_per_window: number;
     canvasNav: CanvasNavConfig;
@@ -107,16 +104,6 @@ export interface SkillFrontmatter {
     keywords?: string[];
     type?: SkillType;
 }
-export interface Skill {
-    name: string;
-    plugin: string;
-    scope: Scope;
-    path: string;
-    pluginRoot: string;
-    frontmatter: SkillFrontmatter;
-    enabled: boolean;
-    disabledIn?: Scope;
-}
 export interface SubagentFrontmatter {
     name: string;
     description?: string;
@@ -127,8 +114,8 @@ export interface SubagentFrontmatter {
 }
 export interface Subagent {
     name: string;
-    /** Plugin the subagent belongs to, or SCOPE_SKILL_PLUGIN ('_') for a
-     *  scope-root agent stored at `<scope-root>/agents/<name>.md`. */
+    /** Plugin the subagent belongs to, or the sentinel '_' for a scope-root
+     *  agent stored at `<scope-root>/agents/<name>.md`. */
     plugin: string;
     scope: Scope;
     /** Absolute path to the agent's .md file. */
@@ -165,7 +152,6 @@ export declare const STATE_FILE = "state.json";
 export declare const SKILL_ENTRY_FILE = "SKILL.md";
 export declare const SKILLS_DIR = "skills";
 export declare const AGENTS_DIR = "agents";
-export declare const SCOPE_SKILL_PLUGIN = "_";
 export declare const DEFAULT_MAX_PANES_PER_WINDOW = 3;
 export declare function defaultScopeConfig(): ScopeConfig;
 /** Built-in canvas-nav binds so an absent config still gives the intended UX.
@@ -173,5 +159,4 @@ export declare function defaultScopeConfig(): ScopeConfig;
  *  1..9 (focus report N) are generated by the menu layer, not literal entries.
  *  graphBinds: empty — built-in GRAPH keys are reserved, custom keys add on. */
 export declare function defaultCanvasNavConfig(): CanvasNavConfig;
-export declare function skillConfigKey(plugin: string, name: string): string;
 export declare function defaultScopeState(): ScopeState;

package/dist/types.js

@@ -23,17 +23,12 @@ export const SKILLS_DIR = 'skills';
 // Subagent definitions live as flat `<name>.md` files under `<root>/agents/`,
 // for both scope roots and plugins. Mirrors SKILLS_DIR.
 export const AGENTS_DIR = 'agents';
-// Sentinel plugin name for skills that live at a scope root (no plugin wrapper).
-// Stored as `<scope-root>/skills/<name>/SKILL.md`. Shown in listings without the
-// `_/` prefix.
-export const SCOPE_SKILL_PLUGIN = '_';
 export const DEFAULT_MAX_PANES_PER_WINDOW = 3;
 export function defaultScopeConfig() {
     return {
         schema_version: SCHEMA_VERSION,
         marketplaces: {},
         plugins: {},
-        skills: {},
         auto_update: { crtr: 'notify', content: 'notify', interval_hours: 24 },
         max_panes_per_window: DEFAULT_MAX_PANES_PER_WINDOW,
         canvasNav: defaultCanvasNavConfig(),
@@ -55,9 +50,6 @@ export function defaultCanvasNavConfig() {
         graphBinds: {},
     };
 }
-export function skillConfigKey(plugin, name) {
-    return `${plugin}/${name}`;
-}
 export function defaultScopeState() {
     return { marketplaces: {}, plugins: {} };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crouton-kit/crouter",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "description": "crtr — fast access to skills, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",
@@ -24,11 +24,12 @@
     "bin"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc && cp -R src/builtin-skills dist/builtin-skills && cp -R src/builtin-personas dist/builtin-personas && cp -R src/builtin-views dist/builtin-views && cp -R src/builtin-memory dist/builtin-memory",
+    "build": "rm -rf dist && tsc && cp -R src/builtin-personas dist/builtin-personas && cp -R src/builtin-views dist/builtin-views && cp -R src/builtin-memory dist/builtin-memory",
     "dev": "tsx src/cli.ts",
     "link": "npm link",
     "prepublishOnly": "npm run build",
-    "test": "node --import tsx/esm --test 'src/**/__tests__/**/*.test.ts'"
+    "test": "node --import tsx/esm --test 'src/**/__tests__/*.test.ts'",
+    "test:full": "node --import tsx/esm --test 'src/**/__tests__/**/*.test.ts'"
   },
   "repository": {
     "type": "git",

package/dist/builtin-skills/.crouter-plugin/plugin.json

@@ -1,5 +0,0 @@
-{
-  "name": "crtr",
-  "version": "0.2.0",
-  "description": "Builtin crouter skills — authoring guidance shipped with the binary"
-}