agent-nuvira 3.3.13 → 3.3.14

package/dist/learning/capability-readiness.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Capability readiness — the dashboard's one view of what the agent can DO here.
+ *
+ * This is the read-model behind `GET /api/capabilities`. It answers the question
+ * a user actually has before asking the agent for something ("will this work on
+ * my machine?") by probing the curated high-level verbs' declared requirements
+ * against the host:
+ *
+ *   - each verb's READINESS (a missing executable blocks; a credential that is
+ *     not an env var is reported but never blocks — see requirement-probe.ts);
+ *   - the MISSING EXECUTABLES aggregated across the verbs, so the same `gh` is
+ *     one row naming every verb that needs it rather than nine;
+ *   - the per-OS command, where the OS genuinely decides it (`onThisMachine`).
+ *
+ * It is the SAME `actionCapabilities()` the capability search serves and the SAME
+ * `probeRequirements` the `tool_search` pre-flight runs, so the dashboard cannot
+ * disagree with what a run actually sees. Live session grants are served by the
+ * existing `/api/session-grants` (one source), so this module stays about
+ * capability, not consent.
+ *
+ * No phrase lists, no guessing: everything is derived from the declarations.
+ */
+import type { CapabilityRequires, PlatformCommand, PlatformKey } from './capability-types.js';
+/** One curated verb as the dashboard shows it. */
+export interface CapabilityReadinessRow {
+    id: string;
+    ref: string;
+    name: string;
+    does: string;
+    effect: string;
+    reversible: boolean;
+    undo?: string;
+    grantable?: string;
+    requires?: CapabilityRequires;
+    /** True when nothing HARD is missing (only a binary gap can make this false). */
+    ready: boolean;
+    /** Human lines: an executable that is missing, or a credential not in the env. */
+    gaps: string[];
+    /** Inputs the model must still decide (never probed — not facts). */
+    ask: string[];
+    /** The command for the machine this server runs on, where the OS decides it. */
+    onThisMachine?: PlatformCommand;
+    /** Every declared per-OS command, where the OS genuinely decides it. */
+    platforms?: Partial<Record<PlatformKey, PlatformCommand>>;
+}
+/** An executable the curated verbs need that is not on PATH. */
+export interface MissingExecutable {
+    /** The verbs (refs) that need it. */
+    forRefs: string[];
+    anyOf: string[];
+    remedy: string;
+}
+export interface CapabilityReadiness {
+    verbs: CapabilityReadinessRow[];
+    missingExecutables: MissingExecutable[];
+    readyCount: number;
+    blockedCount: number;
+}
+/**
+ * Build the readiness view. `platform` is injectable so a test can prove the
+ * per-OS resolution without the host's real platform.
+ */
+export declare function capabilityReadiness(platform?: string): CapabilityReadiness;
+//# sourceMappingURL=capability-readiness.d.ts.map

package/dist/learning/capability-readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-readiness.d.ts","sourceRoot":"","sources":["../../src/learning/capability-readiness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE9F,kDAAkD;AAClD,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,iFAAiF;IACjF,KAAK,EAAE,OAAO,CAAC;IACf,kFAAkF;IAClF,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qEAAqE;IACrE,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,gFAAgF;IAChF,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC,wEAAwE;IACxE,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC,CAAC;CAC3D;AAED,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,qCAAqC;IACrC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,GAAE,MAAyB,GAAG,mBAAmB,CA+C5F"}

package/dist/learning/capability-readiness.js

