@crouton-kit/crouter 0.3.18 → 0.3.20

package/dist/core/memory-resolver.js

@@ -0,0 +1,141 @@
+import { join, relative, sep } from 'node:path';
+import { pathExists, readText, walkFiles } from './fs-utils.js';
+import { parseFrontmatterGeneric } from './frontmatter.js';
+import { parseSkillQualifier } from './resolver.js';
+import { ambiguous, notFound, usage } from './errors.js';
+import { warn } from './output.js';
+import { projectScopeRoot, scopeMemoryDir } from './scope.js';
+/** Canonical, unambiguous identifier for a memory document: `<scope>/<name>`. */
+export function memoryDocId(doc) {
+    return `${doc.scope}/${doc.name}`;
+}
+/** The memory scopes in resolution precedence: project > user > builtin.
+ *  Project is included only when a project scope exists for the cwd. A single
+ *  `scope` narrows to just that scope. */
+function scopesInPrecedence(scope) {
+    if (scope)
+        return [scope];
+    const out = [];
+    if (projectScopeRoot())
+        out.push('project');
+    out.push('user');
+    out.push('builtin');
+    return out;
+}
+function loadMemoryDoc(name, scope, path) {
+    const { data, body } = parseFrontmatterGeneric(readText(path));
+    return { name, scope, path, frontmatter: data, body };
+}
+/** All memory docs in one scope's memory/ dir, scanned recursively for *.md
+ *  (topical subdirs supported), sorted by path-derived name. */
+export function listMemoryDocs(scope) {
+    const dir = scopeMemoryDir(scope);
+    if (!dir || !pathExists(dir))
+        return [];
+    const docs = [];
+    for (const file of walkFiles(dir, (n) => n.endsWith('.md'))) {
+        const name = relative(dir, file).replace(/\.md$/i, '').split(sep).join('/');
+        if (!name)
+            continue;
+        // COLLECTION layer: the strict frontmatter parser throws on invalid YAML.
+        // Isolate one malformed doc with a clear scoped notice + skip, so a single
+        // bad file can't brick `memory list`/`find` or the substrate boot render.
+        try {
+            docs.push(loadMemoryDoc(name, scope, file));
+        }
+        catch (e) {
+            const msg = (e instanceof Error ? e.message : String(e)).split('\n')[0];
+            warn(`invalid frontmatter in ${file}: ${msg}`);
+        }
+    }
+    return docs.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** All memory docs across the resolved scopes, in precedence order
+ *  (project, then user, then builtin), each scope's docs name-sorted within. */
+export function listAllMemoryDocs(scope) {
+    return scopesInPrecedence(scope).flatMap(listMemoryDocs);
+}
+/** Direct full-path lookup of memory/<name>.md across scopes, precedence-first.
+ *  Returns every scope's hit in precedence order; the resolver takes the first
+ *  (highest-precedence) one — a fully-specified name is never ambiguous. */
+function findMemoryMatches(name, scope) {
+    const matches = [];
+    for (const s of scopesInPrecedence(scope)) {
+        const dir = scopeMemoryDir(s);
+        if (!dir)
+            continue;
+        const path = join(dir, ...name.split('/')) + '.md';
+        if (!pathExists(path))
+            continue;
+        matches.push(loadMemoryDoc(name, s, path));
+    }
+    return matches;
+}
+/** Leaf-name fallback: match docs whose final path segment equals `leaf`.
+ *  Only meaningful for a bare segment (a slashed query can never equal a single
+ *  segment), mirroring findSkillsByLeaf. Returns matches precedence-ordered. */
+function findMemoryByLeaf(leaf, scope) {
+    if (leaf.includes('/'))
+        return [];
+    let all;
+    try {
+        all = listAllMemoryDocs(scope);
+    }
+    catch {
+        return [];
+    }
+    return all.filter((d) => (d.name.split('/').pop() ?? d.name) === leaf);
+}
+function formatLeafAmbiguous(leaf, matches) {
+    const ids = matches.map(memoryDocId).join(', ');
+    return `ambiguous memory document: ${leaf} matches multiple documents: ${ids}`;
+}
+/**
+ * Resolve a path-derived name to a single memory document.
+ *
+ * Accepted identifier forms (mirroring parseSkillQualifier, no plugins):
+ *   <name>            — bare name; resolved by scope precedence project>user>builtin
+ *   <scope>/<name>    — pinned to one scope (user|project)
+ * `<name>` may carry topical subdirs (`taste/foo`); a bare leaf (`foo`) falls
+ * back to a last-segment match across the resolved scopes.
+ *
+ * Resolution order: parse qualifier → direct memory/<name>.md lookup
+ * (precedence-first) → leaf-name fallback (ambiguity error listing candidates).
+ */
+export function resolveMemoryDoc(rawName, opts = {}) {
+    const parsed = parseSkillQualifier(rawName);
+    if (parsed.scope && opts.scope && parsed.scope !== opts.scope) {
+        throw usage(`scope conflict: identifier "${rawName}" uses scope "${parsed.scope}" but --scope is "${opts.scope}"`);
+    }
+    const effectiveScope = opts.scope ?? parsed.scope;
+    const name = parsed.segments.join('/');
+    if (name === '')
+        throw usage(`memory document name required`);
+    // Direct full-path lookup: a fully-specified name resolves by scope precedence.
+    const direct = findMemoryMatches(name, effectiveScope);
+    if (direct.length > 0)
+        return direct[0];
+    // Leaf-name fallback: the caller gave only the final segment (e.g. "foo" for
+    // "taste/foo"). Match by last segment across the resolved scope dirs.
+    const byLeaf = findMemoryByLeaf(name, effectiveScope);
+    if (byLeaf.length > 0) {
+        // Same path-derived name across scopes → precedence wins (return first);
+        // genuinely different docs sharing a leaf → ambiguous.
+        const distinctNames = new Set(byLeaf.map((d) => d.name));
+        if (distinctNames.size === 1)
+            return byLeaf[0];
+        throw ambiguous(formatLeafAmbiguous(name, byLeaf), {
+            memory: name,
+            candidates: byLeaf.map((d) => ({
+                id: memoryDocId(d),
+                scope: d.scope,
+                path: d.path,
+            })),
+            next: 'Multiple documents share this leaf name. Re-run with one of the full names in candidates.',
+        });
+    }
+    throw notFound(`memory document not found: ${rawName}`, {
+        memory: name,
+        scope: parsed.scope,
+    });
+}

package/dist/core/personas/loader.d.ts

@@ -39,6 +39,13 @@ export declare function loadKernel(): string;
  * live in their own fragments, loaded below.
  */
 export declare function loadRuntimeBase(): string;
+/**
+ * Load the waiting fragment — the cross-kind "waiting is a way to end a turn"
+ * operating posture (arm a wake + go dormant instead of busy-looping or
+ * finishing-to-stop). Spliced into every node's baked prompt immediately after
+ * the lifecycle fragment (resolve.ts). Returns '' if the fragment is missing.
+ */
+export declare function loadWaitingFragment(): string;
 /**
  * Load the lifecycle fragment — the "how you end" contract, keyed on the node's
  * lifecycle axis: `terminal` (drive to done + `push final`) or `resident`

package/dist/core/personas/loader.js

@@ -56,6 +56,23 @@ function personaSearchRoots() {
     return roots;
 }
 // ---------------------------------------------------------------------------
+// Frontmatter scalar coercion
+// ---------------------------------------------------------------------------
+/** Coerce a frontmatter scalar to its string form, matching the legacy
+ *  hand-rolled parser (which stringified every scalar). Strings pass through;
+ *  number/boolean coerce via String(); null/undefined and non-scalars
+ *  (objects/arrays) are dropped (→ null). The `yaml` package returns native
+ *  scalar types, so without this a `typeof === 'string'` guard would silently
+ *  DROP a numeric/boolean frontmatter value (e.g. blanking a menu line) where
+ *  the old parser kept its stringified form. */
+function scalarToString(v) {
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return null;
+}
+// ---------------------------------------------------------------------------
 // File resolution helpers
 // ---------------------------------------------------------------------------
 /**
@@ -143,6 +160,19 @@ export function loadRuntimeBase() {
     const { body } = parseFrontmatterGeneric(src);
     return body.trim();
 }
+/**
+ * Load the waiting fragment — the cross-kind "waiting is a way to end a turn"
+ * operating posture (arm a wake + go dormant instead of busy-looping or
+ * finishing-to-stop). Spliced into every node's baked prompt immediately after
+ * the lifecycle fragment (resolve.ts). Returns '' if the fragment is missing.
+ */
+export function loadWaitingFragment() {
+    const filePath = resolveFile('waiting.md');
+    if (!filePath)
+        return '';
+    const { body } = parseFrontmatterGeneric(readFileSync(filePath, 'utf8'));
+    return body.trim();
+}
 /**
  * Load the lifecycle fragment — the "how you end" contract, keyed on the node's
  * lifecycle axis: `terminal` (drive to done + `push final`) or `resident`
@@ -205,7 +235,7 @@ export function kindWhenToUse(kind) {
     if (!filePath)
         return '';
     const { data } = parseFrontmatterGeneric(readFileSync(filePath, 'utf8'));
-    return data && typeof data['whenToUse'] === 'string' ? data['whenToUse'] : '';
+    return scalarToString(data?.['whenToUse']) ?? '';
 }
 /** Recursively yield every dir under `dir` (inclusive) that holds a PERSONA.md,
  *  with `relKind` = the dir's path relative to the scope root (slash-joined).
@@ -233,10 +263,11 @@ function parseAvailableTo(data, topKind) {
     const v = data ? data['availableTo'] : undefined;
     if (v === undefined)
         return [topKind];
-    if (typeof v === 'string')
-        return isWild(v) ? '*' : [v];
+    const scalar = scalarToString(v);
+    if (scalar !== null)
+        return isWild(scalar) ? '*' : [scalar];
     if (Array.isArray(v)) {
-        const arr = v.filter((x) => typeof x === 'string');
+        const arr = v.map(scalarToString).filter((x) => x !== null);
         if (arr.some(isWild))
             return '*';
         return arr.length > 0 ? arr : [topKind];
@@ -283,7 +314,7 @@ export function subPersonasFor(kind) {
                 const availableTo = parseAvailableTo(data, topKind);
                 if (availableTo !== '*' && !availableTo.includes(kind))
                     continue;
-                const whenToUse = data && typeof data['whenToUse'] === 'string' ? data['whenToUse'] : '';
+                const whenToUse = scalarToString(data?.['whenToUse']) ?? '';
                 out.push({ kind: relKind, name: relKind.split('/').pop(), whenToUse });
             }
         }

package/dist/core/personas/resolve.js

@@ -19,17 +19,26 @@
  * derived here; they select the lifecycle/spine protocol fragments spliced
  * ahead of the persona body.
  */
-import { loadPersona, loadKernel, loadRuntimeBase, loadSpineFragment, loadLifecycleFragment, subPersonasFor } from './loader.js';
+import { loadPersona, loadKernel, loadRuntimeBase, loadSpineFragment, loadLifecycleFragment, loadWaitingFragment, subPersonasFor } from './loader.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function toStringArray(v) {
     if (!Array.isArray(v))
         return [];
-    return v.filter((x) => typeof x === 'string');
+    // yaml.parse coerces scalars to native types; the persona prompt needs strings,
+    // so coerce each scalar element (dropping nested objects/arrays/null) — this
+    // mirrors the prior hand-rolled parser, which returned every scalar as a string.
+    return v.filter((x) => x != null && typeof x !== 'object').map((x) => String(x));
 }
 function toOptionalString(v) {
-    return typeof v === 'string' ? v : undefined;
+    if (typeof v === 'string')
+        return v;
+    // Preserve the legacy parser's string-typed contract for native scalars
+    // (e.g. `model: 4` must compose as "4", not be dropped as a non-string).
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return undefined;
 }
 /** The bare-minimum system prompt used when no persona file is found at all. */
 function fallbackBasePrompt(kind) {
@@ -65,6 +74,7 @@ function composeProtocol(personaPrompt, kind, lifecycle, hasManager) {
         loadRuntimeBase(),
         loadSpineFragment(hasManager),
         loadLifecycleFragment(lifecycle),
+        loadWaitingFragment(),
     ]
         .filter((s) => s.length > 0)
         .join('\n\n');

package/dist/core/predicate.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Predicate matcher engine — vendored verbatim from pi's frontmatter-rules
+ * extension.
+ *
+ * Source: pi-personal-extensions/extensions/frontmatter-rules/index.ts
+ *         (the "Condition language" block, functions `asArray` … `evalCondition`).
+ *
+ * The unified document substrate uses this to evaluate a document's `gate`
+ * predicate against a node-config subject (e.g. `orchestration.depth: { gte: 2 }`).
+ *
+ * This is intentionally a COPY, not an import: the source lives in a separate,
+ * private, unpublished repo that crtr cannot depend on. The functions are pure
+ * TS over `unknown` / `Record<string, unknown>` with zero external imports, so
+ * vendoring them keeps this module standalone and dependency-free. Keep it in
+ * sync with the source by hand if the matcher language ever changes.
+ *
+ * Condition language (evaluated against the subject object):
+ *   A condition is a map of <field> -> <matcher>, AND-ed across fields.
+ *   `field` may be dotted to reach nested values (e.g. `orchestration.depth`).
+ *
+ *   Matcher forms:
+ *     scalar (string/number/bool/null)
+ *         field === value, OR (if the field is an array) the array includes value
+ *     array  [a, b, c]
+ *         membership/intersection: field is one of these, OR the field array
+ *         shares any element with these
+ *     object { <op>: <arg>, ... }   (multiple ops AND together)
+ *         eq          equals (scalar or array-includes)
+ *         ne          not eq
+ *         in          [..] — field (or any of its array elements) is in the list
+ *         nin         not in
+ *         exists      true|false — field is present / absent
+ *         contains    field array includes this value
+ *         containsAll [..] — field array includes all of these
+ *         containsAny [..] — field array includes any of these
+ *         matches     regex string, case-sensitive (tests String(field); arrays: any)
+ *         imatches    regex string, case-insensitive
+ *         gt gte lt lte   numeric comparison
+ *
+ *   Combinators (reserved keys at any condition level):
+ *     all: [ {..}, {..} ]   every sub-condition true (AND)
+ *     any: [ {..}, {..} ]   at least one true (OR)
+ *     not: { .. }           sub-condition false
+ *   Sibling field matchers next to combinators are AND-ed in.
+ *
+ *   Two load-bearing edge cases preserved from the source:
+ *     - An empty condition (`{}`) is INERT: it returns false, NOT match-all.
+ *     - An unknown op never matches.
+ */
+export declare function asArray(v: unknown): unknown[];
+export declare function scalarEq(a: unknown, b: unknown): boolean;
+export declare function getField(subject: unknown, key: string): unknown;
+export declare function toRegExp(arg: unknown, flags: string): RegExp | null;
+export declare function applyOp(op: string, value: unknown, arg: unknown): boolean;
+export declare function matchField(value: unknown, matcher: unknown): boolean;
+/**
+ * Evaluate a `gate` predicate against a subject object.
+ *
+ * This is the one function consumers call. Returns true iff `condition`
+ * matches `subject`. A null/non-object condition and an empty object both
+ * return false (inert), never match-all.
+ */
+export declare function evalCondition(condition: unknown, subject: Record<string, unknown>): boolean;

package/dist/core/predicate.js

@@ -0,0 +1,189 @@
+/**
+ * Predicate matcher engine — vendored verbatim from pi's frontmatter-rules
+ * extension.
+ *
+ * Source: pi-personal-extensions/extensions/frontmatter-rules/index.ts
+ *         (the "Condition language" block, functions `asArray` … `evalCondition`).
+ *
+ * The unified document substrate uses this to evaluate a document's `gate`
+ * predicate against a node-config subject (e.g. `orchestration.depth: { gte: 2 }`).
+ *
+ * This is intentionally a COPY, not an import: the source lives in a separate,
+ * private, unpublished repo that crtr cannot depend on. The functions are pure
+ * TS over `unknown` / `Record<string, unknown>` with zero external imports, so
+ * vendoring them keeps this module standalone and dependency-free. Keep it in
+ * sync with the source by hand if the matcher language ever changes.
+ *
+ * Condition language (evaluated against the subject object):
+ *   A condition is a map of <field> -> <matcher>, AND-ed across fields.
+ *   `field` may be dotted to reach nested values (e.g. `orchestration.depth`).
+ *
+ *   Matcher forms:
+ *     scalar (string/number/bool/null)
+ *         field === value, OR (if the field is an array) the array includes value
+ *     array  [a, b, c]
+ *         membership/intersection: field is one of these, OR the field array
+ *         shares any element with these
+ *     object { <op>: <arg>, ... }   (multiple ops AND together)
+ *         eq          equals (scalar or array-includes)
+ *         ne          not eq
+ *         in          [..] — field (or any of its array elements) is in the list
+ *         nin         not in
+ *         exists      true|false — field is present / absent
+ *         contains    field array includes this value
+ *         containsAll [..] — field array includes all of these
+ *         containsAny [..] — field array includes any of these
+ *         matches     regex string, case-sensitive (tests String(field); arrays: any)
+ *         imatches    regex string, case-insensitive
+ *         gt gte lt lte   numeric comparison
+ *
+ *   Combinators (reserved keys at any condition level):
+ *     all: [ {..}, {..} ]   every sub-condition true (AND)
+ *     any: [ {..}, {..} ]   at least one true (OR)
+ *     not: { .. }           sub-condition false
+ *   Sibling field matchers next to combinators are AND-ed in.
+ *
+ *   Two load-bearing edge cases preserved from the source:
+ *     - An empty condition (`{}`) is INERT: it returns false, NOT match-all.
+ *     - An unknown op never matches.
+ */
+export function asArray(v) {
+    if (Array.isArray(v))
+        return v;
+    if (v === undefined)
+        return [];
+    return [v];
+}
+// Scalar equality with light, predictable coercion: exact match, or
+// string/number cross-compare so `version: 2` matches a subject "2".
+export function scalarEq(a, b) {
+    if (a === b)
+        return true;
+    if ((typeof a === 'number' || typeof a === 'string') &&
+        (typeof b === 'number' || typeof b === 'string')) {
+        return String(a) === String(b);
+    }
+    return false;
+}
+// Resolve a (possibly dotted) field path against the subject object.
+export function getField(subject, key) {
+    if (subject && typeof subject === 'object' && key in subject) {
+        return subject[key];
+    }
+    if (!key.includes('.'))
+        return undefined;
+    let cur = subject;
+    for (const part of key.split('.')) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[part];
+    }
+    return cur;
+}
+export function toRegExp(arg, flags) {
+    if (typeof arg !== 'string')
+        return null;
+    try {
+        return new RegExp(arg, flags);
+    }
+    catch {
+        return null;
+    }
+}
+export function applyOp(op, value, arg) {
+    const vals = asArray(value);
+    switch (op) {
+        case 'eq':
+            return Array.isArray(value) ? value.some((v) => scalarEq(v, arg)) : scalarEq(value, arg);
+        case 'ne':
+            return !applyOp('eq', value, arg);
+        case 'in':
+            return asArray(arg).some((a) => vals.some((v) => scalarEq(v, a)));
+        case 'nin':
+            return !applyOp('in', value, arg);
+        case 'exists':
+            return (value !== undefined) === (arg !== false);
+        case 'contains':
+            return vals.some((v) => scalarEq(v, arg));
+        case 'containsAll':
+            return asArray(arg).every((a) => vals.some((v) => scalarEq(v, a)));
+        case 'containsAny':
+            return asArray(arg).some((a) => vals.some((v) => scalarEq(v, a)));
+        case 'matches':
+        case 'imatches': {
+            const re = toRegExp(arg, op === 'imatches' ? 'i' : '');
+            if (!re)
+                return false;
+            return vals.some((v) => (typeof v === 'string' || typeof v === 'number' ? re.test(String(v)) : false));
+        }
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte': {
+            const n = Number(value);
+            const t = Number(arg);
+            if (Number.isNaN(n) || Number.isNaN(t))
+                return false;
+            if (op === 'gt')
+                return n > t;
+            if (op === 'gte')
+                return n >= t;
+            if (op === 'lt')
+                return n < t;
+            return n <= t;
+        }
+        default:
+            return false; // unknown op never matches
+    }
+}
+export function matchField(value, matcher) {
+    if (matcher === null || ['string', 'number', 'boolean'].includes(typeof matcher)) {
+        if (Array.isArray(value))
+            return value.some((v) => scalarEq(v, matcher));
+        return scalarEq(value, matcher);
+    }
+    if (Array.isArray(matcher)) {
+        const vals = asArray(value);
+        return matcher.some((m) => vals.some((v) => scalarEq(v, m)));
+    }
+    if (matcher && typeof matcher === 'object') {
+        return Object.entries(matcher).every(([op, arg]) => applyOp(op, value, arg));
+    }
+    return false;
+}
+/**
+ * Evaluate a `gate` predicate against a subject object.
+ *
+ * This is the one function consumers call. Returns true iff `condition`
+ * matches `subject`. A null/non-object condition and an empty object both
+ * return false (inert), never match-all.
+ */
+export function evalCondition(condition, subject) {
+    if (condition == null)
+        return false;
+    if (Array.isArray(condition))
+        return condition.every((sub) => evalCondition(sub, subject));
+    if (typeof condition !== 'object')
+        return false;
+    const c = condition;
+    const hasCombinator = 'all' in c || 'any' in c || 'not' in c;
+    if (hasCombinator) {
+        let ok = true;
+        if ('all' in c)
+            ok = ok && asArray(c.all).every((s) => evalCondition(s, subject));
+        if ('any' in c)
+            ok = ok && asArray(c.any).some((s) => evalCondition(s, subject));
+        if ('not' in c)
+            ok = ok && !evalCondition(c.not, subject);
+        for (const k of Object.keys(c)) {
+            if (k === 'all' || k === 'any' || k === 'not')
+                continue;
+            ok = ok && matchField(getField(subject, k), c[k]);
+        }
+        return ok;
+    }
+    const keys = Object.keys(c);
+    if (keys.length === 0)
+        return false; // empty condition is inert, not match-all
+    return keys.every((k) => matchField(getField(subject, k), c[k]));
+}

