agentfootprint 9.41.0 → 9.44.0

package/dist/types/lib/injection-engine/skillGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillGraph.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillGraph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"skillGraph.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillGraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAoB,MAAM,YAAY,CAAC;AAChF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE9E,OAAO,EAIL,KAAK,YAAY,EAElB,MAAM,wBAAwB,CAAC;AAMhC,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG3F,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGhF,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,YAAY,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,4DAA4D;AAC5D,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAEtD,8BAA8B;AAC9B,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,qCAAqC;AACrC,MAAM,WAAW,cAAc;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB;IACE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB;8CAC0C;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC,GACD;IACE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IACtB;8CAC0C;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC,CAAC;AAEN,8DAA8D;AAC9D,MAAM,MAAM,eAAe,GACvB,MAAM,GACN;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACxB;IACE,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAC9C;oEACgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACjC;gEAC4D;IAC5D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAC3C,GACD;IACE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;mFAC+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;IAChC;2EACuE;IACvE,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC;CACjC,CAAC;AAEN,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxC;kDAC8C;IAC9C,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,2BAA2B;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;IACjC,oFAAoF;IACpF,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IACtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC;8EAC0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB;;kDAE8C;IAC9C,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;AAK3E,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;AAEzC,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;6EAQyE;IACzE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE;QACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;KACpC,KAAK,OAAO,CAAC;IACd;+DAC2D;IAC3D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,gBAAgB,GAAG,aAAa,CAAC,gBAAgB,CAAC,CAAC;IAC3E,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,6EAA6E;AAC7E,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IACnD;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,uCAAuC;AACvC,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,WAAW,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,OAAO,CAAC;AAElG,MAAM,WAAW,SAAS;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;6BAEyB;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;CACjC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IACvD,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,YAAY,GAAG,SAAS,CAAC;IAC7C,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;gDAEgD;AAChD,wBAAgB,WAAW,CACzB,SAAS,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,EAC7C,QAAQ,EAAE,YAAY,GAAG,SAAS,EAClC,SAAS,EAAE,YAAY,GAAG,SAAS,EACnC,KAAK,CAAC,EAAE,MAAM,GACb,YAAY,CAEd;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,eAAe,GACvB,OAAO,GACP,OAAO,GACP,YAAY,GACZ,eAAe,GACf,QAAQ,GACR,YAAY,GACZ,SAAS,GACT,MAAM,GACN,MAAM,CAAC;AAEX;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;6EACyE;IACzE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC/C;AAED,qEAAqE;AACrE,MAAM,WAAW,UAAU;IACzB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,4BAA4B;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,EAAE,eAAe,CAAC;IAC7B;;gFAE4E;IAC5E,QAAQ,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IACvC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;CACjC;AAED,0EAA0E;AAC1E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B;yEACqE;IACrE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IACnD;;gCAE4B;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC5C;;4EAEwE;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,SAAS,gBAAgB,EAAE,CAAC,CAAC;IAC5D,gCAAgC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;kFAC8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,8DAA8D;AAC9D,eAAO,MAAM,wBAAwB,cAAwB,CAAC;AAE9D;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC;mEAC+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,iCAAiC,kCAA4C,CAAC;AAE3F,MAAM,WAAW,UAAU;IACzB;oDACgD;IAChD,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC;gEAC4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,sEAAsE;IACtE,SAAS,IAAI,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAAS,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,GAAG,SAAS,CAAC;IACrD;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,UAAU,CAAC;IACpD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,iBAAiB,CAAC,GAAG,EAAE,gBAAgB,GAAG,SAAS,MAAM,EAAE,CAAC;IAC5D;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAAe,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IAC5D;;;;;;OAMG;IACH,YAAY,CAAC,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAClF;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,YAAY,CAAC;IAChD;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC;IAC/D;;;;;;;;;;;;;;;;OAgBG;IACH,cAAc,CAAC,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC7D;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CACtD;AAED,MAAM,WAAW,iBAAiB;IAChC,+EAA+E;IAC/E,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAAC;IACrE,gFAAgF;IAChF,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAAC;IACnF;;;8EAG0E;IAC1E,IAAI,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,iBAAiB,CAAC;IAC5E;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,CAAC;IAChD;;;;;OAKG;IACH,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,iBAAiB,CAAC;IACxD;;;;;;;;;;;;;OAaG;IACH,WAAW,IAAI,iBAAiB,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,iBAAiB,CAAC;IACnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,iBAAiB,CAAC;IACpE,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;CACxC;AA6DD,wBAAgB,UAAU,IAAI,iBAAiB,CAAC;AAChD,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAAC"}