@@ -0,0 +1,74 @@
+/**
+ * Capability readiness — the dashboard's one view of what the agent can DO here.
+ *
+ * This is the read-model behind `GET /api/capabilities`. It answers the question
+ * a user actually has before asking the agent for something ("will this work on
+ * my machine?") by probing the curated high-level verbs' declared requirements
+ * against the host:
+ *
+ *   - each verb's READINESS (a missing executable blocks; a credential that is
+ *     not an env var is reported but never blocks — see requirement-probe.ts);
+ *   - the MISSING EXECUTABLES aggregated across the verbs, so the same `gh` is
+ *     one row naming every verb that needs it rather than nine;
+ *   - the per-OS command, where the OS genuinely decides it (`onThisMachine`).
+ *
+ * It is the SAME `actionCapabilities()` the capability search serves and the SAME
+ * `probeRequirements` the `tool_search` pre-flight runs, so the dashboard cannot
+ * disagree with what a run actually sees. Live session grants are served by the
+ * existing `/api/session-grants` (one source), so this module stays about
+ * capability, not consent.
+ *
+ * No phrase lists, no guessing: everything is derived from the declarations.
+ */
+import { actionCapabilities } from '../tools/capability-registry.js';
+import { probeRequirements, describeGap } from './requirement-probe.js';
+/**
+ * Build the readiness view. `platform` is injectable so a test can prove the
+ * per-OS resolution without the host's real platform.
+ */
+export function capabilityReadiness(platform = process.platform) {
+    const verbs = [];
+    const missing = new Map();
+    for (const cap of actionCapabilities()) {
+        const requires = cap.requires && Object.keys(cap.requires).length > 0 ? cap.requires : undefined;
+        const readiness = requires
+            ? probeRequirements(requires)
+            : { ready: true, gaps: [], ask: [] };
+        // Aggregate the executable gaps: the same `gh` is one row naming every verb
+        // that needs it, not one row per verb.
+        for (const gap of readiness.gaps) {
+            if (gap.kind !== 'binary')
+                continue;
+            const key = gap.anyOf.join('|');
+            const existing = missing.get(key) ?? { forRefs: [], anyOf: gap.anyOf, remedy: gap.remedy };
+            if (!existing.forRefs.includes(cap.ref))
+                existing.forRefs.push(cap.ref);
+            missing.set(key, existing);
+        }
+        const onThisMachine = cap.platforms ? cap.platforms[platform] : undefined;
+        verbs.push({
+            id: cap.id,
+            ref: cap.ref,
+            name: cap.name,
+            does: cap.oneLiner,
+            effect: cap.effectClass,
+            reversible: cap.reversible,
+            ...(cap.reversibleHow ? { undo: cap.reversibleHow } : {}),
+            ...(cap.grantCategory ? { grantable: cap.grantCategory } : {}),
+            ...(requires ? { requires } : {}),
+            ready: readiness.ready,
+            gaps: readiness.gaps.map(describeGap),
+            ask: readiness.ask,
+            ...(onThisMachine ? { onThisMachine } : {}),
+            ...(cap.platforms ? { platforms: cap.platforms } : {}),
+        });
+    }
+    const readyCount = verbs.filter((v) => v.ready).length;
+    return {
+        verbs,
+        missingExecutables: [...missing.values()],
+        readyCount,
+        blockedCount: verbs.length - readyCount,
+    };
+}
+//# sourceMappingURL=capability-readiness.js.map

package/dist/learning/capability-readiness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-readiness.js","sourceRoot":"","sources":["../../src/learning/capability-readiness.ts"],"names":[],"mappings":"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"}

