vigiles 16.1.3 → 17.0.0

package/dist/adapters/claude-code/run-scripts.d.ts

@@ -74,10 +74,16 @@ import type { NodeCaps } from "../../ts-runner-caps.js";
  * type stripping. Throws a clear, actionable error when neither is available.
  * Pure — exported for testing.
  *
+ * `entry` interposes a program that takes the script as its ARGUMENT instead of
+ * running the script as the program. `vigiles eval` passes one: an eval file
+ * describes its eval rather than running it (see `src/eval-define.ts`), so
+ * something has to import the description and execute what it declares. Harness
+ * scripts pass nothing and are launched exactly as before.
+ *
  * 🔴 The disjunction below is `canRunTypeScript` — keep them together. When they
  * drifted, the tool recommended a `.ts` file and then refused to run it.
  */
-export declare function interpreterArgs(file: string, caps: NodeCaps): string[];
+export declare function interpreterArgs(file: string, caps: NodeCaps, entry?: string): string[];
 /**
  * Expand the given path/glob patterns into concrete script files. A pattern
  * that is an existing file passes through unchanged; anything else is treated
@@ -85,8 +91,18 @@ export declare function interpreterArgs(file: string, caps: NodeCaps): string[];
  * are deduped and sorted; `node_modules` and `dist` are always ignored.
  */
 export declare function discoverScripts(patterns: readonly string[], defaultGlob: string, cwd: string): string[];
+/** Extra wiring for {@link runScripts}. */
+export interface RunScriptsOptions {
+    /**
+     * A program to run INSTEAD of each script, with the script's path as its one
+     * argument. `vigiles eval` passes `dist/eval-entry.js`; `vigiles test` passes
+     * nothing. See {@link interpreterArgs}.
+     */
+    readonly entry?: string;
+}
 /**
- * Run each script as `node <file>`, inheriting stdio so the script's own report
+ * Run each script as `node <file>` (or `node <entry> <file>`, see
+ * {@link RunScriptsOptions}), inheriting stdio so the script's own report
  * streams to the console. `env` is merged over `process.env` for every child
  * (e.g. `VIGILES_TRIALS`). Returns the per-file exit codes + check counts.
  *
@@ -100,7 +116,7 @@ export declare function discoverScripts(patterns: readonly string[], defaultGlob
  * record them (`.vigiles/coverage.json`) and coverage can answer "tested?" from
  * execution rather than from a matching file name.
  */
-export declare function runScripts(files: readonly string[], cwd: string, env?: NodeJS.ProcessEnv): ScriptRunResult[];
+export declare function runScripts(files: readonly string[], cwd: string, env?: NodeJS.ProcessEnv, opts?: RunScriptsOptions): ScriptRunResult[];
 /**
  * Whether any script FAILED. Neither a skip nor a vacuous run counts: the first
  * declined to run, the second ran and verified nothing, and neither is evidence

package/dist/adapters/claude-code/run-scripts.js

@@ -88,16 +88,25 @@ const ts_runner_caps_js_2 = require("../../ts-runner-caps.js");
  * type stripping. Throws a clear, actionable error when neither is available.
  * Pure — exported for testing.
  *
+ * `entry` interposes a program that takes the script as its ARGUMENT instead of
+ * running the script as the program. `vigiles eval` passes one: an eval file
+ * describes its eval rather than running it (see `src/eval-define.ts`), so
+ * something has to import the description and execute what it declares. Harness
+ * scripts pass nothing and are launched exactly as before.
+ *
  * 🔴 The disjunction below is `canRunTypeScript` — keep them together. When they
  * drifted, the tool recommended a `.ts` file and then refused to run it.
  */
-function interpreterArgs(file, caps) {
+function interpreterArgs(file, caps, entry) {
+    // The TS flags are chosen from FILE's extension even when `entry` runs — a
+    // JavaScript entry importing a `.ts` eval still needs the loader installed.
+    const tail = entry === undefined ? [file] : [entry, file];
     if (!TS_EXT.test(file))
-        return [file];
+        return tail;
     if (caps.tsx)
-        return ["--import", "tsx", file];
+        return ["--import", "tsx", ...tail];
     if (caps.stripTypes)
-        return ["--experimental-strip-types", file];
+        return ["--experimental-strip-types", ...tail];
     throw new Error(`Cannot run TypeScript test script "${file}": install tsx ` +
         `(npm i -D tsx) or use Node >= 22.6, or author it as a .mjs file.`);
 }
@@ -154,7 +163,8 @@ function readCheckReport(path) {
     }
 }
 /**
- * Run each script as `node <file>`, inheriting stdio so the script's own report
+ * Run each script as `node <file>` (or `node <entry> <file>`, see
+ * {@link RunScriptsOptions}), inheriting stdio so the script's own report
  * streams to the console. `env` is merged over `process.env` for every child
  * (e.g. `VIGILES_TRIALS`). Returns the per-file exit codes + check counts.
  *
@@ -168,7 +178,7 @@ function readCheckReport(path) {
  * record them (`.vigiles/coverage.json`) and coverage can answer "tested?" from
  * execution rather than from a matching file name.
  */