package/dist/types/lib/injection-engine/skillGraphCheckup.d.ts

@@ -34,7 +34,7 @@ import { type SkillMatchData } from './skillMatch.js';
  * engine-type-free, which is what keeps that law intact here).
  */
 export type CheckupTriggerKind = 'always' | 'rule' | 'on-tool-return' | 'llm-activated';
-export type GraphProblemCode = 'unknown-skill' | 'no-entry' | 'unreachable-skill' | 'model-edge-only' | 'multi-entry-fanout' | 'dead-entry-step' | 'ambiguous-routes' | 'self-loop' | 'rule-id-exists' | 'overlapping-rules' | 'rules-shadowed-by-order' | 'intent-without-classify' | 'duplicate-intent-example' | 'overlapping-intents' | 'body-foreign-tool' | 'body-unknown-tool' | 'example-misses-own-rule' | 'example-shadowed-by-earlier' | 'example-shadowed-by-default' | 'example-unclaimed' | 'artifact-kind-unsatisfied';
+export type GraphProblemCode = 'unknown-skill' | 'no-entry' | 'unreachable-skill' | 'model-edge-only' | 'multi-entry-fanout' | 'dead-entry-step' | 'ambiguous-routes' | 'self-loop' | 'rule-id-exists' | 'overlapping-rules' | 'rules-shadowed-by-order' | 'intent-without-classify' | 'duplicate-intent-example' | 'overlapping-intents' | 'body-foreign-tool' | 'body-unknown-tool' | 'example-misses-own-rule' | 'example-shadowed-by-earlier' | 'example-shadowed-by-default' | 'example-unclaimed' | 'never-routes-claimed' | 'never-routes-by-default' | 'never-routes-contradicts-example' | 'tools-share-prefix' | 'few-declared-edges' | 'skill-wraps-one-tool' | 'artifact-kind-unsatisfied';
 /** One issue found by the check-up. `kind: 'error'` fails `ok` (and `'throw'`). */
 export interface GraphProblem {
     readonly kind: 'error' | 'warning';
@@ -45,10 +45,11 @@ export interface GraphProblem {
     readonly from?: string;
     readonly to?: string;
     /**
-     * The declared example phrase this problem is about — present only on the
-     * `example-*` codes, which are the only checks that reason about a concrete
-     * phrase. The message always quotes it too; this is the same string as data,
-     * so a tool can group by phrase without parsing prose.
+     * The declared phrase this problem is about — present on the `example-*`
+     * codes and on the `never-routes-*` ones, the checks that reason about a
+     * concrete phrase (in the positive and the negative direction respectively).
+     * The message always quotes it too; this is the same string as data, so a
+     * tool can group by phrase without parsing prose.
      */
     readonly example?: string;
 }

package/dist/types/lib/injection-engine/skillGraphCheckup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillGraphCheckup.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillGraphCheckup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,MAAM,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAExF,MAAM,MAAM,gBAAgB,GACxB,eAAe,GACf,UAAU,GACV,mBAAmB,GACnB,iBAAiB,GACjB,oBAAoB,GACpB,iBAAiB,GACjB,kBAAkB,GAClB,WAAW,GAEX,gBAAgB,GAKhB,mBAAmB,GACnB,yBAAyB,GAIzB,yBAAyB,GAIzB,0BAA0B,GAG1B,qBAAqB,GAIrB,mBAAmB,GACnB,mBAAmB,GAInB,yBAAyB,GAKzB,6BAA6B,GAO7B,6BAA6B,GAO7B,mBAAmB,GAInB,2BAA2B,CAAC;AAMhC,mFAAmF;AACnF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;qDACiD;IACjD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;+EAG2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,mCAAmC;IACnC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACzF,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC/D;;;;;;;;OAQG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,8BAA8B;AAC9B,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAwV9D;AA2CD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAI3D"}
+{"version":3,"file":"skillGraphCheckup.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillGraphCheckup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,MAAM,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAExF,MAAM,MAAM,gBAAgB,GACxB,eAAe,GACf,UAAU,GACV,mBAAmB,GACnB,iBAAiB,GACjB,oBAAoB,GACpB,iBAAiB,GACjB,kBAAkB,GAClB,WAAW,GAEX,gBAAgB,GAKhB,mBAAmB,GACnB,yBAAyB,GAIzB,yBAAyB,GAIzB,0BAA0B,GAG1B,qBAAqB,GAIrB,mBAAmB,GACnB,mBAAmB,GAInB,yBAAyB,GAKzB,6BAA6B,GAO7B,6BAA6B,GAO7B,mBAAmB,GAOnB,sBAAsB,GAKtB,yBAAyB,GAIzB,kCAAkC,GAOlC,oBAAoB,GAEpB,oBAAoB,GAEpB,sBAAsB,GAGtB,2BAA2B,CAAC;AAMhC,mFAAmF;AACnF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;qDACiD;IACjD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;+EAG2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,mCAAmC;IACnC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACzF,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC/D;;;;;;;;OAQG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,8BAA8B;AAC9B,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAwV9D;AA2CD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAI3D"}

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

@@ -0,0 +1,132 @@
+/**
+ * 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;
+//# sourceMappingURL=skillNeverRoutes.d.ts.map

package/dist/types/lib/injection-engine/skillNeverRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillNeverRoutes.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillNeverRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAE7B;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAI6B,CAAC;AAEhE;;yEAEyE;AACzE,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;iEACiE;AACjE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAOD;;;;8DAI8D;AAC9D,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,GACnC,SAAS,MAAM,EAAE,CAsCnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,GAAG,kBAAkB,CA0FrB"}

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

@@ -0,0 +1,70 @@
+/**
+ * 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[];
+//# sourceMappingURL=skillPartition.d.ts.map

package/dist/types/lib/injection-engine/skillPartition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillPartition.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillPartition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AA+G5C;qEACqE;AACrE,MAAM,WAAW,cAAc;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC;;sDAEkD;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;uEACmE;IACnE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,YAAY,EAAE,CAsFpE"}

package/dist/types/lib/injection-engine/skillsFromDir.d.ts

@@ -76,9 +76,36 @@
  *     others take `defineSkill`'s defaults.
  *   - unknown frontmatter keys are still IGNORED, not rejected, so a file
  *     carrying another tool's metadata still loads here. `name`,
- *     `description`, `tools`, `steps` and `onSkip` are the KNOWN keys — a file
- *     that used one of those five for something else is the one case this
- *     release can change, and it changes it loudly.
+ *     `description`, `tools`, `steps`, `onSkip` and `routes` are the KNOWN
+ *     keys — a file that used one of those six for something else is the one
+ *     case a release can change, and it changes it loudly.
+ *
+ * ── The routing, and the door that reads it (9.43.0) ─────────────────────────
+ * A runbook says what to do, what to do it with, in what order — and where the
+ * work goes NEXT. That last part is the graph, and until now it had to be
+ * hand-wired in code even when the files said it plainly. `routes:` closes it:
+ *
+ *   ---
+ *   name: billing
+ *   tools: lookup_order, issue_refund
+ *   routes:
+ *     - escalation: on issue_refund status=denied
+ *     - receipts: on issue_refund
+ *   ---
+ *
+ *   const runbook = await runbookFromDir('./skills', { tools: [...] });
+ *   const graph = skillGraph({ ...runbook, start: 'billing' });
+ *
+ * TWO DOORS, one truth: `skillsFromDir` returns skills and REFUSES a file that
+ * declares `routes:` (a door that dropped the routing would hand back a graph
+ * you believed was declared on disk); {@link runbookFromDir} returns
+ * `{ skills, steps }`. Same law as `tools:` — the file PICKS (a route names a
+ * skill id this directory declares; an unknown id is refused at load, by name,
+ * listing what is available), it never DEFINES. A guard is one of the two DATA
+ * conditions a route already has (`on <tool_name>`, `status=<outcome>`), and
+ * nothing else: a `when` predicate is CODE, no file can carry code, and that
+ * conditional stays in your source. See `skillsFromDirRoutes.ts` for the whole
+ * grammar and every refusal.
  *
  * A worked example feeding this into a graph:
  * `examples/features/47-skills-from-dir-graph.ts`.
@@ -111,6 +138,7 @@
 import type { Injection } from './types.js';
 import type { Tool } from '../../core/tools.js';
 import { type SurfaceMode } from './factories/defineSkill.js';
+import type { SkillGraphStep } from './skillGraph.js';
 export interface SkillsFromDirOptions {
     /**
      * Where a loaded skill's body lands once activated. Defaults to
@@ -133,6 +161,31 @@ export interface SkillsFromDirOptions {
      */
     readonly tools?: readonly Tool[];
 }
