autor3search-typescript 0.1.0

package/dist/cli/main.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { cmdBaseline } from './cmd-baseline.js';
+import { cmdDoctor } from './cmd-doctor.js';
+import { cmdEval } from './cmd-eval.js';
+import { cmdInit } from './cmd-init.js';
+import { cmdProfile } from './cmd-profile.js';
+import { cmdReport } from './cmd-report.js';
+import { cmdStatus } from './cmd-status.js';
+import { cmdStop } from './cmd-stop.js';
+import { resolveCtx, splitDashC } from './runctx.js';
+/**
+ * The command table.
+ *
+ * Ruling 34: a command implemented and tested but never added here is
+ * unreachable, yet looks completely healthy from inside its own task's
+ * suite -- the missing piece lives in a file that task never touches, and
+ * `--help` would still print successfully, just without it. Every command
+ * task must register itself here, and prove it with a test that dispatches
+ * through `main`, not one that only calls the command function directly.
+ * Exported (only) so the COMMANDS/HELP invariant test below can compare
+ * this table's keys against what `--help` actually lists.
+ */
+export const COMMANDS = {
+    init: cmdInit,
+    doctor: cmdDoctor,
+    baseline: cmdBaseline,
+    eval: cmdEval,
+    status: cmdStatus,
+    stop: cmdStop,
+    report: cmdReport,
+    profile: cmdProfile,
+};
+const HELP = `autor3search-typescript -- autonomous performance optimization for a TypeScript repository
+
+Usage: autor3search-typescript [-C <dir>] <command> [flags]
+
+Commands:
+  init      Discover benchmarks and write .autor3search/config.yaml and program.md
+  doctor    Report whether this machine can measure reliably (informational, always exits 0)
+  baseline  Freeze tests/benchmarks, pin a worktree at HEAD, install and prove it can measure
+  eval      Run one experiment through the gate chain and report a verdict (0 KEEP, 1 DISCARD, 2 FAIL, 3 CRASH)
+  status    Report where a run is: branch, commits, worktree, experiment counts, in-flight eval, pending stop (read-only)
+  stop      Ask the agent to stop after its current experiment; -clear cancels, -force also signals the running eval
+  report    Summarize results.tsv: counts by status, cumulative speedup, largest individual wins
+  profile   Run the declared benchmarks under Node's CPU profiler and print the hottest functions
+
+Global flags:
+  -C <dir>  Run as if invoked from <dir> (resolves that directory's git repository root)
+  --help    Print this message
+`;
+function printHelp() {
+    process.stdout.write(HELP);
+}
+/**
+ * Dispatch only: parse the leading `-C <dir>`, take the subcommand, and
+ * delegate. Every command is `(ctx, argv) => Promise<number>`, and its
+ * return value becomes the process exit code directly -- exit codes are
+ * reserved project-wide (0 KEEP, 1 DISCARD, 2 FAIL, 3 CRASH), and a usage
+ * error or an `init` failure is a FAIL (2).
+ *
+ * This function never rejects: everything below -- including `resolveCtx`
+ * failing on a `-C` outside any git repository -- is caught here and
+ * turned into `error: <message>` on stderr plus a `2` return, never a raw
+ * stack trace. That makes it directly testable (call it, read the
+ * returned number) without a test having to unwrap a promise rejection.
+ */
+export async function main(argv) {
+    try {
+        // The same `splitDashC` that `resolveCtx` uses below: one implementation
+        // of "-C is only recognized as the leading token," so this and
+        // `resolveCtx` cannot silently drift apart into two different parsings
+        // of the same flag.
+        const { rest } = splitDashC(argv);
+        const [name, ...commandArgv] = rest;
+        if (name === undefined || name === '--help' || name === '-h') {
+            printHelp();
+            return 2;
+        }
+        const command = COMMANDS[name];
+        if (!command) {
+            process.stderr.write(`error: unknown command "${name}"\n\n`);
+            printHelp();
+            return 2;
+        }
+        const ctx = await resolveCtx(argv);
+        return await command(ctx, commandArgv);
+    }
+    catch (e) {
+        process.stderr.write(`error: ${e.message}\n`);
+        return 2;
+    }
+}
+/**
+ * True only when THIS file is the process's actual entry point, not when it
+ * is merely imported (by a test, or as a dependency).
+ *
+ * `npm` installs a package's `bin` as a symlink under `node_modules/.bin/`,
+ * so a real installed invocation runs this file through that symlink.
+ * `import.meta.url` for the entry module is Node's own resolved (symlink-
+ * followed) URL, while `process.argv[1]` is left exactly as invoked -- the
+ * symlink path itself. Comparing the two directly, as a naive
+ * `import.meta.url === \`file://${process.argv[1]}\`` check does, therefore
+ * NEVER matches for an installed package: this guard would silently never
+ * fire, `main()` would never run, and the process would exit 0 -- the KEEP
+ * exit code -- having done nothing at all, for every command including
+ * `--help`. `realpathSync` resolves both the symlink and any other
+ * indirection (a relative path, `.` segments) before comparing, so a
+ * symlinked, a relative, and a directly-invoked entry point all still match.
+ *
+ * `realpathSync` requires the path to exist; the fallback below only ever
+ * matters for a degenerate invocation (no `argv[1]` at all, e.g. a REPL) and
+ * intentionally reports "not the entry point" rather than throwing, since a
+ * thrown error here would crash an import that merely wants `COMMANDS` or
+ * `main` for testing.
+ */
+function isEntryPoint() {
+    if (process.argv[1] === undefined)
+        return false;
+    try {
+        return import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+    }
+    catch {
+        return false;
+    }
+}
+if (isEntryPoint()) {
+    main(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    });
+}
+//# sourceMappingURL=main.js.map

