@tangle-network/agent-eval 0.94.0 → 0.95.0

package/dist/{dataset-BbGkaN2I.d.ts → dataset.d.ts}

@@ -1,5 +1,3 @@
-import { V as ValidationError } from './errors-CzMUYo7b.js';
-
 /**
  * Dataset — versioned, sliceable, content-hashed scenario collection.
  *
@@ -16,9 +14,9 @@ import { V as ValidationError } from './errors-CzMUYo7b.js';
  * can read them but `mutate` throws, which prevents "oh I'll just
  * tweak that one scenario" contamination drift.
  */
-type DatasetSplit = 'train' | 'dev' | 'test' | 'holdout';
-type DatasetDifficulty = 'easy' | 'medium' | 'hard' | 'extreme';
-interface DatasetScenario {
+export type DatasetSplit = 'train' | 'dev' | 'test' | 'holdout';
+export type DatasetDifficulty = 'easy' | 'medium' | 'hard' | 'extreme';
+export interface DatasetScenario {
     id: string;
     /** Arbitrary payload; the framework doesn't interpret it. */
     payload: unknown;
@@ -38,7 +36,7 @@ interface DatasetScenario {
     forbiddenPattern?: string;
     tags?: Record<string, string>;
 }
-interface DatasetProvenance {
+export interface DatasetProvenance {
     contributor?: string;
     createdAt: string;
     sourceUrl?: string;
@@ -47,7 +45,7 @@ interface DatasetProvenance {
     /** Monotonic human-readable version (e.g. "2026.04.20"). */
     version: string;
 }
-interface DatasetManifest {
+export interface DatasetManifest {
     name: string;
     provenance: DatasetProvenance;
     /** sha256 hex over canonicalized scenarios. */
@@ -55,7 +53,7 @@ interface DatasetManifest {
     scenarioCount: number;
     splitCounts: Record<DatasetSplit, number>;
 }
-interface SliceOptions {
+export interface SliceOptions {
     split?: DatasetSplit;
     difficulty?: DatasetDifficulty;
     /** Number of scenarios (random sample, seeded). Omit to take all that match. */
@@ -66,12 +64,12 @@ interface SliceOptions {
     /** If true, include scenarios marked as holdout. Default false. */
     includeHoldout?: boolean;
 }
-
+import { ValidationError } from './errors';
 /** Locked holdouts — throws on mutate. Callers that need a mutable dataset fork it. */
-declare class HoldoutLockedError extends ValidationError {
+export declare class HoldoutLockedError extends ValidationError {
     constructor(datasetName: string);
 }
-declare class Dataset {
+export declare class Dataset {
     readonly name: string;
     readonly provenance: DatasetProvenance;
     private scenarios;
@@ -110,6 +108,5 @@ declare class Dataset {
     toJsonl(): string;
     static fromJsonl(jsonl: string, manifest: Omit<DatasetManifest, 'contentHash' | 'scenarioCount' | 'splitCounts'>): Dataset;
 }
-declare function hashScenarios(scenarios: DatasetScenario[]): Promise<string>;
-
-export { type DatasetSplit as D, HoldoutLockedError as H, type SliceOptions as S, type DatasetScenario as a, Dataset as b, type DatasetManifest as c, type DatasetDifficulty as d, type DatasetProvenance as e, hashScenarios as h };
+export declare function hashScenarios(scenarios: DatasetScenario[]): Promise<string>;
+//# sourceMappingURL=dataset.d.ts.map

package/dist/dataset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.d.ts","sourceRoot":"","sources":["../src/dataset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,CAAA;AAC/D,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAA;AAEtE,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,iBAAiB,CAAA;IAC7B,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAA;CAC1C;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAA;IAC/C,mEAAmE;IACnE,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,uFAAuF;AACvF,qBAAa,kBAAmB,SAAQ,eAAe;gBACzC,WAAW,EAAE,MAAM;CAKhC;AAED,qBAAa,OAAO;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;IACtC,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,MAAM,CAAS;gBAEX,IAAI,EAAE;QAChB,IAAI,EAAE,MAAM,CAAA;QACZ,UAAU,EAAE,iBAAiB,CAAA;QAC7B,SAAS,EAAE,eAAe,EAAE,CAAA;QAC5B,MAAM,CAAC,EAAE,OAAO,CAAA;KACjB;IAOD,4EAA4E;IAC5E,GAAG,IAAI,SAAS,eAAe,EAAE;IAIjC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,eAAe,EAAE;IAiBpD;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,eAAe,CAAC;IAe1C,4EAA4E;IAC5E,KAAK,CAAC,SAAS,GAAE,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAM,GAAG,OAAO;IAW1E,IAAI,IAAI,IAAI;IAIZ,GAAG,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAQpC,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOhC;;;OAGG;IACH,OAAO,IAAI,MAAM;IAQjB,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,aAAa,GAAG,eAAe,GAAG,aAAa,CAAC,GAC/E,OAAO;CASX;AAID,wBAAsB,aAAa,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAWjF"}

package/dist/deploy-gate-layer.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Deploy gate layer — would the agent's build actually publish?
+ *
+ * The product Blueprint Agent fronts promises "go from idea to live URL."
+ * Pre-Gen-48 the eval stopped at install/typecheck/build/serve — every
+ * one of which can pass while `vite build` (or `next build`, etc) fails
+ * on a production-only constraint (env-var requirement, dynamic import
+ * not statically resolvable, missing public asset).
+ *
+ * Deploy gate runs the production build via the supplied {@link DeployRunner}
+ * and asserts:
+ *   - command exited 0
+ *   - artifact dir contains an entry point (index.html for static SPAs,
+ *     equivalent per framework family)
+ *
+ * Ships with a canonical `vite` runner. Additional runners
+ * (wrangler-deploy --dry-run, next-build, etc.) plug in as factories.
+ */
+import type { Layer } from './multi-layer-verifier';
+export type DeployFamily = 'frontend-static' | 'nextjs' | 'remix' | 'fullstack-ts';
+export interface DeployRunResult {
+    ok: boolean;
+    /** Stdout/stderr tail surfaced as evidence. Bounded in caller. */
+    output?: string;
+    /** Wall-clock duration of the build command. */
+    durationMs?: number;
+    /** Path to artifact directory the runner expects (dist/, .next/, build/, etc). */
+    artifactDir?: string;
+    /** True iff artifactDir contains the family's expected entry point. */
+    artifactValid?: boolean;
+}
+export interface DeployRunner {
+    /** Run the production build. The runner owns command + cwd. */
+    run(): Promise<DeployRunResult>;
+}
+export interface DeployGateLayerInput {
+    /** Build the runner per call. */
+    runner: () => DeployRunner | Promise<DeployRunner>;
+    /** Family hint — for logging, surfaced in diagnostics. */
+    family?: DeployFamily;
+    /** Layer name. Default `deploy`. */
+    name?: string;
+    /** Layer dependencies — default `['build']`. */
+    dependsOn?: string[];
+    /** Weight in blendedScore. Default 1. */
+    weight?: number;
+    /** Cap (ms). Default 120s — prod builds are slower than dev. */
+    capMs?: number;
+    /** When true, treat artifactValid=false as a fail (default true). */
+    requireArtifact?: boolean;
+}
+/**
+ * Build a deploy gate layer that runs the production build and verifies
+ * the artifact. Pass: ok && artifactValid. Score: 1.0 (pass) or 0 (fail).
+ *
+ * For families where artifact-validation isn't applicable (e.g. a
+ * server-rendered build that prints a manifest), set `requireArtifact:
+ * false` and rely on the runner's own ok signal.
+ */
+export declare function deployGateLayer<Env = unknown>(input: DeployGateLayerInput): Layer<Env>;
+export interface ViteDeployRunnerInput {
+    /** Workdir to build. The runner cd's here. */
+    workdir: string;
+    /**
+     * Function to run a shell command in `workdir`. Same shape as
+     * agent-eval's CommandRunner.run for compositional reuse.
+     */
+    exec: (cmd: string, opts?: {
+        cwd?: string;
+        timeoutMs?: number;
+    }) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    /**
+     * Function to test whether a path exists in the workdir. Inject
+     * `(p) => existsSync(join(workdir, p))` for host runs.
+     */
+    exists: (relativePath: string) => boolean | Promise<boolean>;
+    /** Build command. Default `npm run build`. */
+    buildCommand?: string;
+    /** Artifact directory to validate. Default `dist`. */
+    artifactDir?: string;
+    /** Entry-point file under artifactDir. Default `index.html`. */
+    artifactEntry?: string;
+    /** Per-build cap (ms). Default 90s. */
+    timeoutMs?: number;
+}
+/**
+ * Canonical runner for `frontend-static` family — runs the build script,
+ * validates `<artifactDir>/<artifactEntry>` exists. Use as the `runner:`
+ * factory for {@link deployGateLayer}.
+ */
+export declare function viteDeployRunner(input: ViteDeployRunnerInput): DeployRunner;
+export interface WranglerDeployRunnerInput {
+    workdir: string;
+    exec: (cmd: string, opts?: {
+        cwd?: string;
+        timeoutMs?: number;
+    }) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    exists: (relativePath: string) => boolean | Promise<boolean>;
+    /** Build command. Default `npm run build`. */
+    buildCommand?: string;
+    /** Wrangler dry-run command. Default `npx wrangler deploy --dry-run --outdir dist`. */
+    dryRunCommand?: string;
+    /** Per-step cap (ms). Default 120s. */
+    timeoutMs?: number;
+}
+/**
+ * Canonical runner for the `fullstack-ts` family on Cloudflare Workers
+ * (Remix / React Router v7 / Hono on Workers). Detects wrangler.toml or
+ * wrangler.jsonc in the workdir, builds, then `wrangler deploy --dry-run`
+ * to catch missing bindings, syntax errors in wrangler config, and
+ * import-time crashes that don't surface in `tsc`.
+ *
+ * No wrangler config = skip with "no wrangler" evidence (not a failure
+ * — the gate caller decides whether to require deploy validation).
+ */
+export declare function wranglerDeployRunner(input: WranglerDeployRunnerInput): DeployRunner;
+//# sourceMappingURL=deploy-gate-layer.d.ts.map

package/dist/deploy-gate-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-gate-layer.d.ts","sourceRoot":"","sources":["../src/deploy-gate-layer.ts"],"names":[],"mappings":"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"}

package/dist/deploy-gate-layer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deploy-gate-layer.test.d.ts.map

package/dist/deploy-gate-layer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-gate-layer.test.d.ts","sourceRoot":"","sources":["../src/deploy-gate-layer.test.ts"],"names":[],"mappings":""}

package/dist/description-length-gate.d.ts

@@ -0,0 +1,119 @@
+import type { RunRecord } from './run-record';
+/**
+ * DescriptionLengthGate — a Minimum-Description-Length promotion gate, the
+ * Builder/Breaker acceptance rule from Wang & Buehler, "Self-Revising Discovery
+ * Systems for Science" (arXiv:2606.01444, MIT LAMM), eq. 5:
+ *
+ *     L(M, D) = L_model(M) + L_data(D | M)
+ *     accept M' over M  iff  L(M', D∪E) < L(M, D∪E)
+ *
+ * Both candidate and baseline are scored on the SAME enlarged evidence set
+ * (every accumulated task — NOT just the held-out split), and the candidate is
+ * accepted only if it lowers the TOTAL bit cost. This is the gate's whole
+ * point and what distinguishes it from a monotone held-out delta:
+ *
+ *   - L_model(M)  — the candidate's own description length: the compressed size
+ *     of its model text (a prompt, skill, profile, or symbolic model). A bigger
+ *     model pays more bits.
+ *   - L_data(D|M) — the residual: bits of "surprise" that the model did not
+ *     simply succeed, −Σ_i log2(s_i) over the model's per-task score s_i.
+ *     Perfect scores cost 0 bits; failure costs a lot (capped, not infinite).
+ *
+ * A candidate that merely memorizes new counterexamples grows L_model faster
+ * than it shrinks L_data and LOSES — a principled, complexity-penalized
+ * alternative to HeldOutGate's held-out paired delta. Use this gate
+ * when the model text whose size you want to penalize is available; use
+ * HeldOutGate when promotion should turn on held-out generalization with an
+ * overfit-gap check instead.
+ *
+ * Scale / calibration: a gzip'd prose model is hundreds–thousands of bits;
+ * a single task contributes at most −log2(scoreFloor) data bits (≈10). So with
+ * little evidence the model term dominates and the gate is conservative about
+ * model GROWTH — it promotes a larger model only once accumulated evidence
+ * genuinely pays for the added bits (exactly the paper's regime, where D∪E
+ * grows). `lambda` is the lever: λ<1 discounts model bits (more permissive),
+ * λ>1 is stricter. A shrinking-or-equal model that does no worse always wins.
+ *
+ * Stateless: construct once with the description-length budget, call
+ * `evaluate` per (candidate, baseline) pair.
+ */
+export type DescriptionLengthRejectionCode = 'few_tasks' | 'no_total_gain' | 'model_bloat';
+export interface DescriptionLengthConfig {
+    /** Stable label of the baseline. Required — paper-grade evaluation never
+     *  compares two unlabelled candidates. */
+    baselineKey: string;
+    /** Weight on model bits relative to data bits (the description-length
+     *  budget λ). 1 = bits are bits. >1 = more complexity-averse. Default 1. */
+    lambda?: number;
+    /** The candidate must beat the baseline by at least this many bits to
+     *  promote — a robustness margin against measurement noise. Default 0
+     *  (strict `<`, as the paper). */
+    marginBits?: number;
+    /** Per-task score floor for the residual code: −log2(max(s, floor)). Caps a
+     *  total-failure task's surprise instead of letting it diverge. Default
+     *  2^-10 (a failed task costs 10 bits, not ∞). */
+    scoreFloor?: number;
+    /** Minimum number of shared (candidate, baseline) tasks before the gate will
+     *  consider promoting. Default 3. */
+    minTasks?: number;
+}
+export interface DescriptionLengthEvidence {
+    /** Shared tasks scored on both sides (the enlarged evidence D∪E). */
+    tasks: number;
+    /** Compressed-model bits — L_model. */
+    modelBits: {
+        candidate: number;
+        baseline: number;
+    };
+    /** Residual surprise bits — L_data(D|M). */
+    dataBits: {
+        candidate: number;
+        baseline: number;
+    };
+    /** λ·L_model + L_data — the quantity the gate minimizes. */
+    totalBits: {
+        candidate: number;
+        baseline: number;
+    };
+    /** candidate − baseline total. Negative = candidate compresses better. */
+    deltaBits: number;
+    /** Per-component deltas, for audit: did the win come from a smaller model,
+     *  better outcomes, or both? */
+    modelBitsDelta: number;
+    dataBitsDelta: number;
+}
+export interface DescriptionLengthDecision {
+    promote: boolean;
+    candidateId: string;
+    baselineId: string;
+    evidence: DescriptionLengthEvidence;
+    reason: string;
+    rejectionCode: DescriptionLengthRejectionCode | null;
+}
+export interface DescriptionLengthCandidate {
+    /** The model text whose size is L_model (a prompt, skill, profile, or
+     *  symbolic model; concatenated if several files). */
+    content: string;
+    /** Runs whose per-task scores form L_data. */
+    runs: RunRecord[];
+}
+/** Compressed-model bits — the model's description length L_model. gzip is a
+ *  deterministic, dependency-free stand-in for Kolmogorov complexity; it
+ *  rewards genuine compactness and penalizes boilerplate padding. */
+export declare function modelDescriptionBits(content: string): number;
+/** Residual surprise L_data(D|M) = −Σ_i log2(max(s_i, floor)) over the given
+ *  per-task scores. Lower = the model more reliably succeeds. */
+export declare function dataDescriptionBits(scoreByTask: Map<string, number>, keys: Iterable<string>, scoreFloor: number): number;
+export declare class DescriptionLengthGate {
+    private readonly baselineKey;
+    private readonly lambda;
+    private readonly marginBits;
+    private readonly scoreFloor;
+    private readonly minTasks;
+    constructor(config: DescriptionLengthConfig);
+    /** Decide whether `candidate` should replace `baseline`. Both are scored on
+     *  the shared task set (the enlarged evidence); the candidate promotes only
+     *  if λ·L_model + L_data is strictly lower by at least `marginBits`. */
+    evaluate(candidate: DescriptionLengthCandidate, baseline: DescriptionLengthCandidate): DescriptionLengthDecision;
+}
+//# sourceMappingURL=description-length-gate.d.ts.map

package/dist/description-length-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"description-length-gate.d.ts","sourceRoot":"","sources":["../src/description-length-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,MAAM,MAAM,8BAA8B,GAAG,WAAW,GAAG,eAAe,GAAG,aAAa,CAAA;AAE1F,MAAM,WAAW,uBAAuB;IACtC;8CAC0C;IAC1C,WAAW,EAAE,MAAM,CAAA;IACnB;gFAC4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;sCAEkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;sDAEkD;IAClD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;yCACqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,yBAAyB;IACxC,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAA;IACb,uCAAuC;IACvC,SAAS,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAClD,4CAA4C;IAC5C,QAAQ,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IACjD,4DAA4D;IAC5D,SAAS,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAClD,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAA;IACjB;oCACgC;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,yBAAyB,CAAA;IACnC,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,8BAA8B,GAAG,IAAI,CAAA;CACrD;AAED,MAAM,WAAW,0BAA0B;IACzC;0DACsD;IACtD,OAAO,EAAE,MAAM,CAAA;IACf,8CAA8C;IAC9C,IAAI,EAAE,SAAS,EAAE,CAAA;CAClB;AA8BD;;qEAEqE;AACrE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;iEACiE;AACjE,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EACtB,UAAU,EAAE,MAAM,GACjB,MAAM,CAQR;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,MAAM,EAAE,uBAAuB;IAY3C;;4EAEwE;IACxE,QAAQ,CACN,SAAS,EAAE,0BAA0B,EACrC,QAAQ,EAAE,0BAA0B,GACnC,yBAAyB;CA+D7B"}

package/dist/detectors/edge.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=edge.test.d.ts.map

package/dist/detectors/edge.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.test.d.ts","sourceRoot":"","sources":["../../src/detectors/edge.test.ts"],"names":[],"mappings":""}

package/dist/detectors/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Streaming detectors — the canonical, online failure-mode kernel.
+ *
+ * A `StreamingDetector` is a pure incremental reducer: fold one normalized step, get a signal the
+ * moment a threshold trips (else null). The SAME kernel runs in two places, so the logic lives once:
+ *   - ONLINE, over a live agent pipe (a worker's tool-call stream) → raise a finding mid-run.
+ *   - INSIDE the control loop (`control-runtime`) → its `stopOn*` policies fold these detectors.
+ *
+ * Detectors are stateful but self-contained; `streak` is exposed for telemetry and `reset` clears it.
+ * Fingerprinting is the CALLER's job — the control loop hashes state/action with `stableFingerprint`,
+ * a tool-call pipe hashes args with `argHash` — so a detector stays agnostic to what it's watching.
+ */
+import type { FailureClass } from '../trace/schema';
+export type DetectorSeverity = 'info' | 'warn' | 'critical';
+/** A normalized step a detector folds over. Fields are optional; each detector reads only what it
+ *  needs (repeated-action → `actionFingerprint`; no-progress → `stateFingerprint` + `score`;
+ *  error-streak → `status`). */
+export interface DetectorEvent {
+    /** Fingerprint of the action/tool-call this step took (caller pre-hashes). */
+    readonly actionFingerprint?: string;
+    /** Fingerprint of observable state AFTER this step. */
+    readonly stateFingerprint?: string;
+    /** Score after this step (the score-flat half of no-progress). */
+    readonly score?: number;
+    /** Whether this step errored. */
+    readonly status?: 'ok' | 'error';
+    /** Free-form label carried into the signal evidence (e.g. the tool name). */
+    readonly label?: string;
+}
+export interface DetectorSignal {
+    readonly detector: string;
+    readonly severity: DetectorSeverity;
+    readonly failureClass?: FailureClass;
+    readonly reason: string;
+    /** Consecutive matching steps at the moment the signal fired. */
+    readonly streak: number;
+    readonly evidence?: Record<string, unknown>;
+}
+export interface StreamingDetector {
+    readonly id: string;
+    /** Current streak (consecutive matching steps) — for telemetry/introspection between observes. */
+    readonly streak: number;
+    /** Fold one event; return a signal when the threshold trips, else null. */
+    observe(event: DetectorEvent): DetectorSignal | null;
+    /** Clear all state. */
+    reset(): void;
+}
+export interface RepeatedActionOptions {
+    /** Signal once the same action fingerprint repeats this many CONSECUTIVE steps (default 3).
+     *  `<= 0` disables the signal (the streak is still tracked, for telemetry). */
+    readonly maxRepeated?: number;
+    readonly severity?: DetectorSeverity;
+    /** Failure class to stamp on the signal (default `tool_recovery_failure`). */
+    readonly failureClass?: FailureClass;
+}
+/** Same action fingerprint N consecutive steps = a stuck loop (the #1 long-horizon failure mode). */
+export declare function repeatedActionDetector(opts?: RepeatedActionOptions): StreamingDetector;
+export interface NoProgressOptions {
+    /** Signal once state is unchanged AND score is flat for this many CONSECUTIVE steps (default 3).
+     *  `<= 0` disables the signal. */
+    readonly maxNoProgress?: number;
+    /** Minimum |score change| that counts as progress (default 0.001). */
+    readonly minScoreDelta?: number;
+    readonly severity?: DetectorSeverity;
+    readonly failureClass?: FailureClass;
+}
+/** State + score unchanged across N steps = spinning wheels. Compares each step to the previous one,
+ *  so prime with the initial state (observe it once before the first real step) to detect on step 1. */
+export declare function noProgressDetector(opts?: NoProgressOptions): StreamingDetector;
+export interface ErrorStreakOptions {
+    /** Signal once this many CONSECUTIVE steps errored (default 3). `<= 0` disables. */
+    readonly maxErrors?: number;
+    readonly severity?: DetectorSeverity;
+    readonly failureClass?: FailureClass;
+}
+/** N consecutive tool errors = the worker is hammering a broken approach. */
+export declare function errorStreakDetector(opts?: ErrorStreakOptions): StreamingDetector;
+/** Fold one event through many detectors at once; returns every signal that fired this step. The
+ *  natural shape for an online pipe watching with a whole panel of detectors. */
+export declare function observeAll(detectors: ReadonlyArray<StreamingDetector>, event: DetectorEvent): DetectorSignal[];
+//# sourceMappingURL=index.d.ts.map

package/dist/detectors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detectors/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAA;AAE3D;;gCAEgC;AAChC,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;IACnC,uDAAuD;IACvD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAClC,kEAAkE;IAClE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,iCAAiC;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,GAAG,OAAO,CAAA;IAChC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAA;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC5C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,kGAAkG;IAClG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,2EAA2E;IAC3E,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,GAAG,IAAI,CAAA;IACpD,uBAAuB;IACvB,KAAK,IAAI,IAAI,CAAA;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC;mFAC+E;IAC/E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAA;IACpC,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAA;CACrC;AAED,qGAAqG;AACrG,wBAAgB,sBAAsB,CAAC,IAAI,GAAE,qBAA0B,GAAG,iBAAiB,CA+B1F;AAED,MAAM,WAAW,iBAAiB;IAChC;sCACkC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAA;IACpC,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAA;CACrC;AAED;wGACwG;AACxG,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,iBAAsB,GAAG,iBAAiB,CAmClF;AAED,MAAM,WAAW,kBAAkB;IACjC,oFAAoF;IACpF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAA;IACpC,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAA;CACrC;AAED,6EAA6E;AAC7E,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,kBAAuB,GAAG,iBAAiB,CA2BpF;AAED;iFACiF;AACjF,wBAAgB,UAAU,CACxB,SAAS,EAAE,aAAa,CAAC,iBAAiB,CAAC,EAC3C,KAAK,EAAE,aAAa,GACnB,cAAc,EAAE,CAOlB"}

package/dist/detectors/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/detectors/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/detectors/index.test.ts"],"names":[],"mappings":""}

package/dist/diagnose/causal-sweep.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Causal sweep — WHY did this run fail?
+ *
+ * Orchestrates the dormant counterfactual primitives into a responsibility
+ * report: for each candidate step, run `reps` counterfactual replays per
+ * mutation (via `runCounterfactual` — the consumer's `CounterfactualRunner`
+ * is the execution seam) and reduce the per-rep score deltas into a mean
+ * effect + bootstrap confidence interval (via `confidenceInterval`).
+ *
+ * Why `reps` is REQUIRED: a single intervention delta is one stochastic
+ * draw — LLM re-execution from a prefix is sampled, so one replay cannot
+ * distinguish "this step caused the failure" from sampling noise. The
+ * signal is the distribution of deltas across reps; the CI over that
+ * distribution is what lets a caller say "this step's effect excludes
+ * zero" instead of eyeballing a point estimate.
+ *
+ * Budget discipline: the sweep never silently drops cells. When the
+ * remaining budget cannot fund a full `reps`-sized cell, the sweep halts
+ * and every step not fully probed is named in `uncovered`.
+ */
+import { attributeCounterfactuals, type CounterfactualMutation, type CounterfactualRunner } from '../counterfactual';
+import type { Span } from '../trace/schema';
+import type { TraceStore } from '../trace/store';
+import { type TrajectoryStep } from '../trajectory';
+/** Stable reference to a trajectory step — carried through reports,
+ *  findings, and corpus records so evidence stays addressable. */
+export interface StepRef {
+    index: number;
+    spanId: string;
+    kind: Span['kind'];
+    name: string;
+}
+export declare function stepRefOf(step: TrajectoryStep): StepRef;
+export interface CausalSweepOptions {
+    store: TraceStore;
+    /** The failed run to diagnose. Its `outcome.score` is the baseline every
+     *  counterfactual delta is measured against. */
+    runId: string;
+    /** Execution seam — identical contract to `runCounterfactual`: re-runs the
+     *  agent from the mutation point and MUST `endRun` with a numeric score. */
+    runner: CounterfactualRunner;
+    /** Trajectory indices to probe. Default: every llm + tool span — the kinds
+     *  the existing `CounterfactualMutation` set targets. */
+    candidateSteps?: number[];
+    /**
+     * Mutations to probe a given step with. Returned mutations MUST target
+     * `step.index`. Default probes are the payload-free existing kinds:
+     *   - tool span → `swap-tool-result` with `newResult: null` (knockout:
+     *     how much did the run depend on this tool's information?)
+     *   - llm span → `truncate-after` (re-roll: how much did the realized
+     *     turn deviate from the policy's typical continuation?)
+     * `swap-model` / `inject-system-message` need consumer payloads, so they
+     * are opt-in via this callback.
+     */
+    mutationsPerStep?: (step: TrajectoryStep) => CounterfactualMutation[];
+    /** Replays per (step, mutation) cell. Minimum 2 — see module doc. */
+    reps: number;
+    /** Hard cap on total counterfactual replays across the whole sweep. */
+    budget: number;
+    /** Seed for the bootstrap CI resampler. Deterministic default so two
+     *  sweeps over the same deltas report identical intervals. */
+    ciSeed?: number;
+    /** Bootstrap CI confidence level. Default 0.95. */
+    ciConfidence?: number;
+}
+export interface StepResponsibility {
+    stepRef: StepRef;
+    mutationKind: CounterfactualMutation['kind'];
+    /** Mean of per-rep score deltas (counterfactual − original). */
+    meanEffect: number;
+    /** Bootstrap CI over the per-rep deltas. */
+    ci: {
+        mean: number;
+        lower: number;
+        upper: number;
+    };
+    /** `ci.lower > 0 || ci.upper < 0` — the effect is distinguishable from noise. */
+    ciExcludesZero: boolean;
+    reps: number;
+    /** Raw per-rep deltas — downstream evidence, never re-derived. */
+    deltas: number[];
+    /** Replay run ids (layer='meta', parentRunId=original) for audit. */
+    counterfactualRunIds: string[];
+}
+export interface CausalResponsibilityReport {
+    runId: string;
+    originalScore: number;
+    /** Ranked by |meanEffect| descending — the blame ordering. */
+    steps: StepResponsibility[];
+    /** Kind-level aggregate from the existing `attributeCounterfactuals`. */
+    byMutationKind: ReturnType<typeof attributeCounterfactuals>;
+    replaysUsed: number;
+    budget: number;
+    /** Steps planned but not fully probed before the budget ran out.
+     *  Named, never silent: an absent step is "no effect found"; an
+     *  uncovered step is "not measured". */
+    uncovered: StepRef[];
+}
+export declare function causalSweep(opts: CausalSweepOptions): Promise<CausalResponsibilityReport>;
+//# sourceMappingURL=causal-sweep.d.ts.map

package/dist/diagnose/causal-sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"causal-sweep.d.ts","sourceRoot":"","sources":["../../src/diagnose/causal-sweep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACL,wBAAwB,EACxB,KAAK,sBAAsB,EAE3B,KAAK,oBAAoB,EAE1B,MAAM,mBAAmB,CAAA;AAG1B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAoC,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AAErF;kEACkE;AAClE,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAOvD;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,UAAU,CAAA;IACjB;oDACgD;IAChD,KAAK,EAAE,MAAM,CAAA;IACb;gFAC4E;IAC5E,MAAM,EAAE,oBAAoB,CAAA;IAC5B;6DACyD;IACzD,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,sBAAsB,EAAE,CAAA;IACrE,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAA;IACd;kEAC8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,mDAAmD;IACnD,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAA;IAC5C,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAClD,iFAAiF;IACjF,cAAc,EAAE,OAAO,CAAA;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,kEAAkE;IAClE,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,qEAAqE;IACrE,oBAAoB,EAAE,MAAM,EAAE,CAAA;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,CAAA;IACrB,8DAA8D;IAC9D,KAAK,EAAE,kBAAkB,EAAE,CAAA;IAC3B,yEAAyE;IACzE,cAAc,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;IAC3D,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd;;4CAEwC;IACxC,SAAS,EAAE,OAAO,EAAE,CAAA;CACrB;AAcD,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAmG/F"}

package/dist/diagnose/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Diagnose chain — WHY a run failed, WHAT should have happened, HOW to
+ * make it happen.
+ *
+ * The full remediation pipeline this subpath closes:
+ *
+ *   fuzz finds → sweep blames → repair prescribes (validated) →
+ *   findings / corpus / invariant remediate → gates verify
+ *
+ * Three stages, all orchestration over existing primitives — nothing here
+ * re-implements replay, mutation, or attribution:
+ *
+ *   1. `causalSweep` — WHY. Runs `reps` counterfactual replays per
+ *      (step, mutation) cell through `runCounterfactual` (the consumer's
+ *      `CounterfactualRunner` is the execution seam) and reduces the
+ *      per-rep deltas into a responsibility ranking with bootstrap CIs
+ *      (`confidenceInterval`). Budget-bounded; unprobed steps are named
+ *      in `uncovered`, never dropped.
+ *   2. `prescribeRepair` — WHAT SHOULD HAVE HAPPENED. Consumer-supplied
+ *      `proposeFix` (LLM-backed in live use) proposes candidate mutations
+ *      for the blamed steps; each candidate is machine-verified by
+ *      replaying WITH it. Only candidates whose every validation rep
+ *      crosses `flipThreshold` become repairs; the rest are rejected
+ *      with a typed reason.
+ *   3. Remediation adapters — HOW. `toAnalystFindings` feeds the analyst
+ *      registry, `toCorpusRecord` pins the failure as a permanent corpus
+ *      scenario, `suggestInvariant` emits the trace-contracts hint shape.
+ */
+export type { CounterfactualContext, CounterfactualMutation, CounterfactualResult, CounterfactualRunner, } from '../counterfactual';
+export type { CausalResponsibilityReport, CausalSweepOptions, StepRef, StepResponsibility, } from './causal-sweep';
+export { causalSweep, stepRefOf } from './causal-sweep';
+export type { InvariantHint } from './remediation';
+export { DIAGNOSE_ANALYST_ID, describeMutation, severityFromEffect, suggestInvariant, toAnalystFindings, toCorpusRecord, } from './remediation';
+export type { PrescribeRepairOptions, RejectedRepair, RepairContext, RepairReport, ValidatedRepair, } from './repair';
+export { prescribeRepair } from './repair';
+//# sourceMappingURL=index.d.ts.map

package/dist/diagnose/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/diagnose/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,YAAY,EACV,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,mBAAmB,CAAA;AAC1B,YAAY,EACV,0BAA0B,EAC1B,kBAAkB,EAClB,OAAO,EACP,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACvD,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,GACf,MAAM,eAAe,CAAA;AACtB,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,YAAY,EACZ,eAAe,GAChB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA"}