+/**
+ * A whole runbook directory, read as the two things a graph is made of
+ * (9.43.0): the skills, and the edges between them.
+ *
+ * Spreads straight into the graph — the field names are the graph's own, so
+ * nothing has to be translated at the call site:
+ *
+ *   const runbook = await runbookFromDir('./skills', { tools });
+ *   const graph = skillGraph({ ...runbook, start: 'triage' });
+ */
+export interface DirRunbook {
+    /** Every `SKILL.md` under the directory, as Skill Injections — byte-identical
+     *  to what `skillsFromDir` returns for the same directory. */
+    readonly skills: readonly Injection[];
+    /**
+     * The declared edges, ready for `skillGraph({ steps })`. In skill-name order,
+     * then file order, so a graph built from a directory is stable.
+     *
+     * NAME NOTE, because two different things are spelled `steps` in this
+     * library: a file's own `steps:` key is that SKILL's tool sequence (which
+     * rides on the skill, unchanged); these `steps` are the GRAPH's edges, read
+     * from each file's `routes:` key. They never meet.
+     */
+    readonly steps: readonly SkillGraphStep[];
+}
 /**
  * Load every `SKILL.md` under `dir` as a Skill Injection.
  *
@@ -155,4 +208,31 @@ export interface SkillsFromDirOptions {
  *   does not carry, or sequences a tool the file itself did not declare.
  */
 export declare function skillsFromDir(dir: string, opts?: SkillsFromDirOptions): Promise<readonly Injection[]>;