package/dist/learning/capability-types.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Capability types — ONE descriptor for everything the agent can DO.
+ *
+ * WHY THIS EXISTS. "What an action needs, what it costs, and what it touches"
+ * was scattered: tools carried it in prose descriptions, each gate hardcoded its
+ * own effect class, skills carried only methodology, and the CLI manifest carried
+ * a single boolean. Adding a verb (install / uninstall / publish / deploy / push)
+ * meant editing all of them. The capability descriptor is the ONE shape those
+ * sources are normalized into, so discovery, gating, the consent picture and the
+ * refusal wording all read from one place and cannot drift.
+ *
+ * A capability is the ENVELOPE (`kind`, `ref`, `requires`, `effectClass`,
+ * `reversible`); a SKILL is one implementation of it (`kind: 'skill'`) alongside
+ * a TOOL (`kind: 'tool'`) and a curated high-level ACTION (`kind: 'action'`).
+ *
+ * These are pure types — no imports, no side effects — so both the tool side and
+ * the learning side can depend on them without a cycle.
+ */
+/** What an action does to the world. The gate's source of truth (Phase 2). */
+export type EffectClass = 'read' | 'local-write' | 'local-state' | 'external' | 'destructive';
+/** Which session grant may cover the action (see `session-grant.ts`). */
+export type GrantCategory = 'write' | 'terminal' | 'external';
+/**
+ * ONE requirement, in a shape that can be both SHOWN and CHECKED.
+ *
+ * The alternative — a human phrase like `'NPM_TOKEN or a GitHub token'` — can be
+ * displayed but never probed, so the agent could only discover it was missing by
+ * failing halfway through. `anyOf` is machine-checkable (an env var NAMES list
+ * for a credential, an executable list for a binary) and `join(' or ')` renders
+ * the same sentence a reader used to see. One source, so the displayed and the
+ * checked forms cannot drift.
+ */
+export interface CapabilityNeed {
+    /** Satisfied when ANY of these is present. */
+    anyOf: string[];
+    /** How to satisfy it — shown when it is missing. */
+    note?: string;
+}
+/** What has to exist before the capability can run. */
+export interface CapabilityRequires {
+    /** Env var names; satisfied when any one is set and non-empty. */
+    credentials?: CapabilityNeed[];
+    /** Executables; satisfied when any one resolves on PATH. */
+    binaries?: CapabilityNeed[];
+    /**
+     * Things only the MODEL can supply (a bump type, a target host) — a decision,
+     * not an environment fact, so never probed.
+     */
+    inputs?: string[];
+}
+/**
+ * How to satisfy a capability on ONE operating system.
+ *
+ * WHY THIS IS NOT ON EVERY CAPABILITY. The OS determines the command for some
+ * verbs and not others, and saying otherwise would be inventing a mapping that
+ * does not exist:
+ *
+ *   - `install-system-tool` IS OS-determined — winget on Windows, brew on macOS,
+ *     apt-get on Linux. There is no portable form.
+ *   - `store-credential` IS OS-determined — the OS keychain on macOS/Linux versus
+ *     a credentials file on Windows.
+ *   - `add-dependency` is NOT — `npm install` is the same command everywhere, and
+ *     npm-vs-pnpm is a USER PREFERENCE, not an OS affordance.
+ *   - `deploy-app` is NOT — the choice between vercel and flyctl is a platform
+ *     choice, not an OS one. (Windows and macOS both deploy to Vercel.)
+ *
+ * So `platforms` is present exactly where the OS genuinely decides, and ABSENT
+ * means "there is one command, or the model/user picks" — which is a different and
+ * equally truthful statement.
+ */
+export interface PlatformCommand {
+    /** The command to run on this OS, with the variable part in angle brackets. */
+    command: string;
+    /**
+     * The binary it runs, WHEN an external one does. MUST be a binary this
+     * capability also declares it needs — a test asserts it, so a platform hint can
+     * never name a tool the requirement pre-flight did not check for.
+     *
+     * ABSENT means the command runs through nuvira itself, not through a binary on
+     * PATH. `store-credential` is the case that forced this: the OS decides WHERE a
+     * secret can safely live (Keychain / secret-tool / a vault file), but the command
+     * is identical on all three, so claiming a PATH binary would be a false fact.
+     */
+    binary?: string;
+    /** A caveat worth showing (a privilege requirement, or a fallback). */
+    note?: string;
+}
+/** The OSes a `platforms` map may key on. */
+export type PlatformKey = 'win32' | 'darwin' | 'linux';
+/**
+ * How to actually invoke a capability whose `ref` is NOT a callable tool name.
+ * An ingested MCP tool, for instance, is invoked through the `mcp_tool`
+ * dispatcher with the server and tool it names, so a discovery hit must say so
+ * rather than hand the model a name it cannot call.
+ */
+export interface CapabilityInvoke {
+    /** The real tool to call. */
+    tool: string;
+    /** Fixed arguments that identify the capability (e.g. server + tool). */
+    args: Record<string, string>;
+}
+/** One thing the agent can do, normalized from a tool, a skill, an MCP server, or the catalog. */
+export interface Capability {
+    /** Stable id (`tool:write_file`, `action:publish-site`, `skill:deploy-vercel`). */
+    id: string;
+    /**
+     * Which registry this came from. `mcp` is a FOREIGN tool, discovered from an
+     * external MCP server at runtime — it has no place in this repo's registry, so
+     * it carries `invoke` to say how it is reached.
+     */
+    kind: 'tool' | 'skill' | 'action' | 'mcp';
+    /** The thing to invoke: a tool name, a skill id, a curated action key, or `<server>/<tool>`. */
+    ref: string;
+    /** How to reach it, when `ref` is not itself a callable tool name. */
+    invoke?: CapabilityInvoke;
+    /** Short human name. */
+    name: string;
+    /** ONE sentence: what it does. Used for display and refusal wording. */
+    oneLiner: string;
+    effectClass: EffectClass;
+    reversible: boolean;
+    /** How to undo it, when it is reversible. */
+    reversibleHow?: string;
+    /** The session grant that can cover it (absent = no grant covers it). */
+    grantCategory?: GrantCategory;
+    requires: CapabilityRequires;
+    /** Discovery keywords — a hint for search, NEVER a decision rule. */
+    tags: string[];
+    /**
+     * How to do it on each OS — present ONLY where the OS genuinely determines the
+     * command (see {@link PlatformCommand}). Absent everywhere else, deliberately.
+     */
+    platforms?: Partial<Record<PlatformKey, PlatformCommand>>;
+}
+/**
+ * A TOOL's own capability declaration — the fact the descriptor used to hold in
+ * one hand-maintained name-keyed map (`EFFECT_BY_TOOL`).
+ *
+ * WHY IT LIVES ON THE TOOL. The map meant a tool could be born unclassified and
+ * its gate could hardcode a different answer than its descriptor; the map was the
+ * last place the layer did not let the TOOL own its own facts. The tool declares
+ * these at `registerTool`, `registry.ts` records them, and every consumer
+ * (fan-out, the write/terminal/external grants, the capability descriptor) reads
+ * the same declaration.
+ *
+ * `reversible` defaults to `true` (matching the old map's every read/write
+ * entry), and every field except `effectClass` is optional so a silent tool still
+ * declares the one fact that matters.
+ */
+export interface ToolCapabilityDeclaration {
+    /** What the action does to the world — the one REQUIRED fact. */
+    effectClass: EffectClass;
+    /** Can re-running undo it? Defaults to true; set false for off-machine effects. */
+    reversible?: boolean;
+    /** How to undo it, when it is reversible. */
+    reversibleHow?: string;
+    /** The session grant that may cover it (absent = no grant covers it). */
+    grantCategory?: GrantCategory;
+    /** What has to exist before it can run. */
+    requires?: CapabilityRequires;
+}
+/** A ranked discovery result. */
+export interface CapabilityHit {
+    capability: Capability;
+    score: number;
+    /** The tokens that matched — so a reader can see WHY it ranked. */
+    matched: string[];
+}
+//# sourceMappingURL=capability-types.d.ts.map