package/dist/core/resolver.js

@@ -5,6 +5,7 @@ import { listDirs, pathExists, readText, readTextIfExists, walkFiles, } from './
 import { readMarketplaceManifest, readPluginManifest } from './manifest.js';
 import { parseFrontmatter } from './frontmatter.js';
 import { ambiguous, notFound, usage } from './errors.js';
+import { warn } from './output.js';
 import { InputError } from './io.js';
 import { builtinSkillsRoot, marketplacesDir, pluginsDir, projectScopeRoot, scopeSkillsDir, userScopeRoot, } from './scope.js';
 function getBuiltinPlugin() {
@@ -94,6 +95,22 @@ export function effectiveSkillEnabled(pluginName, skillName, cfgs) {
     }
     return { enabled: true };
 }
+/** Parse one skill file's frontmatter at the COLLECTION layer: the strict
+ *  parser THROWS on invalid YAML (the frontmatter contract is "valid YAML"),
+ *  so a single malformed SKILL.md must not brick a whole `skill find`/catalog
+ *  scan across the corpus. On a parse error, emit a clear scoped notice naming
+ *  the file and return null so the iterator SKIPS it and continues. A doc with
+ *  no frontmatter block parses fine (data === null) and is kept. */
+function readSkillFrontmatterSafe(file) {
+    try {
+        return parseFrontmatter(readText(file));
+    }
+    catch (e) {
+        const msg = (e instanceof Error ? e.message : String(e)).split('\n')[0];
+        warn(`invalid frontmatter in ${file}: ${msg}`);
+        return null;
+    }
+}
 export function listSkillsInPlugin(plugin, cfgs) {
     const skillsRoot = join(plugin.root, SKILLS_DIR);
     if (!pathExists(skillsRoot))
@@ -106,8 +123,10 @@ export function listSkillsInPlugin(plugin, cfgs) {
         const name = rel.split(sep).join('/');
         if (!name)
             continue;
-        const source = readText(file);
-        const { data } = parseFrontmatter(source);
+        const parsed = readSkillFrontmatterSafe(file);
+        if (parsed === null)
+            continue;
+        const { data } = parsed;
         const { enabled, disabledIn } = effectiveSkillEnabled(plugin.name, name, configs);
         skills.push({
             name,
@@ -136,8 +155,10 @@ export function listScopeRootSkills(scope, cfgs) {
         const name = rel.split(sep).join('/');
         if (!name)
             continue;
-        const source = readText(file);
-        const { data } = parseFrontmatter(source);
+        const parsed = readSkillFrontmatterSafe(file);
+        if (parsed === null)
+            continue;
+        const { data } = parsed;
         const { enabled, disabledIn } = effectiveSkillEnabled(SCOPE_SKILL_PLUGIN, name, configs);
         skills.push({
             name,
@@ -639,7 +660,7 @@ export function buildCategoryIndex(cat) {
         lines.push(`- \`${fullId}\` — ${desc}`);
     }
     lines.push('');
-    lines.push(`Read one with \`crtr skill read <full-id>\`. Narrow with \`crtr skill find list --plugin ${cat.plugin ?? cat.id}\`.`);
+    lines.push('Read one with `crtr memory read <full-id>`. Search with `crtr memory find "<topic>"`.');
     return lines.join('\n');
 }
 export function scopeRootsLabel() {

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

@@ -1,20 +1,61 @@
+import { type WakeKind, type Wakeup } from '../canvas/index.js';
 /** Base framing — present for every node. No path baked in: the caller carries
- *  the dir in the <crtr-context dir="…"> attribute. */
+ *  the dir in the `<crtr-context dir="…">` attribute. */
 export declare const BASE_CONTEXT_NOTE: string;
 /** Orchestrator-only framing: a resident orchestrator survives refresh cycles,
  *  so its context dir is also where a future cycle of itself resumes the work.
  *  Used inside the bearings block AND in the promotion guidance dump, so a
  *  promoted node gets the same note a born-orchestrator gets. */
 export declare function orchestratorContextNote(nodeId: string): string;
-/** The <memory> block (orchestrators only): the scoped stores merged, each a
- *  `label · dir` header over its live index pointer lines. A memory's `type`
- *  decides which store it lands in — the mapping + the how-to live once in the
- *  orchestration kernel ("Your long-term memory"); here we carry only the live
- *  data + a one-line pointer back to it. user-global rides in when the node has
- *  a user store, project when it has a project store, node-local always (the
- *  orchestrator gate). */
-export declare function buildMemoryBlock(nodeId: string, cwd: string): string;
-/** The full <crtr-context> bearings block: base framing always, plus the
- *  orchestrator addendum + the merged three-store <memory> block when the node
- *  has a node-local memory store (the orchestrator gate). */
+/** The IDENTITY assertion that opens every boot intro — the load-bearing fix
+ *  for the `--fork-from` impersonation bug. A fork copies the SOURCE node's
+ *  entire first-person conversation into its own session, so without an explicit
+ *  re-assertion the forked agent reads that copied narrative as its own and
+ *  impersonates the source (it kept "monitoring itself" as a phantom child).
+ *  This block names the node unambiguously. ONLY when the node IS a fork does it
+ *  additionally name the source AND disown the copied first-person narrative as
+ *  inherited reference material — a non-fork node's bearings are its first session
+ *  entry, so there is no earlier narrative to disown (emitting a disown line there
+ *  is dead weight that reads as a contradiction with no referent). Always the FIRST
+ *  thing the node reads. Exported for testing. */
+export declare function buildIdentityAssertion(nodeId: string): string;
+/** Why a node woke or was born, as carried from the fired wakeup row to the
+ *  injection seam. `ownerName` is the armer's resolved display name when it
+ *  still exists (a reaped cron's armer renders as a bare id, never crashes). */
+export interface WakeOrigin {
+    /** The firing kind. The <crtr-wake> block is rendered for 'spawn' (birth) and
+     *  'bare' (revive); 'noted'/'deadline' self-mark at the message seam instead. */
+    kind: WakeKind;
+    /** The armer node id (wakeups.owner_id), or null if somehow absent. */
+    ownerId: string | null;
+    /** The armer's display name, resolved if it still exists. */
+    ownerName?: string;
+    /** wakeups.created — when the wake was armed (ISO). */
+    armedAt: string;
+    /** wakeups.recur JSON when recurring, else null/undefined for a one-shot. */
+    recur?: string | null;
+}
+/** Build a WakeOrigin from a fired wakeup row, resolving the armer's display
+ *  name if the node still exists. The daemon calls this at fire time for the
+ *  bare-revive and spawn-birth seams. */
+export declare function wakeOriginFrom(w: Wakeup): WakeOrigin;
+/** The <crtr-wake> provenance block — load-bearing agent-facing prose read by
+ *  every wake-born or wake-woken node. Decision-first: it leads with the fact a
+ *  TIMER (not a message/event) caused this turn, names the wake kind, surfaces
+ *  the cadence for a recurrence (so the agent knows it is one run of a standing
+ *  job, not a one-off), and ends with the directive. The spawn (birth) variant
+ *  names the ARMER explicitly ("armed by node X") so the newborn never reads that
+ *  id as its own; the bare (revive) variant drops armer attribution entirely — a
+ *  bare wake can be armed for a node by ANOTHER (`--node`), and who armed it is
+ *  not decision-relevant to a timed re-check. No timestamp is rendered ("to fire
+ *  now" / the cadence already carry the signal; a raw ISO instant is noise an
+ *  agent cannot cheaply turn into an elapsed delta). Rendered for 'spawn' and
+ *  'bare'; other kinds self-mark elsewhere. */
+export declare function buildWakeBearings(origin: WakeOrigin): string;
+/** The full boot intro: the IDENTITY assertion (always first, so it overrides
+ *  any copied-in persona) followed by the `<crtr-context>` bearings block. Base
+ *  framing rides for EVERY node; the across-cycles context-dir note is added
+ *  ONLY for an orchestrator (by mode) — the one node whose dir a future cycle
+ *  resumes from. The `## References` block (substrate reference docs +
+ *  node-local docs) replaces the old `<memory>` block. */
 export declare function buildContextBearings(nodeId: string): string;