@crouton-kit/crouter 0.3.18 → 0.3.19

package/dist/core/frontmatter.js

@@ -1,3 +1,4 @@
+import { parse as parseYaml } from 'yaml';
 import { isSkillType } from '../types.js';
 const FRONTMATTER_RE = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/;
 export function parseFrontmatter(source) {
@@ -7,7 +8,7 @@ export function parseFrontmatter(source) {
     }
     const raw = match[1];
     const body = source.slice(match[0].length);
-    return { data: toSkillFrontmatter(parseYamlRecord(raw)), body, raw };
+    return { data: toSkillFrontmatter(parseYamlBlock(raw)), body, raw };
 }
 /** Like parseFrontmatter but returns the raw key/value record instead of
  *  coercing to SkillFrontmatter. Used by consumers (e.g. subagents) that read
@@ -19,138 +20,50 @@ export function parseFrontmatterGeneric(source) {
     }
     const raw = match[1];
     const body = source.slice(match[0].length);
-    return { data: parseYamlRecord(raw), body, raw };
+    return { data: parseYamlBlock(raw), body, raw };
 }
 function toSkillFrontmatter(out) {
     const fm = {
-        name: typeof out.name === 'string' ? out.name : '',
-        description: typeof out.description === 'string' ? out.description : undefined,
-        keywords: Array.isArray(out.keywords) ? out.keywords : undefined,
+        name: scalarToString(out.name) ?? '',
+        description: scalarToString(out.description),
+        keywords: Array.isArray(out.keywords) ? out.keywords.map((k) => String(k)) : undefined,
         type: isSkillType(out.type) ? out.type : undefined,
     };
     return fm;
 }
-function parseYamlRecord(yaml) {
-    const lines = yaml.split(/\r?\n/);
-    const out = {};
-    let i = 0;
-    while (i < lines.length) {
-        const raw = lines[i];
-        if (!raw.trim()) {
-            i++;
-            continue;
-        }
-        const idx = raw.indexOf(':');
-        if (idx === -1) {
-            i++;
-            continue;
-        }
-        const key = raw.slice(0, idx).trim();
-        const rest = raw.slice(idx + 1).trim();
-        // Block scalar: `key: |` or `key: >` with optional chomp indicator (-/+)
-        const blockMatch = rest.match(/^([|>])([-+]?)\s*$/);
-        if (blockMatch) {
-            const style = blockMatch[1];
-            const chomp = blockMatch[2];
-            const collected = [];
-            let blockIndent = null;
-            let j = i + 1;
-            while (j < lines.length) {
-                const r = lines[j];
-                if (r.trim() === '') {
-                    collected.push('');
-                    j++;
-                    continue;
-                }
-                const ind = r.match(/^(\s*)/)?.[1].length ?? 0;
-                if (blockIndent === null) {
-                    if (ind === 0)
-                        break;
-                    blockIndent = ind;
-                }
-                if (ind < blockIndent)
-                    break;
-                collected.push(r.slice(blockIndent));
-                j++;
-            }
-            while (collected.length > 0 && collected[collected.length - 1] === '')
-                collected.pop();
-            let value;
-            if (style === '|') {
-                value = collected.join('\n');
-            }
-            else {
-                const parts = [];
-                let para = [];
-                for (const ln of collected) {
-                    if (ln === '') {
-                        if (para.length > 0) {
-                            parts.push(para.join(' '));
-                            para = [];
-                        }
-                        parts.push('');
-                    }
-                    else {
-                        para.push(ln);
-                    }
-                }
-                if (para.length > 0)
-                    parts.push(para.join(' '));
-                const folded = [];
-                for (let k = 0; k < parts.length; k++) {
-                    if (parts[k] === '' && (k === 0 || parts[k - 1] === ''))
-                        continue;
-                    folded.push(parts[k]);
-                }
-                value = folded.join('\n').replace(/\n+$/, '');
-            }
-            if (chomp !== '+')
-                value = value.replace(/\n+$/, '');
-            out[key] = value;
-            i = j;
-            continue;
-        }
-        // Empty value: could be a list on subsequent lines
-        if (rest === '') {
-            const buf = [];
-            let j = i + 1;
-            while (j < lines.length) {
-                const r = lines[j];
-                if (r.trim() === '') {
-                    j++;
-                    continue;
-                }
-                if (/^\s*-\s+/.test(r)) {
-                    buf.push(stripQuotes(r.replace(/^\s*-\s+/, '').trim()));
-                    j++;
-                    continue;
-                }
-                break;
-            }
-            if (buf.length > 0)
-                out[key] = buf;
-            i = j;
-            continue;
-        }
-        if (rest.startsWith('[') && rest.endsWith(']')) {
-            out[key] = rest
-                .slice(1, -1)
-                .split(',')
-                .map((s) => stripQuotes(s.trim()))
-                .filter(Boolean);
-            i++;
-            continue;
-        }
-        out[key] = stripQuotes(rest);
-        i++;
-    }
-    return out;
+/** Coerce a YAML scalar (string/number/boolean) to its string form. A skill's
+ *  `name`/`description` are always strings to consumers; native non-string
+ *  scalars (a numeric/boolean value) render as their string form, and
+ *  non-scalars (null/undefined/array/object) yield undefined. */
+function scalarToString(v) {
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return undefined;
+}
+/** Parse the inner YAML of a frontmatter block into a key/value record.
+ *
+ *  ONE strict parser, no fallback. The frontmatter contract IS "valid YAML":
+ *  the single `yaml`-package path handles the substrate's nested `gate:` maps,
+ *  inline `{…}` objects, and native scalar typing — and a doc whose frontmatter
+ *  is NOT valid YAML THROWS, by design. There is deliberately no second lenient
+ *  parser; a dual parsing strategy is the hedge we reject. Callers that iterate
+ *  MANY docs isolate a per-doc throw at the COLLECTION layer (a clear scoped
+ *  notice naming the bad file, then continue); single-doc callers let the error
+ *  surface so the user learns their one requested doc is malformed.
+ *
+ *  A VALID non-object document (a bare scalar, a top-level list, or an empty
+ *  block) normalizes to an empty record, preserving the contract that callers
+ *  always receive a Record for well-formed-but-non-mapping frontmatter. */
+function parseYamlBlock(raw) {
+    return normalizeToRecord(parseYaml(raw));
 }
