agentfootprint 10.3.0 → 10.4.0

package/dist/esm/lib/injection-engine/skillNeverRoutes.d.ts

@@ -1,131 +0,0 @@
-/**
- * skillNeverRoutes — the NEGATIVE routing row: a phrase this graph must claim
- * NOWHERE.
- *
- * ## Why the negative form is the valuable one
- *
- * `skillExamples.ts` pins the positive assertion — this rule claims this
- * phrasing — and it cannot state the opposite. Field use says the opposite is
- * the one that catches the expensive failure. An UNDER-triggering skill costs a
- * turn: the deterministic layer declines, the model tier picks, and the answer
- * is usually still reachable. An OVER-triggering skill costs the whole answer:
- * the wrong body enters the system prompt, the wrong tools enter the tools
- * slot, and everything the model then says is shaped by a skill that had no
- * business in the turn. One reviewer of a production graph had written his own
- * harness for exactly this, outside the library, because the library could only
- * express the cheap half.
- *
- * ## Where a negative row lives, and why it is NOT on a skill
- *
- * `examples` sits on the rule it is about. A negative row cannot: the phrase it
- * describes belongs to NO skill, and hanging it on one would make three things
- * wrong at once —
- *
- *   • it would read as that skill's business ("weather questions, filed under
- *     billing") when the point is that it is nobody's;
- *   • the assertion is satisfied only when EVERY rule declines, so a row read
- *     as one rule's property would be checked against one rule and pass while
- *     another rule swallowed the phrase;
- *   • deleting the skill would delete the assertion — exactly when a graph is
- *     re-partitioned, which is exactly when over-triggering is introduced.
- *
- * A negative row is a property of the PARTITION, so it is declared at the graph
- * level (`.neverRoutes([...])` / `neverRoutes: [...]`) and judged against every
- * rule in declaration order.
- *
- * ## What is asserted — precisely, and what it does NOT cover
- *
- * The claim this module proves is: **no declared start RULE claims the
- * phrase.** It runs the compiled conditions on a cold-start context, exactly as
- * `skillExamples.ts` does, and reports the rule that says yes.
- *
- * It does NOT prove "no routing at all occurs", and could not without becoming
- * a different kind of check:
- *
- *   • an INTENT rule compiles to no sync predicate — a classifier judges it at
- *     run time, with a scorer (and, for `llmClassifier`, a model call). Running
- *     that would make the check async, non-deterministic, and in the LLM case
- *     billable — `graph.checkupIntents()` is where scorer-dependent auditing
- *     already lives;
- *   • a scorer menu (`.entryBy()`) and `.entryByRead()` RANK descriptions;
- *     there is no claim to run;
- *   • the model tier can open any open skill by name with `read_skill`, at
- *     which point no declaration is deciding anything.
- *
- * That statement ships on the report as {@link NEVER_ROUTES_BOUNDARY}, next to
- * the problems, for the same reason the examples boundary does: a reader who
- * meets a boundary only in prose docs meets a clean report first.
- *
- * A predicate that THROWS on the cold context counts as a no-match here, and is
- * not reported — because routing itself treats a throw as a no-match, so the
- * phrase really does not route through that rule. Its own rule's `examples`
- * report the throw as an error (that is a defect in the rule, not in the
- * partition).
- *
- * Composed into `graph.checkup()` by `skillGraph.ts`, like every other domain
- * check, and reporting in the shared `GraphProblem` voice.
- *
- * Zone: PURE CORE. Pinned by
- * `test/lib/injection-engine/skill-graph-fence.test.ts`.
- */
-import type { GraphProblem } from './skillGraphCheckup.js';
-import { type StartRuleDecl } from './startRuleClaim.js';
-/**
- * The statement the negative check makes about its own reach, carried on
- * `GraphCheckup.notes` whenever a graph declared any negative row. Same voice
- * as `EXAMPLES_BOUNDARY` (skillExamples.ts): silence here is evidence about the declared
- * RULES, and about nothing downstream of them.
- */
-export declare const NEVER_ROUTES_BOUNDARY: string;
-/** The slice of an entry declaration this check reads: the shared claim shape,
- *  plus the POSITIVE phrases the same rule declared (a phrase asserted both
- *  ways is a contradiction the author wrote, and is reported as one). */
-export interface NeverRoutesRuleDecl extends StartRuleDecl {
-    readonly examples?: readonly string[];
-}
-/** What {@link checkNeverRoutes} found, plus what it wants to say about its own
- *  reach. Both empty when the graph declared no negative row. */
-export interface NeverRoutesCheckup {
-    readonly problems: readonly GraphProblem[];
-    readonly notes: readonly string[];
-}
-/** How two phrases are compared for "the same phrase": trimmed and
- *  case-folded, the same normalization `duplicate-intent-example` uses — an
- *  author who writes one row in two casings meant one row. Exported so the
- *  builder's accumulated-rows set is keyed the SAME way the refusal is; two
- *  spellings of one rule is how a duplicate slips through. */
-export declare function neverRouteKey(phrase: string): string;
-/**
- * Validate a graph-level `neverRoutes` list at DECLARATION time, refusing every
- * shape whose check-up answer could only mislead — each refusal naming the fix:
- *
- *   • not an array / an EMPTY array — nothing to assert, and a check-up that
- *     passes in silence reads as coverage;
- *   • a non-string or blank entry — there is no phrase to run a matcher on;
- *   • a phrase already declared — a repeat asserts nothing the first one did
- *     not, and reads as if two different phrasings were meant.
- *
- * A single string is accepted and read as a one-row list: `.neverRoutes('what
- * is the weather')` is the commonest call, and making the author type brackets
- * for it buys nothing.
- *
- * Returns a frozen copy of the ROWS THIS CALL ADDS, so the stored list cannot
- * drift from the validated one.
- */
-export declare function validateNeverRoutes(phrases: unknown, where: string, alreadyDeclared: ReadonlySet<string>): readonly string[];
-/**
- * Run the negative rows against the declared start rules. Pure, and
- * byte-identically silent when the graph declared none (one length check and
- * out).
- *
- * Unlike the positive examples, this needs NO `orderDecides` gate: the
- * assertion is "nobody claims it", which every rule has to satisfy, so the
- * order they are read in cannot change the answer. That is also why it is the
- * one phrase check that stays meaningful under a classifier — tier 1 is still
- * read first there, and a rule that claims the phrase still takes the turn
- * before any scorer runs.
- */
-export declare function checkNeverRoutes(input: {
-    readonly entries: readonly NeverRoutesRuleDecl[];
-    readonly phrases: readonly string[];
-}): NeverRoutesCheckup;