package/dist/cli/main.js.map

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

package/dist/cli/runctx.d.ts

@@ -0,0 +1,29 @@
+/** Repo-root-relative default location of the unattended run's transcript. */
+export declare const LOG_PATH = "run.log";
+export interface RunCtx {
+    repoRoot: string;
+    configPath: string;
+    resultsPath: string;
+    logPath: string;
+}
+/**
+ * Splits a leading `-C <dir>` off argv, recognized only as the very first
+ * token (the same convention `git -C` uses). Never touches `process.cwd()`
+ * or `process.chdir` -- the directory is only ever handed to a spawned
+ * `git` as its `cwd` option, so this is safe to call concurrently from
+ * multiple invocations and to unit test without disturbing the test
+ * process's own working directory.
+ */
+export declare function splitDashC(argv: readonly string[], cwd?: string): {
+    dir: string;
+    rest: string[];
+};
+/**
+ * Resolves the run context for one invocation: the `-C <dir>` (or the
+ * current working directory) is walked up to its git repository root via a
+ * spawned `git rev-parse --show-toplevel`, and every path the harness
+ * writes -- the config, `results.tsv`, `run.log` -- is anchored to that
+ * root. Since resolution goes through a subprocess `cwd`, not
+ * `process.chdir`, `process.cwd()` in this process is never touched.
+ */
+export declare function resolveCtx(argv: readonly string[]): Promise<RunCtx>;

package/dist/cli/runctx.js

@@ -0,0 +1,49 @@
+import path from 'node:path';
+import { CONFIG_PATH } from '../config/schema.js';
+import { repoRoot as gitRepoRoot } from '../gitx/git.js';
+import { RESULTS_PATH } from '../results/results.js';
+/** Repo-root-relative default location of the unattended run's transcript. */
+export const LOG_PATH = 'run.log';
+/**
+ * Splits a leading `-C <dir>` off argv, recognized only as the very first
+ * token (the same convention `git -C` uses). Never touches `process.cwd()`
+ * or `process.chdir` -- the directory is only ever handed to a spawned
+ * `git` as its `cwd` option, so this is safe to call concurrently from
+ * multiple invocations and to unit test without disturbing the test
+ * process's own working directory.
+ */
+export function splitDashC(argv, cwd = process.cwd()) {
+    if (argv[0] !== '-C') {
+        return { dir: cwd, rest: [...argv] };
+    }
+    const dir = argv[1];
+    if (dir === undefined) {
+        throw new Error('-C requires a directory argument');
+    }
+    return { dir, rest: argv.slice(2) };
+}
+/**
+ * Resolves the run context for one invocation: the `-C <dir>` (or the
+ * current working directory) is walked up to its git repository root via a
+ * spawned `git rev-parse --show-toplevel`, and every path the harness
+ * writes -- the config, `results.tsv`, `run.log` -- is anchored to that
+ * root. Since resolution goes through a subprocess `cwd`, not
+ * `process.chdir`, `process.cwd()` in this process is never touched.
+ */
+export async function resolveCtx(argv) {
+    const { dir } = splitDashC(argv);
+    let root;
+    try {
+        root = await gitRepoRoot(dir);
+    }
+    catch (e) {
+        throw new Error(`${dir} is not inside a git repository (or a subdirectory of one): ${e.message}`);
+    }
+    return {
+        repoRoot: root,
+        configPath: path.join(root, CONFIG_PATH),
+        resultsPath: path.join(root, RESULTS_PATH),
+        logPath: path.join(root, LOG_PATH),
+    };
+}
+//# sourceMappingURL=runctx.js.map

