@vibe-agent-toolkit/agent-skills 0.1.42 → 0.2.0-rc.10

package/dist/skill-test/eval-fragment.d.ts

@@ -1,3 +1,4 @@
+import { VatError } from '@vibe-agent-toolkit/utils';
 import { z } from 'zod';
 /** One graded expectation inside a per-eval grader fragment. */
 export declare const EvalFragmentExpectationSchema: z.ZodObject<{
@@ -5,17 +6,17 @@ export declare const EvalFragmentExpectationSchema: z.ZodObject<{
     passed: z.ZodBoolean;
     evidence: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    passed: boolean;
     text: string;
+    passed: boolean;
     evidence?: string | undefined;
 }, {
-    passed: boolean;
     text: string;
+    passed: boolean;
     evidence?: string | undefined;
 }>;
 export type EvalFragmentExpectation = z.infer<typeof EvalFragmentExpectationSchema>;
 /**
- * Strict shape of a single grader subagent's output (issue #145 Task 4). One
+ * Strict shape of a single grader subagent's output. One
  * GRADER spawn grades ONE eval's expectations from that eval's captured
  * transcript and writes exactly one fragment matching this schema; vat reads
  * every eval's fragment back and merges them into the run's aggregate grading
@@ -28,7 +29,7 @@ export type EvalFragmentExpectation = z.infer<typeof EvalFragmentExpectationSche
  * `arm` distinguishes a WITH/WITHOUT baseline run's fragment; absent means the
  * default 'with' (skill present) arm.
  *
- * `tool` (issue #145 Phase T) carries this eval's tool-expectation verdict —
+ * `tool` carries this eval's tool-expectation verdict —
  * a SEPARATE channel from `expectations[]` and from `friction` (see
  * tool-eval-schema.ts). It is {@link ToolVerdictBodySchema}, i.e. a
  * {@link import('./tool-eval-schema.js').ToolVerdict} WITHOUT `evalId`: the
@@ -38,19 +39,19 @@ export type EvalFragmentExpectation = z.infer<typeof EvalFragmentExpectationSche
  */
 export declare const EvalFragmentSchema: z.ZodObject<{
     runNonce: z.ZodString;
-    evalId: z.ZodString;
+    evalId: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, string, string | number>;
     arm: z.ZodOptional<z.ZodEnum<["with", "without"]>>;
     expectations: z.ZodArray<z.ZodObject<{
         text: z.ZodString;
         passed: z.ZodBoolean;
         evidence: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
-        passed: boolean;
         text: string;
+        passed: boolean;
         evidence?: string | undefined;
     }, {
-        passed: boolean;
         text: string;
+        passed: boolean;
         evidence?: string | undefined;
     }>, "many">;
     friction: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -171,22 +172,61 @@ export declare const EvalFragmentSchema: z.ZodObject<{
             evidence?: string | undefined;
         }[] | undefined;
     }>>;
+    /**
+     * WITHOUT-arm baseline-integrity hits (see baseline-integrity.ts). Like `arm`,
+     * this is attached by VAT after the strict parse — it is derived from the
+     * executor transcript, which the grader never sees, so a value arriving from a
+     * grader is meaningless and is overwritten rather than trusted.
+     */
+    contamination: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["harness-path", "declared-executable", "sibling-arm", "vat-private-dir", "skill-content"]>;
+        match: z.ZodString;
+        excerpt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        match: string;
+        kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+        excerpt: string;
+    }, {
+        match: string;
+        kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+        excerpt: string;
+    }>, "many">>;
+    /**
+     * Why THIS eval's contamination scan could not run at full strength, when it
+     * could not (see `BaselineScanDegradation`). Attached by VAT after the strict
+     * parse for exactly the reasons `contamination` is, and stripped from grader
+     * output for exactly the same reason: it is derived from the executor
+     * transcript's structure, which the grader never inspects, so a value arriving
+     * from a grader is meaningless — and this one is worse than meaningless,
+     * because a grader talked into omitting it turns a blind scan back into a
+     * confident clean one.
+     *
+     * This is the per-eval half of the run-level `baselineIntegrity.degraded` list.
+     * It exists because the degradation is detected per eval, deep inside a
+     * pipeline worker, while the block that has to report it is assembled once at
+     * the end from fragments — the fragment is the only channel between the two.
+     */
+    degraded: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<["transcript-unparsed", "cwd-unknown", "cwd-untracked", "transcript-malformed", "glob-unexpanded"]>;
+        detail: z.ZodString;
+        evalId: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        detail: string;
+        reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+        evalId?: string | undefined;
+    }, {
+        detail: string;
+        reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+        evalId?: string | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     expectations: {
-        passed: boolean;
         text: string;
+        passed: boolean;
         evidence?: string | undefined;
     }[];
     evalId: string;
     runNonce: string;
-    arm?: "with" | "without" | undefined;
-    friction?: {
-        message: string;
-        severity: "high" | "medium" | "low";
-        category: "path-assumption" | "undeclared-dependency" | "ambient-propping" | "doc-engine-drift" | "missing-bundled-file" | "tool-expectation";
-        evidence?: string | undefined;
-        subjectFile?: string | undefined;
-    }[] | undefined;
     tool?: {
         passed: boolean;
         mustRun?: {
@@ -210,14 +250,11 @@ export declare const EvalFragmentSchema: z.ZodObject<{
             evidence?: string | undefined;
         }[] | undefined;
     } | undefined;
-}, {
-    expectations: {
-        passed: boolean;
-        text: string;
-        evidence?: string | undefined;
-    }[];
-    evalId: string;
-    runNonce: string;
+    degraded?: {
+        detail: string;
+        reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+        evalId?: string | undefined;
+    } | undefined;
     arm?: "with" | "without" | undefined;
     friction?: {
         message: string;
@@ -226,6 +263,19 @@ export declare const EvalFragmentSchema: z.ZodObject<{
         evidence?: string | undefined;
         subjectFile?: string | undefined;
     }[] | undefined;
+    contamination?: {
+        match: string;
+        kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+        excerpt: string;
+    }[] | undefined;
+}, {
+    expectations: {
+        text: string;
+        passed: boolean;
+        evidence?: string | undefined;
+    }[];
+    evalId: string | number;
+    runNonce: string;
     tool?: {
         passed: boolean;
         mustRun?: {
@@ -249,6 +299,24 @@ export declare const EvalFragmentSchema: z.ZodObject<{
             evidence?: string | undefined;
         }[] | undefined;
     } | undefined;
+    degraded?: {
+        detail: string;
+        reason: "transcript-unparsed" | "cwd-unknown" | "cwd-untracked" | "transcript-malformed" | "glob-unexpanded";
+        evalId?: string | undefined;
+    } | undefined;
+    arm?: "with" | "without" | undefined;
+    friction?: {
+        message: string;
+        severity: "high" | "medium" | "low";
+        category: "path-assumption" | "undeclared-dependency" | "ambient-propping" | "doc-engine-drift" | "missing-bundled-file" | "tool-expectation";
+        evidence?: string | undefined;
+        subjectFile?: string | undefined;
+    }[] | undefined;
+    contamination?: {
+        match: string;
+        kind: "harness-path" | "declared-executable" | "sibling-arm" | "vat-private-dir" | "skill-content";
+        excerpt: string;
+    }[] | undefined;
 }>;
 export type EvalFragment = z.infer<typeof EvalFragmentSchema>;
 /**
@@ -261,7 +329,8 @@ export type EvalFragment = z.infer<typeof EvalFragmentSchema>;
  * should point at the offending eval, not at "Re-sync the vendored
  * skill-creator".
  */
-export declare class EvalFragmentError extends Error {
+export declare class EvalFragmentError extends VatError {
+    readonly reason: "internal";
     constructor(message: string);
 }
 /**
@@ -271,8 +340,17 @@ export declare class EvalFragmentError extends Error {
  *
  * The verdict channels are strict. The auxiliary `friction` field is sanitized
  * leniently first (see {@link sanitizeFrictionField}); when items are dropped,
- * `onWarn` (if given) is called so the operator sees that friction was partial —
- * grading itself is never affected.
+ * `onWarn` is called so the operator sees that friction was partial — grading
+ * itself is never affected. `onWarn` is REQUIRED: a caller that could omit it
+ * received a fragment with friction silently missing, and "friction is
+ * advisory" is only true when the operator is told it was cut.
+ *
+ * THIS IS THE TEXT BOUNDARY. Every string in the fragment is run through
+ * {@link sanitizeGraderTextDeep} BEFORE anything else looks at it, so no
+ * grader-supplied newline or ANSI sequence can reach an artifact or an operator
+ * line downstream (see grader-text.ts for the threat). It runs first, ahead of
+ * the friction sanitizer and the strict parse, because both of those quote
+ * grader text into messages of their own.
  */
-export declare function parseEvalFragment(raw: unknown, onWarn?: (message: string) => void): EvalFragment;
+export declare function parseEvalFragment(raw: unknown, onWarn: (message: string) => void): EvalFragment;
 //# sourceMappingURL=eval-fragment.d.ts.map

package/dist/skill-test/eval-fragment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eval-fragment.d.ts","sourceRoot":"","sources":["../../src/skill-test/eval-fragment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,gEAAgE;AAChE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAI/B,CAAC;AAEZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOpB,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAI5B;AA+CD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,YAAY,CAkBhG"}
+{"version":3,"file":"eval-fragment.d.ts","sourceRoot":"","sources":["../../src/skill-test/eval-fragment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,gEAAgE;AAChE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAI/B,CAAC;AAEZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAU7B;;;;;OAKG;;;;;;;;;;;;;;IAEH;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEM,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,QAAQ;IAC7C,QAAQ,CAAC,MAAM,EAAG,UAAU,CAAU;gBAC1B,OAAO,EAAE,MAAM;CAG5B;AAgED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,YAAY,CAyB/F"}

package/dist/skill-test/eval-fragment.js

@@ -1,5 +1,8 @@
+import { VatError } from '@vibe-agent-toolkit/utils';
 import { z } from 'zod';
+import { BaselineContaminationHitSchema, BaselineScanDegradationSchema } from './baseline-integrity.js';
 import { FrictionItemSchema } from './friction-schema.js';
+import { sanitizeGraderText, sanitizeGraderTextDeep } from './grader-text.js';
 import { ToolVerdictBodySchema } from './tool-eval-schema.js';
 /** One graded expectation inside a per-eval grader fragment. */
 export const EvalFragmentExpectationSchema = z.object({
@@ -8,7 +11,7 @@ export const EvalFragmentExpectationSchema = z.object({
     evidence: z.string().optional(),
 }).strict();
 /**
- * Strict shape of a single grader subagent's output (issue #145 Task 4). One
+ * Strict shape of a single grader subagent's output. One
  * GRADER spawn grades ONE eval's expectations from that eval's captured
  * transcript and writes exactly one fragment matching this schema; vat reads
  * every eval's fragment back and merges them into the run's aggregate grading
@@ -21,7 +24,7 @@ export const EvalFragmentExpectationSchema = z.object({
  * `arm` distinguishes a WITH/WITHOUT baseline run's fragment; absent means the
  * default 'with' (skill present) arm.
  *
- * `tool` (issue #145 Phase T) carries this eval's tool-expectation verdict —
+ * `tool` carries this eval's tool-expectation verdict —
  * a SEPARATE channel from `expectations[]` and from `friction` (see
  * tool-eval-schema.ts). It is {@link ToolVerdictBodySchema}, i.e. a
  * {@link import('./tool-eval-schema.js').ToolVerdict} WITHOUT `evalId`: the
@@ -31,11 +34,37 @@ export const EvalFragmentExpectationSchema = z.object({
  */
 export const EvalFragmentSchema = z.object({
     runNonce: z.string().min(1),
-    evalId: z.string().min(1),
+    // evals.json allows an integer id and every other layer carries it as a
+    // string; a grader that echoes the number names the same eval, so it is
+    // normalised here rather than refused as a forged fragment.
+    evalId: z.union([z.string().min(1), z.number().int()]).transform(String),
     arm: z.enum(['with', 'without']).optional(),
     expectations: z.array(EvalFragmentExpectationSchema).min(1),
     friction: z.array(FrictionItemSchema).optional(),
     tool: ToolVerdictBodySchema.optional(),
+    /**
+     * WITHOUT-arm baseline-integrity hits (see baseline-integrity.ts). Like `arm`,
+     * this is attached by VAT after the strict parse — it is derived from the
+     * executor transcript, which the grader never sees, so a value arriving from a
+     * grader is meaningless and is overwritten rather than trusted.
+     */
+    contamination: z.array(BaselineContaminationHitSchema).optional(),
+    /**
+     * Why THIS eval's contamination scan could not run at full strength, when it
+     * could not (see `BaselineScanDegradation`). Attached by VAT after the strict
+     * parse for exactly the reasons `contamination` is, and stripped from grader
+     * output for exactly the same reason: it is derived from the executor
+     * transcript's structure, which the grader never inspects, so a value arriving
+     * from a grader is meaningless — and this one is worse than meaningless,
+     * because a grader talked into omitting it turns a blind scan back into a
+     * confident clean one.
+     *
+     * This is the per-eval half of the run-level `baselineIntegrity.degraded` list.
+     * It exists because the degradation is detected per eval, deep inside a
+     * pipeline worker, while the block that has to report it is assembled once at
+     * the end from fragments — the fragment is the only channel between the two.
+     */
+    degraded: BaselineScanDegradationSchema.optional(),
 }).strict();
 /**
  * Thrown when a single grader subagent's fragment output does not match
@@ -47,26 +76,43 @@ export const EvalFragmentSchema = z.object({
  * should point at the offending eval, not at "Re-sync the vendored
  * skill-creator".
  */
-export class EvalFragmentError extends Error {
+export class EvalFragmentError extends VatError {
+    reason = 'internal';
     constructor(message) {
-        super(message);
-        this.name = 'EvalFragmentError';
+        super('EVAL_FRAGMENT', message);
     }
 }
-/** Best-effort extraction of `evalId` from raw input for error messages, tolerating any shape. */
+/**
+ * Best-effort extraction of `evalId` from raw input for error messages,
+ * tolerating any shape. Sanitized: this value lands in a thrown message that a
+ * human reads on stderr, and at the point it is read the fragment has NOT been
+ * validated — so it is raw grader text with no schema between it and the
+ * terminal.
+ */
 function extractRawEvalId(raw) {
     if (typeof raw === 'object' && raw !== null && 'evalId' in raw) {
         const value = raw['evalId'];
+        if (typeof value === 'number')
+            return `"${String(value)}"`;
         if (typeof value === 'string' && value.length > 0)
-            return `"${value}"`;
+            return `"${sanitizeGraderText(value)}"`;
     }
     return '(unknown)';
 }
+/**
+ * Fragment keys whose value must NOT be normalized.
+ *
+ * `runNonce` is compared byte-for-byte against the run's secret by the
+ * integrity gate in eval-grader.ts. Normalizing it would mean the gate no
+ * longer compares what the grader actually wrote — the one field in this
+ * fragment that exists to be compared exactly.
+ */
+const UNSANITIZED_FRAGMENT_KEYS = new Set(['runNonce']);
 /**
  * Sanitize ONLY the (non-verdict-bearing) `friction` field before the strict
  * fragment parse. Friction is auxiliary advisory data, not a verdict channel —
  * so a grader that wobbles on the friction shape (e.g. emits bare strings, the
- * common failure mode — PR #147) must NOT be allowed to discard the
+ * common failure mode) must NOT be allowed to discard the
  * verdict-bearing grading for the whole run. We drop friction items that don't
  * match {@link FrictionItemSchema} (and a `friction` that isn't an array at
  * all), then hand the rest to the STRICT fragment parse — so the verdict
@@ -107,21 +153,37 @@ function sanitizeFrictionField(raw) {
  *
  * The verdict channels are strict. The auxiliary `friction` field is sanitized
  * leniently first (see {@link sanitizeFrictionField}); when items are dropped,
- * `onWarn` (if given) is called so the operator sees that friction was partial —
- * grading itself is never affected.
+ * `onWarn` is called so the operator sees that friction was partial — grading
+ * itself is never affected. `onWarn` is REQUIRED: a caller that could omit it
+ * received a fragment with friction silently missing, and "friction is
+ * advisory" is only true when the operator is told it was cut.
+ *
+ * THIS IS THE TEXT BOUNDARY. Every string in the fragment is run through
+ * {@link sanitizeGraderTextDeep} BEFORE anything else looks at it, so no
+ * grader-supplied newline or ANSI sequence can reach an artifact or an operator
+ * line downstream (see grader-text.ts for the threat). It runs first, ahead of
+ * the friction sanitizer and the strict parse, because both of those quote
+ * grader text into messages of their own.
  */
 export function parseEvalFragment(raw, onWarn) {
-    const { value, dropped } = sanitizeFrictionField(raw);
+    const sanitized = sanitizeGraderTextDeep(raw, UNSANITIZED_FRAGMENT_KEYS);
+    const { value, dropped } = sanitizeFrictionField(sanitized);
     if (dropped > 0) {
-        onWarn?.(`grader fragment for eval ${extractRawEvalId(raw)} had ${dropped} malformed friction item(s) — ` +
+        onWarn(`grader fragment for eval ${extractRawEvalId(sanitized)} had ${dropped} malformed friction item(s) — ` +
             `dropped them (friction is advisory; grading is unaffected).`);
     }
     const result = EvalFragmentSchema.safeParse(value);
     if (!result.success) {
         const firstIssue = result.error.issues[0];
-        const path = firstIssue?.path.join('.') ?? '(root)';
-        const evalId = extractRawEvalId(raw);
-        throw new EvalFragmentError(`grader fragment for eval ${evalId} has an invalid shape: invalid field at "${path}" (${firstIssue?.message ?? 'unknown'})`);
+        // Both halves quote grader-chosen text. The path names the offending FIELD,
+        // and a `.strict()` failure puts the offending KEY inside zod's own issue
+        // MESSAGE ("Unrecognized key(s) in object: '<key>'") — the key never becomes
+        // fragment data, so the deep walk above cannot reach it, and it is the only
+        // route by which an unparseable fragment can still paint the terminal.
+        const path = sanitizeGraderText(firstIssue?.path.join('.') ?? '(root)');
+        const issue = sanitizeGraderText(firstIssue?.message ?? 'unknown');
+        const evalId = extractRawEvalId(sanitized);
+        throw new EvalFragmentError(`grader fragment for eval ${evalId} has an invalid shape: invalid field at "${path}" (${issue})`);
     }
     return result.data;
 }

package/dist/skill-test/eval-fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"eval-fragment.js","sourceRoot":"","sources":["../../src/skill-test/eval-fragment.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"eval-fragment.js","sourceRoot":"","sources":["../../src/skill-test/eval-fragment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxG,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,gEAAgE;AAChE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAAC;IACpD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;IACnB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC,MAAM,EAAE,CAAC;AAIZ;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,wEAAwE;IACxE,wEAAwE;IACxE,4DAA4D;IAC5D,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC;IACxE,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC3C,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,6BAA6B,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3D,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE;IAChD,IAAI,EAAE,qBAAqB,CAAC,QAAQ,EAAE;IACtC;;;;;OAKG;IACH,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC,QAAQ,EAAE;IACjE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,EAAE,6BAA6B,CAAC,QAAQ,EAAE;CACnD,CAAC,CAAC,MAAM,EAAE,CAAC;AAIZ;;;;;;;;;GASG;AACH,MAAM,OAAO,iBAAkB,SAAQ,QAAQ;IACpC,MAAM,GAAG,UAAmB,CAAC;IACtC,YAAY,OAAe;QACzB,KAAK,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;IAClC,CAAC;CACF;AAED;;;;;;GAMG;AACH,SAAS,gBAAgB,CAAC,GAAY;IACpC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,IAAI,QAAQ,IAAI,GAAG,EAAE,CAAC;QAC/D,MAAM,KAAK,GAAI,GAA+B,CAAC,QAAQ,CAAC,CAAC;QACzD,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;QAC3D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,IAAI,kBAAkB,CAAC,KAAK,CAAC,GAAG,CAAC;IAC7F,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,yBAAyB,GAAwB,IAAI,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;GAcG;AACH,SAAS,qBAAqB,CAAC,GAAY;IACzC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,IAAI,CAAC,CAAC,UAAU,IAAI,GAAG,CAAC,EAAE,CAAC;QACpE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IACpC,CAAC;IACD,MAAM,GAAG,GAAG,GAA8B,CAAC;IAC3C,MAAM,QAAQ,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC;IACjC,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAC9D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,4EAA4E;QAC5E,yDAAyD;QACzD,MAAM,IAAI,GAA4B,EAAE,CAAC;QACzC,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7C,IAAI,GAAG,KAAK,UAAU;gBAAE,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;QAC1C,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IACrC,CAAC;IACD,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,kBAAkB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;IACnF,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM;QAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IACvE,OAAO,EAAE,KAAK,EAAE,EAAE,GAAG,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;AACvF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY,EAAE,MAAiC;IAC/E,MAAM,SAAS,GAAG,sBAAsB,CAAC,GAAG,EAAE,yBAAyB,CAAC,CAAC;IACzE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC5D,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;QAChB,MAAM,CACJ,4BAA4B,gBAAgB,CAAC,SAAS,CAAC,QAAQ,OAAO,gCAAgC;YACpG,6DAA6D,CAChE,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,kBAAkB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACnD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC1C,4EAA4E;QAC5E,0EAA0E;QAC1E,6EAA6E;QAC7E,4EAA4E;QAC5E,uEAAuE;QACvE,MAAM,IAAI,GAAG,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,CAAC;QACxE,MAAM,KAAK,GAAG,kBAAkB,CAAC,UAAU,EAAE,OAAO,IAAI,SAAS,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;QAC3C,MAAM,IAAI,iBAAiB,CACzB,4BAA4B,MAAM,4CAA4C,IAAI,MAAM,KAAK,GAAG,CACjG,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC"}

package/dist/skill-test/eval-grader.d.ts

@@ -1,4 +1,5 @@
-import { spawnHeadlessClaude } from '@vibe-agent-toolkit/utils';
+import { VatError } from '@vibe-agent-toolkit/utils';
+import { spawnHeadlessClaude } from '@vibe-agent-toolkit/utils/skill-test';
 import { type EvalFragment } from './eval-fragment.js';
 import type { ToolExpectations } from './eval-inputs.js';
 export interface RunGraderInput {
@@ -10,7 +11,7 @@ export interface RunGraderInput {
     /** Path to the vendored skill-creator grader rubric (references/grader.md). */
     rubricPath: string;
     /**
-     * The eval's declared tool expectations (issue #145 Phase T). Optional — when
+     * The eval's declared tool expectations. Optional — when
      * absent, `buildGraderPrompt` emits no tool-verdict instruction and the
      * returned fragment omits `tool`. See `grader-prompt.ts`'s
      * `BuildGraderPromptOptions.toolExpectations`.
@@ -40,15 +41,72 @@ export interface RunGraderInput {
     env: NodeJS.ProcessEnv;
     /** Injectable seam for tests; defaults to the real {@link spawnHeadlessClaude}. */
     spawn?: typeof spawnHeadlessClaude;
-    /** Called with each stdout chunk as it streams (for progress echo). */
-    onProgress?: (chunk: string) => void;
     /**
-     * Reports this grader session's `total_cost_usd` (parsed from its stream-json
+     * Called with each stdout chunk as it streams (for progress echo), and with
+     * the `[skill-test]` warning line when the grader's friction was cut — see
+     * {@link fragmentWarnRouter}. Required: it is the only channel on which a
+     * dropped friction item is ever said, and an optional sink here was the
+     * optional `onWarn` one layer down wearing a different name.
+     */
+    onProgress: (chunk: string) => void;
+    /**
+     * Reports each grader session's `total_cost_usd` (parsed from its stream-json
      * transcript's terminal result; `undefined` when the transcript carried none,
-     * e.g. a mock spawn). Called once after a successful grader spawn so the run can
-     * aggregate total spend across all executor+grader sessions (adopter follow-up).
+     * e.g. a mock spawn). Called once per successful grader spawn — twice when the
+     * unparseable-fragment re-grade fires — so the run can aggregate total spend
+     * across all executor+grader sessions (adopter follow-up).
      */
     costSink?: (totalCostUsd: number | undefined) => void;
 }
+/** The reason named in {@link GraderFragmentUnparseableError}'s message and in every `evidence` of the failing fragment vat synthesizes from it. */
+export declare const GRADER_FRAGMENT_UNPARSEABLE = "grader-fragment-unparseable";
+/**
+ * Thrown when the grader's fragment was not valid JSON on BOTH attempts (see
+ * {@link runGraderForEval}). A per-eval GRADING failure, deliberately neither
+ * {@link InternalHarnessError} nor `EvalFragmentError`: the harness did its
+ * job twice and the model could not write strict JSON, which is a verdict about
+ * this eval's grading, not about the suite — so it ends on the verdict path
+ * (`FINDINGS`), never on `ERROR` with `Reason: internal`. `runEvalWorker` (run-harness.ts)
+ * turns it into that eval's failing fragment (reason
+ * {@link GRADER_FRAGMENT_UNPARSEABLE}) on the treatment arm, and into a recorded
+ * control-arm failure on the other — where a fabricated `fail` would read as
+ * skill lift. `detail` is already sanitized. Carries no `reason` on purpose:
+ * `skillTestFailureReason` would read it only if this escaped, and escaping IS
+ * the bug — the worker catches it on both arms.
+ */
+export declare class GraderFragmentUnparseableError extends VatError {
+    readonly evalId: string;
+    readonly detail: string;
+    constructor(evalId: string, detail: string);
+}
+/**
+ * Run ONE eval's grader: a blind `claude -p` spawn (grader model, NO
+ * skill/plugin loaded) that reads the executor's captured transcript via its
+ * prompt and writes a nonce'd fragment JSON to `graderOutDir`.
+ * `graderOutDir` is vat-only and separate from the skill sandbox the
+ * executor ran in — the grader's `sandboxDir` --add-dir is
+ * `graderOutDir` itself, and `pluginDirs: []` means no skill code ever runs
+ * inside the grader's process, so skill code cannot forge or tamper with the
+ * fragment this run trusts.
+ *
+ * The grader is vat infrastructure, not the thing under test: unlike the
+ * executor (see eval-executor.ts), there is NO clean-failure path here. A
+ * spawn rejection, watchdog kill (`timedOut`/`stalled`), non-zero exit, or a
+ * missing fragment file all mean the grader failed to do its ONE job and are
+ * thrown as {@link InternalHarnessError} (`ERROR`, `Reason: internal`) — never laundered into a
+ * passing (or even a valid failing) verdict.
+ *
+ * A fragment that exists but is not valid JSON is the one exception, because
+ * the grader MODEL writes it: one bad escape in a free-text `evidence` took a
+ * six-eval suite down as harness-broke after five evals had graded fine. That
+ * attempt is re-run ONCE — same transcript, a FRESH nonce (so the stale file, or
+ * anything left behind, cannot satisfy the retry), the bad file consumed first,
+ * and the prompt told what went wrong. Only a second unparseable fragment
+ * surfaces, as {@link GraderFragmentUnparseableError}. Once a fragment parses,
+ * shape problems throw `EvalFragmentError` (via {@link parseEvalFragment})
+ * and a nonce that doesn't match the nonce THAT attempt was prompted with throws
+ * {@link GradingNonceError} — both fail-closed with no retry, because the grader
+ * DID produce JSON, just not JSON we can trust.
+ */
 export declare function runGraderForEval(input: RunGraderInput): Promise<EvalFragment>;
 //# sourceMappingURL=eval-grader.d.ts.map

package/dist/skill-test/eval-grader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eval-grader.d.ts","sourceRoot":"","sources":["../../src/skill-test/eval-grader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsD,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAEpH,OAAO,EAAwC,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAMzD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,uGAAuG;IACvG,mBAAmB,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChF;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,mFAAmF;IACnF,KAAK,CAAC,EAAE,OAAO,mBAAmB,CAAC;IACnC,uEAAuE;IACvE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;CACvD;AAsCD,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC,CAoGnF"}
+{"version":3,"file":"eval-grader.d.ts","sourceRoot":"","sources":["../../src/skill-test/eval-grader.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,EAEL,mBAAmB,EACpB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAOzD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,uGAAuG;IACvG,mBAAmB,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChF;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,mFAAmF;IACnF,KAAK,CAAC,EAAE,OAAO,mBAAmB,CAAC;IACnC;;;;;;OAMG;IACH,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;CACvD;AAED,oJAAoJ;AACpJ,eAAO,MAAM,2BAA2B,gCAAgC,CAAC;AAEzE;;;;;;;;;;;;;GAaG;AACH,qBAAa,8BAA+B,SAAQ,QAAQ;aAExC,MAAM,EAAE,MAAM;aACd,MAAM,EAAE,MAAM;gBADd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM;CAQjC;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC,CAwDnF"}