package/dist/learning/capability-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-types.d.ts","sourceRoot":"","sources":["../../src/learning/capability-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,8EAA8E;AAC9E,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,aAAa,GAAG,aAAa,GAAG,UAAU,GAAG,aAAa,CAAC;AAE9F,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC;AAE9D;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,uDAAuD;AACvD,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;IAC5B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,eAAe;IAC9B,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,6CAA6C;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,kGAAkG;AAClG,MAAM,WAAW,UAAU;IACzB,mFAAmF;IACnF,EAAE,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IAC1C,gGAAgG;IAChG,GAAG,EAAE,MAAM,CAAC;IACZ,sEAAsE;IACtE,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,6CAA6C;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,qEAAqE;IACrE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC,CAAC;CAC3D;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,yBAAyB;IACxC,iEAAiE;IACjE,WAAW,EAAE,WAAW,CAAC;IACzB,mFAAmF;IACnF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,6CAA6C;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B;AAED,iCAAiC;AACjC,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB"}

package/dist/learning/capability-types.js

@@ -0,0 +1,20 @@
+/**
+ * Capability types — ONE descriptor for everything the agent can DO.
+ *
+ * WHY THIS EXISTS. "What an action needs, what it costs, and what it touches"
+ * was scattered: tools carried it in prose descriptions, each gate hardcoded its
+ * own effect class, skills carried only methodology, and the CLI manifest carried
+ * a single boolean. Adding a verb (install / uninstall / publish / deploy / push)
+ * meant editing all of them. The capability descriptor is the ONE shape those
+ * sources are normalized into, so discovery, gating, the consent picture and the
+ * refusal wording all read from one place and cannot drift.
+ *
+ * A capability is the ENVELOPE (`kind`, `ref`, `requires`, `effectClass`,
+ * `reversible`); a SKILL is one implementation of it (`kind: 'skill'`) alongside
+ * a TOOL (`kind: 'tool'`) and a curated high-level ACTION (`kind: 'action'`).
+ *
+ * These are pure types — no imports, no side effects — so both the tool side and
+ * the learning side can depend on them without a cycle.
+ */
+export {};
+//# sourceMappingURL=capability-types.js.map

package/dist/learning/capability-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-types.js","sourceRoot":"","sources":["../../src/learning/capability-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG"}

package/dist/learning/catalog-feed.d.ts

