agentfootprint 10.2.0 → 10.3.1

package/dist/types/resilience/withCircuitBreaker.d.ts

@@ -96,7 +96,7 @@
  * field-validated rung — a real degradation, with a real vendor's error mix and
  * a real recovery time, remains unexercised.
  */
-import type { LLMProvider } from '../adapters/types.js';
+import type { LLMProvider } from '../provider-contract/types.js';
 export interface WithCircuitBreakerOptions {
     /** Consecutive failures before the breaker OPENS. Default 5. */
     readonly failureThreshold?: number;

package/dist/types/resilience/withCircuitBreaker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withCircuitBreaker.d.ts","sourceRoot":"","sources":["../../../src/resilience/withCircuitBreaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGG;AAEH,OAAO,KAAK,EAGV,WAAW,EAGZ,MAAM,sBAAsB,CAAC;AAK9B,MAAM,WAAW,yBAAyB;IACxC,gEAAgE;IAChE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,mEAAmE;IACnE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAC3C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IACnD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACxE;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAI3D;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,qBAA+B;IAC5C;+CAC2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAChB,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM;CAYrE;AAYD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,WAAW,EAClB,OAAO,GAAE,yBAA8B,GACtC,WAAW,CAmKb"}
+{"version":3,"file":"withCircuitBreaker.d.ts","sourceRoot":"","sources":["../../../src/resilience/withCircuitBreaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGG;AAEH,OAAO,KAAK,EAGV,WAAW,EAGZ,MAAM,+BAA+B,CAAC;AAKvC,MAAM,WAAW,yBAAyB;IACxC,gEAAgE;IAChE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,mEAAmE;IACnE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAC3C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IACnD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACxE;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAI3D;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,qBAA+B;IAC5C;+CAC2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAChB,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM;CAYrE;AAYD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,WAAW,EAClB,OAAO,GAAE,yBAA8B,GACtC,WAAW,CA0Kb"}

package/dist/types/resilience/withFallback.d.ts

@@ -28,7 +28,7 @@
  * GCP credit"*). **No failover between two live providers has been exercised
  * from this repository**, so this is not the field-validated rung.
  */
-import type { LLMProvider } from '../adapters/types.js';
+import type { LLMProvider } from '../provider-contract/types.js';
 export interface WithFallbackOptions {
     /**
      * Predicate to decide whether an error from the primary should

package/dist/types/resilience/withFallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withFallback.d.ts","sourceRoot":"","sources":["../../../src/resilience/withFallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAGV,WAAW,EAIZ,MAAM,sBAAsB,CAAC;AA2H9B,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IACtD;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAChD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,GAAE,mBAAwB,GAChC,WAAW,CAoIb"}
+{"version":3,"file":"withFallback.d.ts","sourceRoot":"","sources":["../../../src/resilience/withFallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAGV,WAAW,EAIZ,MAAM,+BAA+B,CAAC;AA4HvC,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IACtD;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAChD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,GAAE,mBAAwB,GAChC,WAAW,CA+Ib"}

package/dist/types/resilience/withRetry.d.ts

@@ -42,7 +42,7 @@
  * repository**, so this is not the field-validated rung: a real 503 from a real
  * vendor, with a real Retry-After and real latency, remains unexercised.
  */
-import type { LLMProvider } from '../adapters/types.js';
+import type { LLMProvider } from '../provider-contract/types.js';
 export interface WithRetryOptions {
     /** Total attempts including the first. Default 3. Must be >= 1. */
     readonly maxAttempts?: number;

package/dist/types/resilience/withRetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withRetry.d.ts","sourceRoot":"","sources":["../../../src/resilience/withRetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,KAAK,EAGV,WAAW,EAGZ,MAAM,sBAAsB,CAAC;AAK9B,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,sEAAsE;IACtE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IACpE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CAoJ5F;AA2CD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAW1E"}
+{"version":3,"file":"withRetry.d.ts","sourceRoot":"","sources":["../../../src/resilience/withRetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,KAAK,EAGV,WAAW,EAGZ,MAAM,+BAA+B,CAAC;AAKvC,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,sEAAsE;IACtE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IACpE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CA4J5F;AA2CD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAW1E"}

package/dist/types/security/PermissionPolicy.d.ts

@@ -72,7 +72,7 @@
  *   const adminPolicy = policy.withActiveRole('admin');
  *   // Same allowlist data; different active role.
  */
-import type { PermissionCapability, PermissionChecker, PermissionRequest, PermissionDecision, ToolCapability } from '../adapters/types.js';
+import type { PermissionCapability, PermissionChecker, PermissionRequest, PermissionDecision, ToolCapability } from '../provider-contract/types.js';
 /**
  * Map of role name → list of tool ids that role is allowed to invoke.
  * The shape consumers extend over time as new tools / roles arrive.

package/dist/types/security/PermissionPolicy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PermissionPolicy.d.ts","sourceRoot":"","sources":["../../../src/security/PermissionPolicy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AAEH,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACf,MAAM,sBAAsB,CAAC;AAa9B;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;AAExE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC,CAAC,CAAC;IAC5E;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,qBAAqB,CAAC;CACxC;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,iBAAiB;IAapC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZzC,QAAQ,CAAC,IAAI,sBAAsB;IAEnC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAEnD,OAAO;IAkBP;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,MAAM,EAClB,KAAK,CAAC,EAAE,qBAAqB,GAC5B,gBAAgB;IAInB;;;;;;;OAOG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,KAAK,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4BpE;;;;;;;;OAQG;IACH,OAAO,CAAC,UAAU;IAgBlB;;;;;;OAMG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB;IAUpD,gEAAgE;IAChE,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,iEAAiE;IACjE,IAAI,KAAK,IAAI,SAAS,MAAM,EAAE,CAE7B;IAED,0DAA0D;IAC1D,cAAc,IAAI,SAAS,MAAM,EAAE;CAGpC"}
+{"version":3,"file":"PermissionPolicy.d.ts","sourceRoot":"","sources":["../../../src/security/PermissionPolicy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AAEH,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACf,MAAM,+BAA+B,CAAC;AAavC;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;AAExE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC,CAAC,CAAC;IAC5E;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,qBAAqB,CAAC;CACxC;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,iBAAiB;IAapC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZzC,QAAQ,CAAC,IAAI,sBAAsB;IAEnC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAEnD,OAAO;IAkBP;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,MAAM,EAClB,KAAK,CAAC,EAAE,qBAAqB,GAC5B,gBAAgB;IAInB;;;;;;;OAOG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,KAAK,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4BpE;;;;;;;;OAQG;IACH,OAAO,CAAC,UAAU;IAgBlB;;;;;;OAMG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB;IAUpD,gEAAgE;IAChE,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,iEAAiE;IACjE,IAAI,KAAK,IAAI,SAAS,MAAM,EAAE,CAE7B;IAED,0DAA0D;IAC1D,cAAc,IAAI,SAAS,MAAM,EAAE;CAGpC"}

package/dist/types/security/PolicyHaltError.d.ts

@@ -35,7 +35,7 @@
  *     }
  *   }
  */
-import type { LLMMessage, ToolCallEntry, ToolResultContent } from '../adapters/types.js';
+import type { LLMMessage, ToolCallEntry, ToolResultContent } from '../provider-contract/types.js';
 export interface PolicyHaltContext {
     /** Telemetry tag from the matched rule. Stable across versions. */
     readonly reason: string;

package/dist/types/security/PolicyHaltError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PolicyHaltError.d.ts","sourceRoot":"","sources":["../../../src/security/PolicyHaltError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzF,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC;gEAC4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,yCAAyC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;IACrE,kEAAkE;IAClE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,oBAA8B;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;IACrE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAEhB,GAAG,EAAE,iBAAiB;CAWnC"}
+{"version":3,"file":"PolicyHaltError.d.ts","sourceRoot":"","sources":["../../../src/security/PolicyHaltError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAElG,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC;gEAC4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,yCAAyC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;IACrE,kEAAkE;IAClE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,oBAA8B;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;IACrE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAEhB,GAAG,EAAE,iBAAiB;CAWnC"}

package/dist/types/security/extractSequence.d.ts

@@ -50,7 +50,7 @@
  *
  * A history without a settled message pairs exactly as before 9.113.0.
  */
-import type { LLMMessage, ToolCallEntry } from '../adapters/types.js';
+import type { LLMMessage, ToolCallEntry } from '../provider-contract/types.js';
 /** Prefix the framework writes on synthetic deny tool_results. Used to
  *  distinguish "denied but in history" from "actually dispatched". */
 export declare const SYNTHETIC_DENY_PREFIX = "[permission denied:";

package/dist/types/security/extractSequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractSequence.d.ts","sourceRoot":"","sources":["../../../src/security/extractSequence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEtE;sEACsE;AACtE,eAAO,MAAM,qBAAqB,wBAAwB,CAAC;AAE3D,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,sBAA2B,GACnC,aAAa,EAAE,CAiDjB"}
+{"version":3,"file":"extractSequence.d.ts","sourceRoot":"","sources":["../../../src/security/extractSequence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE/E;sEACsE;AACtE,eAAO,MAAM,qBAAqB,wBAAwB,CAAC;AAE3D,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,sBAA2B,GACnC,aAAa,EAAE,CAiDjB"}

package/dist/types/security/index.d.ts

@@ -53,6 +53,6 @@ export type { ExtractSequenceOptions } from './extractSequence.js';
 export { redactThinkingBlocks, REDACTED_PLACEHOLDER } from './thinkingRedaction.js';
 export { conversationRedaction } from '../redaction/conversation.js';
 export { SKILL_TARGET_PREFIX, skillTarget, skillIdFromTarget } from './skillTarget.js';
-export type { PermissionCapability, PermissionChecker, PermissionRequest, PermissionDecision, ToolCallEntry, ToolCapability, ToolResultContent, } from '../adapters/types.js';
-export { checkerGoverns } from '../adapters/types.js';
+export type { PermissionCapability, PermissionChecker, PermissionRequest, PermissionDecision, ToolCallEntry, ToolCapability, ToolResultContent, } from '../provider-contract/types.js';
+export { checkerGoverns } from '../provider-contract/types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/security/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/security/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EACV,aAAa,EACb,WAAW,EACX,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGpF,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAIrE,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAMvF,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,cAAc,EACd,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/security/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EACV,aAAa,EACb,WAAW,EACX,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGpF,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAIrE,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAMvF,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,cAAc,EACd,iBAAiB,GAClB,MAAM,+BAA+B,CAAC;AAIvC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/types/semantics/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/semantics/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAEzB;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,iGAAiG;IACjG,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;CACzF;AAED;4EAC4E;AAC5E,MAAM,MAAM,oBAAoB,GAC5B,qBAAqB,GACrB,sBAAsB,GACtB,8BAA8B,GAC9B,yBAAyB,GACzB,yBAAyB,GACzB,4BAA4B,GAC5B,0BAA0B,GAC1B,sBAAsB,GACtB,eAAe,CAAC,MAAM,CAAC,CAAC;AAE5B;2CAC2C;AAC3C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,kFAAkF;IAClF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,oEAAoE;IACpE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;8DAC8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAqCD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,qBAAqB,EAAE,GAAG,eAAe,CA8HzF"}

package/dist/types/semantics/cli.d.ts

@@ -0,0 +1,41 @@
+/**
+ * check:semantics CLI core (9.53.0 — the build gate).
+ *
+ * Pattern: humble shell (the tool-lint `cli.ts` precedent) —
+ *          `bin/agentfootprint-check-semantics.mjs` is a 2-line wrapper;
+ *          ALL behavior (arg parsing, catalog coercion, report, exit code)
+ *          lives here so it is unit-testable without spawning a process.
+ * Role:    `src/semantics/`. Reads ONE JSON file of tools + sample
+ *          results, prints a report, returns the process exit code:
+ *            0 — report.ok (and, under --strict, zero warnings)
+ *            1 — findings failed the gate
+ *            2 — usage / input error (bad flags, unreadable file,
+ *                unrecognized JSON shape, unknown resultClass)
+ *
+ * Consumers wire it beside their other gates (the `check:tools` convention):
+ *
+ *   "check:semantics": "node scripts/dump-semantics-catalog.mjs && agentfootprint-check-semantics semantics-catalog.json"
+ *
+ * The catalog is sample results — what your MOCK tools return — because the
+ * gate judges result shapes, and a build must never run tools that touch
+ * live systems. A mock catalog is something this ecosystem already has
+ * everywhere the check matters.
+ */
+import { type SemanticsCatalogEntry } from './check.js';
+export interface SemanticsCliIO {
+    readonly stdout: (line: string) => void;
+    readonly stderr: (line: string) => void;
+}
+/**
+ * Normalize the accepted JSON shapes to the checker's catalog. Throws (with
+ * a shape description) on unrecognized input — the CLI maps that to exit
+ * code 2. `resultClass` values are passed through untouched; the checker is
+ * the one owner of the closed-set refusal.
+ */
+export declare function coerceSemanticsCatalog(json: unknown): readonly SemanticsCatalogEntry[];
+/**
+ * Run the gate CLI. Returns the exit code (never calls `process.exit` — the
+ * bin wrapper assigns it to `process.exitCode`).
+ */
+export declare function runCheckSemanticsCli(argv: readonly string[], io?: SemanticsCliIO): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/types/semantics/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/semantics/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAkB,KAAK,qBAAqB,EAAwB,MAAM,YAAY,CAAC;AAI9F,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAkBD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,qBAAqB,EAAE,CA6CtF;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,GAAE,cAKH,GACA,OAAO,CAAC,MAAM,CAAC,CA4CjB"}

package/dist/types/semantics/coverage/absent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"absent.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/absent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAOH,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAI5F,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;AAEvC;;;;;GAKG;AAGH,eAAO,MAAM,YAAY,sYAC4W,CAAC;AAEtY;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,QAI8C,CAAC;AAmJlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,WAAW,CA4D5D;AAED;sDACsD;AACtD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,QAAQ,CAMhE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,CAExF"}

package/dist/types/semantics/coverage/answer.d.ts

@@ -0,0 +1,198 @@
+/**
+ * answer — how a ledger survives into the final answer.
+ *
+ * Pattern: composed by the FRAMEWORK, not requested from the model. Pure
+ *          function of the run's declarations; the stage that calls it is a
+ *          two-line wrapper (see `stages/prepareFinal.ts`).
+ * Role:    core/ layer, pure.
+ * Emits:   N/A.
+ *
+ * ## Why this is an append and not a check
+ *
+ * A ledger the model can drop is worthless, and every mechanism that ASKS the
+ * model to carry it can be dropped: a note in the tool result is advice, a
+ * system-prompt rule is advice, and a judge that reads the answer back and
+ * asks "did it state its limits?" needs a second model to decide what
+ * counts — which would put a language judgement in the one place this library
+ * refuses to put one (see `evidence/README.md`: the guard may not need a
+ * bigger model than the thing it guards).
+ *
+ * So the limits are APPENDED. The model does not write them, so the model
+ * cannot drop them, and the mechanism is a string concatenation over data the
+ * tools declared — deterministic, auditable, and cheap. It changes the bytes
+ * of the answer, which is why it is opt-in
+ * (`.limitsTravelWithTheAnswer()`): an agent that never asks for it is
+ * byte-identical.
+ *
+ * ## Why a TYPED answer gets the same fold as data, never the block
+ *
+ * An answer with an output schema is JSON, and JSON followed by prose is not
+ * JSON — appending the block made `runTyped()` throw on every answer that had
+ * limits. So when an output schema is configured the answer string stays the
+ * model's own, and the same fold travels BESIDE it: `coverageOfAnswer` below,
+ * committed as `AgentState.answerCoverage`. The model still cannot drop it —
+ * the framework composes it from what the tools declared — and a person reads
+ * it wherever the app draws it, not wherever the prose happened to end.
+ *
+ * ## Why an absence contributes too
+ *
+ * `absent()` and `coverage()` make the same kind of statement about the same
+ * run. A search that found nothing in the fcns database really did cover the
+ * fcns database, and a search that could not reach the archive really is a
+ * limit on the answer. Folding both into one block is the only way the reader
+ * gets ONE boundary instead of a boundary per tool — and duplicates are
+ * dropped, so five tools naming the same missing collector say it once.
+ */
+import { type DeclaredPeriod } from './period.js';
+import type { BoundPresentation } from '../../time/present.js';
+import type { Coverage, DeclaredCoverage, InProgressItem } from './types.js';
+/**
+ * One declaring call's period, as the answer's limits carry it (honesty step
+ * 7b) — the tool, the call, and the period AS DECLARED: the data twin of one
+ * `Period:` line.
+ *
+ * @inline
+ */
+export interface AnswerPeriod extends DeclaredPeriod {
+    readonly toolName: string;
+    readonly toolCallId?: string;
+}
+/**
+ * One declaring call's in-progress items, as the answer's limits carry them —
+ * the tool, the call, and what its read found still running, as declared: the
+ * data twin of that call's lines under "In progress (outcome not known yet)".
+ *
+ * @inline
+ */
+export interface AnswerInProgress {
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    readonly items: readonly InProgressItem[];
+}
+/**
+ * A TYPED answer's limits, as data — the three coverage lists the prose block
+ * would print, plus the values a tool's `assume` rule filled this turn (the
+ * inputs layer, honesty layer 2), which the prose answer prints as its
+ * "Assumed" block. The value of `AgentState.answerCoverage`,
+ * `turn_end.answerCoverage` and `agent.answerCoverage()`.
+ *
+ * `assumed` is the SAME reading of the SAME rows the block prints
+ * (`arguments/serve.ts` · `assumedLinesFor`): one entry per distinct (tool,
+ * argument, value), in the order the rows were filed, a row a before-tool
+ * rewrite superseded left out. `value` is the tool's own argument view —
+ * `'REDACTED'`, with `hidden: true`, when that view hides the argument.
+ * Present only when a value was assumed. `periods` (honesty step 7b) is the
+ * data twin of the block's `Period:` lines, present only when a call declared one.
+ */
+export interface AnswerCoverage extends Coverage {
+    /** The periods the calls declared (honesty step 7b) — one per declaring
+     *  call, as declared; present only when one did. */
+    readonly periods?: readonly AnswerPeriod[];
+    /** What the calls found still running — its outcome not known yet — one
+     *  entry per declaring call, as declared; present only when one did. Never a
+     *  reason on the answer's standing: a label that travels with the limits. */
+    readonly inProgress?: readonly AnswerInProgress[];
+    readonly assumed?: readonly {
+        readonly toolName: string;
+        readonly argument: string;
+        readonly value: string;
+        readonly hidden: boolean;
+    }[];
+}
+/** One assumed value as `AnswerCoverage` carries it. */
+type AssumedValue = NonNullable<AnswerCoverage['assumed']>[number];
+/** The block's opening line. Stable — tests and readers match on it. */
+export declare const COVERAGE_BLOCK_HEADING = "Coverage of this answer";
+/**
+ * The inputs layer's "Assumed" block's opening line (`arguments/serve.ts` ·
+ * `assumedBlock` composes the block). Owned here, beside the limits block's
+ * heading: this module's `composeAnswerWithCoverage` is the one composer of
+ * the section the framework appends after an answer, and a reader of the
+ * answer's text (`answer-account/account.ts` · `readAnswer`) finds every
+ * block of it through this one module. Stable — tests and readers match on it.
+ */
+export declare const ASSUMED_BLOCK_HEADING = "Assumed (a tool's rule, not your words):";
+/** The section heading the periods print under (honesty step 7b). Stable — readers match on it. */
+export declare const PERIOD_SECTION_LABEL = "Period";
+/** The section heading the wall-clock sources print under (the time layer, step T8). Stable. */
+export declare const CLOCKS_SECTION_LABEL = "Clocks";
+/**
+ * The time layer's limits lines (step T8), already composed from the record
+ * (`coverage/period.ts` · `periodCheckLine`, `clockLines`): `period` — one per
+ * call whose read differs from what was asked, shifted, or was older than the
+ * source keeps, printed under `Period` after the declared periods; `clocks` —
+ * the wall-clock sources, under `Clocks`. Passed only under `.time()`.
+ */
+export interface TimeLimitLines {
+    readonly period: readonly string[];
+    readonly clocks: readonly string[];
+    /**
+     * The MODEL's audience only (`coverage/timeLimits.ts` · `heldLine`): per call
+     * whose source holds none or only part of the asked time, what it asked
+     * about and what the source holds, in the person's zone. The person's block
+     * never reads it — its `Period:` line already prints both spans.
+     */
+    readonly held?: readonly string[];
+}
+/**
+ * The run's declarations folded into the ANSWER's coverage — the three lists
+ * `composeAnswerWithCoverage` renders, as data.
+ *
+ * `.limitsTravelWithTheAnswer()` on a typed answer (`.outputSchema()`): the
+ * answer string has to stay the model's JSON for `runTyped()` to parse it, so
+ * the limits travel beside it instead of inside it — this value, committed as
+ * `AgentState.answerCoverage`, projected onto `turn_end.answerCoverage` and
+ * returned by `agent.answerCoverage()`.
+ *
+ * Folded by the block's own fold (`foldSections`, the one place each list is
+ * merged — declaration order, duplicates dropped), so every entry is one the
+ * block would print and none is added. It keeps EVERY entry: the block's cap
+ * (twelve per section, then "… and N more") is a reading aid for prose, not a
+ * limit on the data.
+ *
+ * Fresh plain objects, copied field by field (`what`, `why`, and the
+ * record-only `short` / `kind` when declared), never a reference into the rows
+ * it was folded from — so the value can be committed, emitted and handed to a
+ * caller as detached data. `undefined` when nothing was declared: the identity
+ * case, the one every run whose tools declare nothing takes.
+ */
+export declare function coverageOfAnswer(declared: readonly DeclaredCoverage[]): AnswerCoverage | undefined;
+/**
+ * A typed answer's limits as ONE value: the folded coverage (or three empty
+ * lists) and the values assumed this turn, `assumed` present only when one
+ * was. `undefined` when there is neither — the identity case, so a run whose
+ * tools declared nothing and assumed nothing commits exactly the keys it
+ * always did.
+ */
+export declare function answerCoverageOf(folded: AnswerCoverage | undefined, assumed: readonly AssumedValue[]): AnswerCoverage | undefined;
+/** A coverage value as detached plain data — the same three lists, every item copied. */
+export declare function copyCoverage(value: Coverage): Coverage;
+/** A typed answer's limits as detached plain data — the lists and any assumed values, copied. */
+export declare function copyAnswerCoverage(value: AnswerCoverage): AnswerCoverage;
+/**
+ * Fold the run's declarations into one block and append it to the answer.
+ *
+ * Returns the answer UNCHANGED when nothing was declared — the identity case
+ * matters, because it is the one every agent that never returns a coverage
+ * shape takes.
+ *
+ * `standing` (the answer layer, honesty layer 4, under
+ * `.answerLayer({ standingLine: true })`) is the answer's standing as one
+ * already-composed line (`assessment/compose.ts` · `standingLineOf`); it opens
+ * the section, and while it is on the caller passes no `assumed` block — the
+ * line names the assumed values itself (one composer for one fact).
+ *
+ * `assumed` (the inputs layer, honesty layer 2) is a second, already-composed
+ * block — the values a tool's `assume` rule filled this turn
+ * (`arguments/serve.ts` · `assumedBlock`) — appended after the coverage block
+ * under the same separator. With neither declarations nor an assumed block the
+ * answer is unchanged, byte for byte.
+ *
+ * `presentation` (the time layer, only under `.time()`) is the run's clock
+ * zone: each `Period:` line renders its instants there, the zone named
+ * (`period.ts` · `periodLine`). Absent → the lines are the declared instants
+ * verbatim, as they always were.
+ */
+export declare function composeAnswerWithCoverage(answer: string, declared: readonly DeclaredCoverage[], assumed?: string, standing?: string, presentation?: BoundPresentation, time?: TimeLimitLines): string;
+export {};
+//# sourceMappingURL=answer.d.ts.map

package/dist/types/semantics/coverage/answer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/answer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH,OAAO,EAA0B,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAgB,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG3F;;;;;;GAMG;AACH,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;CAC3C;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cAAe,SAAQ,QAAQ;IAC9C;wDACoD;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C;;iFAE6E;IAC7E,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;QAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;KAC1B,EAAE,CAAC;CACL;AAED,wDAAwD;AACxD,KAAK,YAAY,GAAG,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAiBnE,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,4BAA4B,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,6CAA6C,CAAC;AAiChF,mGAAmG;AACnG,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAE7C,gGAAgG;AAChG,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AA2CD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,cAAc,GAAG,SAAS,CAwB5B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,OAAO,EAAE,SAAS,YAAY,EAAE,GAC/B,cAAc,GAAG,SAAS,CAI5B;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAMtD;AAED,iGAAiG;AACjG,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAaxE;AAsCD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACrC,OAAO,SAAK,EACZ,QAAQ,SAAK,EACb,YAAY,CAAC,EAAE,iBAAiB,EAChC,IAAI,CAAC,EAAE,cAAc,GACpB,MAAM,CAeR"}

package/dist/types/semantics/coverage/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/evidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AAqDH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAM9E"}

package/dist/types/semantics/coverage/inProgress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inProgress.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/inProgress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;IAC3B,wDAAwD;;IAExD,sEAAsE;;EAE7D,CAAC;AAEZ;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,QAGjB,CAAC;AAUf,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAA;CAAE,GAC3E;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAS7D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,EACZ,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,OAAO,GAClB,iBAAiB,CAenB;AAyDD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,cAAc,EAAE,CAKtE;AAMD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,EAC1C,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,SAAS,cAAc,EAAE,GAAG,SAAS,CASvC;AAcD;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAenE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAUtE;AAED,yGAAyG;AACzG,eAAO,MAAM,yBAAyB,wCAAwC,CAAC;AAE/E;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAI7E;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,CAOvE"}

package/dist/types/semantics/coverage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACnG,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,kBAAkB,EAClB,YAAY,EACZ,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EACL,QAAQ,EACR,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC9F,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,gBAAgB,EAChB,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,WAAW,EACX,cAAc,GACf,MAAM,YAAY,CAAC"}

package/dist/types/semantics/coverage/items.d.ts

@@ -0,0 +1,89 @@
+/**
+ * coverage/items — normalizing and refusing coverage lists.
+ *
+ * Pattern: one validator, two doors (`absent()` and `coverage()`), so the two
+ *          primitives cannot disagree about what a well-formed piece of
+ *          ground looks like.
+ * Role:    core/ layer, pure. Throws at the CALL SITE (the
+ *          `resolveEvidenceGate` precedent): a malformed declaration is a
+ *          mistake in the line the author just wrote, and the stack should
+ *          say so — not fail on the first absence of the first incident.
+ * Emits:   N/A.
+ */
+import type { CoverageInput, CoverageItem } from './types.js';
+/** Section names, as the author spells them — used verbatim in refusals. */
+export type CoverageSection = 'checked' | 'notChecked' | 'cannotCover';
+/** The closed kind vocabulary — `CoverageItem.kind`, named for this file. */
+export type CoverageKind = NonNullable<CoverageItem['kind']>;
+/** The longest `short` a report prints on one line. */
+export declare const MAX_SHORT_CHARS = 80;
+/** The item keys that are RECORD-ONLY — never served to the model, never
+ *  evidence. `read.ts` · `servedToModel` and `evidence.ts` remove these. */
+export declare const RECORD_ONLY_ITEM_KEYS: readonly string[];
+/** What is wrong with a `short`, or `undefined` when it is fine. `what` is the
+ *  item's own (trimmed) `what`. */
+export declare function shortProblem(short: unknown, what: string): string | undefined;
+/** The record-only extras a well-formed item may carry. */
+export interface CoverageItemExtras {
+    readonly short?: string;
+    readonly kind?: CoverageKind;
+}
+/**
+ * The item's `short` / `kind`, when each is valid — the NON-throwing reader
+ * every dispatch door uses (`../../core/agent/stages/toolCalls.ts` · `declareCoverage`'s
+ * copy), so the event and the tracked row carry the same fields.
+ *
+ * An invalid value is DROPPED, never repaired, and named once per tool in dev
+ * mode: an envelope minted elsewhere (a Python sidecar, a hand-built value)
+ * is read as found, and the absence it carries is still an absence either
+ * way. `{}` when the item declares neither — so a spread of it adds no key.
+ */
+export declare function readItemExtras(item: unknown, section: CoverageSection, toolName?: string): CoverageItemExtras;
+/**
+ * One coverage list with the record-only keys removed from every item that
+ * has one — the SAME reference when no item has one (the zero-cost law: a
+ * run whose tools declare neither serves exactly the value it always did).
+ * Anything that is not an array, and any item that is not an object, is left
+ * as found.
+ */
+export declare function listWithoutRecordOnly(list: unknown): unknown;
+/**
+ * The keys a {@link CoverageDeclaration} has — the three lists, as the author
+ * spells them — tied to the type in BOTH directions: a key the interface
+ * gains, or one listed here that it does not have, fails to compile.
+ * `coverage()` and a `describedResult()` declaration's
+ * `coverage` refuse any other
+ * key (`refusal.ts` · `refuseUnknownKeys`), so `not_checked` is refused,
+ * naming `notChecked`, instead of vanishing.
+ */
+export declare const COVERAGE_DECLARATION_KEYS: readonly string[];
+/**
+ * Normalize one author list into {@link CoverageItem}s, refusing anything a
+ * reader could not act on. Every refusal starts with `refusal.ts` ·
+ * `REFUSED_PREFIX` and names the list and index, never the helper.
+ *
+ * `requireWhy` is true only for `cannotCover`. The asymmetry is deliberate:
+ * "we checked the fcns database" and "we did not check the archive" are
+ * complete statements on their own, but "this tool can never see host-side
+ * multipathing" is a claim about capability — and a permanent blind spot with
+ * no reason attached cannot be acted on, escalated, or disproved. It is also
+ * the one an operator is most likely to want to fix, so the reason is the
+ * useful half.
+ */
+export declare function normalizeCoverageList(section: CoverageSection, list: readonly CoverageInput[] | undefined, requireWhy: boolean): readonly CoverageItem[];
+/** Two entries are the same ground when they say the same two things. Used to
+ *  fold the run's declarations into ONE answer-level block: five tools that
+ *  all name the same missing collector should say it once. */
+export declare function sameItem(a: CoverageItem, b: CoverageItem): boolean;
+/** Merge lists in declaration order, dropping repeats. Order is the run's own
+ *  order on purpose — it is the only ordering that means anything here. */
+export declare function mergeItems(lists: ReadonlyArray<readonly CoverageItem[]>): readonly CoverageItem[];
+/**
+ * `holder` (an envelope or a ledger marker) with each wire list stripped of
+ * the record-only keys — the SAME reference when none of its lists carried
+ * one. The one helper `read.ts` · `servedToModel` (what the model is served)
+ * and `evidence.ts` (what may ground) both use, so the two cannot disagree
+ * about which keys are record-only.
+ */
+export declare function listsWithoutRecordOnly<T extends object>(holder: T): T;
+//# sourceMappingURL=items.d.ts.map

package/dist/types/semantics/coverage/items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/items.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAuB,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEnF,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,YAAY,GAAG,aAAa,CAAC;AAavE,6EAA6E;AAC7E,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;AAE7D,uDAAuD;AACvD,eAAO,MAAM,eAAe,KAAK,CAAC;AASlC;4EAC4E;AAC5E,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAAsB,CAAC;AAE1E;mCACmC;AACnC,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAc7E;AAgBD,2DAA2D;AAC3D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;CAC9B;AAYD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,eAAe,EACxB,QAAQ,CAAC,EAAE,MAAM,GAChB,kBAAkB,CAuBpB;AAcD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAmB5D;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,MAAM,EAIH,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,SAAS,EAC1C,UAAU,EAAE,OAAO,GAClB,SAAS,YAAY,EAAE,CA+DzB;AAED;;8DAE8D;AAC9D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CAElE;AAED;2EAC2E;AAC3E,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,SAAS,YAAY,EAAE,CAAC,GAAG,SAAS,YAAY,EAAE,CAQjG;AASD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAUrE"}

package/dist/types/semantics/coverage/ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAMH,OAAO,KAAK,EAAE,QAAQ,EAAE,yBAAyB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAoBrF,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,QAKc,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,yBAAyB,GAAG,aAAa,CAAC,CAAC,CAAC,CAsDzF;AAED,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,QAAQ,CAOjE"}