+/**
+ * Load a directory as a whole RUNBOOK (9.43.0) — the skills AND the edges
+ * between them.
+ *
+ * `skillsFromDir` reads what one skill is; this reads what the skills are TO
+ * EACH OTHER, from each file's `routes:` key, and hands back both halves ready
+ * for `skillGraph({ ...runbook, start })`. Everything else is identical: same
+ * layouts, same frontmatter, same tool registry, same refusals.
+ *
+ * The routing a file may carry is deliberately small, and the boundary is a
+ * security property rather than a limitation — see `skillsFromDirRoutes.ts`:
+ * a route NAMES a skill this directory declares (an unknown id is refused at
+ * load, by name, listing what is available — never a half-graph), and a guard
+ * is one of the two DATA conditions a route already has (`on <tool>`,
+ * `status=<outcome>`). A `when` predicate is code, so no file can express one;
+ * that conditional stays in your source, where `skillGraph({ steps })` takes it.
+ *
+ * @param dir - A local filesystem path. Same rule as `skillsFromDir`.
+ * @param opts - Applied uniformly to every loaded skill.
+ *
+ * @throws everything `skillsFromDir` throws, plus: a route to an id no
+ *   `SKILL.md` in the directory declares (the message lists what is
+ *   available), a guard the grammar cannot express (the message quotes the
+ *   whole grammar), a guard naming a tool the file itself does not declare,
+ *   and a file routing to the same skill twice.
+ */
+export declare function runbookFromDir(dir: string, opts?: SkillsFromDirOptions): Promise<DirRunbook>;
 //# sourceMappingURL=skillsFromDir.d.ts.map

