@vibe-agent-toolkit/agent-skills 0.2.0-rc.7 → 0.2.0-rc.8

package/dist/skill-test/prompt-invariants.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-invariants.js","sourceRoot":"","sources":["../../src/skill-test/prompt-invariants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAe;QACzB,KAAK,CAAC,8BAA8B,OAAO,EAAE,CAAC,CAAC;QAC/C,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,6BAA6B,CAAC,MAAc,EAAE,KAAa;IACzE,OAAO;QACL,MAAM;QACN,EAAE;QACF,2EAA2E;QAC3E,6DAA6D,KAAK,EAAE;QACpE,+EAA+E;KAChF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}
+{"version":3,"file":"prompt-invariants.js","sourceRoot":"","sources":["../../src/skill-test/prompt-invariants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAErD;;;;;;;;;GASG;AACH,MAAM,OAAO,oBAAqB,SAAQ,QAAQ;IACvC,MAAM,GAAG,WAAoB,CAAC;IACvC,YAAY,OAAe;QACzB,KAAK,CAAC,kBAAkB,EAAE,8BAA8B,OAAO,EAAE,CAAC,CAAC;IACrE,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,6BAA6B,CAAC,MAAc,EAAE,KAAa;IACzE,OAAO;QACL,MAAM;QACN,EAAE;QACF,2EAA2E;QAC3E,6DAA6D,KAAK,EAAE;QACpE,+EAA+E;KAChF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/skill-test/run-harness.d.ts

@@ -3,7 +3,7 @@
  *
  * Implements the full harness sequence as a pure async function (no process.exit):
  *   lock → assert safe workdir + harness root → stage → resolve staged-subject
- *   eval path → bootstrap-check (scaffold template + exit 3 if absent)
+ *   eval path → bootstrap-check (scaffold template + exit 2 with `Reason: bootstrap` if absent)
  *   → preflight (return early exitCode 2 on failure) → ack enforcement
  *   → dry-run short-circuit → build per-eval work items → run the vat-owned
  *   executor→grader pipeline (bounded-parallel) → merge grader fragments →
@@ -11,16 +11,16 @@
  *   → release lock → return result
  */
 import type { SkillSourceDescriptor } from '@vibe-agent-toolkit/resources';
+import { ExitCode, type ExitCodeValue } from '@vibe-agent-toolkit/schema';
 import { type spawnHeadlessClaude, type ResolvedAuth } from '@vibe-agent-toolkit/utils/skill-test';
 import type { ResolveSkillSourceContext, SkillSource } from '../skill-source/types.js';
 import { type BaselineDelta } from './baseline-delta.js';
-import { type ArmEvalGrade, type BaselineControlArmFailure, type BaselineIntegrity, type DetectBaselineContaminationInput } from './baseline-integrity.js';
+import { type ArmEvalGrade, type BaselineIntegrity, type DetectBaselineContaminationInput } from './baseline-integrity.js';
 import type { EvalFragment } from './eval-fragment.js';
 import { type ArmWorkspaceDirs, type EvalArm, type EvalEntry, type EvalSuite } from './eval-inputs.js';
-import { type SkillTestExitCodeValue } from './exit-codes.js';
+import { type SkillTestFailureReason } from './failure-reason.js';
 import { type FrictionItem } from './friction-schema.js';
 import { type GradingVerdict } from './grading-adapter.js';
-import { RateLimitSignal } from './pipeline.js';
 import { type PreflightInput } from './preflight.js';
 import { type StageItem } from './staging.js';
 import { type SkippedEvalsSummary } from './tier-plan.js';
@@ -127,6 +127,11 @@ export interface RunHarnessOptions {
      * not the dist. Absent → derived from subject (legacy).
      */
     subjectScaffoldDir?: string;
+    /**
+     * True when the subject is an IN-PLACE skill (`publish: false`): no bundle exists,
+     * so it is staged from source and the run's friction report says so.
+     */
+    subjectInPlace: boolean;
     /**
      * True when run.ts actually rebuilt the subject (declared skill, no
      * --no-build/--dry-run). Recorded in provenance. Absent/false → staged as-is.
@@ -153,7 +158,7 @@ export interface RunHarnessOptions {
      * Declared executables the subject skill ships (name + kind + howInvoked),
      * populated by run.ts from the resolved subject's packaging config WHEN cleanly
      * reachable (a `buildable` ref carries `packagingConfig`; a plain path source
-     * does not — issue #145 Phase T). Passed to the grader on the WITH arm ONLY as
+     * does not). Passed to the grader on the WITH arm ONLY as
      * a recognition aid alongside each eval's `toolExpectations`. Absent → the
      * grader still matches tools by the commands it sees in the transcript.
      *
@@ -171,7 +176,7 @@ export interface RunHarnessOptions {
     }>;
     /**
      * Opt-OUT of eval gating (for interactive use). By DEFAULT (false/absent) a
-     * failing verdict returns exit EvalFailure (4) — fail-closed, so CI catches a
+     * failing verdict returns exit FINDINGS — fail-closed, so CI catches a
      * regression without an extra flag. When true, a failing verdict is downgraded
      * to Ok (0) and the pass/fail count lives only in the summary/grading.json.
      * Harness-broke codes (1/2/3) are unaffected either way.
@@ -180,7 +185,13 @@ export interface RunHarnessOptions {
 }
 export interface RunHarnessResult {
     harnessPath: string;
-    exitCode: number;
+    exitCode: ExitCodeValue;
+    /**
+     * Present exactly when `exitCode` is `ERROR`: why the harness could not run.
+     * The CLI prints it as `Reason: …` on stderr. Absent on a completed run,
+     * whatever its verdict.
+     */
+    reason?: SkillTestFailureReason;
     summary: string;
     /**
      * Where the executor's per-eval working directories were materialized. Lives
@@ -226,22 +237,24 @@ export declare const SKILL_TEST_BUILTIN_CAPS: {
 };
 /**
  * Resolve the effective PER-EVAL wall-clock timeout (ms). Each executor and
- * grader spawn is an independent, bounded-parallel unit (issue #145), so the
+ * grader spawn is an independent, bounded-parallel unit, so the
  * budget is a flat per-spawn ceiling — NOT scaled by the suite size the way the
  * old single serial run's budget was. An explicit `--timeout` (seconds)
  * wins; otherwise the flat {@link DEFAULT_TIMEOUT_MS} default applies.
  */
-export declare function resolveTimeoutMs(opts: RunHarnessOptions): number;
+declare function resolveTimeoutMs(opts: RunHarnessOptions): number;
 /**
  * Map an eval verdict to a process exit code. Default behavior (fail-closed): a
- * failing verdict escalates to EvalFailure (4) — distinct from the harness-broke
- * codes (1/2/3) so a CI consumer can `case $? in 0);; 4) tolerate;; *) hard fail;; esac`.
+ * failing verdict is `FINDINGS` — the harness ran to completion and what it
+ * examined did not pass, exactly as `vat skills validate` reports an
+ * error-severity finding — while a harness that could not run is `ERROR`, so a
+ * CI consumer can `case $? in 0);; 1) tolerate;; *) hard fail;; esac`.
  * When `tolerateEvalFailure` is set (interactive opt-out), a failing verdict is
- * downgraded to Ok (0) and the count lives only in the summary/grading.json.
+ * downgraded to `OK` and the count lives only in the summary/grading.json.
  */
-export declare function verdictExitCode(allPassed: boolean, tolerateEvalFailure: boolean): SkillTestExitCodeValue;
-export declare function resolveStallMs(opts: RunHarnessOptions): number | undefined;
-export declare function resolveKnobs(opts: RunHarnessOptions): {
+export declare function verdictExitCode(allPassed: boolean, tolerateEvalFailure: boolean): typeof ExitCode.OK | typeof ExitCode.FINDINGS;
+declare function resolveStallMs(opts: RunHarnessOptions): number | undefined;
+declare function resolveKnobs(opts: RunHarnessOptions): {
     model?: string;
     maxTurns: number;
     maxBudgetUsd: number;
@@ -255,21 +268,21 @@ export declare function resolveKnobs(opts: RunHarnessOptions): {
  * sources (npm/url/vendored/workspace) have no local source tree to walk, so they
  * are always staged flat (returns undefined). undefined → flat staging.
  */
-export declare function detectItemPluginLayout(source: SkillSource, repoRoot: string): StageItem['pluginLayout'] | undefined;
-export declare function makeStageItem(name: string, source: SkillSource, repoRoot: string, role: 'subject' | undefined, optional?: true): StageItem;
+declare function detectItemPluginLayout(source: SkillSource, repoRoot: string): StageItem['pluginLayout'] | undefined;
+declare function makeStageItem(name: string, source: SkillSource, repoRoot: string, role: 'subject' | undefined, optional?: true): StageItem;
 /**
  * Build the full set of items `stageHarness` will stage: the subject, every
  * REQUIRED `--with` companion, and every OPTIONAL `--with-optional` companion.
  * Both `with` and `optional` STAGE the named companion and make it invocable —
- * they differ only in required-vs-optional resolution (issue #153; a `--with`
- * name that named no positional skill used to be silently dropped, never staged,
- * no manifest trace). Fail-closed on a DUPLICATE staged name (subject / `with` /
+ * they differ only in required-vs-optional resolution (a `--with` name that
+ * names no positional skill must never be silently dropped — unstaged, with no
+ * manifest trace). Fail-closed on a DUPLICATE staged name (subject / `with` /
  * `optional` all share one namespace): the first repeat throws
  * {@link DuplicateStagedSkillError} rather than silently letting a later item
  * clobber an earlier one under the same staged slot.
  */
-export declare function buildStageItems(opts: RunHarnessOptions, repoRoot: string): StageItem[];
-export declare function buildResolveCtx(harnessRoot: string, repoRoot: string): ResolveSkillSourceContext;
+declare function buildStageItems(opts: RunHarnessOptions, repoRoot: string): StageItem[];
+declare function buildResolveCtx(harnessRoot: string, repoRoot: string): ResolveSkillSourceContext;
 /**
  * Match a flag name as a whole token in `claude --help` output.
  *
@@ -278,13 +291,7 @@ export declare function buildResolveCtx(harnessRoot: string, repoRoot: string):
  * of each other (`--max-turns` / `--max-turns-per-eval` would collide). Neither
  * side of the token may be a letter or a dash.
  */
-export declare function helpTextDeclaresFlag(helpText: string, flag: string): boolean;
-/**
- * A flag name no `claude` will ever accept. It is probed alongside the real ones
- * as a NEGATIVE CONTROL: if the probe reports this as supported, the probe is
- * broken and its answer about every other flag is worthless.
- */
-export declare const FLAG_PROBE_SENTINEL = "--vat-probe-flag-that-cannot-exist";
+declare function helpTextDeclaresFlag(helpText: string, flag: string): boolean;
 /**
  * Build a token-free flag-support probe from `claude --help`.
  *
@@ -305,8 +312,17 @@ export declare const FLAG_PROBE_SENTINEL = "--vat-probe-flag-that-cannot-exist";
  * outright — the probe reports EVERY flag unsupported rather than every flag
  * supported. A probe that cannot tell must fail closed and be seen; the defect it
  * replaces failed open and was invisible.
+ *
+ * `--help` runs on the FIRST flag query, not when the probe is built. Building
+ * it is part of assembling preflight's input, and a preflight that never asks
+ * (a stubbed one, or one that fails an earlier check) must not have already
+ * paid for a subprocess: with the spawn at build time every harness run cost
+ * one real `claude --help` — 75 ms where the CLI is installed, an instant
+ * ENOENT where it is not — which read as a 10× platform split in a test that
+ * had injected a fake spawn and stubbed preflight precisely so no process
+ * would start.
  */
-export declare function buildFlagParseProbe(runHelp?: () => string | null): (flag: string) => boolean;
+declare function buildFlagParseProbe(runHelp?: () => string | null): (flag: string) => boolean;
 /**
  * ⚠️ KNOWN OPEN — `costEstimate` here is DEAD, in three independent ways, and none
  * of them is fixable from inside this function:
@@ -326,10 +342,10 @@ export declare function buildFlagParseProbe(runHelp?: () => string | null): (fla
  * reachable: a reachable estimate that says "1 evals × 2 config" is worse than a
  * silent one, because it is quotable.
  */
-export declare function buildPreflightInput(evalsPath: string, pluginDirs: string[], opts: RunHarnessOptions, knobs: {
+declare function buildPreflightInput(evalsPath: string, pluginDirs: string[], opts: RunHarnessOptions, knobs: {
     maxBudgetUsd: number;
 }): PreflightInput;
-export declare function renderPreflightSummary(checks: {
+declare function renderPreflightSummary(checks: {
     name: string;
     passed: boolean;
     message: string;
@@ -355,6 +371,18 @@ export declare function isAcknowledged(opts: Pick<RunHarnessOptions, 'dryRun' |
  * code can reach and rewrite after vat wrote it.
  */
 export declare function formatFrictionReport(items: readonly FrictionItem[]): string;
+/**
+ * Read the run's friction.json (if present + valid) and echo a concise report to
+ * STDERR so users don't miss packaging-fidelity friction VAT merged from the grader
+ * fragments (it is otherwise only written to disk). Best-effort: a missing or empty
+ * report emits nothing. A report that is there but cannot be read or does not parse
+ * emits a one-line warning instead — this runs from the harness `finally`, so it
+ * must not throw, but vat is the sole writer of friction.json and a file it wrote
+ * that it cannot read back is worth a line. Never touches stdout (which stays
+ * machine-readable). Accepts `undefined` (a no-op) so the harness `finally` can
+ * call it unconditionally even when a throw preempted assignment of the path.
+ */
+declare function emitFrictionReport(frictionPath: string | undefined): void;
 /**
  * Resolve the PERSISTENT location where a bootstrap scaffold should be written
  * so "fill it in and re-run" actually works for the user (the staged copy is
@@ -362,7 +390,7 @@ export declare function formatFrictionReport(items: readonly FrictionItem[]): st
  * that real source dir; otherwise we anchor under the repo root by skill name.
  */
 /** The subject skill's display name (trailing segment of the subject arg). */
-export declare function subjectSkillName(opts: RunHarnessOptions): string;
+declare function subjectSkillName(opts: RunHarnessOptions): string;
 /**
  * Where this run READS its eval suite from, anchored at the subject's authored
  * source dir.
@@ -385,16 +413,7 @@ export declare function subjectSkillName(opts: RunHarnessOptions): string;
  * into `<skillDir>/<path>`, which does not exist — so the run did not fail, it
  * bootstrapped a starter template at the bogus location and graded that.
  */
-export declare function resolveScaffoldEvalsPath(opts: RunHarnessOptions, repoRoot: string, evalsRef: string | undefined): string;
-/**
- * The vat-only directory a subject's eval suite is relocated to when the resolved
- * artifact is the only place it exists (npm/url/vendored, or a source tree that
- * ships its own evals). Deliberately OUTSIDE the harness root — the harness root is
- * the executor's sandbox, and the suite is the answer key to the task the executor
- * is performing. Created 0700 and removed in the run's cleanup, exactly like
- * {@link resolveGraderOutDir}. Pure (derives a path only).
- */
-export declare function resolveEvalSuiteHoldDir(dirToken: string): string;
+declare function resolveScaffoldEvalsPath(opts: RunHarnessOptions, repoRoot: string, evalsRef: string | undefined): string;
 /**
  * Locate the eval suite the run will read, WITHOUT it ever being reachable by the
  * executor. Precedence, and why:
@@ -405,12 +424,12 @@ export declare function resolveEvalSuiteHoldDir(dirToken: string): string;
  * 2. **The vat-only hold dir**, when staging harvested a suite that exists nowhere
  *    else (a fetched artifact). Its layout mirrors an authored evals dir, so
  *    `fixtures/` resolve relative to it unchanged.
- * 3. Neither → `undefined`, and the caller bootstraps a template (exit 3).
+ * 3. Neither → `undefined`, and the caller bootstraps a template (exit 2, `Reason: bootstrap`).
  *
  * Returns the suite's absolute path; its `dirname` is the base for each eval's
  * declared input `files`.
  */
-export declare function resolveEvalSuitePath(input: {
+declare function resolveEvalSuitePath(input: {
     opts: RunHarnessOptions;
     repoRoot: string;
     /** Explicit `test.evals` / `--evals` value, or `undefined` for the convention. */
@@ -434,7 +453,7 @@ export declare function resolveEvalSuitePath(input: {
  * Named by an unpredictable token, like the other vat-only dirs, and removed by
  * the same cleanup. Pure (derives a path only).
  */
-export declare function resolveWorkspacesRoot(dirToken: string): string;
+declare function resolveWorkspacesRoot(dirToken: string): string;
 /** Parse the staged eval suite and materialize each eval's input `files` into
  * `<workspacesRoot>/<arm>/<id>/`, once per arm this run will execute. Returns the
  * workspaces root, the parsed {@link EvalSuite} (so the eval loop has the entries
@@ -452,8 +471,8 @@ export declare function resolveWorkspacesRoot(dirToken: string): string;
  * 8 bytes is ample for "not guessable within a run that lasts minutes"; these are
  * blinding/anti-enumeration tokens, not secrets protecting data at rest.
  */
-export declare function mintArmWorkspaceDirs(baseline: boolean): ArmWorkspaceDirs;
-export declare function stageWorkspacesForRun(evalsPath: string, workspacesRoot: string, armDirs: ArmWorkspaceDirs): {
+declare function mintArmWorkspaceDirs(baseline: boolean): ArmWorkspaceDirs;
+declare function stageWorkspacesForRun(evalsPath: string, workspacesRoot: string, armDirs: ArmWorkspaceDirs): {
     workspacesRoot: string;
     declaredEvalCount: number;
     suite: EvalSuite;
@@ -555,12 +574,6 @@ export interface CleanupHarnessOptions {
      */
     created: boolean;
 }
-/**
- * The one child of the harness root that cleanup NEVER removes. Cleanup exists to
- * evict staged untrusted skill bytes and prompts from OS tmp; `results/` is the
- * opposite — it is the run's product, written solely by vat.
- */
-export declare const RETAINED_RESULTS_DIRNAME = "results";
 /**
  * Remove the harness directory's staged contents after a run so untrusted skill
  * bytes and prompts do not accumulate in OS tmp. No-op when the user asked to keep
@@ -588,7 +601,7 @@ export declare const RETAINED_RESULTS_DIRNAME = "results";
  * the run and cleanup is left in place rather than followed — `rmSync(recursive)`
  * could otherwise delete the symlink's target outside tmp.
  */
-export declare function cleanupHarness(harnessRoot: string, opts: CleanupHarnessOptions): void;
+declare function cleanupHarness(harnessRoot: string, opts: CleanupHarnessOptions): void;
 /** One unit of executor→grader work: an eval + which arm (with/without skill). */
 export interface EvalWorkItem {
     entry: EvalEntry;
@@ -602,14 +615,14 @@ export interface EvalWorkItem {
  * (see {@link partitionFragmentsByArm}) and never drives tier gating. Pure +
  * unit-testable.
  */
-export declare function buildEvalWorkItems(evals: readonly EvalEntry[], baseline: boolean): EvalWorkItem[];
+declare function buildEvalWorkItems(evals: readonly EvalEntry[], baseline: boolean): EvalWorkItem[];
 /**
  * Partition graded fragments into the WITH arm (the authoritative verdict +
  * grading.json) and the WITHOUT arm (baseline.json, informational only). A
  * fragment with no `arm` (or `arm: 'with'`) is a WITH-arm fragment. Pure +
  * unit-testable.
  */
-export declare function partitionFragmentsByArm(fragments: EvalFragment[]): {
+declare function partitionFragmentsByArm(fragments: EvalFragment[]): {
     withArm: EvalFragment[];
     withoutArm: EvalFragment[];
 };
@@ -633,7 +646,7 @@ export declare function partitionFragmentsByArm(fragments: EvalFragment[]): {
  * container; that is tracked as a follow-up (see CHANGELOG "Security" notes) and
  * is the only thing that closes the residual race outright.
  */
-export declare function resolveGraderOutDir(dirToken: string): string;
+declare function resolveGraderOutDir(dirToken: string): string;
 /**
  * The executor working directory for one eval ON ONE ARM: its staged input
  * workspace `<workspacesRoot>/<arm>/<id>`, ALWAYS — empty when the eval declares
@@ -655,7 +668,7 @@ export declare function resolveGraderOutDir(dirToken: string): string;
  * told the control arm it was the control, and `../with/e1` told it where to look.
  * See {@link mintArmWorkspaceDirs}. Pure + unit-testable.
  */
-export declare function resolvePerEvalWorkspaceDir(entry: EvalEntry, workspacesRoot: string, arm: EvalArm, armDirs: ArmWorkspaceDirs): string;
+declare function resolvePerEvalWorkspaceDir(entry: EvalEntry, workspacesRoot: string, arm: EvalArm, armDirs: ArmWorkspaceDirs): string;
 /**
  * Best-effort removal of a vat-only tmp dir that lives OUTSIDE the harness root —
  * the grader fragment dir and the held eval suite. Never throws (it runs from
@@ -684,8 +697,12 @@ export declare function resolvePerEvalWorkspaceDir(entry: EvalEntry, workspacesR
  * could not be removed will break the NEXT run with a "busy" error, and an operator
  * who saw nothing here has no way to connect the two.
  */
-export declare function swallowCleanupFailure(step: () => void): void;
-export declare function removeVatOnlyDir(dir: string | undefined): void;
+declare function swallowCleanupFailure(step: () => void): void;
+/**
+ * Remove one vat-only temp dir. Same discipline as {@link cleanupHarness}: a failed
+ * removal is not a run failure, and it is reported rather than swallowed.
+ */
+declare function removeVatOnlyDir(dir: string | undefined): void;
 /** Everything one executor→grader pipeline worker needs, built once per run. */
 interface EvalRunContext {
     subjectStagedDir: string;
@@ -745,24 +762,6 @@ interface EvalRunContext {
      */
     harnessRoot: string;
 }
-/**
- * The control arm ran out of rate-limit retries — record it and let the run live.
- *
- * The retryable case is handled correctly by {@link runEvalWorker} and must stay that
- * way; this is the EXHAUSTED case, which used to be indistinguishable from it. A
- * control executor rate-limited on every attempt threw after five retries, taking
- * down a run in which both treatment executors and both treatment graders had already
- * completed and been billed, leaving `results/` holding `provenance.json` and nothing
- * else — the exact failure {@link runEvalWorker} exists to prevent, reached by the one
- * error class it had to let through.
- *
- * The treatment arm still hard-fails: there is no treatment result to salvage, which
- * is the same asymmetry {@link EvalWorkOutcome} documents.
- *
- * Wired as the pipeline's `onRetriesExhausted`, and `--baseline` — which doubles the
- * spawn count — is the run most likely to need it.
- */
-export declare function rateLimitExhaustedOutcome(item: EvalWorkItem, error: RateLimitSignal): EvalWorkOutcome;
 /**
  * Strip the fields VAT attaches itself, before VAT attaches them.
  *
@@ -778,28 +777,7 @@ export declare function rateLimitExhaustedOutcome(item: EvalWorkItem, error: Rat
  * scanned properly, and an operator who learns to ignore that warning stops reading
  * the real ones.
  */
-export declare function withoutGraderContamination(fragment: EvalFragment): EvalFragment;
-/**
- * What one work item produced: a graded fragment, or — CONTROL ARM ONLY — a
- * recorded failure that the run carries on past.
- *
- * The asymmetry is the whole point and it is not a subjective call. A treatment-arm
- * failure leaves nothing to salvage: `grading.json` IS the treatment arm, so a run
- * that cannot produce it has produced nothing and may as well stop. A control-arm
- * failure destroys only the second half of a comparison whose first half is already
- * bought and paid for — and the artifact that reports that comparison already has a
- * way to say "I do not exist here" (`delta: null`). Failing the whole run on a
- * control-arm timeout threw away every treatment executor and grader spawn that had
- * already completed, wrote no `grading.json` at all, and left `results/` holding
- * only `provenance.json`.
- */
-type EvalWorkOutcome = {
-    readonly fragment: EvalFragment;
-    readonly controlFailure?: undefined;
-} | {
-    readonly fragment?: undefined;
-    readonly controlFailure: BaselineControlArmFailure;
-};
+declare function withoutGraderContamination(fragment: EvalFragment): EvalFragment;
 /**
  * Lift the run's content needles off the STAGED SKILL.md.
  *
@@ -821,13 +799,14 @@ type EvalWorkOutcome = {
  * Fixtures are read from the STAGED workspace rather than the suite directory, for
  * the same reason the SKILL.md is: that is byte-for-byte what the arm was handed.
  *
- * Returns `[]` when the file cannot be read. A missing SKILL.md is not this
+ * Returns `[]` when there is no staged SKILL.md. A missing SKILL.md is not this
  * function's error to raise (staging has already validated the subject), and an
- * unarmed signal is reported as unarmed rather than claimed as clean. An
- * unreadable FIXTURE is skipped for the same reason, and errs the safe way: a
- * fixture we could not exclude can only make the signal noisier, never blinder.
+ * unarmed signal is reported as unarmed rather than claimed as clean. A SKILL.md
+ * that is THERE but refused is a different thing — `[]` would silently disarm the
+ * contamination signal for the whole run — so a refusal propagates. The same split
+ * applies to fixtures: see {@link collectFixtureText}.
  */
-export declare function resolveSkillContentNeedles(subjectStagedDir: string, evals: readonly EvalEntry[], 
+declare function resolveSkillContentNeedles(subjectStagedDir: string, evals: readonly EvalEntry[], 
 /**
  * Where the staged fixtures live, as the two inputs an arm root is DERIVED from
  * rather than as the pre-joined path itself — see {@link armWorkspaceRoot}. Taking
@@ -886,13 +865,13 @@ export type ContaminationCtx = Pick<EvalRunContext, 'armDirs' | 'workspacesRoot'
  * not to run. That is the same shape as the dropped `armCwd` that anchored the whole
  * walk one directory too high, also green.
  */
-export declare function buildContaminationInput(transcript: string, ctx: ContaminationCtx, evalId: string): DetectBaselineContaminationInput;
+declare function buildContaminationInput(transcript: string, ctx: ContaminationCtx, evalId: string): DetectBaselineContaminationInput;
 /**
  * The same input built for the "which detectors are ARMED?" question, which is asked
  * once per run with no transcript and no eval — so it can honestly supply neither,
  * and `armCwd` is correctly absent rather than accidentally dropped.
  */
-export declare function buildContaminationSignalsInput(ctx: ContaminationCtx): DetectBaselineContaminationInput;
+declare function buildContaminationSignalsInput(ctx: ContaminationCtx): DetectBaselineContaminationInput;
 /** The results/ artifacts vat is the SOLE writer of, resolved for one run. */
 export interface ArtifactPaths {
     gradingOut: string;
@@ -903,7 +882,7 @@ export interface ArtifactPaths {
 /** Resolve the run's grading/friction/baseline/tool-eval artifact paths under
  *  `resultsDir`. Single source of truth for the filenames (used by the
  *  pre-pipeline stale wipe AND the post-merge writer). */
-export declare function resolveArtifactPaths(resultsDir: string): ArtifactPaths;
+declare function resolveArtifactPaths(resultsDir: string): ArtifactPaths;
 /**
  * Remove any PRIOR run's artifacts before this run writes its own. The harness
  * root is deterministic per skill-set and reused across runs (`--keep`/`--out`, or
@@ -913,7 +892,7 @@ export declare function resolveArtifactPaths(resultsDir: string): ArtifactPaths;
  * run's. Wiping all three up front closes that cross-run leak. Best-effort
  * (`force: true`) — a missing file is fine.
  */
-export declare function wipeStaleArtifacts(paths: ArtifactPaths): void;
+declare function wipeStaleArtifacts(paths: ArtifactPaths): void;
 /**
  * Where a results artifact goes when it fails the fail-closed gate.
  *
@@ -924,7 +903,7 @@ export declare function wipeStaleArtifacts(paths: ArtifactPaths): void;
  * a maintainer needs in order to see which refine tripped, and a name ending in
  * `.rejected` cannot be mistaken for the artifact a reader came for.
  */
-export declare function rejectedArtifactPath(path: string): string;
+declare function rejectedArtifactPath(path: string): string;
 /**
  * Merge the run's grader fragments and WRITE the run artifacts (vat is the SOLE
  * writer): grading.json from the WITH-arm fragments, friction.json from ALL
@@ -952,7 +931,7 @@ export declare function rejectedArtifactPath(path: string): string;
  * everything it declared, so the two fields were numerically identical in all of
  * them and the ONE thing this function exists to keep distinct was unpinned.
  */
-export declare function gradedCounts(fragments: EvalFragment[]): ArmEvalGrade[];
+declare function gradedCounts(fragments: EvalFragment[]): ArmEvalGrade[];
 /**
  * The stderr report for a `--baseline` run: the delta line, then the ⚠️ banner when
  * the run is unusable. Pure — the caller decides WHEN it goes out, which is the
@@ -992,24 +971,24 @@ export declare function gradedCounts(fragments: EvalFragment[]): ArmEvalGrade[];
  * on a run where they can be. A contaminated delta is also diagnostic in its own
  * right: it collapses toward zero, which is corroboration, not noise.
  */
-export declare function formatBaselineReport(delta: BaselineDelta, integrity: BaselineIntegrity): string;
+declare function formatBaselineReport(delta: BaselineDelta, integrity: BaselineIntegrity): string;
 /**
- * The COMPOSITE run verdict (issue #145 Phase T): the run passes only when BOTH
+ * The COMPOSITE run verdict: the run passes only when BOTH
  * the prose-expectation grading passed AND every tool-expectation verdict passed.
  * Tool verdicts live in tool-eval.json (a SEPARATE channel — C2); this combines
  * the two at the exit-code layer WITHOUT mixing the channels' data. When no eval
  * declared `toolExpectations`, `toolEval.evals` is empty and this equals
  * `outputAllPassed`. Pure + unit-testable.
  */
-export declare function computeCompositeVerdict(outputAllPassed: boolean, toolEval: ToolEvalReport): boolean;
+declare function computeCompositeVerdict(outputAllPassed: boolean, toolEval: ToolEvalReport): boolean;
 /**
  * The run's final pass/fail after cost-tiered fail-fast: the {@link
  * computeCompositeVerdict} of the tiers that RAN, AND no tiers were skipped. A
  * fail-fast run that gated higher tiers is NEVER a pass (skipped ≠ passed) — this
- * forces `false` so the exit code is EvalFailure (4), never downgraded to 0 by the
+ * forces `false` so the exit code is FINDINGS, never downgraded to 0 by the
  * composite path alone. Pure + unit-testable.
  */
-export declare function resolveCompositeAllPassed(outputAllPassed: boolean, toolEval: ToolEvalReport, skipped: SkippedEvalsSummary | undefined): boolean;
+declare function resolveCompositeAllPassed(outputAllPassed: boolean, toolEval: ToolEvalReport, skipped: SkippedEvalsSummary | undefined): boolean;
 /**
  * Running total of spend across every executor+grader session in a run (adopter
  * follow-up). `sessions` counts only sessions that REPORTED a `total_cost_usd`, so
@@ -1022,13 +1001,13 @@ export interface RunCostSummary {
     sessions: number;
 }
 /** Fold one session's `total_cost_usd` into the accumulator; a non-number (mock spawn / missing result) is ignored. */
-export declare function recordSessionCost(acc: RunCostSummary, totalCostUsd: number | undefined): void;
+declare function recordSessionCost(acc: RunCostSummary, totalCostUsd: number | undefined): void;
 /**
  * The ` | ≈$0.42 across 6 sessions` spend suffix for the summary line, or `''`
  * when no session reported a cost (e.g. every spawn was a test mock) so the suffix
  * never adds noise to a run with no cost signal. Pure + unit-testable.
  */
-export declare function formatRunCostSuffix(cost: RunCostSummary | undefined): string;
+declare function formatRunCostSuffix(cost: RunCostSummary | undefined): string;
 /**
  * The run's human summary line, computed from the COMPOSITE verdict so an
  * output-pass with a failing tool verdict still reads FAIL. The prose-expectation
@@ -1036,7 +1015,7 @@ export declare function formatRunCostSuffix(cost: RunCostSummary | undefined): s
  * verdict failed, a `(N tool)` suffix names how many — so a composite FAIL whose
  * OUTPUT counts look all-green (e.g. `FAIL 3/3 (1 tool)`) is self-explaining. Pure.
  */
-export declare function buildRunSummary(verdict: GradingVerdict, toolEval: ToolEvalReport, compositeAllPassed: boolean): string;
+declare function buildRunSummary(verdict: GradingVerdict, toolEval: ToolEvalReport, compositeAllPassed: boolean): string;
 /**
  * The run summary line, appending the fail-fast SKIPPED note when the tier gate
  * stopped higher tiers. Legibility is required — the skipped tiers are named on
@@ -1044,7 +1023,7 @@ export declare function buildRunSummary(verdict: GradingVerdict, toolEval: ToolE
  * tiers ALWAYS reads FAIL (skipped ≠ passed forces `compositeAllPassed` false at
  * the call site), so the base line is already FAIL when the note is present.
  */
-export declare function buildRunSummaryWithSkips(verdict: GradingVerdict, toolEval: ToolEvalReport, compositeAllPassed: boolean, skipped: SkippedEvalsSummary | undefined, cost?: RunCostSummary): string;
+declare function buildRunSummaryWithSkips(verdict: GradingVerdict, toolEval: ToolEvalReport, compositeAllPassed: boolean, skipped: SkippedEvalsSummary | undefined, cost?: RunCostSummary): string;
 /**
  * Post-merge D2 gate over the vat-written results artifacts (vat is SOLE writer):
  * grading.json, friction.json, tool-eval.json — and, on a baseline run, baseline.json
@@ -1065,7 +1044,7 @@ export declare function buildRunSummaryWithSkips(verdict: GradingVerdict, toolEv
  * baseline and wrote nothing), which is exactly what a fail-CLOSED gate must not do.
  * A non-baseline run writes no baseline.json at all and is not asked about one.
  */
-export declare function assertVatWroteArtifacts(paths: ArtifactPaths, baselineRun: boolean): void;
+declare function assertVatWroteArtifacts(paths: ArtifactPaths, baselineRun: boolean): void;
 /**
  * Domain orchestrator for `vat skill test run`. Pure of process.exit — all
  * exit-code decisions live in the caller (run.ts).
@@ -1082,10 +1061,68 @@ export declare function assertVatWroteArtifacts(paths: ArtifactPaths, baselineRu
  * `harnessCreated` is true only for the derived-under-OS-tmp case; an explicit
  * `--out` or `--workdir` is a location the user owns and is never auto-removed.
  */
-export declare function resolveHarnessLocation(opts: Pick<RunHarnessOptions, 'out' | 'workdir' | 'subject'>): {
+declare function resolveHarnessLocation(opts: Pick<RunHarnessOptions, 'out' | 'workdir' | 'subject'>): {
     harnessRoot: string;
     harnessCreated: boolean;
 };
 export declare function runSkillTestHarness(opts: RunHarnessOptions): Promise<RunHarnessResult>;
+/**
+ * The test-facing seam — every helper the unit tests reach that is NOT part of
+ * this module's API.
+ *
+ * These used to be forty-four separate `export`s, indistinguishable at the export
+ * keyword from the seven names the skill-test barrel actually publishes, so
+ * "is this API?" was a question for a JSDoc rather than a grep. Now it is a
+ * grep: a name here is reachable by a test and by nothing else. Nothing under
+ * `src/` imports `__internal` and no barrel re-exports it — a dev-tools test
+ * holds both lines. Types stay exported on their own: an object cannot carry
+ * them, and a type is not a call site.
+ */
+export declare const __internal: {
+    readonly assertVatWroteArtifacts: typeof assertVatWroteArtifacts;
+    readonly buildContaminationInput: typeof buildContaminationInput;
+    readonly buildContaminationSignalsInput: typeof buildContaminationSignalsInput;
+    readonly buildEvalWorkItems: typeof buildEvalWorkItems;
+    readonly buildFlagParseProbe: typeof buildFlagParseProbe;
+    readonly buildPreflightInput: typeof buildPreflightInput;
+    readonly buildResolveCtx: typeof buildResolveCtx;
+    readonly buildRunSummary: typeof buildRunSummary;
+    readonly buildRunSummaryWithSkips: typeof buildRunSummaryWithSkips;
+    readonly computeCompositeVerdict: typeof computeCompositeVerdict;
+    readonly detectItemPluginLayout: typeof detectItemPluginLayout;
+    readonly emitFrictionReport: typeof emitFrictionReport;
+    readonly FLAG_PROBE_SENTINEL: "--vat-probe-flag-that-cannot-exist";
+    readonly formatBaselineReport: typeof formatBaselineReport;
+    readonly formatRunCostSuffix: typeof formatRunCostSuffix;
+    readonly gradedCounts: typeof gradedCounts;
+    readonly helpTextDeclaresFlag: typeof helpTextDeclaresFlag;
+    readonly makeStageItem: typeof makeStageItem;
+    readonly mintArmWorkspaceDirs: typeof mintArmWorkspaceDirs;
+    readonly partitionFragmentsByArm: typeof partitionFragmentsByArm;
+    readonly recordSessionCost: typeof recordSessionCost;
+    readonly rejectedArtifactPath: typeof rejectedArtifactPath;
+    readonly removeVatOnlyDir: typeof removeVatOnlyDir;
+    readonly renderPreflightSummary: typeof renderPreflightSummary;
+    readonly resolveArtifactPaths: typeof resolveArtifactPaths;
+    readonly resolveCompositeAllPassed: typeof resolveCompositeAllPassed;
+    readonly resolveHarnessLocation: typeof resolveHarnessLocation;
+    readonly resolveKnobs: typeof resolveKnobs;
+    readonly resolvePerEvalWorkspaceDir: typeof resolvePerEvalWorkspaceDir;
+    readonly resolveScaffoldEvalsPath: typeof resolveScaffoldEvalsPath;
+    readonly resolveSkillContentNeedles: typeof resolveSkillContentNeedles;
+    readonly resolveStallMs: typeof resolveStallMs;
+    readonly resolveTimeoutMs: typeof resolveTimeoutMs;
+    readonly resolveWorkspacesRoot: typeof resolveWorkspacesRoot;
+    readonly RETAINED_RESULTS_DIRNAME: "results";
+    readonly stageWorkspacesForRun: typeof stageWorkspacesForRun;
+    readonly subjectSkillName: typeof subjectSkillName;
+    readonly swallowCleanupFailure: typeof swallowCleanupFailure;
+    readonly wipeStaleArtifacts: typeof wipeStaleArtifacts;
+    readonly withoutGraderContamination: typeof withoutGraderContamination;
+    readonly cleanupHarness: typeof cleanupHarness;
+    readonly buildStageItems: typeof buildStageItems;
+    readonly resolveGraderOutDir: typeof resolveGraderOutDir;
+    readonly resolveEvalSuitePath: typeof resolveEvalSuitePath;
+};
 export {};
 //# sourceMappingURL=run-harness.d.ts.map