@@ -0,0 +1,89 @@
+/** The opt-in switch. Absent / 0 / false / off / no ⇒ DISABLED (rule 5). */
+export declare const CATALOG_FEED_ENV = "NUVIRA_CATALOG_FEED";
+export declare const CATALOG_FEED_URL = "https://openrouter.ai/api/v1/models";
+/** A snapshot older than this is treated as ABSENT (rule 5), not as a slightly-wrong prior. */
+export declare const CATALOG_FEED_TTL_MS: number;
+/**
+ * `ecosystem` priors derived from the catalogue's TOOL-SUPPORT fact.
+ *
+ * WHY THESE NUMBERS ARE ALL BELOW 0.7. §7.2 decided that `ecosystem`'s cold-start prior is 0.5 and that
+ * this "keeps a pair OUT of the `Frontier` tier (that needs ≥ 0.7) — a pair we have never watched call a
+ * tool is not a frontier agent model". A catalogue row saying `tools` is advertised is still not us
+ * having watched it call a tool, so it must not cross that gate either: 0.6 informs the ranking without
+ * promoting the tier. The demotion is factual and may be stronger than the promotion — a model the
+ * catalogue says CANNOT call tools is a real negative, and no amount of measurement-free optimism should
+ * hide it.
+ */
+export declare const ECOSYSTEM_PRIOR_WITH_TOOLS = 0.6;
+export declare const ECOSYSTEM_PRIOR_WITHOUT_TOOLS = 0.25;
+/** One catalogue row, normalised. Pricing is USD per 1K tokens (the router's own unit). */
+export interface CatalogModelRow {
+    id: string;
+    /** USD per 1K input tokens, from the catalogue's per-token figure. */
+    inputPer1K?: number;
+    /** USD per 1K output tokens. */
+    outputPer1K?: number;
+    contextLength?: number;
+    /** Lower-cased catalogue parameter names, verbatim. */
+    supportedParameters: string[];
+}
+export interface CatalogSnapshot {
+    version: number;
+    source: 'openrouter';
+    /** Epoch ms of the fetch this snapshot came from. */
+    fetchedAt: number;
+    ttlMs: number;
+    models: Record<string, CatalogModelRow>;
+}
+/** A prior that knows where it came from — rule 4's whole point. */
+export interface ExternalPrior {
+    parameter: 'cost' | 'ecosystem';
+    /** 0–1, on the scorecard's scale. */
+    value: number;
+    /** e.g. `openrouter catalogue` — printed beside the number, never omitted. */
+    source: string;
+    fetchedAt: number;
+    /** Human basis: the fact the number was derived FROM (so a reader can disagree with it). */
+    basis: string;
+}
+/**
+ * Is the feed switched on?
+ *
+ * The vocabulary is EXACTLY the dashboard's `asks` rule (`1`/`true`/`yes` enable; everything else,
+ * including unset, is off) rather than something friendlier like `truthy`. Two reasons: this switch
+ * causes a NETWORK fetch, so an unrecognised value must fail CLOSED; and the dashboard's process-env page
+ * states a rule per variable, so a reader that behaved differently from its declared rule would make that
+ * page lie — the one thing it exists not to do. `nuvira config catalog-feed set on` writes the canonical `1`.
+ */
+export declare function catalogFeedEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function catalogSnapshotPath(): string;
+/** Parse an OpenRouter `/api/v1/models` payload into a snapshot. Pure — no clock, no I/O. */
+export declare function parseOpenRouterModels(payload: unknown, fetchedAt: number): CatalogSnapshot;
+/**
+ * Read the cached snapshot, or `undefined` when there is none OR it has expired.
+ *
+ * Expiry is deliberately indistinguishable from absence: rule 5 says an expired entry is treated as
+ * absent rather than kept, so callers need no separate staleness branch.
+ */
+export declare function loadCatalogSnapshot(now?: number): CatalogSnapshot | undefined;
+export declare function saveCatalogSnapshot(snapshot: CatalogSnapshot): void;
+/** Fetch and store a fresh snapshot. Out-of-band only — the CLI/dashboard call this, the router does not. */
+export declare function refreshCatalogFeed(fetchImpl?: typeof fetch, now?: () => number): Promise<{
+    ok: true;
+    snapshot: CatalogSnapshot;
+} | {
+    ok: false;
+    reason: string;
+}>;
+/** The catalogue row for OUR `provider × model`, or `undefined` — identity-mapped, never guessed (rule 3). */
+export declare function catalogRowFor(provider: string, model: string, snapshot?: CatalogSnapshot | undefined): CatalogModelRow | undefined;
+/**
+ * The priors this feed can supply for one pair, with provenance. Empty when disabled, expired or
+ * unmatched — every one of which is a legitimate "no prior", never a invented number.
+ */
+export declare function externalPriorsFor(provider: string, model: string, opts?: {
+    now?: number;
+    snapshot?: CatalogSnapshot;
+    env?: NodeJS.ProcessEnv;
+}): ExternalPrior[];
+//# sourceMappingURL=catalog-feed.d.ts.map