package/dist/esm/lib/injection-engine/skillNeverRoutes.js

@@ -1,228 +0,0 @@
-/**
- * skillNeverRoutes — the NEGATIVE routing row: a phrase this graph must claim
- * NOWHERE.
- *
- * ## Why the negative form is the valuable one
- *
- * `skillExamples.ts` pins the positive assertion — this rule claims this
- * phrasing — and it cannot state the opposite. Field use says the opposite is
- * the one that catches the expensive failure. An UNDER-triggering skill costs a
- * turn: the deterministic layer declines, the model tier picks, and the answer
- * is usually still reachable. An OVER-triggering skill costs the whole answer:
- * the wrong body enters the system prompt, the wrong tools enter the tools
- * slot, and everything the model then says is shaped by a skill that had no
- * business in the turn. One reviewer of a production graph had written his own
- * harness for exactly this, outside the library, because the library could only
- * express the cheap half.
- *
- * ## Where a negative row lives, and why it is NOT on a skill
- *
- * `examples` sits on the rule it is about. A negative row cannot: the phrase it
- * describes belongs to NO skill, and hanging it on one would make three things
- * wrong at once —
- *
- *   • it would read as that skill's business ("weather questions, filed under
- *     billing") when the point is that it is nobody's;
- *   • the assertion is satisfied only when EVERY rule declines, so a row read
- *     as one rule's property would be checked against one rule and pass while
- *     another rule swallowed the phrase;
- *   • deleting the skill would delete the assertion — exactly when a graph is
- *     re-partitioned, which is exactly when over-triggering is introduced.
- *
- * A negative row is a property of the PARTITION, so it is declared at the graph
- * level (`.neverRoutes([...])` / `neverRoutes: [...]`) and judged against every
- * rule in declaration order.
- *
- * ## What is asserted — precisely, and what it does NOT cover
- *
- * The claim this module proves is: **no declared start RULE claims the
- * phrase.** It runs the compiled conditions on a cold-start context, exactly as
- * `skillExamples.ts` does, and reports the rule that says yes.
- *
- * It does NOT prove "no routing at all occurs", and could not without becoming
- * a different kind of check:
- *
- *   • an INTENT rule compiles to no sync predicate — a classifier judges it at
- *     run time, with a scorer (and, for `llmClassifier`, a model call). Running
- *     that would make the check async, non-deterministic, and in the LLM case
- *     billable — `graph.checkupIntents()` is where scorer-dependent auditing
- *     already lives;
- *   • a scorer menu (`.entryBy()`) and `.entryByRead()` RANK descriptions;
- *     there is no claim to run;
- *   • the model tier can open any open skill by name with `read_skill`, at
- *     which point no declaration is deciding anything.
- *
- * That statement ships on the report as {@link NEVER_ROUTES_BOUNDARY}, next to
- * the problems, for the same reason the examples boundary does: a reader who
- * meets a boundary only in prose docs meets a clean report first.
- *
- * A predicate that THROWS on the cold context counts as a no-match here, and is
- * not reported — because routing itself treats a throw as a no-match, so the
- * phrase really does not route through that rule. Its own rule's `examples`
- * report the throw as an error (that is a defect in the rule, not in the
- * partition).
- *
- * Composed into `graph.checkup()` by `skillGraph.ts`, like every other domain
- * check, and reporting in the shared `GraphProblem` voice.
- *
- * Zone: PURE CORE. Pinned by
- * `test/lib/injection-engine/skill-graph-fence.test.ts`.
- */
-import { COLD_CONTEXT_PHRASE, claimLaws, describeCondition, } from './startRuleClaim.js';
-/**
- * The statement the negative check makes about its own reach, carried on
- * `GraphCheckup.notes` whenever a graph declared any negative row. Same voice
- * as `EXAMPLES_BOUNDARY` (skillExamples.ts): silence here is evidence about the declared
- * RULES, and about nothing downstream of them.
- */
-export const NEVER_ROUTES_BOUNDARY = 'A `neverRoutes` row proves that no DECLARED start rule claims the phrase. It does not ' +
-    'prove the turn routes nowhere: an intent rule is judged by a classifier at run time, a ' +
-    'scorer / `.entryByRead()` menu ranks descriptions, and the model can always open an open ' +
-    'skill by name with read_skill — none of those are run here.';
-const NOTHING = Object.freeze({
-    problems: Object.freeze([]),
-    notes: Object.freeze([]),
-});
-/** How two phrases are compared for "the same phrase": trimmed and
- *  case-folded, the same normalization `duplicate-intent-example` uses — an
- *  author who writes one row in two casings meant one row. Exported so the
- *  builder's accumulated-rows set is keyed the SAME way the refusal is; two
- *  spellings of one rule is how a duplicate slips through. */
-export function neverRouteKey(phrase) {
-    return phrase.trim().toLowerCase();
-}
-/**
- * Validate a graph-level `neverRoutes` list at DECLARATION time, refusing every
- * shape whose check-up answer could only mislead — each refusal naming the fix:
- *
- *   • not an array / an EMPTY array — nothing to assert, and a check-up that
- *     passes in silence reads as coverage;
- *   • a non-string or blank entry — there is no phrase to run a matcher on;
- *   • a phrase already declared — a repeat asserts nothing the first one did
- *     not, and reads as if two different phrasings were meant.
- *
- * A single string is accepted and read as a one-row list: `.neverRoutes('what
- * is the weather')` is the commonest call, and making the author type brackets
- * for it buys nothing.
- *
- * Returns a frozen copy of the ROWS THIS CALL ADDS, so the stored list cannot
- * drift from the validated one.
- */
-export function validateNeverRoutes(phrases, where, alreadyDeclared) {
-    const list = typeof phrases === 'string' ? [phrases] : phrases;
-    if (!Array.isArray(list) || list.length === 0) {
-        throw new Error(`skillGraph: ${where} declares a \`neverRoutes\` list this library cannot honor. ` +
-            `\`neverRoutes\` is the phrasings this graph must claim NOWHERE — a non-empty array ` +
-            `of non-empty strings (or one string), e.g. neverRoutes: ['what is the weather']. ` +
-            `${Array.isArray(list)
-                ? 'An empty list asserts nothing, so the check-up would pass in silence and you ' +
-                    'would read that as proof no rule over-triggers. '
-                : ''}List at least one phrasing, or drop the field.`);
-    }
-    const bad = list.findIndex((p) => typeof p !== 'string' || p.trim().length === 0);
-    if (bad >= 0) {
-        throw new Error(`skillGraph: ${where} declares \`neverRoutes[${bad}]\` = ${JSON.stringify(list[bad])}, which is not a usable phrasing. Every row must be a NON-EMPTY string — the words a ` +
-            `user would really type and that no skill here should take. Fix that entry, or drop it.`);
-    }
-    const seen = new Set(alreadyDeclared);
-    for (const phrase of list) {
-        const key = neverRouteKey(phrase);
-        if (seen.has(key)) {
-            throw new Error(`skillGraph: ${where} declares the \`neverRoutes\` row ${JSON.stringify(phrase)} twice (compared trimmed and case-folded). One row already asserts it against every ` +
-                `rule in the graph; the repeat proves nothing further. Drop the duplicate.`);
-        }
-        seen.add(key);
-    }
-    return Object.freeze([...list]);
-}
-/**
- * Run the negative rows against the declared start rules. Pure, and
- * byte-identically silent when the graph declared none (one length check and
- * out).
- *
- * Unlike the positive examples, this needs NO `orderDecides` gate: the
- * assertion is "nobody claims it", which every rule has to satisfy, so the
- * order they are read in cannot change the answer. That is also why it is the
- * one phrase check that stays meaningful under a classifier — tier 1 is still
- * read first there, and a rule that claims the phrase still takes the turn
- * before any scorer runs.
- */
-export function checkNeverRoutes(input) {
-    const { entries, phrases } = input;
-    if (phrases.length === 0)
-        return NOTHING;
-    const laws = claimLaws(entries);
-    const problems = [];
-    for (const phrase of phrases) {
-        // (a) CONTRADICTION — the author declared the same phrase as a POSITIVE
-        //     example on some rule. Reported first and alone: whichever way the
-        //     router lands, one of the two declarations is wrong, and no fact about
-        //     matchers helps until the author decides which. (Checked before the
-        //     matchers are run, because a rule can declare an example its own
-        //     matcher misses — the contradiction is in the declarations, not in the
-        //     routing.)
-        const contradicting = entries.find((e) => (e.examples ?? []).some((ex) => neverRouteKey(ex) === neverRouteKey(phrase)));
-        if (contradicting !== undefined) {
-            problems.push({
-                kind: 'error',
-                code: 'never-routes-contradicts-example',
-                message: `The graph declares that "${phrase}" must route NOWHERE, and the start rule for ` +
-                    `"${contradicting.id}" declares the SAME phrase in its own \`examples\` — the list ` +
-                    `of phrasings that rule CLAIMS. Two of your own declarations contradict each other ` +
-                    `about one phrase, so one of them is wrong wherever the router lands, and the ` +
-                    `check-up cannot tell which you meant. Decide: drop the \`neverRoutes\` row, or ` +
-                    `drop the phrase from "${contradicting.id}"'s \`examples\`.`,
-                skill: contradicting.id,
-                example: phrase,
-            });
-            continue;
-        }
-        // (b) CLAIMED BY A RULE — the failure this row exists to catch. An ERROR:
-        //     the author personally wrote that no skill should take this phrase, a
-        //     rule takes it, and both start laws agree it does (a CONDITIONAL
-        //     claimant is read by tier 1 AND by the cold walk). The turn would open
-        //     with that skill's body and tools on the wire.
-        const byRule = laws.underCascade(phrase);
-        if (byRule !== undefined) {
-            problems.push({
-                kind: 'error',
-                code: 'never-routes-claimed',
-                message: `The graph declares that "${phrase}" must route NOWHERE, but the start rule for ` +
-                    `"${byRule.entry.id}" claims it — ${describeCondition(byRule.entry)} matches the phrase, so a turn phrased that way STARTS on "${byRule.entry.id}", ` +
-                    `with that skill's body in the system prompt and that skill's tools on the wire ` +
-                    `shaping the whole answer. Narrow "${byRule.entry.id}"'s ${byRule.entry.match === undefined ? 'predicate' : 'matcher'} until it stops claiming this phrasing, or drop the row if "${byRule.entry.id}" ` +
-                    `really should take it. (Proved by running the declared conditions on the phrase on ` +
-                    `${COLD_CONTEXT_PHRASE} — no regex intersection was decided.)`,
-                skill: byRule.entry.id,
-                example: phrase,
-            });
-            continue;
-        }
-        // (c) CLAIMED BY A DEFAULT — no RULE claims it, but an unconditional entry
-        //     does under one of the two start laws. That is the one place the laws
-        //     differ (`skillExamples.ts` header), and which one applies is decided
-        //     at AGENT MOUNT, not here — so a WARNING naming both readings, never
-        //     an error the router might disagree with.
-        const byWalk = laws.underColdWalk(phrase);
-        if (byWalk === undefined)
-            continue;
-        problems.push({
-            kind: 'warning',
-            code: 'never-routes-by-default',
-            message: `The graph declares that "${phrase}" must route NOWHERE, and no start RULE claims it ` +
-                `— but the entry "${byWalk.entry.id}" ${describeCondition(byWalk.entry)}, so whether the phrase routes depends on how this graph is MOUNTED and the check-up ` +
-                `cannot decide it. Mounted the default way (continuity: 'turn'), the declaration-order ` +
-                `cold start stops at "${byWalk.entry.id}" and every message starts there, this one ` +
-                `included. Mounted with a classifier or with continuity: 'conversation', the turn-start ` +
-                `cascade's tier 1 reads the CONDITIONAL rules only — an unconditional entry is a ` +
-                `default, not a rule — so nothing claims the phrase and the turn falls onward. Give ` +
-                `"${byWalk.entry.id}" a \`match\`/\`when\` if it is meant to be a rule; if it is meant ` +
-                `to be the catch-all, a negative row can only ever be a statement about the RULES ` +
-                `above it (which is what this warning reports).`,
-            skill: byWalk.entry.id,
-            example: phrase,
-        });
-    }
-    return { problems, notes: [NEVER_ROUTES_BOUNDARY] };
-}
-//# sourceMappingURL=skillNeverRoutes.js.map