package/dist/cli/runctx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runctx.js","sourceRoot":"","sources":["../../src/cli/runctx.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,QAAQ,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,8EAA8E;AAC9E,MAAM,CAAC,MAAM,QAAQ,GAAG,SAAS,CAAA;AASjC;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,IAAuB,EAAE,MAAc,OAAO,CAAC,GAAG,EAAE;IAC7E,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QACrB,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,EAAE,CAAA;IACtC,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;IACnB,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;IACrD,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;AACrC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,IAAuB;IACtD,MAAM,EAAE,GAAG,EAAE,GAAG,UAAU,CAAC,IAAI,CAAC,CAAA;IAChC,IAAI,IAAY,CAAA;IAChB,IAAI,CAAC;QACH,IAAI,GAAG,MAAM,WAAW,CAAC,GAAG,CAAC,CAAA;IAC/B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,GAAG,GAAG,+DAAgE,CAAW,CAAC,OAAO,EAAE,CAC5F,CAAA;IACH,CAAC;IACD,OAAO;QACL,QAAQ,EAAE,IAAI;QACd,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC;QACxC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;QAC1C,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC;KACnC,CAAA;AACH,CAAC"}

package/dist/cli/speedup.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `summarize()`'s `cumulativeSpeedup` is a product of candidate/baseline
+ * TIME RATIOS -- below 1 is faster -- not a speedup factor itself. Printing
+ * it directly, suffixed `x`, reads as its own inverse: a genuine 12x win
+ * (a ratio of ~0.0833) prints as "0.0833x," which a human reads as "twelve
+ * times slower." This is the one number most likely to be read without the
+ * surrounding context of `summarize`'s own doc comment, so it must read
+ * correctly on its own.
+ *
+ * `1 / cumulativeSpeedup` is the actual "N times faster" figure a human
+ * expects; the raw ratio is kept alongside it, labeled explicitly, for
+ * anyone who wants the underlying number `summarize` actually computed.
+ */
+export declare function formatCumulativeSpeedup(cumulativeSpeedup: number): string;

package/dist/cli/speedup.js

@@ -0,0 +1,25 @@
+/**
+ * `summarize()`'s `cumulativeSpeedup` is a product of candidate/baseline
+ * TIME RATIOS -- below 1 is faster -- not a speedup factor itself. Printing
+ * it directly, suffixed `x`, reads as its own inverse: a genuine 12x win
+ * (a ratio of ~0.0833) prints as "0.0833x," which a human reads as "twelve
+ * times slower." This is the one number most likely to be read without the
+ * surrounding context of `summarize`'s own doc comment, so it must read
+ * correctly on its own.
+ *
+ * `1 / cumulativeSpeedup` is the actual "N times faster" figure a human
+ * expects; the raw ratio is kept alongside it, labeled explicitly, for
+ * anyone who wants the underlying number `summarize` actually computed.
+ */
+export function formatCumulativeSpeedup(cumulativeSpeedup) {
+    if (!(cumulativeSpeedup > 0) || !Number.isFinite(cumulativeSpeedup)) {
+        // Never reachable through `summarize`'s own product-of-scores (score is
+        // validated positive and finite before it ever reaches decide(), let
+        // alone this), but this function must still be total for whatever
+        // corrupted or synthetic input it is ever handed.
+        return `${cumulativeSpeedup.toFixed(4)}x (cumulative time ratio)`;
+    }
+    const factor = 1 / cumulativeSpeedup;
+    return `${factor.toFixed(2)}x faster (cumulative time ratio ${cumulativeSpeedup.toFixed(4)})`;
+}
+//# sourceMappingURL=speedup.js.map