-function stripQuotes(s) {
-    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
-        return s.slice(1, -1);
+function normalizeToRecord(parsed) {
+    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        return parsed;
     }
-    return s;
+    return {};
 }
 export function serializeFrontmatter(data) {
     const lines = ['---'];

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

@@ -0,0 +1,49 @@
+import type { Scope } from '../types.js';
+/**
+ * Thin memory-document resolver for the document substrate. Mirrors the SHAPE
+ * of the skill resolver (qualifier parse → scope precedence → direct path
+ * lookup → leaf-name fallback) but drops ALL plugin machinery: memory
+ * resolution is scope + leaf/path ONLY. The three memory scopes resolve in
+ * precedence order project > user > builtin (the same precedence concept as
+ * orderPluginsByResolution, minus plugins). It returns the raw parsed
+ * frontmatter + body; it does NOT interpret the schema, kind, gate, or rungs —
+ * that is the schema/gate layer's job (callers filter by `frontmatter.kind`).
+ */
+export interface MemoryDoc {
+    /** Path-derived identity: the doc's path under the scope's memory/ root, no
+     *  extension, slash-separated — e.g. memory/taste/foo.md → "taste/foo". */
+    name: string;
+    scope: Scope;
+    /** Absolute path to the resolved .md file. */
+    path: string;
+    /** Raw, uncoerced frontmatter record (null when the doc has no frontmatter). */
+    frontmatter: Record<string, unknown> | null;
+    /** Document body, with the frontmatter block stripped. */
+    body: string;
+}
+export interface MemoryResolutionOpts {
+    /** Restrict resolution to a single scope. Conflicts with a scope prefix on
+     *  the identifier (e.g. `user/foo` with scope=project) throw. */
+    scope?: Scope;
+}
+/** Canonical, unambiguous identifier for a memory document: `<scope>/<name>`. */
+export declare function memoryDocId(doc: MemoryDoc): string;
+/** All memory docs in one scope's memory/ dir, scanned recursively for *.md
+ *  (topical subdirs supported), sorted by path-derived name. */
+export declare function listMemoryDocs(scope: Scope): MemoryDoc[];
+/** All memory docs across the resolved scopes, in precedence order
+ *  (project, then user, then builtin), each scope's docs name-sorted within. */
+export declare function listAllMemoryDocs(scope?: Scope): MemoryDoc[];
+/**
+ * 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 declare function resolveMemoryDoc(rawName: string, opts?: MemoryResolutionOpts): MemoryDoc;

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;