@tangle-network/agent-eval 0.172.1 → 0.173.0

package/dist/{matrix-Ch8JO1pG.d.ts → matrix-DGu8KhSs.d.ts}

@@ -1,5 +1,5 @@
 import { p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { w as JudgeScore } from "./types-nokrtr7M.js";
+import { w as JudgeScore } from "./types-Ba5UQyVD.js";
 import { o as MatrixResult } from "./index-DNgf5gyG.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/types.d.ts
@@ -398,4 +398,4 @@ interface RunMultishotMatrixResult {
 declare function runMultishotMatrix<TPersona extends MultishotPersona>(opts: RunMultishotMatrixOptions<TPersona>): Promise<RunMultishotMatrixResult>;
 //#endregion
 export { MultishotToolExecutor as A, MultishotFatalToolError as C, MultishotShape as D, MultishotResult as E, assertMultishotShotResult as F, MultishotTransportRequest as M, MultishotTransportResponse as N, MultishotShotResultError as O, MultishotTransportToolCall as P, MultishotDriverEmptyError as S, MultishotPersona as T, JudgeRunResult as _, MultishotCellOutput as a, runJudge as b, RunMultishotMatrixResult as c, MultishotShot as d, RunMultishotOptions as f, JudgeDimension as g, JudgeConfig as h, ConversationJudgeInput as i, MultishotTransport as j, MultishotToolDefinition as k, computeCellComposite as l, DEFAULT_JUDGE_MODEL as m, CellCompositeInput as n, MultishotJudges as o, runMultishot as p, CellCompositeScore as r, RunMultishotMatrixOptions as s, ArtifactJudgeInput as t, runMultishotMatrix as u, renderDimensions as v, MultishotMessage as w, MultishotArtifact as x, renderJsonFooter as y };
-//# sourceMappingURL=matrix-Ch8JO1pG.d.ts.map
+//# sourceMappingURL=matrix-DGu8KhSs.d.ts.map

package/dist/{matrix-Ch8JO1pG.d.ts.map → matrix-DGu8KhSs.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"matrix-Ch8JO1pG.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}
+{"version":3,"file":"matrix-DGu8KhSs.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}

package/dist/meta-eval/index.d.ts

@@ -1,10 +1,10 @@
-import { f as Run } from "../schema-DID1Cqct.js";
+import { f as Run } from "../schema-CR5cpjQ3.js";
 import { a as ContinuousCalibrationResult, n as CandidateScore, o as GoldenItem, r as ContinuousAgreement, t as CalibrationResult } from "../judge-calibration-C5CbMYce.js";
-import { n as SeriesConvergenceResult, o as CorpusAgreementReport, t as SeriesConvergenceOptions } from "../series-convergence-D9WgpXGi.js";
+import { n as SeriesConvergenceResult, o as CorpusAgreementReport, t as SeriesConvergenceOptions } from "../series-convergence-DeG33RpC.js";
 import { r as LedgerHash } from "../canonical-CFpojCN5.js";
-import { s as TraceStore } from "../store-Cq9oOrI1.js";
+import { s as TraceStore } from "../store-BErPvYBr.js";
 import { a as OutcomeFilter, i as InMemoryOutcomeStore, n as FileSystemOutcomeStore, o as OutcomeStore, r as FileSystemOutcomeStoreOptions, t as DeploymentOutcome } from "../outcome-store-BYHIuO0e.js";
-import { a as rubricPredictiveValidity, i as RubricRanking, n as RubricPredictiveValidityInput, r as RubricPredictiveValidityReport, t as RubricOutcomePair } from "../rubric-predictive-validity-DluJLCKQ.js";
+import { a as rubricPredictiveValidity, i as RubricRanking, n as RubricPredictiveValidityInput, r as RubricPredictiveValidityReport, t as RubricOutcomePair } from "../rubric-predictive-validity-Dl1dvKCv.js";
 //#region src/meta-eval/correlation-study.d.ts
 interface EvalMetricSpec {
   id: string;
@@ -130,6 +130,101 @@ declare function definePlant(input: {
   item: GoldenItem;
   expectedVerdict: PlantExpectation;
 }): Plant;
+/**
+ * A claim's executable evidence: the command a grader runs and the output it
+ * must produce.
+ */
+interface PlantEvidence {
+  /** The command a grader runs to test the claim. */
+  check?: string;
+  /** The output that command must produce for the claim to stand. */
+  expect?: string;
+}
+/** Which evidence field {@link perturbEvidence} altered. */
+type PerturbedField = 'check' | 'expect';
+/** How {@link perturbEvidence} altered it. */
+type PerturbationKind = 'number-off-by-one' | 'comparison-flipped';
+interface EvidencePerturbation {
+  /** The evidence with exactly one value altered. */
+  evidence: PlantEvidence;
+  /** Which field changed. */
+  field: PerturbedField;
+  /** How it changed. */
+  how: PerturbationKind;
+  /**
+   * The exact substring that was replaced. A comparison token carries its
+   * surrounding spaces, because the spaces are what make ` -ge ` a comparison
+   * and not part of a word.
+   */
+  original: string;
+  /** What replaced it. */
+  perturbed: string;
+}
+/**
+ * Derive a known-wrong version of a claim's evidence by altering exactly one
+ * value, or return null when no value can be altered safely.
+ *
+ * Exactly one value changes. A perturbation that moves two does not name the
+ * defect it seeded, so a grader that catches it says nothing about which defect
+ * the grader can see.
+ *
+ * The preference order IS the safety order:
+ *
+ * 1. the last standalone number in `expect` — it falsifies the claim while the
+ *    command still runs exactly as it did;
+ * 2. a flipped comparison in `check` — it inverts a test that was passing;
+ * 3. the last standalone number in `check` — last because a number in a command
+ *    can name an input (a port, a width, a version) rather than a threshold,
+ *    and renaming an input breaks execution, not the claim.
+ *
+ * "Standalone" excludes a digit run glued to a word, a dot, a slash, or a
+ * hyphen: `python3`, `file42.txt`, `1.5`, `utf-8`. That exclusion is why this
+ * helper exists. Hand-rolled perturbation bumps one of those, the check stops
+ * executing, and the plant measures the environment instead of the grader.
+ *
+ * A number is bumped with BigInt, so a value wider than
+ * `Number.MAX_SAFE_INTEGER` moves by exactly one. Bumped as a `number` it
+ * rounds back to itself, and the plant is then a correct claim the grader is
+ * right to verify.
+ */
+declare function perturbEvidence(evidence: PlantEvidence): EvidencePerturbation | null;
+interface PerturbedPlant {
+  plant: Plant;
+  /** The perturbed evidence to write into the item the grader is handed. */
+  evidence: PlantEvidence;
+  field: PerturbedField;
+  how: PerturbationKind;
+  original: string;
+  perturbed: string;
+}
+/**
+ * Derive a reject-direction plant from a claim a grader verified, by perturbing
+ * one value.
+ *
+ * {@link definePlant} takes a {@link GoldenItem} and never authors a wrong item
+ * from a right one, so until now every caller hand-rolled the perturbation.
+ * This is that step, done once and the same way every time: the claim's
+ * evidence is altered by {@link perturbEvidence}, the result is a `wrong-value`
+ * plant the grader owes a `reject`, and the record itself is built by
+ * `definePlant` so every refusal there still applies — in particular the one
+ * that catches an `expectedVerdict` its `humanScore` contradicts.
+ *
+ * Returns null when nothing in the evidence can be perturbed. That is not a
+ * failure: a claim with no executable evidence cannot be made wrong in a way a
+ * grader could execute, and seeding it would measure prose.
+ *
+ * Refuses an empty `id` or `itemId`. Both name the record — one in the manifest
+ * and in `missedIds`, the other in the join with the results — and a miss
+ * nobody can look up is not a measurement.
+ */
+declare function plantByPerturbation(input: {
+  id: string;
+  itemId: string;
+  evidence: PlantEvidence;
+  /** Score for the perturbed item. Must sit below the run's accept threshold. Default 0. */
+  humanScore?: number;
+  group?: string;
+}): PerturbedPlant | null;
 interface PlantManifest {
   /**
    * Digest over the seeded order, the plants, and the threshold. Publish it
@@ -375,5 +470,5 @@ interface EvalHealthStamp {
  */
 declare function evalHealthStamp(report: SentinelReport): EvalHealthStamp;
 //#endregion
-export { CalibrationBin, CalibrationOptions, CalibrationPair, CalibrationReport, CatchRateReport, CatchRateStatus, CorrelationResult, CorrelationStudyOptions, CorrelationStudyResult, DeploymentOutcome, EvalHealthStamp, EvalMetricSpec, FileSystemOutcomeStore, FileSystemOutcomeStoreOptions, InMemoryOutcomeStore, JudgeSentinelOptions, OutcomeFilter, OutcomePair, OutcomeStore, Plant, PlantExpectation, PlantKind, PlantKindCounts, PlantManifest, PlantOutcome, RubricOutcomePair, RubricPredictiveValidityInput, RubricPredictiveValidityReport, RubricRanking, SeedPlantsOptions, SeededGradingSet, SentinelMetricName, SentinelMetrics, SentinelReport, SentinelSetOptions, SentinelSnapshot, SentinelStore, SentinelThresholds, SentinelTrend, SnapshotMeta, UnseededRejection, calibrationCurve, catchRate, correlationStudy, definePlant, evalHealthStamp, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, rubricPredictiveValidity, seedPlants, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot };
+export { CalibrationBin, CalibrationOptions, CalibrationPair, CalibrationReport, CatchRateReport, CatchRateStatus, CorrelationResult, CorrelationStudyOptions, CorrelationStudyResult, DeploymentOutcome, EvalHealthStamp, EvalMetricSpec, EvidencePerturbation, FileSystemOutcomeStore, FileSystemOutcomeStoreOptions, InMemoryOutcomeStore, JudgeSentinelOptions, OutcomeFilter, OutcomePair, OutcomeStore, PerturbationKind, PerturbedField, PerturbedPlant, Plant, PlantEvidence, PlantExpectation, PlantKind, PlantKindCounts, PlantManifest, PlantOutcome, RubricOutcomePair, RubricPredictiveValidityInput, RubricPredictiveValidityReport, RubricRanking, SeedPlantsOptions, SeededGradingSet, SentinelMetricName, SentinelMetrics, SentinelReport, SentinelSetOptions, SentinelSnapshot, SentinelStore, SentinelThresholds, SentinelTrend, SnapshotMeta, UnseededRejection, calibrationCurve, catchRate, correlationStudy, definePlant, evalHealthStamp, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, perturbEvidence, plantByPerturbation, rubricPredictiveValidity, seedPlants, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot };
 //# sourceMappingURL=index.d.ts.map

package/dist/meta-eval/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/meta-eval/correlation-study.ts","../../src/meta-eval/calibration.ts","../../src/meta-eval/plants.ts","../../src/meta-eval/sentinel.ts"],"mappings":";;;;;;;;UAkBiB;EACf;;;EAGA,WAAW,KAAK,KAAK,OAAO,eAAe;;UAG5B;EACf;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;EAEA;IAAe;IAAe;;;EAE9B;;UAGe;EACf,OAAO;EACP;EACA;;UAGe;;EAEf;;EAEA,gBAAgB;;EAEhB;;EAEA;;;EAGA;;iBAGoB,iBACpB,YAAY,YACZ,cAAc,cACd,aAAa,kBACb,8BACA,UAAS,0BACR,QAAQ;;;UCtDM;EACf;EACA;EACA;EACA;EACA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,MAAM;;EAEN;;EAEA;;UAGe;EACf;;EAEA;;EAEA;IAAU;IAAY;;;UAGP;EACf;EACA;;iBAGoB,iBACpB,YAAY,YACZ,cAAc,cACd,YAAY,gBACZ,uBACA,UAAS,qBACR,QAAQ;;;;;;;;KCDC;;;;;;;;;;KAkBA;UAOK;;EAEf;EACA,MAAM;;EAEN,MAAM;;EAEN,iBAAiB;;;;;;;;;;;;;;iBAeH,YAAY;EAC1B;EACA,MAAM;EACN,MAAM;EACN,iBAAiB;IACf;UAiDa;;;;;;EAMf,MAAM;;EAEN;;EAEA;;EAEA;;EAEA,QAAQ;;UAGO;;;;;;EAMf,OAAO;EACP,UAAU;;UAGK;;;;;EAKf;;;;;;EAMA;;;;;;;;;;;iBAYc,WACd,kBAAkB,cAClB,iBAAiB,SACjB,UAAS,oBACR;;;;;;UAqGc;EACf;EACA;;;;;;KAOU;UAEK;EACf;EACA;EACA;EACA;;EAEA;;;;;;;;UASe;EACf;EACA;EACA;;EAEA;;UAGe;EACf,QAAQ;;EAER;EACA;EACA;EACA;;;;;EAKA;;EAEA;;EAEA,QAAQ,QAAQ,OAAO,WAAW;;EAElC;;EAEA;EACA,UAAU;;;;;;;;;;iBAWI,UACd,kBAAkB,gBAClB,UAAU,gBACT;;;cCpUG;KAEM,6BAA6B;UAExB;;EAEf;;EAEA;;EAEA;;UAGe;;EAEf;EACA;;EAEA;;;;;;;EAOA,SAAS;;;UAIM;EACf;EACA;EACA;;;iBAcc,yBAAyB,UAAU,kBAAkB;;;;;;iBAiCrD,wBACd,QAAQ,oBAAoB,6BAC5B,MAAM,eACL;;;;;;;;iBAmBa,sBACd,QAAQ,wBAAwB,qBAChC,MAAM,eACL;UAYc;;EAEf;;;;;;;;;iBAUc,wBACd,QAAQ,kBACR,QAAQ,cACR,MAAM,cACN,UAAS,qBACR;UA4Cc;EACf,OAAO,UAAU,mBAAmB;;EAEpC,QAAQ,mBAAmB,QAAQ;;iBAGrB,sBAAsB,UAAS,qBAA0B;;;;;;;iBAqBzD,kBAAkB,eAAe;UA0ChC;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;EACA,aAAa;;EAEb,cAAc;;UAGC;EACf;EACA,QAAQ;;EAER,OAAO;;EAEP;;EAEA;;EAEA;EACA;EACA;;UAGe;EACf,UAAU;EACV;EACA;;;;;;;EAOA;;iBAKc,oBACd,SAAS,oBACT,MAAM,uBACL;UA6Gc;EACf;EACA;;;;;;;;;;iBAWc,gBAAgB,QAAQ,iBAAiB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/meta-eval/correlation-study.ts","../../src/meta-eval/calibration.ts","../../src/meta-eval/plants.ts","../../src/meta-eval/sentinel.ts"],"mappings":";;;;;;;;UAkBiB;EACf;;;EAGA,WAAW,KAAK,KAAK,OAAO,eAAe;;UAG5B;EACf;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;EAEA;IAAe;IAAe;;;EAE9B;;UAGe;EACf,OAAO;EACP;EACA;;UAGe;;EAEf;;EAEA,gBAAgB;;EAEhB;;EAEA;;;EAGA;;iBAGoB,iBACpB,YAAY,YACZ,cAAc,cACd,aAAa,kBACb,8BACA,UAAS,0BACR,QAAQ;;;UCtDM;EACf;EACA;EACA;EACA;EACA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,MAAM;;EAEN;;EAEA;;UAGe;EACf;;EAEA;;EAEA;IAAU;IAAY;;;UAGP;EACf;EACA;;iBAGoB,iBACpB,YAAY,YACZ,cAAc,cACd,YAAY,gBACZ,uBACA,UAAS,qBACR,QAAQ;;;;;;;;KCQC;;;;;;;;;;KAkBA;UAOK;;EAEf;EACA,MAAM;;EAEN,MAAM;;EAEN,iBAAiB;;;;;;;;;;;;;;iBAeH,YAAY;EAC1B;EACA,MAAM;EACN,MAAM;EACN,iBAAiB;IACf;;;;;UAqDa;;EAEf;;EAEA;;;KAIU;;KAGA;UAEK;;EAEf,UAAU;;EAEV,OAAO;;EAEP,KAAK;;;;;;EAML;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsJc,gBAAgB,UAAU,gBAAgB;UA8BzC;EACf,OAAO;;EAEP,UAAU;EACV,OAAO;EACP,KAAK;EACL;EACA;;;;;;;;;;;;;;;;;;;;;;iBAuBc,oBAAoB;EAClC;EACA;EACA,UAAU;;EAEV;EACA;IACE;UA0Ba;;;;;;EAMf,MAAM;;EAEN;;EAEA;;EAEA;;EAEA,QAAQ;;UAGO;;;;;;EAMf,OAAO;EACP,UAAU;;UAGK;;;;;EAKf;;;;;;EAMA;;;;;;;;;;;iBAYc,WACd,kBAAkB,cAClB,iBAAiB,SACjB,UAAS,oBACR;;;;;;UAqGc;EACf;EACA;;;;;;KAOU;UAEK;EACf;EACA;EACA;EACA;;EAEA;;;;;;;;UASe;EACf;EACA;EACA;;EAEA;;UAGe;EACf,QAAQ;;EAER;EACA;EACA;EACA;;;;;EAKA;;EAEA;;EAEA,QAAQ,QAAQ,OAAO,WAAW;;EAElC;;EAEA;EACA,UAAU;;;;;;;;;;iBAWI,UACd,kBAAkB,gBAClB,UAAU,gBACT;;;cC/lBG;KAEM,6BAA6B;UAExB;;EAEf;;EAEA;;EAEA;;UAGe;;EAEf;EACA;;EAEA;;;;;;;EAOA,SAAS;;;UAIM;EACf;EACA;EACA;;;iBAcc,yBAAyB,UAAU,kBAAkB;;;;;;iBAiCrD,wBACd,QAAQ,oBAAoB,6BAC5B,MAAM,eACL;;;;;;;;iBAmBa,sBACd,QAAQ,wBAAwB,qBAChC,MAAM,eACL;UAYc;;EAEf;;;;;;;;;iBAUc,wBACd,QAAQ,kBACR,QAAQ,cACR,MAAM,cACN,UAAS,qBACR;UA4Cc;EACf,OAAO,UAAU,mBAAmB;;EAEpC,QAAQ,mBAAmB,QAAQ;;iBAGrB,sBAAsB,UAAS,qBAA0B;;;;;;;iBAqBzD,kBAAkB,eAAe;UA0ChC;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;EACA,aAAa;;EAEb,cAAc;;UAGC;EACf;EACA,QAAQ;;EAER,OAAO;;EAEP;;EAEA;;EAEA;EACA;EACA;;UAGe;EACf,UAAU;EACV;EACA;;;;;;;EAOA;;iBAKc,oBACd,SAAS,oBACT,MAAM,uBACL;UA6Gc;EACf;EACA;;;;;;;;;;iBAWc,gBAAgB,QAAQ,iBAAiB"}

package/dist/meta-eval/index.js

@@ -3,7 +3,7 @@ import { a as hashCanonical } from "../canonical-DPyQ_rpt.js";
 import { i as makeRng } from "../internal-BMFSR8Ns.js";
 import { t as mulberry32 } from "../random-Dn5fPWkt.js";
 import { a as spearmanR, r as pearsonR } from "../descriptive-1V17A-qa.js";
-import { u as runMetricExtractor } from "../query-BPGMVlbM.js";
+import { u as runMetricExtractor } from "../query-D1nLIKt7.js";
 import { t as analyzeSeries } from "../series-convergence-CjO2QdRW.js";
 import { t as rubricPredictiveValidity } from "../rubric-predictive-validity-2D5Gw9z9.js";
 import { n as InMemoryOutcomeStore, t as FileSystemOutcomeStore } from "../outcome-store-ChBKlTd_.js";
@@ -257,6 +257,15 @@ function bootstrapPearsonCi(xs, ys, iterations, seed) {
 *   the digest the sealed-experiment path uses, so the answer key cannot be
 *   revised once the results are in.
 *
+* Authoring the wrong item is the step before all of that, and it is where the
+* measurement silently breaks. {@link plantByPerturbation} takes a claim a
+* grader verified and alters exactly one load-bearing value in its evidence,
+* so the grader is asked a question it must fail. Hand-rolled perturbation
+* bumps a number that is part of an identity — `python3`, `file42.txt`, `1.5`,
+* `utf-8` — and the check stops EXECUTING; the plant then measures the
+* environment rather than the grader. {@link perturbEvidence} refuses those
+* digit runs by construction.
+*
 * Blindness has two halves, and this module owns one. It never puts a plant
 * flag on a graded item: `seedPlants` returns the mixed set and a manifest,
 * and only the manifest knows which ids are seeded. Keeping the manifest out
@@ -315,6 +324,195 @@ function definePlant(input) {
 	};
 }
 /**
+* Characters that make a digit run part of something larger than a number.
+*
+* A run that touches one of these is an identity — `python3`, `file42.txt`,
+* `1.5`, `utf-8` — and bumping it renames a program, a file, a version, or an
+* encoding instead of falsifying the claim. The check then stops EXECUTING,
+* and a plant that cannot run measures the environment rather than the grader:
+* it reads as caught, for a reason that has nothing to do with the seeded
+* defect.
+*/
+const NUMBER_GLUE = /[A-Za-z0-9_./-]/;
+/**
+* Comparison tokens that mean one thing only, each with its inversion.
+*
+* A bare `>` or `<` is absent on purpose: in a shell check it is a
+* redirection, so flipping it rewrites where output goes rather than what the
+* test asks, and the check stops testing the claim.
+*/
+const COMPARISON_FLIPS = [
+	[" -ge ", " -lt "],
+	[" -gt ", " -le "],
+	[" -le ", " -gt "],
+	[" -lt ", " -ge "],
+	[" -eq ", " -ne "],
+	[" -ne ", " -eq "],
+	[">=", "<"],
+	["<=", ">"],
+	["==", "!="],
+	["!=", "=="]
+];
+/**
+* The last digit run in `text` that is a number and nothing else, or null.
+*
+* The last is taken because a measured value trails its label — `count=42`,
+* `n>=5 OK cells=8` — and because the choice has to be deterministic: the same
+* claim must always yield the same plant, or two runs of the same authoring
+* step seed two different answer keys for one item.
+*/
+function lastStandaloneNumber(text) {
+	const digits = /\d+/g;
+	let found = null;
+	let match = digits.exec(text);
+	while (match !== null) {
+		const start = match.index;
+		const end = start + match[0].length;
+		if (!NUMBER_GLUE.test(text.charAt(start - 1)) && !NUMBER_GLUE.test(text.charAt(end))) found = {
+			start,
+			end
+		};
+		match = digits.exec(text);
+	}
+	return found;
+}
+/**
+* The first flippable comparison in `text`, or null.
+*
+* Any single flip inverts the test wherever it sits, so unlike the number rule
+* there is no safety ordering among the matches. The first is taken so the
+* result is fixed by the head of the command and does not move when a later
+* comparison is added.
+*/
+function firstComparison(text) {
+	for (let index = 0; index < text.length; index += 1) for (const [token, flipped] of COMPARISON_FLIPS) if (text.startsWith(token, index)) return {
+		span: {
+			start: index,
+			end: index + token.length
+		},
+		flipped
+	};
+	return null;
+}
+function replaceSpan(text, span, value) {
+	return text.slice(0, span.start) + value + text.slice(span.end);
+}
+/**
+* Rebuild the evidence with one field replaced. An absent field is dropped
+* rather than set to undefined, so the record always has a canonical JSON form.
+*/
+function withField(check, expect, field, value) {
+	const nextCheck = field === "check" ? value : check;
+	const nextExpect = field === "expect" ? value : expect;
+	return {
+		...nextCheck === void 0 ? {} : { check: nextCheck },
+		...nextExpect === void 0 ? {} : { expect: nextExpect }
+	};
+}
+function offByOne(check, expect, field, text, span) {
+	const original = text.slice(span.start, span.end);
+	const perturbed = (BigInt(original) + 1n).toString();
+	return {
+		evidence: withField(check, expect, field, replaceSpan(text, span, perturbed)),
+		field,
+		how: "number-off-by-one",
+		original,
+		perturbed
+	};
+}
+/**
+* Derive a known-wrong version of a claim's evidence by altering exactly one
+* value, or return null when no value can be altered safely.
+*
+* Exactly one value changes. A perturbation that moves two does not name the
+* defect it seeded, so a grader that catches it says nothing about which defect
+* the grader can see.
+*
+* The preference order IS the safety order:
+*
+* 1. the last standalone number in `expect` — it falsifies the claim while the
+*    command still runs exactly as it did;
+* 2. a flipped comparison in `check` — it inverts a test that was passing;
+* 3. the last standalone number in `check` — last because a number in a command
+*    can name an input (a port, a width, a version) rather than a threshold,
+*    and renaming an input breaks execution, not the claim.
+*
+* "Standalone" excludes a digit run glued to a word, a dot, a slash, or a
+* hyphen: `python3`, `file42.txt`, `1.5`, `utf-8`. That exclusion is why this
+* helper exists. Hand-rolled perturbation bumps one of those, the check stops
+* executing, and the plant measures the environment instead of the grader.
+*
+* A number is bumped with BigInt, so a value wider than
+* `Number.MAX_SAFE_INTEGER` moves by exactly one. Bumped as a `number` it
+* rounds back to itself, and the plant is then a correct claim the grader is
+* right to verify.
+*/
+function perturbEvidence(evidence) {
+	const check = typeof evidence.check === "string" ? evidence.check : void 0;
+	const expect = typeof evidence.expect === "string" ? evidence.expect : void 0;
+	if (expect !== void 0) {
+		const span = lastStandaloneNumber(expect);
+		if (span !== null) return offByOne(check, expect, "expect", expect, span);
+	}
+	if (check !== void 0) {
+		const comparison = firstComparison(check);
+		if (comparison !== null) return {
+			evidence: withField(check, expect, "check", replaceSpan(check, comparison.span, comparison.flipped)),
+			field: "check",
+			how: "comparison-flipped",
+			original: check.slice(comparison.span.start, comparison.span.end),
+			perturbed: comparison.flipped
+		};
+		const span = lastStandaloneNumber(check);
+		if (span !== null) return offByOne(check, expect, "check", check, span);
+	}
+	return null;
+}
+/**
+* Derive a reject-direction plant from a claim a grader verified, by perturbing
+* one value.
+*
+* {@link definePlant} takes a {@link GoldenItem} and never authors a wrong item
+* from a right one, so until now every caller hand-rolled the perturbation.
+* This is that step, done once and the same way every time: the claim's
+* evidence is altered by {@link perturbEvidence}, the result is a `wrong-value`
+* plant the grader owes a `reject`, and the record itself is built by
+* `definePlant` so every refusal there still applies — in particular the one
+* that catches an `expectedVerdict` its `humanScore` contradicts.
+*
+* Returns null when nothing in the evidence can be perturbed. That is not a
+* failure: a claim with no executable evidence cannot be made wrong in a way a
+* grader could execute, and seeding it would measure prose.
+*
+* Refuses an empty `id` or `itemId`. Both name the record — one in the manifest
+* and in `missedIds`, the other in the join with the results — and a miss
+* nobody can look up is not a measurement.
+*/
+function plantByPerturbation(input) {
+	const { id, itemId, evidence, humanScore = 0, group } = input;
+	if (typeof id !== "string" || id.trim() === "") throw new ValidationError("plantByPerturbation: id must be a non-empty string");
+	if (typeof itemId !== "string" || itemId.trim() === "") throw new ValidationError(`plantByPerturbation: plant "${id}" has an empty itemId`);
+	const perturbation = perturbEvidence(evidence);
+	if (perturbation === null) return null;
+	return {
+		plant: definePlant({
+			id,
+			kind: "wrong-value",
+			item: {
+				itemId,
+				humanScore,
+				...group === void 0 ? {} : { group }
+			},
+			expectedVerdict: "reject"
+		}),
+		evidence: perturbation.evidence,
+		field: perturbation.field,
+		how: perturbation.how,
+		original: perturbation.original,
+		perturbed: perturbation.perturbed
+	};
+}
+/**
 * Mix plants into a grading set and seal which items they are.
 *
 * Refusals: a duplicate id anywhere in the mixed set (the join is by id, so a
@@ -784,6 +982,6 @@ function evalHealthStamp(report) {
 	};
 }
 //#endregion
-export { FileSystemOutcomeStore, InMemoryOutcomeStore, calibrationCurve, catchRate, correlationStudy, definePlant, evalHealthStamp, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, rubricPredictiveValidity, seedPlants, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot };
+export { FileSystemOutcomeStore, InMemoryOutcomeStore, calibrationCurve, catchRate, correlationStudy, definePlant, evalHealthStamp, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, perturbEvidence, plantByPerturbation, rubricPredictiveValidity, seedPlants, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot };
 
 //# sourceMappingURL=index.js.map