package/dist/cli/speedup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"speedup.js","sourceRoot":"","sources":["../../src/cli/speedup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,uBAAuB,CAAC,iBAAyB;IAC/D,IAAI,CAAC,CAAC,iBAAiB,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACpE,wEAAwE;QACxE,qEAAqE;QACrE,kEAAkE;QAClE,kDAAkD;QAClD,OAAO,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,2BAA2B,CAAA;IACnE,CAAC;IACD,MAAM,MAAM,GAAG,CAAC,GAAG,iBAAiB,CAAA;IACpC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,mCAAmC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAA;AAC/F,CAAC"}

package/dist/config/load.d.ts

@@ -0,0 +1,6 @@
+import { type Config } from './schema.js';
+export declare function defaultConfig(): Config;
+/** Parses a duration into milliseconds. A bare number is refused as ambiguous. */
+export declare function parseDuration(s: string): number;
+export declare function parseConfig(text: string): Config;
+export declare function loadConfig(path: string): Promise<Config>;

package/dist/config/load.js

@@ -0,0 +1,172 @@
+import { readFile } from 'node:fs/promises';
+import { parse as parseYaml } from 'yaml';
+import { MIN_COUNT } from './schema.js';
+/** yaml key -> Config field. The single source of truth for both directions. */
+const KEYS = {
+    benchmarks: 'benchmarks',
+    scope: 'scope',
+    count: 'count',
+    benchtime: 'benchtime',
+    warmup: 'warmup',
+    max_regress_pct: 'maxRegressPct',
+    min_effect_pct: 'minEffectPct',
+    timeout: 'timeout',
+    typecheck_command: 'typecheckCommand',
+    build_command: 'buildCommand',
+    test_command: 'testCommand',
+    node_args: 'nodeArgs',
+    unfreeze: 'unfreeze',
+};
+export function defaultConfig() {
+    return {
+        benchmarks: [],
+        scope: ['src/**'],
+        count: 10,
+        benchtime: '500ms',
+        warmup: '100ms',
+        maxRegressPct: 5,
+        minEffectPct: 1,
+        timeout: '15m',
+        typecheckCommand: 'npx tsc --noEmit',
+        buildCommand: '',
+        testCommand: 'npm test',
+        nodeArgs: [],
+        unfreeze: [],
+    };
+}
+const DURATION = /^(\d+(?:\.\d+)?)(ms|s|m|h)$/;
+/** Parses a duration into milliseconds. A bare number is refused as ambiguous. */
+export function parseDuration(s) {
+    const m = DURATION.exec(String(s).trim());
+    if (!m) {
+        throw new Error(`invalid duration ${JSON.stringify(s)}: use a number with a unit, e.g. 500ms, 2s, 15m`);
+    }
+    const n = Number(m[1]);
+    const unit = m[2];
+    const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60_000 : 3_600_000;
+    return n * mult;
+}
+/** A short, friendly noun phrase describing the runtime type of `v`, for error messages. */
+function describeType(v) {
+    if (Array.isArray(v))
+        return 'an array';
+    if (v === null)
+        return 'null';
+    const t = typeof v;
+    return t === 'object' ? 'an object' : `a ${t}`;
+}
+function requireString(v, yamlKey) {
+    if (typeof v !== 'string') {
+        throw new Error(`${yamlKey} must be a string, got ${describeType(v)}`);
+    }
+    return v;
+}
+function requireNumber(v, yamlKey) {
+    if (typeof v !== 'number' || Number.isNaN(v)) {
+        throw new Error(`${yamlKey} must be a number, got ${describeType(v)}`);
+    }
+    return v;
+}
+function requireStringArray(v, yamlKey) {
+    if (!Array.isArray(v) || !v.every((x) => typeof x === 'string')) {
+        throw new Error(`${yamlKey} must be an array of strings, got ${describeType(v)}`);
+    }
+    return v;
+}
+/** Parses a duration field, prefixing the error with the offending yaml key. */
+function requireDuration(v, yamlKey) {
+    try {
+        parseDuration(v);
+    }
+    catch (e) {
+        throw new Error(`${yamlKey}: ${e.message}`);
+    }
+}
+function validate(c) {
+    // Type checks first: a wrong-typed value (e.g. count: "ten", or scope given
+    // as a bare string instead of an array) must be refused with a clear
+    // explanation rather than silently accepted by a numeric comparison that
+    // coerces it, or crashing later with an unrelated TypeError.
+    requireStringArray(c.benchmarks, 'benchmarks');
+    requireStringArray(c.scope, 'scope');
+    requireNumber(c.count, 'count');
+    requireString(c.benchtime, 'benchtime');
+    requireString(c.warmup, 'warmup');
+    requireNumber(c.maxRegressPct, 'max_regress_pct');
+    requireNumber(c.minEffectPct, 'min_effect_pct');
+    requireString(c.timeout, 'timeout');
+    requireString(c.typecheckCommand, 'typecheck_command');
+    requireString(c.buildCommand, 'build_command');
+    requireString(c.testCommand, 'test_command');
+    requireStringArray(c.nodeArgs, 'node_args');
+    requireStringArray(c.unfreeze, 'unfreeze');
+    if (c.count < MIN_COUNT) {
+        throw new Error(`count must be at least ${MIN_COUNT}: the significance test cannot report p < 0.05 with ` +
+            `fewer than ${MIN_COUNT} measured rounds per side no matter how large the improvement is, ` +
+            `so every experiment would be discarded regardless of what changed (the default is 10)`);
+    }
+    if (c.maxRegressPct < 0)
+        throw new Error('max_regress_pct must not be negative');
+    if (c.minEffectPct < 0)
+        throw new Error('min_effect_pct must be at least 0');
+    if (c.minEffectPct >= 100)
+        throw new Error('min_effect_pct must be less than 100');
+    if (c.scope.length === 0)
+        throw new Error('scope must list at least one path pattern');
+    for (const s of c.scope) {
+        if (s.trim() === '')
+            throw new Error('scope must not contain an empty or whitespace-only entry');
+    }
+    // Throws on anything unparseable, naming the offending key.
+    requireDuration(c.benchtime, 'benchtime');
+    requireDuration(c.warmup, 'warmup');
+    requireDuration(c.timeout, 'timeout');
+    if (c.testCommand.trim() === '')
+        throw new Error('test_command must not be empty');
+    // typecheck_command, unlike test_command, may legitimately be empty: a
+    // repository with no tsconfig.json has nothing for `tsc --noEmit` to check
+    // against, and `cmd-init` writes an empty typecheck_command plus a printed
+    // warning for exactly that case (see task 16 / Ruling 25). The eval gate
+    // chain (task 19) already treats an empty typecheck_command as "skip this
+    // gate," mirroring build_command's existing empty-means-skip semantics
+    // above -- so rejecting empty here would make a config that `init` itself
+    // legitimately writes fail to load, surfacing only at the user's first
+    // `eval`, long after `init` reported success.
+}
+export function parseConfig(text) {
+    const raw = parseYaml(text) ?? {};
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new Error('config must be a YAML mapping');
+    }
+    const c = defaultConfig();
+    for (const [k, v] of Object.entries(raw)) {
+        const field = KEYS[k];
+        if (!field) {
+            throw new Error(`unknown config key ${JSON.stringify(k)}: a typo here would silently leave the ` +
+                `default in force, so it is refused rather than ignored`);
+        }
+        // The cast is safe: validate() below rejects anything of the wrong shape
+        // once the value is in place. It goes through `unknown` first because
+        // `Config` has no index signature for TS to widen from directly.
+        ;
+        c[field] = v;
+    }
+    validate(c);
+    return c;
+}
+export async function loadConfig(path) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (e) {
+        throw new Error(`read ${path}: ${e.message}`);
+    }
+    try {
+        return parseConfig(text);
+    }
+    catch (e) {
+        throw new Error(`invalid ${path}: ${e.message}`);
+    }
+}
+//# sourceMappingURL=load.js.map