package/dist/types/lib/injection-engine/skillsFromDir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillsFromDir.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillsFromDir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6GG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAmB3E,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC;CAClC;AAsBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC,SAAS,SAAS,EAAE,CAAC,CAyF/B"}
+{"version":3,"file":"skillsFromDir.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillsFromDir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAoBtD,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC;CAClC;AA2BD;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB;kEAC8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC,SAAS,SAAS,EAAE,CAAC,CAoB/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC,UAAU,CAAC,CASrB"}

package/dist/types/lib/injection-engine/skillsFromDirRoutes.d.ts

@@ -0,0 +1,106 @@
+/**
+ * skillsFromDirRoutes — the `routes:` half of the on-disk runbook grammar.
+ *
+ * ## What a file may say about routing, and why it is this little
+ *
+ * `skillsFromDir` reads prose, `tools:` and `steps:` — everything about ONE
+ * skill — and stopped exactly where the value was supposed to start: the
+ * routing. A directory of runbooks still had to be hand-wired into a graph in
+ * code, which is the work the graph exists to remove.
+ *
+ * This module adds the missing key under the SAME security law the tools list
+ * follows: **the file PICKS, it never DEFINES.**
+ *
+ *   ---
+ *   name: billing
+ *   tools: lookup_order, issue_refund
+ *   routes:
+ *     - escalation: on issue_refund status=denied
+ *     - receipts: on issue_refund
+ *     - audit
+ *   ---
+ *
+ * A route names a SKILL ID and, optionally, a guard. Both halves are picks:
+ *
+ *   • the id is resolved against the skills THIS DIRECTORY declares — an id
+ *     nothing here declares is refused at load, by name, listing what is
+ *     available. Never a half-graph: one bad id fails the whole load, because
+ *     a graph missing one edge routes silently wrong, which is worse than a
+ *     graph that refuses to exist;
+ *   • the guard is one of the two DATA conditions a route already has
+ *     (`onToolReturn`, `onToolStatus`), and the tool it names must be one of
+ *     this file's own `tools:` — the same law `steps:` follows, for the same
+ *     reason (an edge out of this skill fires on this skill's work).
+ *
+ * Nothing is evaluated, imported or resolved as a path. The strings can only
+ * MATCH — against ids the loader already read off disk and against a closed
+ * status vocabulary.
+ *
+ * ## What a file CANNOT express, said plainly
+ *
+ * A `when:` predicate is CODE. There is no honest way for a markdown file to
+ * carry it: reading one would mean evaluating a string, which is the one thing
+ * this loader exists never to do. So the grammar has no `when` and no
+ * expression language of any kind — a conditional a file cannot express is a
+ * conditional that stays in code:
+ *
+ *   skillGraph({ skills, steps: [{ from: 'billing', to: 'escalation',
+ *                                  when: r => JSON.parse(r.result).tier > 2 }] });
+ *
+ * Anything that is not one of the three forms is refused with the whole grammar
+ * quoted, rather than half-understood by a parser inventing a mini-language.
+ *
+ * Zone: HOST (it belongs to the file loader). Pure over strings all the same —
+ * it reads no filesystem; `skillsFromDir.ts` hands it the parsed lines.
+ */
+import type { SkillGraphStep } from './skillGraph.js';
+import { type ToolResultStatus } from './toolOutcome.js';
+/**
+ * One frontmatter list item, structurally — `skillsFromDir`'s module-private
+ * `ListItem` satisfies it unchanged, so the two never import each other.
+ */
+export interface RouteItem {
+    /** Text before the first `:` — the target skill id. */
+    readonly key: string;
+    /** Text after the first `:` — the guard. Undefined when the item has none. */
+    readonly value?: string;
+    /** 1-based line number in the file. Every refusal quotes it. */
+    readonly line: number;
+}
+/** One route as the FILE declared it: a target id and a parsed guard. The id is
+ *  still unresolved here — a file cannot know what the rest of the directory
+ *  carries, so that refusal waits for {@link toGraphSteps}. */
+export interface DeclaredRoute {
+    readonly to: string;
+    readonly onToolReturn?: string;
+    readonly onToolStatus?: readonly ToolResultStatus[];
+    readonly line: number;
+}
+/**
+ * Read one file's `routes:` items into declared routes, refusing every shape
+ * the grammar does not carry. Pure; every message names the file and the line,
+ * because "malformed routes" over a directory of forty runbooks has told the
+ * author nothing.
+ *
+ * @param items      the `routes:` block-list items, in file order.
+ * @param file       the path, quoted by every refusal.
+ * @param toolNames  this file's own `tools:` — a guard may only name one of
+ *                   them (undefined when the file declared no tools at all).
+ */
+export declare function readDeclaredRoutes(items: readonly RouteItem[], file: string, toolNames: readonly string[] | undefined): readonly DeclaredRoute[];
+/**
+ * Resolve one file's declared routes into graph steps, refusing an id no
+ * SKILL.md in the directory declares.
+ *
+ * The refusal lists what IS available and fails the whole load. A route to a
+ * name nothing declares is the one mistake that cannot be reported later: the
+ * loader would return a skill set the graph then wires with a missing edge, and
+ * a graph that silently does not route is exactly the failure the check-up
+ * exists to prevent. Half a graph is not a smaller version of the graph.
+ *
+ * @param from   the id of the skill whose file declared these routes.
+ * @param file   that skill's path, quoted by the refusal.
+ * @param known  every skill id the directory declared.
+ */
+export declare function toGraphSteps(from: string, routes: readonly DeclaredRoute[], file: string, known: ReadonlySet<string>): readonly SkillGraphStep[];
+//# sourceMappingURL=skillsFromDirRoutes.d.ts.map

