@crouton-kit/crouter 0.3.17 → 0.3.19

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

@@ -5,9 +5,10 @@
  * Resolution order (highest → lowest precedence): project > user > builtin.
  *
  * Layout on disk:
- *   <root>/personas/<kind>/base.md
+ *   <root>/personas/<kind>/PERSONA.md
  *   <root>/personas/<kind>/orchestrator.md
  *   <root>/personas/orchestration-kernel.md
+ *   <root>/personas/<kind>/<...>/PERSONA.md   (nested sub-personas)
  *
  * The builtin root is src/builtin-personas (or dist/builtin-personas in the
  * compiled build), resolved relative to this module — mirrors the pattern used
@@ -38,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`
@@ -55,29 +63,46 @@ export declare function loadLifecycleFragment(lifecycle: 'terminal' | 'resident'
  */
 export declare function loadSpineFragment(hasManager: boolean): string;
 /**
- * Enumerate the kinds with at least one persona file (base.md or
+ * Enumerate the kinds with at least one persona file (PERSONA.md or
  * orchestrator.md) across all scope roots (project/user/builtin). Used to
- * validate a requested `--kind` and to list the valid choices.
+ * validate a requested `--kind` and to list the valid choices. Only the
+ * IMMEDIATE children of each root count — nested sub-personas never pollute
+ * the global kind list (see subPersonasFor).
  */
 export declare function availableKinds(): string[];
-export interface SubKind {
+/**
+ * The one-line "when to use this node type" gloss for `kind`, read from its
+ * `<kind>/PERSONA.md` `whenToUse` frontmatter (resolved project > user >
+ * builtin). Returns '' when the kind has no PERSONA.md or no `whenToUse`.
+ * Drives the dynamic kind list in `node new -h` / `node promote -h`.
+ */
+export declare function kindWhenToUse(kind: string): string;
+export interface SubPersona {
     /** Full kind string to spawn, e.g. 'plan/reviewers/security'. */
     kind: string;
     /** Leaf name, e.g. 'security'. */
     name: string;
-    /** One-line "what it reviews", from the sub-kind base.md `summary` frontmatter (or ''). */
-    summary: string;
+    /** One-line "when to use", from the sub-persona PERSONA.md `whenToUse` frontmatter (or ''). */
+    whenToUse: string;
 }
 /**
- * Enumerate the reviewer sub-kinds owned by `parentKind` — the specialist
- * personas at `<root>/<parentKind>/reviewers/<name>/base.md`, scanned across all
- * scope roots (project > user > builtin; highest precedence wins per name).
+ * Enumerate the sub-personas AVAILABLE TO `kind` — the nested specialist
+ * personas (e.g. `plan/reviewers/security`) a `kind` node may spawn, surfaced
+ * in its composed prompt (resolve.ts) and nowhere else.
+ *
+ * A sub-persona is any descendant dir (ANY depth) under a top-level kind dir
+ * that holds a PERSONA.md, EXCLUDING the top-level PERSONA.md itself. Its
+ * availability is its `availableTo` frontmatter: an explicit list of kind
+ * strings, or the wildcard `"*"`/`"all"` (visible to every kind); absent, it
+ * defaults to its own top-level ancestor kind. So the five `plan/reviewers/*`
+ * (no `availableTo`) are visible only to `plan`, while a sub-persona under
+ * `developer/` can declare `availableTo: [plan]` to surface in plan's menu —
+ * which is why ALL top-level kinds' descendants are scanned, not just `<kind>/`.
  *
- * Sub-kinds are intentionally NOT global kinds: `availableKinds()` scans only the
- * immediate children of each persona root, so `<parentKind>/reviewers/*` never
- * leaks into the global list. A sub-kind is reachable only by its full kind
- * string and is surfaced only in its parent kind's composed prompt (resolve.ts).
- * Kind-parametric: any kind owns a roster simply by adding
- * `<kind>/reviewers/<name>/base.md` — no code change.
+ * Sub-personas are intentionally NOT global kinds: `availableKinds()` scans only
+ * the immediate children of each root, so a nested sub-persona never leaks into
+ * the global list; it is reachable only by its full kind string. Precedence is
+ * project > user > builtin keyed on the FULL kind string — the highest root that
+ * defines a given kind string wins (and owns its `availableTo`).
  */
-export declare function subKindsFor(parentKind: string): SubKind[];
+export declare function subPersonasFor(kind: string): SubPersona[];

package/dist/core/personas/loader.js

@@ -5,9 +5,10 @@
  * Resolution order (highest → lowest precedence): project > user > builtin.
  *
  * Layout on disk:
- *   <root>/personas/<kind>/base.md
+ *   <root>/personas/<kind>/PERSONA.md
  *   <root>/personas/<kind>/orchestrator.md
  *   <root>/personas/orchestration-kernel.md
+ *   <root>/personas/<kind>/<...>/PERSONA.md   (nested sub-personas)
  *
  * The builtin root is src/builtin-personas (or dist/builtin-personas in the
  * compiled build), resolved relative to this module — mirrors the pattern used
@@ -55,11 +56,28 @@ 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
 // ---------------------------------------------------------------------------
 /**
  * Find the first existing file across the scope roots.
- * `relativePath` is relative to each root (e.g. 'general/base.md').
+ * `relativePath` is relative to each root (e.g. 'general/PERSONA.md').
  */
 function resolveFile(relativePath) {
     for (const root of personaSearchRoots()) {
@@ -92,6 +110,11 @@ function inlineIncludes(body) {
         return kernelBody.trim();
     });
 }
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** The role-body filename for every kind/sub-persona (replaces legacy base.md). */
+const PERSONA_FILE = 'PERSONA.md';
 /**
  * Load and parse a persona file for the given `kind` and `mode`.
  *
@@ -99,7 +122,8 @@ function inlineIncludes(body) {
  * On success, `@include` directives in the body are resolved and inlined.
  */
 export function loadPersona(kind, mode) {
-    const relativePath = `${kind}/${mode}.md`;
+    // base → PERSONA.md (the role body); orchestrator → its sibling orchestrator.md.
+    const relativePath = mode === 'orchestrator' ? `${kind}/orchestrator.md` : `${kind}/PERSONA.md`;
     const filePath = resolveFile(relativePath);
     if (!filePath)
         return null;
@@ -136,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`
@@ -165,9 +202,11 @@ export function loadSpineFragment(hasManager) {
     return body.trim();
 }
 /**
- * Enumerate the kinds with at least one persona file (base.md or
+ * Enumerate the kinds with at least one persona file (PERSONA.md or
  * orchestrator.md) across all scope roots (project/user/builtin). Used to
- * validate a requested `--kind` and to list the valid choices.
+ * validate a requested `--kind` and to list the valid choices. Only the
+ * IMMEDIATE children of each root count — nested sub-personas never pollute
+ * the global kind list (see subPersonasFor).
  */
 export function availableKinds() {
     const kinds = new Set();
@@ -178,42 +217,107 @@ export function availableKinds() {
             if (!entry.isDirectory())
                 continue;
             const dir = join(root, entry.name);
-            if (existsSync(join(dir, 'base.md')) || existsSync(join(dir, 'orchestrator.md'))) {
+            if (existsSync(join(dir, PERSONA_FILE)) || existsSync(join(dir, 'orchestrator.md'))) {
                 kinds.add(entry.name);
             }
         }
     }
     return [...kinds].sort();
 }
-const REVIEWERS_SUBDIR = 'reviewers';
 /**
- * Enumerate the reviewer sub-kinds owned by `parentKind` — the specialist
- * personas at `<root>/<parentKind>/reviewers/<name>/base.md`, scanned across all
- * scope roots (project > user > builtin; highest precedence wins per name).
+ * The one-line "when to use this node type" gloss for `kind`, read from its
+ * `<kind>/PERSONA.md` `whenToUse` frontmatter (resolved project > user >
+ * builtin). Returns '' when the kind has no PERSONA.md or no `whenToUse`.
+ * Drives the dynamic kind list in `node new -h` / `node promote -h`.
+ */
+export function kindWhenToUse(kind) {
+    const filePath = resolveFile(`${kind}/${PERSONA_FILE}`);
+    if (!filePath)
+        return '';
+    const { data } = parseFrontmatterGeneric(readFileSync(filePath, 'utf8'));
+    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).
+ *  Dirs WITHOUT a PERSONA.md (e.g. a `reviewers/` grouping namespace) are
+ *  transparent — they yield nothing themselves but are still descended into,
+ *  so `plan/reviewers/security` keeps that exact kind string. */
+function* walkPersonaDirs(dir, relParts) {
+    const file = join(dir, PERSONA_FILE);
+    if (existsSync(file))
+        yield { relKind: relParts.join('/'), file };
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            yield* walkPersonaDirs(join(dir, entry.name), [...relParts, entry.name]);
+    }
+}
+/** Parse a sub-persona's `availableTo` frontmatter into its availability set.
+ *  Returns the wildcard sentinel `'*'` for `"*"`/`"all"` (scalar or in an
+ *  array), an explicit list of kind strings when present, else the default
+ *  `[topKind]` (the top-level ancestor kind). */
+function parseAvailableTo(data, topKind) {
+    const isWild = (s) => {
+        const t = s.trim().toLowerCase();
+        return t === '*' || t === 'all';
+    };
+    const v = data ? data['availableTo'] : undefined;
+    if (v === undefined)
+        return [topKind];
+    const scalar = scalarToString(v);
+    if (scalar !== null)
+        return isWild(scalar) ? '*' : [scalar];
+    if (Array.isArray(v)) {
+        const arr = v.map(scalarToString).filter((x) => x !== null);
+        if (arr.some(isWild))
+            return '*';
+        return arr.length > 0 ? arr : [topKind];
+    }
+    return [topKind];
+}
+/**
+ * Enumerate the sub-personas AVAILABLE TO `kind` — the nested specialist
+ * personas (e.g. `plan/reviewers/security`) a `kind` node may spawn, surfaced
+ * in its composed prompt (resolve.ts) and nowhere else.
  *
- * Sub-kinds are intentionally NOT global kinds: `availableKinds()` scans only the
- * immediate children of each persona root, so `<parentKind>/reviewers/*` never
- * leaks into the global list. A sub-kind is reachable only by its full kind
- * string and is surfaced only in its parent kind's composed prompt (resolve.ts).
- * Kind-parametric: any kind owns a roster simply by adding
- * `<kind>/reviewers/<name>/base.md` — no code change.
+ * A sub-persona is any descendant dir (ANY depth) under a top-level kind dir
+ * that holds a PERSONA.md, EXCLUDING the top-level PERSONA.md itself. Its
+ * availability is its `availableTo` frontmatter: an explicit list of kind
+ * strings, or the wildcard `"*"`/`"all"` (visible to every kind); absent, it
+ * defaults to its own top-level ancestor kind. So the five `plan/reviewers/*`
+ * (no `availableTo`) are visible only to `plan`, while a sub-persona under
+ * `developer/` can declare `availableTo: [plan]` to surface in plan's menu —
+ * which is why ALL top-level kinds' descendants are scanned, not just `<kind>/`.
+ *
+ * Sub-personas are intentionally NOT global kinds: `availableKinds()` scans only
+ * the immediate children of each root, so a nested sub-persona never leaks into
+ * the global list; it is reachable only by its full kind string. Precedence is
+ * project > user > builtin keyed on the FULL kind string — the highest root that
+ * defines a given kind string wins (and owns its `availableTo`).
  */
-export function subKindsFor(parentKind) {
-    const byName = new Map();
+export function subPersonasFor(kind) {
+    const seen = new Set(); // full kind strings already resolved (higher root won)
+    const out = [];
     for (const root of personaSearchRoots()) {
-        const dir = join(root, parentKind, REVIEWERS_SUBDIR);
-        if (!existsSync(dir))
+        if (!existsSync(root))
             continue;
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            if (!entry.isDirectory() || byName.has(entry.name))
-                continue; // higher root already won
-            const baseFile = join(dir, entry.name, 'base.md');
-            if (!existsSync(baseFile))
+        for (const top of readdirSync(root, { withFileTypes: true })) {
+            if (!top.isDirectory())
                 continue;
-            const { data } = parseFrontmatterGeneric(readFileSync(baseFile, 'utf8'));
-            const summary = data && typeof data['summary'] === 'string' ? data['summary'] : '';
-            byName.set(entry.name, { kind: `${parentKind}/${REVIEWERS_SUBDIR}/${entry.name}`, name: entry.name, summary });
+            const topKind = top.name;
+            for (const { relKind, file } of walkPersonaDirs(join(root, topKind), [topKind])) {
+                if (relKind === topKind)
+                    continue; // the top-level PERSONA.md is the kind itself, not a sub-persona
+                if (seen.has(relKind))
+                    continue; // a higher root already resolved this kind string
+                seen.add(relKind);
+                const { data } = parseFrontmatterGeneric(readFileSync(file, 'utf8'));
+                const availableTo = parseAvailableTo(data, topKind);
+                if (availableTo !== '*' && !availableTo.includes(kind))
+                    continue;
+                const whenToUse = scalarToString(data?.['whenToUse']) ?? '';
+                out.push({ kind: relKind, name: relKind.split('/').pop(), whenToUse });
+            }
         }
     }
-    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+    return out.sort((a, b) => a.kind.localeCompare(b.kind));
 }

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

@@ -4,17 +4,17 @@
  *
  * Composition rules:
  *   mode==='base'
- *     → load <kind>/base.md; if missing fall back to general defaults.
+ *     → load <kind>/PERSONA.md; if missing fall back to general defaults.
  *
  *   mode==='orchestrator'
  *     → prefer <kind>/orchestrator.md (which must embed the kernel via
  *       @include orchestration-kernel.md — inlined by the loader).
  *       If no orchestrator.md exists for this kind, compose:
- *         <kind>/base.md body  +  '\n\n'  +  kernel body
- *       If even the base is missing, fall back to general defaults + kernel.
+ *         <kind>/PERSONA.md body  +  '\n\n'  +  kernel body
+ *       If even the PERSONA.md is missing, fall back to general defaults + kernel.
  *
  * Frontmatter from whichever file is the primary source (orchestrator.md >
- * base.md) supplies model/skills/extensions/tools. Lifecycle and spine position
+ * PERSONA.md) supplies model/skills/extensions/tools. Lifecycle and spine position
  * are INPUTS (the caller decides them — root/child, terminal/resident), not
  * derived here; they select the lifecycle/spine protocol fragments spliced
  * ahead of the persona body.

package/dist/core/personas/resolve.js

@@ -4,32 +4,41 @@
  *
  * Composition rules:
  *   mode==='base'
- *     → load <kind>/base.md; if missing fall back to general defaults.
+ *     → load <kind>/PERSONA.md; if missing fall back to general defaults.
  *
  *   mode==='orchestrator'
  *     → prefer <kind>/orchestrator.md (which must embed the kernel via
  *       @include orchestration-kernel.md — inlined by the loader).
  *       If no orchestrator.md exists for this kind, compose:
- *         <kind>/base.md body  +  '\n\n'  +  kernel body
- *       If even the base is missing, fall back to general defaults + kernel.
+ *         <kind>/PERSONA.md body  +  '\n\n'  +  kernel body
+ *       If even the PERSONA.md is missing, fall back to general defaults + kernel.
  *
  * Frontmatter from whichever file is the primary source (orchestrator.md >
- * base.md) supplies model/skills/extensions/tools. Lifecycle and spine position
+ * PERSONA.md) supplies model/skills/extensions/tools. Lifecycle and spine position
  * are INPUTS (the caller decides them — root/child, terminal/resident), not
  * derived here; they select the lifecycle/spine protocol fragments spliced
  * ahead of the persona body.
  */