-function runScripts(files, cwd, env = {}) {
+function runScripts(files, cwd, env = {}, opts = {}) {
     const caps = (0, ts_runner_caps_js_2.detectNodeCaps)(cwd);
     const results = [];
     const countDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-checks-"));
@@ -176,7 +186,7 @@ function runScripts(files, cwd, env = {}) {
         files.forEach((file, i) => {
             let argv;
             try {
-                argv = interpreterArgs(file, caps);
+                argv = interpreterArgs(file, caps, opts.entry);
             }
             catch (e) {
                 console.error(`✗ ${file}: ${e.message}`);

package/dist/adapters/codex/eval.js

@@ -36,6 +36,7 @@ exports.codexEvalAgentRunner = codexEvalAgentRunner;
 exports.codexEvalRunner = codexEvalRunner;
 const node_child_process_1 = require("node:child_process");
 const foreign_runner_js_1 = require("../../core/foreign-runner.js");
+const eval_load_phase_js_1 = require("../../core/eval-load-phase.js");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const str = (v) => (typeof v === "string" ? v : "");
@@ -229,6 +230,7 @@ function codexEvalRunner(args) {
     // The DOCUMENTED alternative to the default Claude runner, and the one the
     // untested-skill nudge now recommends — so it is exactly as able to be
     // collected by a stray `npx vitest run`, and exactly as expensive.
+    (0, eval_load_phase_js_1.refuseDuringEvalLoad)("driving `codex exec`");
     (0, foreign_runner_js_1.refuseUnderForeignRunner)("driving `codex exec`");
     const r = (0, node_child_process_1.spawnSync)("codex", [
         "exec",

package/dist/audit-score.js

@@ -49,7 +49,7 @@ const score_core_js_1 = require("./score-core.js");
 const W_UNTESTED = 3;
 /** The command that answers the firing question — named, not alluded to. */
 const MEASURE_FIRING_COMMAND = "run `npx vigiles audit` interactively to measure, or add a `*.eval.mjs` " +
-    "(`paid_measureTriggerRate`, vigiles/eval)";
+    "(`export default defineEval({ measureTriggerRate: … })`, vigiles)";
 /** Resolve the terse "thing(s)" plural placeholder against a count:
  * n===1 drops the "(s)" ("1 tool"); otherwise it becomes "s" ("3 tools"). */
 function pluralizeLabel(n, label) {

package/dist/cli.js

@@ -1706,7 +1706,7 @@ function formatTriggerNudge(triggerableSkills) {
         return "";
     const n = triggerableSkills;
     return (`ℹ Do your ${String(n)} skill${n === 1 ? "" : "s"} actually fire? The deterministic read can't tell — ` +
-        `run \`audit\` interactively to measure, or test with \`paid_measureTriggerRate\` (vigiles/eval).`);
+        `run \`audit\` interactively to measure, or add a \`*.eval.mjs\` declaring \`measureTriggerRate\` (vigiles).`);
 }
 /** A terminal summary of the rule map: the CONFIDENT lane counts + the POSSIBLE
  * (review) and SKIPPED tiers, with the honest caveat that detection is a
@@ -4336,7 +4336,12 @@ async function handleRunScripts(kind, args, restArgs) {
     if (trialsFlag)
         env.VIGILES_TRIALS = trialsFlag.split("=")[1];
     console.log(`Running ${String(files.length)} ${kind} file(s):\n`);
-    const results = (0, run_scripts_js_1.runScripts)(files, cwd, env);
+    // An eval file DESCRIBES its eval; `dist/eval-entry.js` is what imports the
+    // description and runs what it declares. A harness script is still its own
+    // program (it is free, so "import spends money" never applied to it).
+    const results = (0, run_scripts_js_1.runScripts)(files, cwd, env, {
+        ...(kind === "eval" ? { entry: (0, node_path_1.resolve)(__dirname, "eval-entry.js") } : {}),
+    });
     // Write down WHAT the run exercised, so `lint`/`audit` can answer "tested?"
     // from execution instead of from a matching file name. Not a new verb and not
     // a flag: the run already happened, and this is the runner recording what it

package/dist/core/eval-load-phase.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The paid tier is closed while an eval file is being LOADED.
+ *
+ * ## The failure this removes
+ *
+ * An eval file used to do its work at the top level:
+ *
+ *   const report = await measureTriggerRate({ … });   // ← module body
+ *
+ * In ESM, `import` IS execution, so *reading* such a file spends real money.
+ * Measured 2026-08-12 (and reproduced 2026-08-18 with an inert stand-in that
+ * writes a marker file instead of spawning): `node -e 'import("./x.eval.mjs")'`
+ * ran the whole body and the one guard that exists — `refuseUnderForeignRunner`
+ * — stayed SILENT, because under `node -e` there is no `process.argv[1]` at all:
+ *
+ *   node -e 'import(x)'   argv[1] = undefined  → foreignRunner(…) = null
+ *
+ * That guard is not broken; it answers a different question ("does somebody
+ * else's test runner own this process?"). No process fact distinguishes
+ * `node -e 'import(x)'` from a legitimate runner doing `import(x)`, so no
+ * argv-shaped guard can close this door without also refusing the correct
+ * invocation — the exact failure mode that got `process.env.VITEST` rejected in
+ * `foreign-runner.ts`.
+ *
+ * ## What closes it instead
+ *
+ * The SHAPE changed: an eval file now DESCRIBES its eval (`defineEval`) and
+ * `vigiles eval` runs it. A description cannot spend, so for a conforming file
+ * the door is shut by construction and this module is not needed.
+ *
+ * This module covers the file that is only HALF migrated — a `defineEval` export
+ * plus a leftover top-level `measure(…)`. During the import that the eval runner
+ * performs, the paid tier refuses. So the usual way anyone runs an eval turns a
+ * silent bill into a loud error that names the fix, instead of paying it.
+ *
+ * ⚠️ HONEST BOUNDARY, stated rather than implied. This is scoped to the runner's
+ * own import. `node -e 'import("./half-migrated.eval.mjs")'` still spends,
+ * because that file still contains the original defect — the redesign made the
+ * defect *avoidable and detectable*, it cannot retroactively fix a file that did
+ * not adopt it. The free syntax check is `node --check <file>`, which never
+ * executes anything.
+ *
+ * ## Why the default is OPEN
+ *
+ * `paid_runEval` and friends are public API; somebody's own script calling them
+ * at top level is their business. A gate that defaulted to closed would refuse
+ * every correct direct call — again, "a guard that fires on correct input is a
+ * guard people delete". So the window is opened by nobody and closed by exactly
+ * one caller: `eval-entry.ts`, around its `import()`.
+ *
+ * Imports NOTHING, so every spawn door (including the adapters) can call it
+ * without a cycle — the same reason `foreign-runner.ts` is a leaf.
+ */
+/**
+ * Open the no-spend window. Called by `eval-entry.ts` immediately before it
+ * imports an eval file, and paired with {@link endEvalLoad} in a `finally`.
+ */
+export declare function beginEvalLoad(): void;
+/** Close the no-spend window: the description is loaded, the runner may spend. */
+export declare function endEvalLoad(): void;
+/** Whether the no-spend window is open (exported for tests + the entry). */
+export declare function inEvalLoad(): boolean;
+/**
+ * The refusal message. Separate from the check so a test can assert the WORDS:
+ * this fires on a file whose author has not seen the new shape yet, so it has to
+ * teach it, not just stop.
+ */
+export declare function evalLoadRefusal(what: string): string;
+/**
+ * Refuse to spend model budget while an eval file is being imported.
+ *
+ * 🔴 CALL THIS AT EVERY REAL-MODEL SPAWN, beside `refuseUnderForeignRunner`, and
+ * OUTSIDE any `try` that swallows — `judge` and `deriveAttackReal` both wrap
+ * their spawn in `try { … } catch { return fallback }`, so a refusal thrown
+ * inside would be downgraded to a score of 0 instead of stopping the run.
+ */
+export declare function refuseDuringEvalLoad(what: string): void;
+//# sourceMappingURL=eval-load-phase.d.ts.map

package/dist/core/eval-load-phase.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * The paid tier is closed while an eval file is being LOADED.
+ *
+ * ## The failure this removes
+ *
+ * An eval file used to do its work at the top level:
+ *
+ *   const report = await measureTriggerRate({ … });   // ← module body
+ *
+ * In ESM, `import` IS execution, so *reading* such a file spends real money.
+ * Measured 2026-08-12 (and reproduced 2026-08-18 with an inert stand-in that
+ * writes a marker file instead of spawning): `node -e 'import("./x.eval.mjs")'`
+ * ran the whole body and the one guard that exists — `refuseUnderForeignRunner`
+ * — stayed SILENT, because under `node -e` there is no `process.argv[1]` at all:
+ *
+ *   node -e 'import(x)'   argv[1] = undefined  → foreignRunner(…) = null
+ *
+ * That guard is not broken; it answers a different question ("does somebody
+ * else's test runner own this process?"). No process fact distinguishes
+ * `node -e 'import(x)'` from a legitimate runner doing `import(x)`, so no
+ * argv-shaped guard can close this door without also refusing the correct
+ * invocation — the exact failure mode that got `process.env.VITEST` rejected in
+ * `foreign-runner.ts`.
+ *
+ * ## What closes it instead
+ *
+ * The SHAPE changed: an eval file now DESCRIBES its eval (`defineEval`) and
+ * `vigiles eval` runs it. A description cannot spend, so for a conforming file
+ * the door is shut by construction and this module is not needed.
+ *
+ * This module covers the file that is only HALF migrated — a `defineEval` export
+ * plus a leftover top-level `measure(…)`. During the import that the eval runner
+ * performs, the paid tier refuses. So the usual way anyone runs an eval turns a
+ * silent bill into a loud error that names the fix, instead of paying it.
+ *
+ * ⚠️ HONEST BOUNDARY, stated rather than implied. This is scoped to the runner's
+ * own import. `node -e 'import("./half-migrated.eval.mjs")'` still spends,
+ * because that file still contains the original defect — the redesign made the
+ * defect *avoidable and detectable*, it cannot retroactively fix a file that did
+ * not adopt it. The free syntax check is `node --check <file>`, which never
+ * executes anything.
+ *
+ * ## Why the default is OPEN
+ *
+ * `paid_runEval` and friends are public API; somebody's own script calling them
+ * at top level is their business. A gate that defaulted to closed would refuse
+ * every correct direct call — again, "a guard that fires on correct input is a
+ * guard people delete". So the window is opened by nobody and closed by exactly
+ * one caller: `eval-entry.ts`, around its `import()`.
+ *
+ * Imports NOTHING, so every spawn door (including the adapters) can call it
+ * without a cycle — the same reason `foreign-runner.ts` is a leaf.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beginEvalLoad = beginEvalLoad;
+exports.endEvalLoad = endEvalLoad;
+exports.inEvalLoad = inEvalLoad;
+exports.evalLoadRefusal = evalLoadRefusal;
+exports.refuseDuringEvalLoad = refuseDuringEvalLoad;
+/** Whether an eval module is being imported by the eval runner right now. */
+let loading = false;
+/**
+ * Open the no-spend window. Called by `eval-entry.ts` immediately before it
+ * imports an eval file, and paired with {@link endEvalLoad} in a `finally`.
+ */
+function beginEvalLoad() {
+    loading = true;
+}
+/** Close the no-spend window: the description is loaded, the runner may spend. */
+function endEvalLoad() {
+    loading = false;
+}
+/** Whether the no-spend window is open (exported for tests + the entry). */
+function inEvalLoad() {
+    return loading;
+}
+/**
+ * The refusal message. Separate from the check so a test can assert the WORDS:
+ * this fires on a file whose author has not seen the new shape yet, so it has to
+ * teach it, not just stop.
+ */
+function evalLoadRefusal(what) {
+    return (`vigiles refused to spawn a model: ${what} while an eval file was being IMPORTED.\n` +
+        `  An eval file DESCRIBES its eval; it must not run one at the top level — importing such a\n` +
+        `  file spends real money (that is the defect this shape removes).\n` +
+        `  Move the runner call into the description, keyed by the runner's own name:\n` +
+        `      import { defineEval } from "vigiles";\n` +
+        `      export default defineEval({ measureTriggerRate: { …the spec you passed… } });\n` +
+        `  and read the report in \`assert(report)\`. See docs/harness-testing.md § Eval files.`);
+}
+/**
+ * Refuse to spend model budget while an eval file is being imported.
+ *
+ * 🔴 CALL THIS AT EVERY REAL-MODEL SPAWN, beside `refuseUnderForeignRunner`, and
+ * OUTSIDE any `try` that swallows — `judge` and `deriveAttackReal` both wrap
+ * their spawn in `try { … } catch { return fallback }`, so a refusal thrown
+ * inside would be downgraded to a score of 0 instead of stopping the run.
+ */
+function refuseDuringEvalLoad(what) {
+    if (loading)
+        throw new Error(evalLoadRefusal(what));
+}
+//# sourceMappingURL=eval-load-phase.js.map

package/dist/eval-define.d.ts

@@ -0,0 +1,166 @@
+import type { ArmsCheckReport, EvalDriver, ArmsMeasureSpec, CheckReport, EvalReport, EvalSpec, MeasureSpec, Metrics, TriggerRateReport, TriggerRateSpec } from "./eval.js";
+import type { SelectionMatrixOptions, SelectionReport } from "./scan-behavioral.js";
+/**
+ * Brand marking a value as built by {@link defineEval}. A registered symbol, so
+ * a descriptor still reads as one across two copies of the package on disk —
+ * the shape a monorepo produces routinely.
+ */
+export declare const EVAL_DEFINITION: unique symbol;
+/** `measureSelectionMatrix`'s two arguments as one declarable object. */
+export interface SelectionMatrixSpec extends SelectionMatrixOptions {
+    /** The plugin root whose skills are measured against each other. */
+    readonly pluginDir: string;
+}
+/**
+ * The five measurements an eval file may declare — the runners that already
+ * exist, keyed by their own names, so migrating is renaming a call to a key.
+ * EXACTLY ONE must be present: zero is a file that declares nothing, and two is
+ * a file whose author expected both to run.
+ */
+export interface EvalMeasurements {
+    /** A/B across arms with derived metrics — `paid_runEval`. */
+    readonly runEval?: EvalSpec<Metrics>;
+    /** Checks scored over N trials of one task — `paid_measure`. */
+    readonly measure?: MeasureSpec;
+    /** The same checks per arm — `paid_measureArms`. */
+    readonly measureArms?: ArmsMeasureSpec;
+    /** Does a skill's description actually fire — `paid_measureTriggerRate`. */
+    readonly measureTriggerRate?: TriggerRateSpec;
+    /**
+     * The N×N skill-selection collision matrix — `measureSelectionMatrix` from
+     * `vigiles/claude-code`. Declared here because a description is a description
+     * whatever harness answers it; only `eval-entry.ts` resolves it to a runner.
+     */
+    readonly measureSelectionMatrix?: SelectionMatrixSpec;
+}
+/** The report type produced by each declared measurement. */
+export interface EvalReports {
+    readonly runEval: EvalReport;
+    readonly measure: CheckReport;
+    readonly measureArms: ArmsCheckReport;
+    readonly measureTriggerRate: TriggerRateReport;
+    readonly measureSelectionMatrix: SelectionReport;
+}
+/** The measurement names, as a type. */
+export type EvalKind = keyof EvalMeasurements;
+/** Everything an eval file declares beyond the measurement itself. */
+export interface EvalHooks<K extends EvalKind> {
+    /**
+     * A lazy precondition. Return a reason to SKIP (exit 77, loud — never a silent
+     * green); return nothing to run. Lazy is the point: a probe at the top of the
+     * file would be work at import time, which is the shape being removed.
+     */
+    readonly skipIf?: () => string | false | undefined | null;
+    /**
+     * What the report has to show. Throw to fail. The runner has already printed
+     * the standard report by the time this is called, so this is for the derived
+     * reads — gates, per-arm significance, a verdict line.
+     */
+    readonly assert?: (report: EvalReports[K]) => void | Promise<void>;
+    /**
+     * Drive the measurement with this harness instead of the real `claude` CLI —
+     * the declarative home for the second argument of
+     * `measureTriggerRate(spec, { evalDriver })`, e.g. `codexEvalDriver` from
+     * `vigiles/codex`, or a fake runner in a test.
+     *
+     * ⚠️ `measureTriggerRate` ONLY. That is not a limitation of this shape but of
+     * the product as it stands: `measureTriggerRate` is the one measurement with a
+     * public driver seam, and `runEval(spec)` always drives Claude Code (see
+     * docs/harnesses.md, footnote 2). Declaring it with any other measurement is a
+     * loud error rather than a field that silently does nothing.
+     */
+    readonly evalDriver?: EvalDriver;
+}
+/** One measurement + its hooks: what an eval file default-exports. */
+export type EvalDefinitionInput<K extends EvalKind> = Pick<EvalMeasurements, K> & EvalHooks<K>;
+/** The branded value {@link defineEval} returns. */
+export type EvalDefinition<K extends EvalKind = EvalKind> = EvalDefinitionInput<K> & {
+    readonly [EVAL_DEFINITION]: true;
+};
+/**
+ * What a module's default export declares. Total: every answer the runner has to
+ * distinguish is a case here, so no caller can forget one.
+ */
+export type DeclaredEval = {
+    readonly ok: true;
+    readonly kind: EvalKind;
+    readonly spec: unknown;
+} | {
+    readonly ok: false;
+    readonly why: "not-a-definition";
+} | {
+    readonly ok: false;
+    readonly why: "declares-nothing";
+} | {
+    readonly ok: false;
+    readonly why: "declares-several";
+    readonly kinds: readonly EvalKind[];
+};
+/** The measurement keys, in a fixed order — the one list, read by everything. */
+export declare const EVAL_KINDS: readonly EvalKind[];
+/** Whether a value came from {@link defineEval}. */
+export declare function isEvalDefinition(v: unknown): v is EvalDefinition;
+/**
+ * Read a module's default export as a declaration. Pure — this is the whole
+ * reason the descriptor is data: the runner answers "what does this file
+ * declare?" without executing anything and without spending anything.
+ */
+export declare function declaredEval(def: unknown): DeclaredEval;
+/**
+ * The definition a module namespace carries, through the CJS/ESM interop layer.
+ *
+ * 🔴 THE SECOND `.default` IS NOT DEFENSIVE — it is the only way a TypeScript
+ * eval file works, and it was found by a test, not by reading. Three shapes
+ * reach this function and they are genuinely different objects:
+ *
+ *   x.eval.mjs   real ESM        → `mod.default` IS the definition
+ *   x.eval.cjs   `module.exports = defineEval(…)`
+ *                                → `mod.default` is `module.exports`, the definition
+ *   x.eval.ts    `export default …`, transpiled to CJS by tsx
+ *                                → `mod.default` is `module.exports`, and the
+ *                                  definition sits at `mod.default.default`
+ *
+ * Measured 2026-08-18: without the unwrap a `.eval.ts` file reported
+ * "no `export default defineEval({…})` found" — a correct file, refused, with a
+ * message that sent its author looking in the wrong place.
+ *
+ * Brand-directed rather than shape-directed: it reaches deeper ONLY when the
+ * outer value is not a definition, so a definition that happens to carry a
+ * `default` field of its own is never skipped over.
+ */
+export declare function moduleDefault(mod: unknown): unknown;
+/**
+ * Was node pointed STRAIGHT at an eval file? `argv1` is `process.argv[1]`: the
+ * path node was started with, which no stray configuration can forge.
+ *
+ *   node x.eval.mjs                 → the file            → true
+ *   vigiles eval x.eval.mjs         → dist/eval-entry.js  → false
+ *   node -e 'import("x.eval.mjs")'  → undefined           → false
+ *   npx vitest run                  → …/vitest/…/forks.js → false
+ *
+ * Pure: a fact in, a boolean out.
+ */
+export declare function ranAsEntry(argv1: string | undefined): boolean;
+/** The words shown when someone runs an eval file directly. Asserted by a test:
+ *  a refusal that stops a run without saying what to do instead is a ticket. */
+export declare function ranAsEntryRefusal(argv1: string): string;
+/**
+ * Declare the eval a file describes. Returns a plain, branded value; it starts
+ * nothing, spends nothing, and touches no filesystem.
+ *
+ * ```js
+ * import { defineEval, assertRates } from "vigiles";
+ * import { skill } from "vigiles";
+ *
+ * export default defineEval({
+ *   measure: { pluginDir, task: "…", checks: [skill("my:skill")], trials: 3 },
+ *   assert: (report) => assertRates(report, { min: 0.6 }),
+ * });
+ * ```
+ *
+ * @throws if node was pointed straight at the eval file — see the module doc.
+ *   That is the ONE thing this function does besides build a value, and it is
+ *   here rather than in each file precisely so that no author can forget it.
+ */
+export declare function defineEval<K extends EvalKind>(def: EvalDefinitionInput<K>): EvalDefinition<K>;
+//# sourceMappingURL=eval-define.d.ts.map