package/dist/config/load.js.map

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

package/dist/config/schema.d.ts

@@ -0,0 +1,42 @@
+/** The config location, relative to the repository root. */
+export declare const CONFIG_PATH = ".autor3search/config.yaml";
+/** Lockfiles we recognise, in package-manager detection order. */
+export declare const LOCKFILES: readonly ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"];
+/**
+ * Files the agent may never modify, regardless of `scope`.
+ *
+ * A dependency change is a human decision, not an autonomous one, and a
+ * tsconfig change alters what is being measured rather than how fast it runs.
+ * Both would invalidate the comparison rather than win it.
+ */
+export declare const IMMUTABLE_FILES: readonly string[];
+/** The smallest `count` at which the exact rank test can ever reach ALPHA. */
+export declare const MIN_COUNT = 4;
+export interface Config {
+    /** Declared benchmark ids ("<file>:<function>"). Empty means all discovered. */
+    benchmarks: string[];
+    /** Glob patterns the agent may modify. */
+    scope: string[];
+    /** Measured rounds per side. */
+    count: number;
+    /** Measured window per benchmark per round. */
+    benchtime: string;
+    /** Discarded window before each measurement. */
+    warmup: string;
+    /** Largest tolerated significant regression, percent. */
+    maxRegressPct: number;
+    /** Smallest geomean improvement a KEEP will accept, percent. */
+    minEffectPct: number;
+    /** Bounds each subprocess phase. */
+    timeout: string;
+    /** Typecheck gate command. Empty means skip (e.g. no tsconfig.json at init time). */
+    typecheckCommand: string;
+    /** Optional build gate command. Empty means skip. */
+    buildCommand: string;
+    /** Correctness gate command. */
+    testCommand: string;
+    /** Extra flags for the benchmark child process, e.g. ["--expose-gc"]. */
+    nodeArgs: string[];
+    /** Test/bench files deliberately exempted from freezing. */
+    unfreeze: string[];
+}