package/dist/types/lib/injection-engine/skillsFromDirRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillsFromDirRoutes.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillsFromDirRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAwB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAE/E;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,uDAAuD;IACvD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;+DAE+D;AAC/D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAeD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACvC,SAAS,aAAa,EAAE,CA4E1B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,SAAS,cAAc,EAAE,CAmB3B"}

package/dist/types/lib/injection-engine/startRuleClaim.d.ts

@@ -0,0 +1,92 @@
+/**
+ * startRuleClaim — WHO CLAIMS A PHRASE. The one place that answers it.
+ *
+ * Two check-ups ask the same question of a graph's start rules and want
+ * opposite answers:
+ *
+ *   • `skillExamples.ts` declares a phrase and asserts THIS rule claims it;
+ *   • `skillNeverRoutes.ts` declares a phrase and asserts NO rule claims it.
+ *
+ * The question underneath is identical — run the compiled conditions over one
+ * concrete phrase, on the context a turn's first iteration really hands a start
+ * rule, and see who says yes. Two copies of that would drift the moment one of
+ * them learned something about the router the other did not, and the two would
+ * then disagree about the same graph. So it lives here, once, and the modules
+ * that report keep only their own sentences.
+ *
+ * Nothing here decides SEVERITY or writes a message — that is the reporting
+ * module's job, because the same "no" means different things to a positive and
+ * a negative assertion. This module only runs predicates and names conditions.
+ *
+ * Zone: PURE CORE (no engine, no loop). Pinned by
+ * `test/lib/injection-engine/skill-graph-fence.test.ts`.
+ */
+import type { InjectionContext } from './types.js';
+import { type SkillMatchData } from './skillMatch.js';
+/**
+ * The slice of an entry declaration a claim question reads — structural, so
+ * `skillGraph.ts`'s module-private `EntryDecl` satisfies it unchanged (the same
+ * trick `skillIntent.ts` uses).
+ */
+export interface StartRuleDecl {
+    readonly id: string;
+    /** The compiled condition (from `match:`) or the author's `when`. Absent on
+     *  an unconditional entry and on an intent rule (no sync predicate). */
+    readonly when?: (ctx: InjectionContext) => boolean;
+    /** The serializable matcher behind `when`, when declared as data — quoted
+     *  back in the messages, and the one way to spot the intent arm. */
+    readonly match?: SkillMatchData;
+}
+/**
+ * Run one entry's condition over one phrase, on a COLD-START context — the
+ * context a turn's first iteration really hands a start rule: iteration 1, the
+ * phrase as `userMessage`, no history, no cursor, no tool results. A throw is
+ * reported as `'threw'` and treated as a no-match by every caller, which is
+ * exactly what the cursor resolver does with it at run time (so a claim made
+ * here stays true of the run).
+ *
+ * An entry with NO condition matches everything: that is the cold walk's law
+ * (`if (!e.when) return { to: e.id }`), not a shortcut.
+ */
+export declare function runsOn(entry: StartRuleDecl, phrase: string): 'match' | 'no-match' | 'threw';
+/** The one context every predicate in a phrase check is judged on. */
+export declare function coldContext(userMessage: string): InjectionContext;
+/** The one context every predicate here is judged on, spelled out for the
+ *  reader of a message — a check that names its own inputs can be argued with;
+ *  one that hides them can only be guessed at. Kept as ONE string so every
+ *  message describes the SAME context {@link coldContext} really builds. */
+export declare const COLD_CONTEXT_PHRASE: string;
+/** One claimant of a phrase: the entry, and its position in declaration order. */
+export interface Claim {
+    readonly entry: StartRuleDecl;
+    readonly index: number;
+}
+/** How a rule's condition is named in a message: the data matcher quoted back,
+ *  the honest word for opaque code — or, for an entry that declares neither,
+ *  what having no condition MEANS. Naming a `when` predicate an unconditional
+ *  entry does not have is how a report describes a graph nobody wrote. */
+export declare function describeCondition(entry: StartRuleDecl): string;
+/**
+ * The two claimant sets, mirroring the TWO start laws (see `skillExamples.ts`'s
+ * header for the whole statement) rather than re-inventing either:
+ *
+ *   • COLD WALK (`makeResolveCursor`, the default mount): every non-intent
+ *     entry, unconditional ones included — they claim everything from their
+ *     position onward.
+ *   • CASCADE tier 1 (`firstRuleMatch`, mounted by `.classify()` OR by
+ *     `continuity: 'conversation'`): the CONDITIONAL non-intent entries only —
+ *     an unconditional entry is a default, not a rule.
+ *
+ * Intent entries appear in NEITHER: they compile to no sync predicate at all,
+ * and the classifier judges them at run time with a scorer this pass does not
+ * run.
+ */
+export interface ClaimLaws {
+    /** First claimant under the declaration-order cold walk, or undefined. */
+    readonly underColdWalk: (phrase: string) => Claim | undefined;
+    /** First claimant under the turn-start cascade's tier 1, or undefined. */
+    readonly underCascade: (phrase: string) => Claim | undefined;
+}
+/** Build both laws' claim finders over one entry list, in declaration order. */
+export declare function claimLaws(entries: readonly StartRuleDecl[]): ClaimLaws;
+//# sourceMappingURL=startRuleClaim.d.ts.map

package/dist/types/lib/injection-engine/startRuleClaim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startRuleClaim.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/startRuleClaim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAqB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEzE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;4EACwE;IACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IACnD;wEACoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;CACjC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,OAAO,CAO3F;AAED,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAEjE;AAED;;;4EAG4E;AAC5E,eAAO,MAAM,mBAAmB,QAEO,CAAC;AAExC,kFAAkF;AAClF,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;0EAG0E;AAC1E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAK9D;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,SAAS;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CAAC;IAC9D,0EAA0E;IAC1E,QAAQ,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CAAC;CAC9D;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,SAAS,CAStE"}