package/dist/learning/catalog-feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-feed.d.ts","sourceRoot":"","sources":["../../src/learning/catalog-feed.ts"],"names":[],"mappings":"AAuCA,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,wBAAwB,CAAC;AAEtD,eAAO,MAAM,gBAAgB,wCAAwC,CAAC;AAEtE,+FAA+F;AAC/F,eAAO,MAAM,mBAAmB,QAAsB,CAAC;AAIvD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD,2FAA2F;AAC3F,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,YAAY,CAAC;IACrB,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACzC;AAED,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC;IAChC,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,4FAA4F;IAC5F,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAIhF;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAK5C;AAED,6FAA6F;AAC7F,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,CA0B1F;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAmB,GAAG,eAAe,GAAG,SAAS,CAazF;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAKnE;AAED,6GAA6G;AAC7G,wBAAsB,kBAAkB,CACtC,SAAS,GAAE,OAAO,KAAa,EAC/B,GAAG,GAAE,MAAM,MAAiB,GAC3B,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAYlF;AAED,8GAA8G;AAC9G,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,QAAQ,8BAAwB,GAC/B,eAAe,GAAG,SAAS,CAS7B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;CAAO,GAC/E,aAAa,EAAE,CAyCjB"}

package/dist/learning/catalog-feed.js