package/dist/config/schema.js

@@ -0,0 +1,25 @@
+/** The config location, relative to the repository root. */
+export const CONFIG_PATH = '.autor3search/config.yaml';
+/** Lockfiles we recognise, in package-manager detection order. */
+export const LOCKFILES = [
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'bun.lockb',
+    'bun.lock',
+];
+/**
+ * Files the agent may never modify, regardless of `scope`.
+ *
+ * A dependency change is a human decision, not an autonomous one, and a
+ * tsconfig change alters what is being measured rather than how fast it runs.
+ * Both would invalidate the comparison rather than win it.
+ */
+export const IMMUTABLE_FILES = [
+    'package.json',
+    'tsconfig.json',
+    ...LOCKFILES,
+];
+/** The smallest `count` at which the exact rank test can ever reach ALPHA. */
+export const MIN_COUNT = 4;
+//# sourceMappingURL=schema.js.map

package/dist/config/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,MAAM,CAAC,MAAM,WAAW,GAAG,2BAA2B,CAAA;AAEtD,kEAAkE;AAClE,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,mBAAmB;IACnB,gBAAgB;IAChB,WAAW;IACX,WAAW;IACX,UAAU;CACF,CAAA;AAEV;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAsB;IAChD,cAAc;IACd,eAAe;IACf,GAAG,SAAS;CACb,CAAA;AAED,8EAA8E;AAC9E,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAA"}

package/dist/discover/benchmarks.d.ts

@@ -0,0 +1,26 @@
+export interface Benchmark {
+    /** "<repo-relative file>:<function name>". */
+    id: string;
+    file: string;
+    fn: string;
+}
+/**
+ * Exported `bench*` names declared in one source text, keyed by the name a
+ * consumer sees on the imported module — not necessarily the local
+ * declaration name.
+ *
+ * Deduplicated: the same exported name can be reachable twice in one file —
+ * once via a declaration's own `export` modifier and again via a same-file
+ * `export { name }` clause naming it — and a caller measuring one id twice
+ * per round would double the sample rate for that benchmark without anyone
+ * asking for it, corrupting the statistics silently.
+ */
+export declare function benchNamesInSource(text: string, fileName: string): string[];
+/**
+ * Finds every benchmark in the repository by parsing, never executing.
+ *
+ * `init` must work on a tree that does not build, and executing a benchmark
+ * module at discovery time would run arbitrary repository code before the user
+ * has agreed to anything at all.
+ */
+export declare function discoverBenchmarks(root: string): Promise<Benchmark[]>;