-import { loadPersona, loadKernel, loadRuntimeBase, loadSpineFragment, loadLifecycleFragment, subKindsFor } 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) {
@@ -40,29 +49,32 @@ function fallbackBasePrompt(kind) {
  *  fragment (report-up vs. silent, keyed on whether the node has a manager),
  *  then the lifecycle fragment (finish-with-`push final` vs. dormant/wake). The
  *  kind×mode persona body follows after a rule. Empty fragments drop out. */
-/** Render the "sub-kinds you may spawn" menu for a kind that owns a roster.
- *  Returns '' when the kind owns none. Data-driven: one line per sub-kind, its
- *  spawn string + its `summary`. Adding a roster file makes it appear here. */
-function renderSubKindMenu(kind) {
-    const subs = subKindsFor(kind);
+/** Render the "sub-personas you may spawn" menu for a kind that has any
+ *  available to it. Returns '' when none are. Data-driven: one line per
+ *  sub-persona, its spawn string + its `whenToUse`. A sub-persona surfaces here
+ *  for a kind when its `availableTo` includes that kind (default: its own
+ *  top-level ancestor) or is the wildcard. */
+function renderSubPersonaMenu(kind) {
+    const subs = subPersonasFor(kind);
     if (subs.length === 0)
         return '';
-    const lines = subs.map((s) => `- \`${s.kind}\` — ${s.summary}`);
+    const lines = subs.map((s) => `- \`${s.kind}\` — ${s.whenToUse}`);
     return [
-        '## Reviewer sub-kinds you may spawn',
+        '## Sub-personas you may spawn',
         '',
-        `These specialist reviewers exist only in the ${kind} kind's world — no other kind sees them. Spawn one with \`crtr node new --kind <sub-kind> "<scope>"\`, giving it only its scope, never your suspicions: a reviewer handed a hint anchors on it instead of finding problems independently.`,
+        `These specialist sub-personas are available to the ${kind} kind. Spawn one with \`crtr node new --kind <sub> "<scope>"\`, giving it only its scope, never your suspicions: a reviewer handed a hint anchors on it instead of finding problems independently.`,
         '',
         ...lines,
     ].join('\n');
 }
 function composeProtocol(personaPrompt, kind, lifecycle, hasManager) {
-    const menu = renderSubKindMenu(kind);
+    const menu = renderSubPersonaMenu(kind);
     const body = menu ? `${personaPrompt}\n\n${menu}` : personaPrompt;
     const protocol = [
         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;