package/dist/esm/lib/injection-engine/skillNeverRoutes.js.map

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

package/dist/esm/lib/injection-engine/skillPartition.d.ts

@@ -1,69 +0,0 @@
-/**
- * skillPartition — three ADVISORY signals about the shape of the partition
- * itself: how a graph cut the world into skills.
- *
- * ## Why the partition is worth a check at all
- *
- * Everything else the check-up reports is a wiring fact — an edge to a skill
- * that is not there, a rule that can never win. The partition is upstream of
- * all of it, and it is the decision with the most leverage: a graph whose
- * skills follow SYSTEMS rather than CAPABILITIES makes one ordinary question
- * cross four skills, and the capability the user actually wanted ends up
- * implemented outside the graph, by hand, where nothing can see it. Field use
- * produced exactly that shape — nineteen skills, ONE declared edge, and tool
- * names carrying the system that owns them (`influx_*`, `pmax_*`, `pstore_*`,
- * `rvtools_*`) with the skills following the prefixes.
- *
- * The important part: all three of those are visible from NAMES AND STRUCTURE
- * ALONE, at build time, with no run and no model. So the runtime can say them.
- *
- * ## Why every one of them is an advisory, and stays one
- *
- * Each signal has a legitimate design behind it:
- *
- *   • a skill really can be one system's capability (a weather skill wrapping a
- *     weather API is not a mistake);
- *   • a deliberately FLAT menu of independent skills really does declare almost
- *     no edges — a scorer or the model picks, and there is nothing to hand off;
- *   • a one-call capability really can be one tool with a short body.
- *
- * So none of them is ever an error, and none of them says "this is wrong". Each
- * message states the SIGNAL AS A FACT the author can check against their own
- * intent — "your 19 skills declare 1 route", "every tool in `powerstore` shares
- * the prefix `pstore_`" — and then names the design each fact usually indicates
- * and the design it is also consistent with. This library's check-up teaches;
- * it does not grade.
- *
- * ## The thresholds, and why each one is where it is
- *
- * Named constants below, each with the argument beside it. They are chosen so a
- * SMALL graph is silent (small graphs have no partition problem worth naming),
- * so a trivially-true observation is never dressed up as a finding (one tool
- * shares a prefix with itself), and so the commonest honest naming convention —
- * a VERB first — never fires.
- *
- * Zone: PURE CORE. Pinned by
- * `test/lib/injection-engine/skill-graph-fence.test.ts`.
- */
-import type { GraphProblem } from './skillGraphCheckup.js';
-import type { Injection } from './types.js';
-/** What the partition check reads. Counts, because that is what the signals
- *  are about — no check here reasons about which edge goes where. */
-export interface PartitionInput {
-    /** Every skill in the graph (wired or not). */
-    readonly skills: readonly Injection[];
-    /** Declared routes, of any kind (a bare/model edge is still a declared
-     *  handoff — the signal is about handoffs that were never written down at
-     *  all, not about how deterministic they are). */
-    readonly routeCount: number;
-    /** Declared entries — quoted in the ratio message so the fact is complete. */
-    readonly entryCount: number;
-    /** A decision `tree()` owns its own routing and declares no routes by
-     *  construction, so the edge-ratio signal does not apply there. */
-    readonly isTree: boolean;
-}
-/**
- * Run the three partition signals. Pure, and cheap: one pass over the skills
- * and two integers. Every problem it produces is a WARNING.
- */
-export declare function checkPartition(input: PartitionInput): GraphProblem[];