@@ -0,0 +1,211 @@
+/**
+ * The OpenRouter model catalogue as a SOURCE OF PRIORS — never measurements.
+ *
+ * WHY THIS ONE FEED, AND NOT A LEADERBOARD. `docs/DESIGN_CAPABILITY_BY_MEASUREMENT.md` §6 assessed every
+ * public ranking source proposed for the scorecard and found two retired (the HF Open LLM Leaderboard,
+ * Papers With Code), one unrelated (Graphify), and one whose sample names cannot be verified at all —
+ * and then identified exactly one value that attaches to a pair **without an identity guess**:
+ * `GET https://openrouter.ai/api/v1/models`, keyless and documented, returning each catalogue model's
+ * pricing, `context_length` and `supported_parameters` for the ids this router actually routes to.
+ *
+ * It supplies `cost` and `ecosystem` priors. Nothing else, and never `accuracy`: an offline catalogue
+ * says what a model costs and what it advertises, and says nothing about whether OUR work succeeded.
+ *
+ * THE FIVE RULES FROM §6.2 ARE EACH A LINE OF CODE HERE, not an aspiration:
+ *
+ *  1. PRIOR ONLY. Every value this module returns is labelled with its source and fetch time, and
+ *     `capabilityLines` prints it as a prior. Samples always outrank it.
+ *  2. NEVER ON THE ROUTING PATH. Nothing in the router imports this module; a turn cannot wait on —
+ *     or fail because of — a third-party network call. Only the CLI and the dashboard refresh it.
+ *  3. IDENTITY-MAPPED OR UNUSED. A catalogue row attaches to our pair only through A1's `sameModel`
+ *     (exact id, bare id, or a DECLARED alias). No similarity, no prefixes, no vendor guessing —
+ *     an unmatched row is dropped, which is the whole reason the catalogue was chosen over LMArena.
+ *  4. PROVENANCE IS PRINTED. `source` + `fetchedAt` travel with every prior to the scorecard.
+ *  5. OPT-IN, WITH A TTL. Default OFF (`NUVIRA_CATALOG_FEED`); an EXPIRED snapshot is treated as
+ *     absent rather than kept, because a stale prior is worse than none.
+ *
+ * The snapshot lives in the memory dir and is written through `atomic-store`, so two processes cannot
+ * tear it and a reader never parses a half-written file.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { envBuff, resolveNuviraHome } from '../config/paths.js';
+import { withFileLockSync, writeFileAtomicSync } from '../utils/atomic-store.js';
+import { sameModel } from './model-identity.js';
+// Static, not lazy: nothing imports THIS module, so there is no cycle to avoid — and a lazy `require`
+// would simply not exist in this ESM build.
+import { computeCostScore } from './auto-router.js';
+/** The opt-in switch. Absent / 0 / false / off / no ⇒ DISABLED (rule 5). */
+export const CATALOG_FEED_ENV = 'NUVIRA_CATALOG_FEED';
+export const CATALOG_FEED_URL = 'https://openrouter.ai/api/v1/models';
+/** A snapshot older than this is treated as ABSENT (rule 5), not as a slightly-wrong prior. */
+export const CATALOG_FEED_TTL_MS = 24 * 60 * 60 * 1000;
+const SNAPSHOT_VERSION = 1;
+/**
+ * `ecosystem` priors derived from the catalogue's TOOL-SUPPORT fact.
+ *
+ * WHY THESE NUMBERS ARE ALL BELOW 0.7. §7.2 decided that `ecosystem`'s cold-start prior is 0.5 and that
+ * this "keeps a pair OUT of the `Frontier` tier (that needs ≥ 0.7) — a pair we have never watched call a
+ * tool is not a frontier agent model". A catalogue row saying `tools` is advertised is still not us
+ * having watched it call a tool, so it must not cross that gate either: 0.6 informs the ranking without
+ * promoting the tier. The demotion is factual and may be stronger than the promotion — a model the
+ * catalogue says CANNOT call tools is a real negative, and no amount of measurement-free optimism should
+ * hide it.
+ */
+export const ECOSYSTEM_PRIOR_WITH_TOOLS = 0.6;
+export const ECOSYSTEM_PRIOR_WITHOUT_TOOLS = 0.25;
+/**
+ * Is the feed switched on?
+ *
+ * The vocabulary is EXACTLY the dashboard's `asks` rule (`1`/`true`/`yes` enable; everything else,
+ * including unset, is off) rather than something friendlier like `truthy`. Two reasons: this switch
+ * causes a NETWORK fetch, so an unrecognised value must fail CLOSED; and the dashboard's process-env page
+ * states a rule per variable, so a reader that behaved differently from its declared rule would make that
+ * page lie — the one thing it exists not to do. `nuvira config catalog-feed set on` writes the canonical `1`.
+ */
+export function catalogFeedEnabled(env = process.env) {
+    const raw = env[CATALOG_FEED_ENV] ?? envBuff(CATALOG_FEED_ENV);
+    if (raw === undefined)
+        return false;
+    return ['1', 'true', 'yes'].includes(String(raw).trim().toLowerCase());
+}
+export function catalogSnapshotPath() {
+    return join(envBuff('MEMORY_DIR') || join(resolveNuviraHome(), 'memory'), 'catalog-feed.json');
+}
+/** Parse an OpenRouter `/api/v1/models` payload into a snapshot. Pure — no clock, no I/O. */
+export function parseOpenRouterModels(payload, fetchedAt) {
+    const models = {};
+    const data = payload?.data;
+    if (Array.isArray(data)) {
+        for (const raw of data) {
+            const id = typeof raw?.id === 'string' ? raw.id : '';
+            if (!id)
+                continue;
+            // The catalogue gives USD per TOKEN as a decimal string. This router's pricing unit is per 1K,
+            // and the earlier per-1K/per-MTok mix-up is recorded in the parity tracker — so convert exactly
+            // once, here, and never re-derive it downstream.
+            const prompt = Number(raw.pricing?.prompt);
+            const completion = Number(raw.pricing?.completion);
+            const context = Number(raw.context_length);
+            const params = Array.isArray(raw.supported_parameters)
+                ? raw.supported_parameters.filter((p) => typeof p === 'string')
+                : [];
+            models[id] = {
+                id,
+                ...(Number.isFinite(prompt) ? { inputPer1K: prompt * 1000 } : {}),
+                ...(Number.isFinite(completion) ? { outputPer1K: completion * 1000 } : {}),
+                ...(Number.isFinite(context) && context > 0 ? { contextLength: context } : {}),
+                supportedParameters: params.map((p) => p.toLowerCase()),
+            };
+        }
+    }
+    return { version: SNAPSHOT_VERSION, source: 'openrouter', fetchedAt, ttlMs: CATALOG_FEED_TTL_MS, models };
+}
+/**
+ * Read the cached snapshot, or `undefined` when there is none OR it has expired.
+ *
+ * Expiry is deliberately indistinguishable from absence: rule 5 says an expired entry is treated as
+ * absent rather than kept, so callers need no separate staleness branch.
+ */
+export function loadCatalogSnapshot(now = Date.now()) {
+    try {
+        const path = catalogSnapshotPath();
+        if (!existsSync(path))
+            return undefined;
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (!parsed || typeof parsed !== 'object' || !parsed.models)
+            return undefined;
+        if (typeof parsed.fetchedAt !== 'number')
+            return undefined;
+        const ttl = typeof parsed.ttlMs === 'number' ? parsed.ttlMs : CATALOG_FEED_TTL_MS;
+        if (now - parsed.fetchedAt > ttl)
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveCatalogSnapshot(snapshot) {
+    const path = catalogSnapshotPath();
+    withFileLockSync(`${path}.lock`, () => {
+        writeFileAtomicSync(path, `${JSON.stringify(snapshot, null, 2)}\n`);
+    });
+}
+/** Fetch and store a fresh snapshot. Out-of-band only — the CLI/dashboard call this, the router does not. */
+export async function refreshCatalogFeed(fetchImpl = fetch, now = Date.now) {
+    try {
+        const res = await fetchImpl(CATALOG_FEED_URL, { headers: { accept: 'application/json' } });
+        if (!res.ok)
+            return { ok: false, reason: `catalogue returned HTTP ${res.status}` };
+        const snapshot = parseOpenRouterModels(await res.json(), now());
+        const count = Object.keys(snapshot.models).length;
+        if (count === 0)
+            return { ok: false, reason: 'catalogue returned no models' };
+        saveCatalogSnapshot(snapshot);
+        return { ok: true, snapshot };
+    }
+    catch (err) {
+        return { ok: false, reason: err instanceof Error ? err.message : 'fetch failed' };
+    }
+}
+/** The catalogue row for OUR `provider × model`, or `undefined` — identity-mapped, never guessed (rule 3). */
+export function catalogRowFor(provider, model, snapshot = loadCatalogSnapshot()) {
+    if (!snapshot)
+        return undefined;
+    // A catalogue row is an OpenRouter row. For any OTHER provider the id may still be the same model
+    // (A1's whole subject), so the match goes through `sameModel`, which only widens by DECLARATION.
+    if (snapshot.models[model])
+        return snapshot.models[model];
+    for (const row of Object.values(snapshot.models)) {
+        if (sameModel(row.id, model))
+            return row;
+    }
+    return undefined;
+}
+/**
+ * The priors this feed can supply for one pair, with provenance. Empty when disabled, expired or
+ * unmatched — every one of which is a legitimate "no prior", never a invented number.
+ */
+export function externalPriorsFor(provider, model, opts = {}) {
+    // The gate is checked HERE, not at each call site: rule 5 makes the feed opt-in, and a consumer that
+    // forgot to ask would silently use priors the operator switched off. One place, impossible to miss.
+    if (!catalogFeedEnabled(opts.env))
+        return [];
+    const snapshot = opts.snapshot ?? loadCatalogSnapshot(opts.now ?? Date.now());
+    if (!snapshot)
+        return [];
+    const row = catalogRowFor(provider, model, snapshot);
+    if (!row)
+        return [];
+    const priors = [];
+    const base = { source: `${snapshot.source} catalogue`, fetchedAt: snapshot.fetchedAt };
+    // `cost` — only from real pricing, only through the router's OWN scoring formula, so a catalogue
+    // number lands on the same scale as a measured one instead of on a second, private scale.
+    if (typeof row.inputPer1K === 'number' && typeof row.outputPer1K === 'number') {
+        const value = computeCostScore('openrouter', {
+            inputPer1K: row.inputPer1K,
+            outputPer1K: row.outputPer1K,
+        });
+        priors.push({
+            ...base,
+            parameter: 'cost',
+            value,
+            basis: `$${row.inputPer1K.toFixed(5)}/1K in, $${row.outputPer1K.toFixed(5)}/1K out`,
+        });
+    }
+    // `ecosystem` — from the TOOL-SUPPORT fact only. The context window is deliberately NOT scored here:
+    // it already reaches routing as `contextWindowTokens` from the listModels probe, so turning it into a
+    // second, invented 0–1 curve would be a number nobody measured.
+    if (row.supportedParameters.length > 0) {
+        const hasTools = row.supportedParameters.some((p) => p === 'tools' || p === 'tool_choice');
+        priors.push({
+            ...base,
+            parameter: 'ecosystem',
+            value: hasTools ? ECOSYSTEM_PRIOR_WITH_TOOLS : ECOSYSTEM_PRIOR_WITHOUT_TOOLS,
+            basis: hasTools ? 'catalogue advertises tool calling' : 'catalogue advertises no tool calling',
+        });
+    }
+    return priors;
+}
+//# sourceMappingURL=catalog-feed.js.map