package/dist/discover/benchmarks.js

@@ -0,0 +1,88 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { classify, walkRepo } from './files.js';
+const PREFIX = 'bench';
+function isBenchName(name) {
+    // "bench" alone is not a benchmark; there must be a suffix.
+    return name.startsWith(PREFIX) && name.length > PREFIX.length;
+}
+/**
+ * Exported `bench*` names declared in one source text, keyed by the name a
+ * consumer sees on the imported module — not necessarily the local
+ * declaration name.
+ *
+ * Deduplicated: the same exported name can be reachable twice in one file —
+ * once via a declaration's own `export` modifier and again via a same-file
+ * `export { name }` clause naming it — and a caller measuring one id twice
+ * per round would double the sample rate for that benchmark without anyone
+ * asking for it, corrupting the statistics silently.
+ */
+export function benchNamesInSource(text, fileName) {
+    const sf = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true);
+    const names = new Set();
+    for (const stmt of sf.statements) {
+        const modifiers = ts.canHaveModifiers(stmt) ? ts.getModifiers(stmt) : undefined;
+        const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) === true;
+        // A default export is reached as `mod.default`, not `mod[name]` — the measurement
+        // child imports by name, so a default-exported bench* would fail at measurement
+        // time with "does not export a function named X". Excluding it here, at
+        // discovery, is what keeps that failure from ever happening.
+        const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) === true;
+        if (isExported && !isDefault) {
+            if (ts.isFunctionDeclaration(stmt) && stmt.name && isBenchName(stmt.name.text)) {
+                names.add(stmt.name.text);
+            }
+            else if (ts.isVariableStatement(stmt)) {
+                for (const decl of stmt.declarationList.declarations) {
+                    if (!ts.isIdentifier(decl.name) || !isBenchName(decl.name.text))
+                        continue;
+                    const init = decl.initializer;
+                    if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+                        names.add(decl.name.text);
+                    }
+                }
+            }
+        }
+        // `export { local as exported }` / `export { local }`: what a consumer sees is the
+        // *exported* name (`import(file).then((m) => m[fn])`), so that is what must be
+        // bench-named, regardless of what the local declaration is called or even is.
+        // Idiomatic TypeScript often declares a function and exports it later this way, and
+        // missing it would be a silent false negative — the worst failure mode for a tool
+        // whose entire output is a measurement. `export { x } from './other'` and
+        // `export * from` are deliberately excluded: resolving those would mean walking a
+        // module graph, not parsing one file.
+        if (ts.isExportDeclaration(stmt) &&
+            !stmt.isTypeOnly &&
+            !stmt.moduleSpecifier &&
+            stmt.exportClause &&
+            ts.isNamedExports(stmt.exportClause)) {
+            for (const spec of stmt.exportClause.elements) {
+                if (spec.isTypeOnly)
+                    continue;
+                if (isBenchName(spec.name.text))
+                    names.add(spec.name.text);
+            }
+        }
+    }
+    return [...names];
+}
+/**
+ * Finds every benchmark in the repository by parsing, never executing.
+ *
+ * `init` must work on a tree that does not build, and executing a benchmark
+ * module at discovery time would run arbitrary repository code before the user
+ * has agreed to anything at all.
+ */
+export async function discoverBenchmarks(root) {
+    const files = (await walkRepo(root)).filter((f) => classify(f) === 'bench');
+    const out = [];
+    for (const file of files) {
+        const text = await readFile(path.join(root, file), 'utf8');
+        for (const fn of benchNamesInSource(text, file)) {
+            out.push({ id: `${file}:${fn}`, file, fn });
+        }
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+//# sourceMappingURL=benchmarks.js.map