niceeval 0.13.2 → 0.13.3

package/dist/cli/program.cjs

@@ -0,0 +1,2807 @@
+"use strict";
+const __niceevalDynamicImport = (specifier) => import(specifier);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliProgram = exports.EXPERIMENT_RENAME_SCHEMA_VERSION = exports.EXPERIMENT_RENAME_FORMAT = exports.FLAG_OPTIONS = exports.CliOperationError = exports.CliUsageError = void 0;
+exports.renderCliFailure = renderCliFailure;
+exports.foldInvocationEvalStats = foldInvocationEvalStats;
+exports.parseExperimentRenamePositionals = parseExperimentRenamePositionals;
+exports.firstExperimentRenameUnsupportedFlag = firstExperimentRenameUnsupportedFlag;
+exports.renderExperimentRenamePlanHuman = renderExperimentRenamePlanHuman;
+exports.renderExperimentRenameRejectedHuman = renderExperimentRenameRejectedHuman;
+exports.renderExperimentRenameDoneHuman = renderExperimentRenameDoneHuman;
+exports.renderExperimentRenameJson = renderExperimentRenameJson;
+exports.experimentRenameRejectedFromError = experimentRenameRejectedFromError;
+exports.experimentRenameExitCode = experimentRenameExitCode;
+// niceeval CLI 入口。执行 eval 必须以 experiment 为单位;位置参数只在 exp 后筛 eval id 前缀。
+//   niceeval check [组|配置] [pattern]  只做发现、选择与 SandboxLayer pure link
+//   niceeval exp [组|配置] [pattern]    跑实验
+//   niceeval debug <配置> <eval>        只规划一个配对的 Sandbox / Plugin lifecycle
+//   niceeval accept @<locator>...       接受多条历史结果并重锚到当前配置
+//   niceeval show [selection]        终端渲染固定 Sample 的一个目标 Page
+//   niceeval list                    只列出发现到的 eval
+//   niceeval clean [--record <root>] [--yes]    删除未完成 Run
+//   niceeval migrate [--record <root>] [--yes]  显式迁移 Record
+const effect_1 = require("effect");
+const application_ts_1 = require("./application.cjs");
+const project_configuration_ts_1 = require("./project-configuration.cjs");
+const invocationFacts = effect_1.Effect.flatMap(application_ts_1.CliInvocationFacts, (service) => service.facts).pipe(effect_1.Effect.mapError((cause) => cliFailure("read invocation facts", cause)));
+const attempt_locator_ts_1 = require("../attempt-locator.cjs");
+const aggregate_ts_1 = require("../shared/aggregate.cjs");
+const index_ts_1 = require("../experiment/host/index.cjs");
+const project_current_ts_1 = require("../runner/project-current.cjs");
+const index_ts_2 = require("../record/index.cjs");
+const identifiers_ts_1 = require("../record/codec/identifiers.cjs");
+const attempt_overview_ts_1 = require("../report/built-in/attempt-overview.cjs");
+const run_membership_overview_ts_1 = require("../report/built-in/run-membership-overview.cjs");
+const standard_tsx_1 = require("../report/built-in/standard.cjs");
+const execution_ts_1 = require("../report/built-in/execution.cjs");
+const source_ts_1 = require("../report/built-in/source.cjs");
+const from_record_ts_1 = require("../report/host/from-record.cjs");
+const index_ts_3 = require("../report/host/index.cjs");
+const panel_ts_1 = require("../report/model/panel.cjs");
+const progress_ts_1 = require("../report/host/progress.cjs");
+const theme_ts_1 = require("../report/theme.cjs");
+const record_ts_1 = require("./record.cjs");
+const eval_selection_ts_1 = require("../runner/eval-selection.cjs");
+const registry_ts_1 = require("../sandbox/registry.cjs");
+const cli_commands_ts_1 = require("../sandbox/cli-commands.cjs");
+const link_ts_1 = require("../sandbox/link.cjs");
+const plan_ts_1 = require("../sandbox/plan.cjs");
+const experiment_cleanup_registry_ts_1 = require("../runner/experiment-cleanup-registry.cjs");
+const lock_ts_1 = require("../runner/lock.cjs");
+const shared_state_lease_ts_1 = require("../runner/shared-state-lease.cjs");
+const cleanup_timeout_ts_1 = require("../runner/cleanup-timeout.cjs");
+const timeout_ts_1 = require("../runner/timeout.cjs");
+const teardown_registry_ts_1 = require("../runner/teardown-registry.cjs");
+const rename_experiment_ts_1 = require("../runner/rename-experiment.cjs");
+const verdict_ts_1 = require("../shared/verdict.cjs");
+const sandbox_selection_ts_1 = require("../runner/sandbox-selection.cjs");
+const json_ts_1 = require("../runner/reporters/json.cjs");
+const index_ts_4 = require("../runner/feedback/index.cjs");
+const index_ts_5 = require("../i18n/index.cjs");
+const util_ts_1 = require("../util.cjs");
+const session_ts_1 = require("../runner/session.cjs");
+/** A recoverable command-line usage error. Defects deliberately do not enter this channel. */
+class CliUsageError extends effect_1.Data.TaggedError("CliUsageError") {
+}
+exports.CliUsageError = CliUsageError;
+/** A recoverable failure from a concrete CLI-owned boundary (file, process, or dynamic module). */
+class CliOperationError extends effect_1.Data.TaggedError("CliOperationError") {
+}
+exports.CliOperationError = CliOperationError;
+function usageError(message, exitCode = 1) {
+    return new CliUsageError({ message, exitCode });
+}
+function cliFailure(operation, cause, exitCode = 1) {
+    return cause instanceof CliUsageError || cause instanceof CliOperationError
+        ? cause
+        : new CliOperationError({ operation, cause, exitCode });
+}
+/**
+ * Lift one actual Promise boundary into the application Effect. It is never a
+ * private runtime: CLI owns the sole runtime in `cli/bootstrap.ts`.
+ */
+function cliPromise(operation, promise) {
+    return effect_1.Effect.tryPromise({
+        try: promise,
+        catch: (cause) => cliFailure(operation, cause),
+    });
+}
+/** Preserve library effects without running a nested runtime. */
+function cliEffect(operation, effect) {
+    return effect.pipe(effect_1.Effect.mapError((cause) => cliFailure(operation, cause)));
+}
+/** Bootstrap owns presentation of typed failures; defects and interruption stay in Cause. */
+function renderCliFailure(failure) {
+    if (failure._tag === "CliUsageError")
+        return failure.message;
+    if (failure.cause instanceof link_ts_1.SandboxLayerLinkError)
+        return `${(0, link_ts_1.formatSandboxLayerLinkError)(failure.cause)}\n`;
+    if (failure.cause instanceof plan_ts_1.SandboxPhysicalPlanningError)
+        return `${(0, plan_ts_1.formatSandboxPhysicalPlanningError)(failure.cause)}\n`;
+    const assertionsMessage = runnerAssertionsMessage(failure.cause);
+    if (assertionsMessage !== undefined)
+        return `error: ${assertionsMessage}\n`;
+    if (isReportCliOperation(failure.operation)) {
+        const code = failureCode(failure.cause);
+        if (code !== undefined) {
+            const reason = stringProperty(failure.cause, "reason");
+            const operation = stringProperty(failure.cause, "operation");
+            if (reason !== undefined) {
+                const stage = operation === undefined ? "" : `${operation}: `;
+                const retry = code === "report-view-server-failed" && operation === "listen"
+                    ? "\nChoose another port with --port <port>, or stop the process already listening there."
+                    : "";
+                return `${code}: ${stage}${reason}${retry}\n`;
+            }
+            return `${code}\n`;
+        }
+    }
+    return (0, index_ts_5.t)("cli.error", { error: (0, util_ts_1.formatThrown)(failure.cause) });
+}
+function isReportCliOperation(operation) {
+    return operation === "load trusted Report config" ||
+        operation === "load trusted Report module" ||
+        operation === "load trusted Theme module" ||
+        operation === "execute report from Record" ||
+        operation === "render Report show output" ||
+        operation === "open report view session" ||
+        operation === "open report view" ||
+        operation === "export static Report";
+}
+function failureCode(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const code = Reflect.get(value, "code");
+    return typeof code === "string" ? code : undefined;
+}
+function runnerAssertionsMessage(value) {
+    if (failureCode(value) !== "runner-record-assertions-invalid" || typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const issue = Reflect.get(value, "issue");
+    if (typeof issue !== "object" || issue === null)
+        return undefined;
+    const message = Reflect.get(issue, "message");
+    return typeof message === "string" && message.length > 0 ? message : undefined;
+}
+// 表驱动的 flag 定义(node:util parseArgs)。--no-x 显式声明，不依赖 Node 20.14+
+// 才支持的 allowNegative，也避免每个 boolean flag 都隐式获得未设计的负向别名。
+// 未知 flag 由 strict 模式报清晰错误，不会静默吞掉后面的位置参数。
+//
+// 每个 flag 的 JSDoc 就是它在 docs-site/zh/reference/cli.mdx flag 表里的说明,由
+// scripts/generate-reference.ts 提取渲染——改 flag 语义时改这里的注释即可,不用碰生成脚本。
+// 负向 flag(no-x)与正向 flag 合并成一行展示,不需要单独写 JSDoc。
+exports.FLAG_OPTIONS = {
+    /** experiment 运行不支持该 flag。要换 agent,请在 `experiments/` 下新增或复制一个配置文件。 */
+    agent: { type: "string" },
+    /** experiment 运行不支持该 flag。要换模型,请新增或复制一个 experiment 文件并修改 `model`。 */
+    model: { type: "string" },
+    /** 每个 eval 运行多少次,常用于 pass@N。 */
+    attempts: { type: "string" },
+    /** 设置同时运行的 eval 数量。 */
+    "max-concurrency": { type: "string" },
+    /** 设置同时进行的 Sandbox 镜像 lookup/build 数量；与 eval 并发独立，默认 2。 */
+    "max-build-concurrency": { type: "string" },
+    /** 单个 attempt 的超时时间,单位毫秒。解析链:`--timeout` > experiment > eval(`defineEval({ timeoutMs })`)> `niceeval.config.ts`,默认无上限(四层都没声明就不设 deadline);config 是缺省底而不是覆盖层,写了 config 不会让 eval 自己声明的上限失效。 */
+    timeout: { type: "string" },
+    /** 整次运行的预算上限(美元)。 */
+    budget: { type: "string" },
+    /** `exp` 命令专用:跑完留下 failed/errored attempt 的 Sandbox 现场(= `--keep-sandbox=failed`);`--keep-sandbox=all` 连 passed 也留。事后用 `niceeval sandbox list/enter/stop` 查看与销毁。 */
+    "keep-sandbox": { type: "boolean" },
+    /** `sandbox stop` 专用:销毁全部留存 Sandbox。 */
+    all: { type: "boolean" },
+    /** `sandbox diff` 专用:只看某个 send 窗口(如 `--window turn2` 或 `--window session2/turn1`);省略输出全部窗口的串联视图。 */
+    window: { type: "string" },
+    /** `sandbox diff` 专用:只看某个文件的 patch;省略输出该窗口的全部文件。 */
+    path: { type: "string" },
+    /** `sandbox enter` 专用:shell 退出后让现场保持运行,不送回休眠。 */
+    "leave-running": { type: "boolean" },
+    /** `sandbox list` 专用:核对强杀(`SIGKILL` / 断电)路径留下的无主沙箱实例(docker + e2b;vercel 无按元数据检索实例的通道,不参与)。只读,不清理;销毁走 `niceeval sandbox prune`。 */
+    orphans: { type: "boolean" },
+    /** 只运行带有该 tag 的 eval(见 `defineEval` 的 `tags`)。 */
+    tag: { type: "string" },
+    /** 额外写一份 JUnit XML 报告到指定路径,供 CI 消费。 */
+    junit: { type: "string" },
+    /** `exp` 运行在 stdout 输出单一有序的 NDJSON 事件流；`exp --dry` 与 `debug` 输出各自的单个 JSON 计划文档。`show` 输出 Host 拥有的内建或自定义单目标机器文档，不形成完整站点或打开第二条取数路径。 */
+    json: { type: "boolean" },
+    /** `docker profile doctor` 专用：启动受限 DinD 容器并运行内层容器。 */
+    smoke: { type: "boolean" },
+    /** `view` 命令专用:把结果查看器静态导出到指定目录。 */
+    out: { type: "string" },
+    /** `view` 命令专用:指定本地服务器监听端口。 */
+    port: { type: "string" },
+    /** `view` 命令专用:指定监听地址；省略时为 127.0.0.1，只写 `--host` 时为 0.0.0.0。非 loopback 监听无认证或 TLS，会向所有可达客户端暴露报告数据。 */
+    host: { type: "string" },
+    // 以下旧 show 切片只为实现收敛期间保留解析位置，不属于目标公开 CLI，也不进入参考页。
+    /** `show` 专用：按一个 exact Attempt locator 展示已记录的 source snapshot。 */
+    source: { type: "boolean" },
+    /** `show @<AttemptLocator> --execution`：从公开 Record projection 呈现该 Attempt 的 transcript、tool 与 command evidence。 */
+    execution: { type: "boolean" },
+    /** `show @<AttemptLocator> --timing[=summary|full]` 专用：从内建 timing Report 读取该 Attempt 的 runner 阶段树。 */
+    timing: { type: "boolean" },
+    /** `show @<AttemptId> --execution` 专用：JS 正则过滤 retained transcript、tool 与 command evidence。 */
+    grep: { type: "string" },
+    // --diff 是布尔;--diff=<路径> 在 parseArgs 前预扫成 diffPath(路径必须 = 连写,
+    // 空格形式的下一个 token 仍是位置参数 = eval id 前缀,与文档一致)。
+    /** 实现收敛占位；目标公开 CLI 通过 Report page 读取 diff 通道。 */
+    diff: { type: "boolean" },
+    /** 实现收敛占位；目标公开 CLI 不提供跨 Run history。 */
+    history: { type: "boolean" },
+    /** 实现收敛占位；目标公开 CLI 通过 Report Calculation 呈现用量。 */
+    usage: { type: "boolean" },
+    /** 实现收敛占位；目标公开 CLI 不提供隐式跨 Run 统计。 */
+    stats: { type: "boolean" },
+    /** `show` / `view` 命令专用：按完整 ExperimentId 收窄当前项目结果；可重复，不接受前缀或逗号列表。 */
+    experiment: { type: "string", multiple: true },
+    /** `show` / `view` / `accept` / `sandbox enter|list|stop` 共用:指定实际 Record root;CLI 不补接 `.niceeval/record` 或其它后缀。 */
+    record: { type: "string" },
+    /** `show` / `view` 可重复传入 `--run`;每次按完整 RunId 增加一个显式 Run,重复 identity 去重。 */
+    run: { type: "string", multiple: true },
+    /** `show` / `view` 命令专用：内建 `standard` 或受信任的 Report module 路径。 */
+    report: { type: "string" },
+    /** `show` / `view` 命令专用：内建 Theme 或受信任的闭合 Theme module 路径。 */
+    theme: { type: "string" },
+    /** `show` / `view` 命令专用:选择报告的初始页;`show` 渲染该页并在尾部附其余页索引,`view` 以它作初始路由。未命中的页 id 按用法错误退出并列出可用页 id。 */
+    page: { type: "string" },
+    /** `exp` 命令专用:补齐被强杀打断的实验级 teardown——只对选中的实验各执行一次 teardown(新进程语义),不派发 attempt、不跑 setup;没有遗留登记也照常执行。与 eval 前缀位置参数组合是用法错误。 */
+    teardown: { type: "boolean" },
+    /** `exp --teardown` 专用:显式恢复一个永不自动接管的 sharedState lease；必须同时提供 --owner-token、--confirm-owner-terminated 和 --confirm-remote-quiesced。 */
+    "recover-shared-state": { type: "string" },
+    /** `--recover-shared-state` 专用:要恢复的不可变 owner token；错误或过期 token 不会修改 lease。 */
+    "owner-token": { type: "string" },
+    /** `--recover-shared-state` 专用:确认原 owner 已终止。 */
+    "confirm-owner-terminated": { type: "boolean" },
+    /** `--recover-shared-state` 专用:确认远端外部状态已静止。 */
+    "confirm-remote-quiesced": { type: "boolean" },
+    /** 只打印本次会匹配到的 eval × 运行配置,不实际执行(人读文本或 `--json` 单文档,见「机器怎么读:--json」)。 */
+    dry: { type: "boolean" },
+    /** `sandbox prune` 专用:除 orphan 外也销毁 unverified 实例;`exp` 明确拒绝此 flag,重跑失败项或全部项请用 `--rerun` / `--rerun all`。 */
+    force: { type: "boolean" },
+    /** `exp` 命令专用:重新运行失败项(裸写/failed)或全部项(all),不改变长期指纹。 */
+    rerun: { type: "boolean" },
+    /** 某个 eval 的一次 attempt 通过后,停止该 eval 剩余的 attempts;省略默认关(`attempts` 默认跑满、测完整通过率)。 */
+    "early-exit": { type: "boolean" },
+    /** 强制关闭首过即停,即使实验文件里写了 `earlyExit: true`。 */
+    "no-early-exit": { type: "boolean" },
+    /** `view` 命令专用:启动后自动打开浏览器(默认行为)。 */
+    open: { type: "boolean" },
+    "no-open": { type: "boolean" },
+    /** `clean` / `migrate` 专用：确认不可逆 maintenance 动作或在 clean Git restore point 下执行 migration。 */
+    yes: { type: "boolean" },
+    /** 打印用法说明并退出。 */
+    help: { type: "boolean", short: "h" },
+    /** 打印 niceeval 的版本号并退出。 */
+    version: { type: "boolean", short: "v" },
+};
+function numberFlag(name, raw) {
+    if (raw === undefined)
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw usageError((0, index_ts_5.t)("cli.flag.invalidNumber", { flag: name, value: raw }));
+    }
+    return n;
+}
+const CLI_COMMANDS = ["check", "exp", "debug", "accept", "show", "list", "view", "clean", "migrate", "init", "run", "sandbox", "session", "docker"];
+function isCliCommand(candidate) {
+    return CLI_COMMANDS.some((command) => command === candidate);
+}
+function parseArgs(argv, parseTokens) {
+    if (argv[0] === "--")
+        argv = argv.slice(1);
+    if (argv.some((arg) => arg === "--strict" || arg.startsWith("--strict="))) {
+        throw usageError((0, index_ts_5.t)("cli.flag.strictRemoved"));
+    }
+    // --diff=<路径> 预扫:diff 本体是布尔(裸 --diff = 文件级摘要),路径只接受 = 连写。
+    let diffPath;
+    // --keep-sandbox[=failed|all] 预扫:本体是布尔(裸 = failed 档),档位只接受 = 连写。
+    let keepSandboxTier;
+    // --timing[=summary|full] 预扫:node:util 的单个 option 不支持 boolean|string 联合，
+    // 所以 mode 在严格 parseArgs 前提取，再把两种形式统一成布尔 --timing。
+    let timingMode;
+    // --source[=full|<path>] 预扫:本体是布尔，值只接受 = 连写，避免吞掉 eval 前缀位置参数。
+    let sourceValue;
+    let rerunMode;
+    // boolean|string 联合 flag 的空格写法先归一：--rerun all → --rerun=all；
+    // --host 的裸写则补成默认地址，保持 `--host <地址>` 的普通 string flag 形态。
+    {
+        const normalized = [];
+        for (let index = 0; index < argv.length; index += 1) {
+            const arg = argv[index];
+            const next = argv[index + 1];
+            if (arg === "--rerun" && (next === "failed" || next === "all")) {
+                normalized.push(`--rerun=${next}`);
+                index += 1;
+            }
+            else if (arg === "--host" && (next === undefined || next.startsWith("-"))) {
+                normalized.push("--host=0.0.0.0");
+            }
+            else {
+                normalized.push(arg);
+            }
+        }
+        argv = normalized;
+    }
+    argv = argv.map((arg) => {
+        if (arg.startsWith("--host=")) {
+            const value = arg.slice("--host=".length);
+            if (value.length === 0) {
+                throw usageError("--host=<address> requires a non-empty address, or use bare --host.\n");
+            }
+        }
+        if (arg.startsWith("--source=")) {
+            const value = arg.slice("--source=".length);
+            if (value.length === 0) {
+                throw usageError("--source=<path> requires a non-empty captured source path, or use bare --source.\n");
+            }
+            sourceValue = value;
+            return "--source";
+        }
+        if (arg.startsWith("--diff=")) {
+            const path = arg.slice("--diff=".length);
+            if (path)
+                diffPath = path;
+            return "--diff";
+        }
+        if (arg.startsWith("--keep-sandbox=")) {
+            const tier = arg.slice("--keep-sandbox=".length);
+            if (tier !== "failed" && tier !== "all") {
+                throw usageError(`--keep-sandbox only accepts "failed" (default) or "all", got "${tier}".\n`);
+            }
+            keepSandboxTier = tier;
+            return "--keep-sandbox";
+        }
+        if (arg.startsWith("--timing=")) {
+            const mode = arg.slice("--timing=".length);
+            if (mode !== "summary" && mode !== "full") {
+                throw usageError(`--timing only accepts "summary" (default) or "full", got "${mode}".\n`);
+            }
+            timingMode = mode;
+            return "--timing";
+        }
+        if (arg.startsWith("--rerun=")) {
+            const mode = arg.slice("--rerun=".length);
+            if (mode !== "failed" && mode !== "all") {
+                throw usageError(`--rerun only accepts "failed" (default) or "all", got "${mode}".\n`);
+            }
+            rerunMode = mode;
+            return "--rerun";
+        }
+        // `--output` 整个删除(见 docs/feature/experiments/cli.md 与 memory/exp-output-two-forms-ruling.md):
+        // beta 不留别名,任何取值(裸 flag 或 `--output=value`)都按用法错误拒绝,不静默吞掉、也不
+        // 落到 node:util parseArgs 的通用「unknown option」文案——给出专门的 error:/fix: 两行,
+        // 指向唯一还存在的两条路径:不加 flag 跑人读文本,机器面用 `--json`。
+        if (arg === "--output" || arg.startsWith("--output=")) {
+            throw usageError((0, index_ts_5.t)("cli.flag.outputRemoved"));
+        }
+        return arg;
+    });
+    let values;
+    let rawPositionals;
+    let providedOptions;
+    try {
+        const parsed = parseTokens(argv, exports.FLAG_OPTIONS);
+        values = parsed.values;
+        rawPositionals = parsed.positionals;
+        providedOptions = parsed.tokens
+            .filter((token) => token.kind === "option" && token.name !== undefined)
+            .map((token) => token.name);
+    }
+    catch (e) {
+        if (e instanceof CliUsageError)
+            throw e;
+        throw usageError((0, index_ts_5.t)("cli.flag.parseError", { message: e instanceof Error ? e.message : String(e) }));
+    }
+    // 第一个位置参数必须是已知命令;其余是 eval id 前缀 / view 输入。
+    // 裸 eval id 早已不再是运行入口,所以不识别的首 token 应当就地报用法错误,
+    // 不应先装载项目 config / eval 再偶然以其它错误退出。
+    let command = "run";
+    let positionals = rawPositionals;
+    if (rawPositionals.length > 0) {
+        const candidate = rawPositionals[0];
+        if (!isCliCommand(candidate)) {
+            throw usageError((0, index_ts_5.t)("cli.command.unknown", { command: candidate }));
+        }
+        command = candidate;
+        positionals = rawPositionals.slice(1);
+    }
+    const flags = {
+        agent: values.agent,
+        model: values.model,
+        attempts: numberFlag("attempts", values.attempts),
+        maxConcurrency: numberFlag("max-concurrency", values["max-concurrency"]),
+        maxBuildConcurrency: numberFlag("max-build-concurrency", values["max-build-concurrency"]),
+        timeout: numberFlag("timeout", values.timeout),
+        budget: numberFlag("budget", values.budget),
+        tag: values.tag,
+        junit: values.junit,
+        json: values.json === true,
+        smoke: values.smoke === true,
+        out: values.out,
+        port: numberFlag("port", values.port),
+        host: values.host,
+        dry: values.dry === true,
+        force: values.force === true,
+        rerun: values.rerun === true ? (rerunMode ?? "failed") : undefined,
+        earlyExit: values["no-early-exit"] === true ? false : values["early-exit"] === true ? true : undefined,
+        open: values["no-open"] === true ? false : values.open === true ? true : undefined,
+        help: values.help === true,
+        version: values.version === true,
+        yes: values.yes === true,
+        source: values.source === true ? (sourceValue ?? true) : undefined,
+        execution: values.execution === true,
+        diff: values.diff === true && diffPath === undefined,
+        diffPath,
+        timing: values.timing === true ? (timingMode ?? "summary") : undefined,
+        grep: values.grep,
+        keepSandbox: values["keep-sandbox"] === true ? (keepSandboxTier ?? "failed") : undefined,
+        all: values.all === true,
+        window: values.window,
+        sandboxPath: values.path,
+        leaveRunning: values["leave-running"] === true,
+        history: values.history === true,
+        usage: values.usage === true,
+        stats: values.stats === true,
+        experiment: values.experiment,
+        record: values.record,
+        run: values.run,
+        report: values.report,
+        page: values.page,
+        theme: values.theme,
+        orphans: values.orphans === true,
+        teardown: values.teardown === true,
+        recoverSharedState: values["recover-shared-state"],
+        ownerToken: values["owner-token"],
+        confirmOwnerTerminated: values["confirm-owner-terminated"] === true,
+        confirmRemoteQuiesced: values["confirm-remote-quiesced"] === true,
+    };
+    return { command, positionals, flags, providedOptions };
+}
+function projectCurrentDryPlan(input) {
+    return Object.freeze({
+        slots: Object.freeze(input.slots.map(projectCurrentDryPlanSlot)),
+        readbacks: Object.freeze([...input.readbacks]),
+    });
+}
+function projectCurrentDryPlanSlot(slot) {
+    return Object.freeze({
+        runId: String(slot.runId),
+        slotId: String(slot.slotId),
+        experimentId: slot.experimentId,
+        evalId: slot.evalId,
+        attempt: slot.attempt,
+        state: slot.state === "reuse" ? "reused" : "gap",
+        comparisons: Object.freeze(slot.comparisons.map((comparison) => Object.freeze({
+            attachment: comparison.attachment,
+            recordedClaim: comparison.recordedClaim,
+            sourceState: comparison.sourceState,
+            result: comparison.result,
+            reason: comparison.reason,
+        }))),
+        ...(slot.state === "gap" ? { reason: slot.reason, scope: slot.scope } : {}),
+    });
+}
+function currentDryPlanRows(plan) {
+    const rows = new Map();
+    const rowFor = (experimentId, evalId) => {
+        const key = JSON.stringify([experimentId, evalId]);
+        const existing = rows.get(key);
+        if (existing !== undefined)
+            return existing;
+        const created = { experimentId, evalId, slots: [], readbacks: [] };
+        rows.set(key, created);
+        return created;
+    };
+    for (const slot of plan.slots)
+        rowFor(slot.experimentId, slot.evalId).slots.push(slot);
+    for (const readback of plan.readbacks) {
+        rowFor(readback.target.experimentId, readback.target.evalId).readbacks.push(readback);
+    }
+    return Object.freeze([...rows.values()].map((row) => Object.freeze({
+        experimentId: row.experimentId,
+        evalId: row.evalId,
+        slots: Object.freeze([...row.slots].sort((left, right) => left.attempt - right.attempt)),
+        readbacks: Object.freeze([...row.readbacks].sort((left, right) => left.target.attempt - right.target.attempt)),
+    })).sort((left, right) => left.experimentId.localeCompare(right.experimentId) || left.evalId.localeCompare(right.evalId)));
+}
+function renderCurrentDryPlan(input) {
+    const reused = input.rows.reduce((total, row) => total + row.slots.filter((slot) => slot.state === "reused").length, 0);
+    const lines = [
+        `plan: ${input.totalAttempts} attempts · ${input.evals} evals × ${input.configs} configs · runs ${input.attempts}`,
+        ...(reused === 0 ? [] : [`reuse: ${reused}/${input.totalAttempts} exact current Record attempts`]),
+        `plugins: ${input.pluginAudit.occurrences.length} lifecycle occurrences`,
+    ];
+    for (const row of input.rows) {
+        const reusedAttempts = row.slots.filter((slot) => slot.state === "reused").map((slot) => slot.attempt);
+        const gaps = row.slots.filter((slot) => slot.state === "gap");
+        const hasIdentityGap = gaps.some((slot) => slot.reason === "identity-mismatch");
+        const parts = [
+            ...(row.locked ? ["locked"] : []),
+            ...(reusedAttempts.length === 0 ? [] : [`reused ${reusedAttempts.join(",")}`]),
+            ...gaps.map((slot) => `gap ${slot.attempt}:${slot.reason ?? "unknown"}`),
+        ];
+        lines.push(`${row.experimentId}  ${row.evalId}  ${parts.join(" · ") || "no slots"}`);
+        for (const readback of row.readbacks) {
+            const verdict = readback.state === "reused"
+                ? readback.verdict
+                : readback.verdict.state === "available"
+                    ? readback.verdict.value
+                    : readback.verdict.state;
+            const locator = readback.source.locator;
+            lines.push(`  source ${locator} · ${readback.state} · verdict ${verdict}`);
+            if (hasIdentityGap && readback.state === "prior") {
+                lines.push(`  accept: niceeval accept ${locator}`);
+            }
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function renderCurrentDryPlanJson(input) {
+    const reused = input.rows.reduce((total, row) => total + row.slots.filter((slot) => slot.state === "reused").length, 0);
+    return `${JSON.stringify({
+        format: "niceeval.current-reuse-plan/v1",
+        schemaVersion: 1,
+        total: input.totalAttempts,
+        evals: input.evals,
+        configs: input.configs,
+        attempts: input.attempts,
+        reused,
+        matrix: input.rows,
+        plugins: input.pluginAudit.occurrences,
+    })}\n`;
+}
+/**
+ * Fold the invocation's real fresh results and current Record readbacks at the
+ * same eval identity. This intentionally projects only identity + terminal
+ * verdict; a reused readback is never recreated as an EvalResult.
+ */
+function foldInvocationEvalStats(summary) {
+    const terminals = [
+        ...summary.results.map((result) => Object.freeze({
+            identity: `${result.experimentId ?? ""}|${result.id}`,
+            verdict: result.verdict,
+        })),
+        ...summary.reusedAttempts.map((readback) => Object.freeze({
+            identity: `${readback.target.experimentId}|${readback.target.evalId}`,
+            verdict: readback.source.evaluationKind !== "score"
+                ? readback.verdict
+                : readback.score.state === "applicable"
+                    && readback.score.attachment.state === "available"
+                    && readback.score.attachment.value.state === "complete"
+                    ? "passed"
+                    : "errored",
+        })),
+    ];
+    return (0, verdict_ts_1.evalLevelStats)(terminals, (terminal) => terminal.identity);
+}
+function firstViewerOnlyFlag(flags) {
+    const SHOW = "show";
+    const BOTH = "show / view";
+    const VIEW = "view";
+    if (flags.source)
+        return { flag: "--source", command: SHOW };
+    if (flags.execution)
+        return { flag: "--execution", command: SHOW };
+    if (flags.timing !== undefined)
+        return { flag: "--timing", command: SHOW };
+    if (flags.grep !== undefined)
+        return { flag: "--grep", command: SHOW };
+    if (flags.diff || flags.diffPath !== undefined)
+        return { flag: "--diff", command: SHOW };
+    if (flags.history)
+        return { flag: "--history", command: SHOW };
+    if (flags.usage)
+        return { flag: "--usage", command: SHOW };
+    if (flags.stats)
+        return { flag: "--stats", command: SHOW };
+    if (flags.experiment !== undefined)
+        return { flag: "--experiment", command: BOTH };
+    if (flags.report !== undefined)
+        return { flag: "--report", command: BOTH };
+    if (flags.theme !== undefined)
+        return { flag: "--theme", command: VIEW };
+    if (flags.page !== undefined)
+        return { flag: "--page", command: BOTH };
+    if (flags.run !== undefined)
+        return { flag: "--run", command: VIEW };
+    if (flags.out !== undefined)
+        return { flag: "--out", command: VIEW };
+    if (flags.port !== undefined)
+        return { flag: "--port", command: VIEW };
+    if (flags.open !== undefined)
+        return { flag: "--open", command: VIEW };
+    return undefined;
+}
+/** `clean` and `migrate` operate on a current Record root with explicit confirmation. */
+function firstRecordMaintenanceUnsupportedFlag(flags) {
+    const unsupported = [
+        ["--agent", flags.agent],
+        ["--model", flags.model],
+        ["--attempts", flags.attempts],
+        ["--max-concurrency", flags.maxConcurrency],
+        ["--max-build-concurrency", flags.maxBuildConcurrency],
+        ["--timeout", flags.timeout],
+        ["--budget", flags.budget],
+        ["--tag", flags.tag],
+        ["--junit", flags.junit],
+        ["--json", flags.json],
+        ["--smoke", flags.smoke],
+        ["--dry", flags.dry],
+        ["--force", flags.force],
+        ["--rerun", flags.rerun],
+        ["--early-exit/--no-early-exit", flags.earlyExit],
+        ["--open/--no-open", flags.open],
+        ["--out", flags.out],
+        ["--port", flags.port],
+        ["--host", flags.host],
+        ["--source", flags.source],
+        ["--execution", flags.execution],
+        ["--diff", flags.diff || flags.diffPath !== undefined],
+        ["--grep", flags.grep],
+        ["--timing", flags.timing],
+        ["--keep-sandbox", flags.keepSandbox],
+        ["--all", flags.all],
+        ["--window", flags.window],
+        ["--path", flags.sandboxPath],
+        ["--leave-running", flags.leaveRunning],
+        ["--history", flags.history],
+        ["--usage", flags.usage],
+        ["--stats", flags.stats],
+        ["--experiment", flags.experiment],
+        ["--run", flags.run],
+        ["--report", flags.report],
+        ["--page", flags.page],
+        ["--theme", flags.theme],
+        ["--orphans", flags.orphans],
+        ["--teardown", flags.teardown],
+        ["--recover-shared-state", flags.recoverSharedState],
+        ["--owner-token", flags.ownerToken],
+        ["--confirm-owner-terminated", flags.confirmOwnerTerminated],
+        ["--confirm-remote-quiesced", flags.confirmRemoteQuiesced],
+    ];
+    const bad = unsupported.find(([flag, value]) => {
+        if (flag === "--open/--no-open" || flag === "--early-exit/--no-early-exit") {
+            return value !== undefined;
+        }
+        return value !== undefined && value !== false && (!Array.isArray(value) || value.length > 0);
+    });
+    return bad?.[0];
+}
+/**
+ * `accept` 接受一个或多个精确 locator；它不是 `exp` 的另一种选择器，也不派发 attempt。
+ * `--record` 是唯一允许的附加 flag，用来接受发布根或其它显式记录根里的结果。
+ */
+function parseAcceptLocators(positionals, flags) {
+    if (positionals.length === 0 || positionals.some((locator) => !/^@[^@\s]+$/.test(locator))) {
+        throw usageError((0, index_ts_5.t)("cli.accept.usage"));
+    }
+    if (new Set(positionals).size !== positionals.length) {
+        throw usageError("niceeval accept rejects duplicate locators.\n");
+    }
+    // `parseArgs` 已经负责未知 flag；这里拒绝那些虽为全局已知、但会改变运行/查看语义的 flag。
+    // `--record` 是 accept 的唯一范围输入，help/version 在 main() 更早处理。
+    const unsupported = [
+        ["--agent", flags.agent],
+        ["--model", flags.model],
+        ["--attempts", flags.attempts],
+        ["--max-concurrency", flags.maxConcurrency],
+        ["--max-build-concurrency", flags.maxBuildConcurrency],
+        ["--timeout", flags.timeout],
+        ["--budget", flags.budget],
+        ["--tag", flags.tag],
+        ["--junit", flags.junit],
+        ["--json", flags.json],
+        ["--dry", flags.dry],
+        ["--force", flags.force],
+        ["--rerun", flags.rerun],
+        ["--early-exit/--no-early-exit", flags.earlyExit],
+        ["--open/--no-open", flags.open],
+        ["--source", flags.source],
+        ["--execution", flags.execution],
+        ["--diff", flags.diff || flags.diffPath !== undefined],
+        ["--grep", flags.grep],
+        ["--timing", flags.timing],
+        ["--keep-sandbox", flags.keepSandbox],
+        ["--all", flags.all],
+        ["--window", flags.window],
+        ["--path", flags.sandboxPath],
+        ["--leave-running", flags.leaveRunning],
+        ["--history", flags.history],
+        ["--usage", flags.usage],
+        ["--stats", flags.stats],
+        ["--experiment", flags.experiment],
+        ["--run", flags.run],
+        ["--report", flags.report],
+        ["--page", flags.page],
+        ["--theme", flags.theme],
+        ["--orphans", flags.orphans],
+        ["--teardown", flags.teardown],
+        ["--recover-shared-state", flags.recoverSharedState],
+        ["--owner-token", flags.ownerToken],
+        ["--confirm-owner-terminated", flags.confirmOwnerTerminated],
+        ["--confirm-remote-quiesced", flags.confirmRemoteQuiesced],
+    ];
+    const bad = unsupported.find(([flag, value]) => {
+        // `--no-open` / `--no-early-exit` are represented as false, but are still
+        // explicit flags and therefore invalid on this command.
+        if (flag === "--open/--no-open" || flag === "--early-exit/--no-early-exit")
+            return value !== undefined;
+        return value !== undefined && value !== false && (!Array.isArray(value) || value.length > 0);
+    });
+    if (bad) {
+        throw usageError((0, index_ts_5.t)("cli.accept.flagUnsupported", { flag: bad[0] }));
+    }
+    return [...positionals];
+}
+/** 调用 acceptance core；CLI 只负责 cwd/记录根边界、输出与退出码，不重建结果或启动 runner。 */
+function runAcceptCommand(cwd, locators, recordRoot) {
+    return effect_1.Effect.gen(function* () {
+        const config = yield* loadConfig(cwd);
+        const results = yield* cliEffect("accept locators", index_ts_1.experimentHost.accept({
+            cwd,
+            config,
+            locators,
+            ...(recordRoot !== undefined ? { recordRoot } : {}),
+        }));
+        for (const result of results) {
+            yield* writeStdout((0, index_ts_5.t)("cli.accept.done", {
+                runId: result.runId,
+                sourceLocator: result.sourceLocator,
+                locator: result.locator,
+                fingerprint: result.fingerprint ?? "—",
+            }));
+        }
+    });
+}
+// ── exp rename:CLI 契约与纯解析/格式化 ──────────────────────────────────────
+// 核心在 src/runner/rename-experiment.ts(planExperimentRename / renameExperiment,
+// 资格门与写入都在那里,见 docs/source-map.md 与 docs/feature/experiments/rename.md);
+// CLI 只做:解析 `exp rename <oldId> <newId>`、递选项进核心、把核心返回的计划/结果按
+// 形态渲染。稳定 reason、计划与结果文档都是核心导出的契约,CLI 不在渲染层重建资格算法。
+exports.EXPERIMENT_RENAME_FORMAT = "niceeval.experimentRename";
+exports.EXPERIMENT_RENAME_SCHEMA_VERSION = 1;
+const EXPERIMENT_RENAME_REASON_MESSAGE = {
+    "source-empty": "cli.rename.error.sourceEmpty",
+    "target-not-found": "cli.rename.error.targetNotFound",
+    "target-has-results": "cli.rename.error.targetHasResults",
+    "source-unreadable": "cli.rename.error.sourceUnreadable",
+    "artifact-unavailable": "cli.rename.error.artifactUnavailable",
+    "nothing-to-migrate": "cli.rename.error.nothingToMigrate",
+};
+/**
+ * 解析 exp rename 的位置参数:必须恰好两个(一个旧 id、一个新 id)。
+ * 纯函数,CLI 与测试共用。
+ */
+function parseExperimentRenamePositionals(args) {
+    if (args.length !== 2 || args[0] === undefined || args[1] === undefined) {
+        return { ok: false, kind: "usage" };
+    }
+    return { ok: true, oldId: args[0], newId: args[1] };
+}
+/**
+ * exp rename 只允许 --dry / --json;返回第一个被误用的 flag,没有误用返回 undefined。
+ * 与 accept 同一套纪律:node:util parseArgs 已经报未知 flag,这里拒绝那些全局已知、
+ * 但会改变运行/查看语义的 flag。
+ */
+function firstExperimentRenameUnsupportedFlag(flags) {
+    const unsupported = [
+        ["--agent", flags.agent],
+        ["--model", flags.model],
+        ["--attempts", flags.attempts],
+        ["--max-concurrency", flags.maxConcurrency],
+        ["--max-build-concurrency", flags.maxBuildConcurrency],
+        ["--timeout", flags.timeout],
+        ["--budget", flags.budget],
+        ["--tag", flags.tag],
+        ["--junit", flags.junit],
+        ["--force", flags.force],
+        ["--rerun", flags.rerun],
+        ["--early-exit/--no-early-exit", flags.earlyExit],
+        ["--open/--no-open", flags.open],
+        ["--source", flags.source],
+        ["--execution", flags.execution],
+        ["--diff", flags.diff || flags.diffPath !== undefined],
+        ["--grep", flags.grep],
+        ["--timing", flags.timing],
+        ["--keep-sandbox", flags.keepSandbox],
+        ["--all", flags.all],
+        ["--window", flags.window],
+        ["--path", flags.sandboxPath],
+        ["--leave-running", flags.leaveRunning],
+        ["--history", flags.history],
+        ["--usage", flags.usage],
+        ["--stats", flags.stats],
+        ["--experiment", flags.experiment],
+        ["--record", flags.record],
+        ["--run", flags.run],
+        ["--report", flags.report],
+        ["--page", flags.page],
+        ["--theme", flags.theme],
+        ["--orphans", flags.orphans],
+        ["--teardown", flags.teardown],
+        ["--recover-shared-state", flags.recoverSharedState],
+        ["--owner-token", flags.ownerToken],
+        ["--confirm-owner-terminated", flags.confirmOwnerTerminated],
+        ["--confirm-remote-quiesced", flags.confirmRemoteQuiesced],
+        ["--out", flags.out],
+        ["--port", flags.port],
+        ["--host", flags.host],
+    ];
+    const bad = unsupported.find(([flag, value]) => {
+        // `--no-open` / `--no-early-exit` 表现为 false,但仍是显式 flag,在 rename 上同样非法。
+        if (flag === "--open/--no-open" || flag === "--early-exit/--no-early-exit")
+            return value !== undefined;
+        return value !== undefined && value !== false && (!Array.isArray(value) || value.length > 0);
+    });
+    return bad?.[0];
+}
+/** 人读面:核心计划 → 预览文本。逐条列出迁移与排除;有 `blocked` 时点名阻断原因。 */
+function renderExperimentRenamePlanHuman(plan) {
+    const lines = [(0, index_ts_5.t)("cli.rename.previewHeader", { oldId: plan.oldId, newId: plan.newId })];
+    if (plan.blocked !== undefined) {
+        lines.push((0, index_ts_5.t)("cli.rename.blocked", { reason: plan.blocked.reason }));
+        lines.push(...renderExperimentRenameBlockedDetail(plan.blocked));
+    }
+    if (plan.migrations.length > 0) {
+        lines.push((0, index_ts_5.t)("cli.rename.migratingHeader", { count: plan.migrations.length }));
+        for (const entry of plan.migrations) {
+            lines.push((0, index_ts_5.t)("cli.rename.migratingRow", {
+                evalId: entry.evalId,
+                sourceLocator: entry.sourceLocator,
+                newId: plan.newId,
+            }));
+        }
+    }
+    if (plan.excluded.length > 0) {
+        lines.push((0, index_ts_5.t)("cli.rename.excludedHeader", { count: plan.excluded.length }));
+        for (const entry of plan.excluded) {
+            lines.push((0, index_ts_5.t)("cli.rename.excludedRow", { evalId: entry.evalId, reason: entry.reason }));
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** 拒绝的人读面:先给 reason 专属文案(点名旧 id、新 id、受影响 eval 与下一步),再补冲突清单。 */
+function renderExperimentRenameRejectedHuman(rejected) {
+    const lines = [
+        (0, index_ts_5.t)(EXPERIMENT_RENAME_REASON_MESSAGE[rejected.reason], {
+            oldId: rejected.oldId,
+            newId: rejected.newId,
+            evalId: rejected.evalId ?? "",
+        }),
+    ];
+    lines.push(...renderExperimentRenameRejectedDetail(rejected));
+    return `${lines.join("\n")}\n`;
+}
+/** 成功的人读面:新 snapshot 路径 + 逐条新 locator。 */
+function renderExperimentRenameDoneHuman(done) {
+    const lines = [
+        (0, index_ts_5.t)("cli.rename.doneHeader", { oldId: done.oldId, newId: done.newId, count: done.migrated.length }),
+        (0, index_ts_5.t)("cli.rename.snapshotPath", { path: done.snapshotPath }),
+    ];
+    for (const entry of done.migrated) {
+        lines.push((0, index_ts_5.t)("cli.rename.doneRow", {
+            evalId: entry.evalId,
+            sourceLocator: entry.sourceLocator,
+            locator: entry.locator,
+        }));
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** 阻断的逐条事实:冲突 eval 逐行列出，并保留底层读取详情。 */
+function renderExperimentRenameBlockedDetail(blocked) {
+    const lines = [];
+    for (const evalId of blocked.conflictingEvals ?? []) {
+        lines.push(`  ${evalId}`);
+    }
+    if (blocked.detail !== undefined)
+        lines.push(`  ${blocked.detail}`);
+    return lines;
+}
+function renderExperimentRenameRejectedDetail(rejected) {
+    const lines = [];
+    const conflicting = rejected.conflictingEvals ?? [];
+    if (conflicting.length > 0) {
+        lines.push((0, index_ts_5.t)("cli.rename.conflicting", { evals: conflicting.join(", ") }));
+    }
+    return lines;
+}
+/** 机器面:单份 JSON 文档,不混入人读文本(见 rename.md「命令」)。 */
+function renderExperimentRenameJson(document) {
+    return `${JSON.stringify({
+        format: exports.EXPERIMENT_RENAME_FORMAT,
+        schemaVersion: exports.EXPERIMENT_RENAME_SCHEMA_VERSION,
+        ...document,
+    })}\n`;
+}
+/** 把 renameExperiment 抛出的资格错误投影成 rejected 文档(JSON 与拒绝人读共用)。 */
+function experimentRenameRejectedFromError(error) {
+    const plan = error.plan;
+    const blocked = plan?.blocked;
+    return {
+        status: "rejected",
+        oldId: plan?.oldId ?? "",
+        newId: plan?.newId ?? "",
+        reason: error.reason,
+        ...(blocked?.evalId === undefined ? {} : { evalId: blocked.evalId }),
+        ...(blocked?.conflictingEvals === undefined ? {} : { conflictingEvals: blocked.conflictingEvals }),
+        ...(blocked?.detail === undefined ? {} : { detail: blocked.detail }),
+    };
+}
+/** 退出码:可迁移预览与成功执行为 0;blocked 预览 / rejected 整批零写入按失败退出。 */
+function experimentRenameExitCode(document) {
+    if (document.status === "done")
+        return 0;
+    if (document.status === "plan")
+        return document.blocked === undefined ? 0 : 1;
+    return 1;
+}
+/**
+ * exp rename 的 CLI 执行:解析 → 核心 → 渲染 → 退出码。核心契约见
+ * src/runner/rename-experiment.ts(planExperimentRename / renameExperiment)。
+ * renameExperiment 对资格失败抛 ExperimentRenameError,CLI 把它投影成 rejected 文档。
+ */
+function runExperimentRenameCommand(cwd, args, flags) {
+    return effect_1.Effect.gen(function* () {
+        const parsed = parseExperimentRenamePositionals(args);
+        if (!parsed.ok) {
+            yield* writeStderr((0, index_ts_5.t)("cli.rename.usage"));
+            return 1;
+        }
+        const unsupported = firstExperimentRenameUnsupportedFlag(flags);
+        if (unsupported !== undefined) {
+            yield* writeStderr((0, index_ts_5.t)("cli.rename.flagUnsupported", { flag: unsupported }));
+            return 1;
+        }
+        const { oldId, newId } = parsed;
+        const mod = (yield* cliPromise("load experiment rename command", () => __niceevalDynamicImport("../runner/rename-experiment.cjs")));
+        if (flags.dry) {
+            const plan = yield* cliEffect("plan experiment rename", mod.planExperimentRename({ cwd, oldId, newId }));
+            yield* writeStdout(flags.json ? renderExperimentRenameJson(plan) : renderExperimentRenamePlanHuman(plan));
+            return experimentRenameExitCode(plan);
+        }
+        const outcome = yield* effect_1.Effect.either(cliEffect("rename experiment", mod.renameExperiment({ cwd, oldId, newId })));
+        if (effect_1.Either.isRight(outcome)) {
+            yield* writeStdout(flags.json ? renderExperimentRenameJson(outcome.right) : renderExperimentRenameDoneHuman(outcome.right));
+            return 0;
+        }
+        // ExperimentRenameError 携带稳定 reason 与 rejected plan;其它异常按通用失败兜底。
+        const error = outcome.left.cause;
+        if (error instanceof rename_experiment_ts_1.ExperimentRenameError) {
+            const rejected = experimentRenameRejectedFromError(error);
+            yield* writeStdout(flags.json ? renderExperimentRenameJson(rejected) : renderExperimentRenameRejectedHuman(rejected));
+        }
+        else {
+            yield* writeStderr((0, index_ts_5.t)("cli.rename.failed", { error: error instanceof Error ? error.message : String(error) }));
+        }
+        return 1;
+    });
+}
+function loadConfig(cwd) {
+    return effect_1.Effect.gen(function* () {
+        const project = yield* project_configuration_ts_1.ProjectConfiguration;
+        return yield* project.load(cwd).pipe(effect_1.Effect.mapError((cause) => cliFailure("load NiceEval config", cause)));
+    });
+}
+// AGENTS.md/CLAUDE.md 托管区块:告诉在这个项目里干活的 coding agent「niceeval 不在你的训练数据里,
+// 先读随包文档,跑完只经公开 show 面诊断」。随包只发中文准绳版文档(英文站是手工同步、可能滞后,
+// 不进包,见 package.json 的 files);init 时写入/刷新;标记之外的用户内容永不触碰。
+function initProject(cwd) {
+    return effect_1.Effect.flatMap(application_ts_1.ProjectInitializer, (initializer) => initializer.initialize(cwd)).pipe(effect_1.Effect.mapError((cause) => cliFailure("initialize project", cause)));
+}
+function openBrowser(url) {
+    return effect_1.Effect.flatMap(application_ts_1.BrowserLauncher, (launcher) => launcher.open(url)).pipe(effect_1.Effect.mapError((cause) => cliFailure("open browser", cause)));
+}
+/**
+ * run 结束后把 coordinator 累计的诊断折成 `InvocationCompletion`(见 docs/feature/experiments/cli.md
+ * 「运行完成状态不只看 verdict 计数」)。只读已经真实发生过的诊断,不额外发明信号:
+ * - `"interrupted"` 诊断只在 run.ts 判定为真·中断(Effect exit 真实标记中断,不是「signal 被
+ *   abort 过」这种更弱的信号)时才会出现,见 `runner/run.ts` 的 `reportInterrupted()` 调用点。
+ * - `"budget-exhausted:<experimentId>"` 诊断的 `count` 就是该 experiment 因预算耗尽未派发的
+ *   attempt 数(见 `runner/feedback/reducer.ts` 对 `budget-exhausted` 事件的注释),跨
+ *   experiment 求和得到 `unstarted`。
+ * - `"reporter-error:<reporter>"` 诊断转成 `ReporterError[]`;`required` 字段来自事件自带的
+ *   `data.required`,直接反映这个 reporter 注册时的真实 required/best-effort 分类(见上面
+ *   构造 `reporters: ReporterRegistration[]` 的地方——`--junit` 为 `required: true`,
+ *   `config.reporters` 恒 `false`),不是一个统一写死的占位值。
+ * - `earlyExitUnstarted` 从反馈状态的 attempt:early-exit 计数派生(减去 fail-fast 的那部分——
+ *   那是「未完整覆盖」,进 unstarted,不是「省下的重复验证」)。
+ */
+function assembleInvocationCompletion(state) {
+    let unstarted = 0;
+    let failFastSkipped = 0;
+    let haltedSkipped = 0;
+    let interrupted = false;
+    const reporterErrors = [];
+    for (const d of state.diagnostics) {
+        // 归类按**稳定词法** `code`,不按 `key`:`key` 里编着折叠身份(experimentId / evalId /
+        // reporter 名),拿它做前缀匹配会在「把身份从 key 里摘出去」时静默失配——记账悄悄归零,
+        // 没有任何测试或类型会报警。`code` 省略时回落到 key 的首段:缺省 key 恒是
+        // `${code}:${identity}`(见 sink.ts 的 DiagnosticInput),首段即 code。
+        const code = d.code ?? d.key.split(":", 1)[0];
+        if (code === "interrupted") {
+            interrupted = true;
+        }
+        else if (code === "budget-exhausted") {
+            unstarted += d.count;
+        }
+        else if (code === "fail-fast") {
+            // run 级 fail-fast 造成的未派发同样计入 unstarted(结论落 incomplete,见
+            // docs/feature/experiments/architecture.md「Completion 与退出」)。
+            unstarted += d.count;
+            failFastSkipped += d.count;
+        }
+        else if (code === "dispatch-halted") {
+            // 止损闸停派发造成的未派发(见 docs/feature/error-classification/architecture.md
+            // 「记账」)。这条诊断的 count 是「同一死因被声明了几次」(重复声明折叠),不是未派发数——
+            // 未派发数由 emitter 累计后写在 data.unstarted 里(与 budget-exhausted 同一口径)。
+            const halted = typeof d.data?.unstarted === "number" ? d.data.unstarted : 0;
+            unstarted += halted;
+            haltedSkipped += halted;
+        }
+        else if (code === "reporter-error") {
+            // required 决定这条错误是否写进 InvocationCompletion.reporterErrors 并让 completion 非 complete
+            // (见 docs/cli.md「required reporter」);best-effort reporter 的失败只保留为 diagnostic。
+            if (d.data?.required !== true)
+                continue;
+            reporterErrors.push({
+                reporter: typeof d.data?.reporter === "string" ? d.data.reporter : d.key.slice("reporter-error:".length),
+                required: true,
+                message: d.message,
+            });
+        }
+    }
+    // 中断造成的未派发(仍在 queued 的 attempt)同样计入 unstarted(见 docs/feature/experiments/
+    // architecture.md「Completion 与退出」:budget 耗尽、fail-fast 或中断造成的未派发都不伪装成全绿)。
+    if (interrupted)
+        unstarted += state.queued;
+    // attempt:early-exit 计数含 fail-fast 与止损闸的未派发(反馈层同一事件驱动计数守恒);
+    // 「省下的重复验证」= 总数减去那两部分。
+    const earlyExitUnstarted = Math.max(0, state.earlyExitSkipped - failFastSkipped - haltedSkipped);
+    const status = interrupted
+        ? "interrupted"
+        : unstarted > 0 || reporterErrors.length > 0
+            ? "incomplete"
+            : "complete";
+    return { status, unstarted, earlyExitUnstarted, reporterErrors };
+}
+/** package.json 的 version 字段;-v/--version 直接回显这个号。 */
+function packageVersion() {
+    return effect_1.Effect.flatMap(application_ts_1.PackageMetadata, (metadata) => metadata.version).pipe(effect_1.Effect.mapError((cause) => cliFailure("read package version", cause)));
+}
+function writeStdout(text) {
+    return effect_1.Effect.flatMap(application_ts_1.CliOutput, (output) => output.writeStdout(text)).pipe(effect_1.Effect.mapError((cause) => cliFailure("write stdout", cause)));
+}
+function writeStderr(text) {
+    return effect_1.Effect.flatMap(application_ts_1.CliOutput, (output) => output.writeStderr(text)).pipe(effect_1.Effect.mapError((cause) => cliFailure("write stderr", cause)));
+}
+/** Idempotent application-level sweep for resources owned by this invocation. */
+function releaseCliResources() {
+    // Shared-state leases are never part of this exit sweep. A normal Runner
+    // lifecycle releases one only after every pool/provider/Experiment cleanup
+    // succeeds; a failed cleanup intentionally leaves explicit recovery work.
+    return cliPromise("stop remaining sandboxes", () => (0, registry_ts_1.stopAllSandboxes)()).pipe(effect_1.Effect.ignore, effect_1.Effect.zipRight((0, experiment_cleanup_registry_ts_1.drainExperimentTeardowns)().pipe(effect_1.Effect.ignore)), effect_1.Effect.zipRight((0, lock_ts_1.drainHeldCaseLocksEffect)().pipe(effect_1.Effect.ignore)));
+}
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+function runDockerCommand(positionals, flags) {
+    return effect_1.Effect.gen(function* () {
+        const { runDockerProfileCommand } = (yield* cliPromise("load Docker profile command", () => __niceevalDynamicImport("../sandbox/docker-profile/cli.cjs")));
+        return yield* cliPromise("run Docker profile command", () => runDockerProfileCommand(positionals, { json: flags.json, smoke: flags.smoke }));
+    });
+}
+function runSandboxCliCommand(cwd, positionals, flags) {
+    return cliEffect("run sandbox command", (0, cli_commands_ts_1.runSandboxCommandEffect)(cwd, [...positionals], {
+        all: flags.all,
+        window: flags.window,
+        path: flags.sandboxPath,
+        leaveRunning: flags.leaveRunning,
+        run: flags.record,
+        orphans: flags.orphans,
+        force: flags.force,
+    }));
+}
+function runSessionCommand(cwd, positionals, flags) {
+    return effect_1.Effect.gen(function* () {
+        const path = yield* application_ts_1.CliPath;
+        const niceevalRoot = path.resolve(cwd, ".niceeval");
+        const subcommand = positionals[0] ?? "list";
+        if (subcommand === "list") {
+            if (positionals.length > 2) {
+                yield* writeStderr("niceeval session list accepts at most one experiment prefix.\n");
+                return 1;
+            }
+            const outcome = yield* effect_1.Effect.either(cliEffect("list sessions", (0, session_ts_1.listSessions)(niceevalRoot, {
+                all: flags.all,
+                ...(positionals[1] === undefined ? {} : { selector: positionals[1] }),
+            })));
+            if (effect_1.Either.isLeft(outcome)) {
+                yield* writeStderr(`${errorMessage(outcome.left.cause)}\n`);
+                return 1;
+            }
+            yield* writeStdout(flags.json
+                ? `${JSON.stringify(outcome.right)}\n`
+                : (0, session_ts_1.renderSessionListText)(outcome.right, Date.now(), flags.all));
+            return 0;
+        }
+        if (subcommand === "show") {
+            if (positionals.length !== 2 || flags.all) {
+                yield* writeStderr("Usage: niceeval session show <sessionId> [--json]\n");
+                return 1;
+            }
+            const outcome = yield* effect_1.Effect.either(cliEffect("show session", (0, session_ts_1.showSession)(niceevalRoot, positionals[1])));
+            if (effect_1.Either.isLeft(outcome)) {
+                yield* writeStderr(`${errorMessage(outcome.left.cause)}\n`);
+                return 1;
+            }
+            yield* writeStdout(flags.json
+                ? `${JSON.stringify(outcome.right)}\n`
+                : (0, session_ts_1.renderSessionShowText)(outcome.right));
+            return 0;
+        }
+        yield* writeStderr("Usage: niceeval session list [--all] [<experiment-prefix>] [--json]\n" +
+            "       niceeval session show <sessionId> [--json]\n");
+        return 1;
+    });
+}
+function runRecordMaintenanceCommand(cwd, command, positionals, flags) {
+    return effect_1.Effect.gen(function* () {
+        if (positionals.length > 0) {
+            yield* writeStderr(`niceeval ${command} does not accept positional arguments.\n`);
+            return 1;
+        }
+        const unsupported = firstRecordMaintenanceUnsupportedFlag(flags);
+        if (unsupported !== undefined) {
+            yield* writeStderr(`niceeval ${command} does not accept ${unsupported}.\n`);
+            return 1;
+        }
+        const result = yield* cliEffect("run Record maintenance", (0, record_ts_1.runRecordCliCommand)({
+            command,
+            cwd,
+            ...(flags.record === undefined ? {} : { record: flags.record }),
+            yes: flags.yes,
+        }));
+        if (result.stdout !== "")
+            yield* writeStdout(result.stdout);
+        if (result.stderr !== "")
+            yield* writeStderr(result.stderr);
+        return result.exitCode;
+    });
+}
+function agentRunFromExperiment(experiment, selectedEvalIds, overrides = {}) {
+    return {
+        agent: experiment.agent,
+        model: experiment.model,
+        reasoningEffort: experiment.reasoningEffort,
+        flags: experiment.flags ?? {},
+        plugins: experiment.plugins,
+        attempts: overrides.attempts ?? experiment.attempts ?? 1,
+        earlyExit: overrides.earlyExit ?? experiment.earlyExit ?? false,
+        sandbox: experiment.sandbox,
+        sandboxReuse: experiment.sandboxReuse,
+        ...(experiment.sharedState === undefined ? {} : { sharedState: experiment.sharedState }),
+        judge: experiment.judge,
+        ...(0, timeout_ts_1.resolveRunTimeout)(overrides.timeout, experiment.timeoutMs),
+        budget: overrides.budget ?? experiment.budget,
+        selectedEvalIds,
+        experimentId: experiment.id,
+        experimentBaseDir: experiment.baseDir,
+        experimentSourcePath: experiment.sourcePath,
+        description: experiment.description,
+        labels: experiment.labels,
+        maxConcurrency: experiment.maxConcurrency,
+        setup: experiment.setup,
+        teardown: experiment.teardown,
+        classifyFailure: experiment.classifyFailure,
+    };
+}
+function hasSharedStateRecoveryOptions(flags) {
+    return flags.recoverSharedState !== undefined ||
+        flags.ownerToken !== undefined ||
+        flags.confirmOwnerTerminated ||
+        flags.confirmRemoteQuiesced;
+}
+function renderSharedStateRecoveryTarget(record) {
+    return (0, index_ts_5.t)("cli.exp.sharedStateRecoveryTarget", {
+        key: record.key,
+        experimentId: record.experimentId,
+        ownerToken: record.ownerToken,
+        host: record.host,
+        pid: record.pid,
+        processIdentity: record.processIdentity,
+        heartbeatAt: record.heartbeatAt,
+    });
+}
+function experimentTeardownOf(experiment) {
+    return typeof experiment.teardown === "function" ? experiment.teardown : undefined;
+}
+/**
+ * A legacy free generation can exist from an interrupted pre-fix recovery:
+ * it has durable owner evidence but may still have its old teardown entry.
+ * Only the entry keyed by that exact immutable owner is eligible for removal.
+ *
+ * Claimed recovery takes the same path before publishing free. A failed or
+ * contested claim therefore leaves the recovery generation closed rather than
+ * letting a waiter enter while the old teardown could still be replayed.
+ */
+function inspectExactRecoveryTeardownRegistrationEffect(input) {
+    const { niceevalRoot, record, currentHost } = input;
+    const id = (0, teardown_registry_ts_1.teardownEntryId)(record.experimentId, record.pid);
+    return effect_1.Effect.gen(function* () {
+        const registration = yield* (0, teardown_registry_ts_1.readExactTeardownRegistrationEffect)(niceevalRoot, record.experimentId, record.pid);
+        // A holder can die before its registration is durably written. There is
+        // then no old teardown obligation to clear, but no unrelated entry may be
+        // inferred from the current Experiment declaration.
+        if (registration === undefined)
+            return false;
+        if (registration.host !== record.host) {
+            return yield* effect_1.Effect.fail(new Error(`teardown registration ${JSON.stringify(id)} belongs to host ${JSON.stringify(registration.host)}, ` +
+                `not immutable sharedState owner host ${JSON.stringify(record.host)}`));
+        }
+        // The registration does not carry a process identity itself, so recovery
+        // compares it to the immutable sharedState owner. This shares the lease
+        // terminal boundary: an exact local Z/X/x owner is stopped; an unreadable
+        // or malformed identity probe fails closed instead of treating PID
+        // existence as proof that cleanup can still run.
+        const terminated = yield* (0, teardown_registry_ts_1.isExactTeardownRegistrationOwnerTerminatedEffect)({
+            registration,
+            owner: record,
+            currentHost,
+        });
+        if (!terminated) {
+            return yield* effect_1.Effect.fail(new Error(`teardown registration ${JSON.stringify(id)} still belongs to a live exact sharedState owner; refusing to clear it`));
+        }
+        return true;
+    });
+}
+function clearExactRecoveryTeardownRegistrationEffect(input) {
+    const { niceevalRoot, record, currentHost, expectedRegistration } = input;
+    const id = (0, teardown_registry_ts_1.teardownEntryId)(record.experimentId, record.pid);
+    return effect_1.Effect.gen(function* () {
+        const present = yield* inspectExactRecoveryTeardownRegistrationEffect({
+            niceevalRoot,
+            record,
+            currentHost,
+        });
+        if (!present) {
+            if (expectedRegistration) {
+                return yield* effect_1.Effect.fail(new Error(`teardown registration ${JSON.stringify(id)} disappeared before this recovery could clear it`));
+            }
+            return;
+        }
+        if (!expectedRegistration) {
+            return yield* effect_1.Effect.fail(new Error(`teardown registration ${JSON.stringify(id)} appeared after this recovery was claimed`));
+        }
+        const removed = yield* (0, teardown_registry_ts_1.removeTeardownRegistrationIfPresentEffect)(niceevalRoot, id);
+        if (!removed) {
+            return yield* effect_1.Effect.fail(new Error(`teardown registration ${JSON.stringify(id)} changed before this recovery could clear it`));
+        }
+    });
+}
+function renderDebugPlanJson(input) {
+    return `${JSON.stringify({
+        format: "niceeval.debug-plan/v1",
+        schemaVersion: 1,
+        experimentId: input.experimentId,
+        evalId: input.evalId,
+        commandPlan: input.commandPlan,
+    })}\n`;
+}
+function runDebugCommand(cwd, positionals, flags) {
+    return effect_1.Effect.gen(function* () {
+        const facts = yield* invocationFacts;
+        if (positionals.length !== 2) {
+            yield* writeStderr((0, index_ts_5.t)("cli.debug.usage"));
+            return 1;
+        }
+        const [experimentSelector, evalSelector] = positionals;
+        const config = yield* loadConfig(cwd);
+        const result = yield* cliEffect("debug Experiment lifecycle", index_ts_1.experimentHost.debug({
+            cwd,
+            config,
+            experimentSelector,
+            evalSelector,
+        }));
+        switch (result.status) {
+            case "experiment-no-match":
+                yield* writeStderr((0, index_ts_5.t)("cli.debug.experimentNoMatch", {
+                    selector: result.selector,
+                    candidates: result.candidates.join(", ") || (0, index_ts_5.t)("cli.none"),
+                }));
+                return 1;
+            case "experiment-ambiguous":
+                yield* writeStderr((0, index_ts_5.t)("cli.debug.experimentAmbiguous", {
+                    selector: result.selector,
+                    candidates: result.candidates.join(", "),
+                }));
+                return 1;
+            case "eval-no-match":
+                yield* writeStderr((0, index_ts_5.t)("cli.debug.evalNoMatch", {
+                    selector: result.selector,
+                    experimentId: result.experimentId,
+                    candidates: result.candidates.join(", ") || (0, index_ts_5.t)("cli.none"),
+                }));
+                return 1;
+            case "eval-ambiguous":
+                yield* writeStderr((0, index_ts_5.t)("cli.debug.evalAmbiguous", {
+                    selector: result.selector,
+                    experimentId: result.experimentId,
+                    candidates: result.candidates.join(", "),
+                }));
+                return 1;
+            case "planned":
+                yield* writeStdout(flags.json
+                    ? renderDebugPlanJson(result)
+                    : (0, index_ts_4.renderHumanCommandPlan)(result.commandPlan, {
+                        isTTY: facts.stdout.isTTY,
+                        noColor: facts.noColor,
+                        width: facts.stdout.columns,
+                    }));
+                return 0;
+        }
+    });
+}
+function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
+    return effect_1.Effect.gen(function* () {
+        const facts = yield* invocationFacts;
+        const cliOutput = yield* application_ts_1.CliOutput;
+        const path = yield* application_ts_1.CliPath;
+        const terminal = yield* application_ts_1.CliTerminal;
+        // Explicit recovery is intentionally human-only. It has no receipt or
+        // NDJSON contract, so accepting --json would give machine callers an
+        // apparently successful but unparseable interface.
+        if (command === "exp" && flags.recoverSharedState !== undefined && flags.json) {
+            yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryJsonUnsupported"));
+            return 1;
+        }
+        // Keep project-local coordination (sessions, locks, kept sandboxes) separate
+        // from the portable Record root selected by `--record` below.
+        const coordinationRoot = path.resolve(cwd, ".niceeval");
+        const config = yield* loadConfig(cwd);
+        const maxBuildConcurrency = flags.maxBuildConcurrency ?? config.maxBuildConcurrency ?? 2;
+        if (!Number.isInteger(maxBuildConcurrency) || maxBuildConcurrency <= 0) {
+            yield* writeStderr(`maxBuildConcurrency must be a positive integer, got ${maxBuildConcurrency}.\n`);
+            return 1;
+        }
+        let evals = Object.freeze([]);
+        if (command === "list") {
+            const listed = yield* cliEffect("list evals", index_ts_1.experimentHost.list({
+                cwd,
+                ...(flags.tag === undefined ? {} : { tag: flags.tag }),
+            }));
+            evals = listed.evals;
+            yield* writeStdout((0, index_ts_5.t)("cli.list.header", { count: evals.length }));
+            for (const evalDefinition of evals) {
+                yield* writeStdout(`  ${evalDefinition.id}${evalDefinition.description ? `  — ${evalDefinition.description}` : ""}\n`);
+            }
+            return 0;
+        }
+        const agentRuns = [];
+        let experimentSelection = (0, index_ts_5.t)("cli.all");
+        let availableExperimentPaths = (0, index_ts_5.t)("cli.none");
+        if (command === "exp" || command === "check") {
+            if (hasSharedStateRecoveryOptions(flags) && (command !== "exp" || !flags.teardown)) {
+                yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryFlags"));
+                return 1;
+            }
+            if (flags.agent || flags.model) {
+                yield* writeStderr((0, index_ts_5.t)("cli.exp.agentModelFlagUnsupported"));
+                return 1;
+            }
+            if (flags.force) {
+                yield* writeStderr((0, index_ts_5.t)("cli.exp.forceUnsupported"));
+                return 1;
+            }
+            // `--record` selects the fact root for `exp`; `check` has no Record
+            // reader or writer, so accepting it there would silently discard input.
+            if (command === "check" && flags.record !== undefined) {
+                yield* writeStderr((0, index_ts_5.t)("cli.check.recordUnsupported"));
+                return 1;
+            }
+            const viewerFlag = firstViewerOnlyFlag(flags);
+            if (viewerFlag) {
+                yield* writeStderr((0, index_ts_5.t)("cli.exp.viewerFlagUnsupported", { flag: viewerFlag.flag, command: viewerFlag.command }));
+                return 1;
+            }
+            if (command === "exp" && positionals[0] === "list") {
+                if (positionals.length > 2) {
+                    yield* writeStderr("niceeval exp list accepts at most one experiment prefix.\n");
+                    return 1;
+                }
+                const selector = positionals[1];
+                const listed = yield* cliEffect("list experiments", index_ts_1.experimentHost.list({
+                    cwd,
+                    ...(flags.tag === undefined ? {} : { tag: flags.tag }),
+                    ...(selector === undefined ? {} : { selector }),
+                }));
+                if (listed.selections.length === 0 && selector !== undefined) {
+                    yield* writeStderr((0, index_ts_5.t)("cli.experiment.noMatch", {
+                        arg: selector,
+                        experiments: (0, aggregate_ts_1.browsableExperimentPaths)(listed.experimentIds).join(", ") || (0, index_ts_5.t)("cli.none"),
+                    }));
+                    return 1;
+                }
+                const rows = listed.selections.map(({ experiment, selectedEvalIds }) => {
+                    return {
+                        experimentId: experiment.id,
+                        ...(experiment.description !== undefined ? { description: experiment.description } : {}),
+                        agent: experiment.agent.name,
+                        ...(experiment.model !== undefined ? { model: experiment.model } : {}),
+                        attempts: experiment.attempts,
+                        evalCount: selectedEvalIds.length,
+                        labels: { ...experiment.labels },
+                        selectedEvalIds,
+                    };
+                });
+                if (flags.json) {
+                    yield* writeStdout(`${JSON.stringify({ format: "niceeval.experiments", schemaVersion: 1, experiments: rows })}\n`);
+                }
+                else {
+                    for (const row of rows) {
+                        yield* writeStdout([
+                            row.experimentId,
+                            row.description ?? "—",
+                            row.agent,
+                            row.model ?? "—",
+                            `attempts=${row.attempts}`,
+                            `evals=${row.evalCount}`,
+                            `labels=${JSON.stringify(row.labels)}`,
+                        ].join("\t") + "\n");
+                    }
+                }
+                return 0;
+            }
+            const expArg = positionals[0];
+            const extraPatterns = positionals.slice(1);
+            experimentSelection = positionals.join(" ") || (0, index_ts_5.t)("cli.all");
+            const listed = yield* cliEffect("select experiments", index_ts_1.experimentHost.list({
+                cwd,
+                ...(flags.tag === undefined ? {} : { tag: flags.tag }),
+                ...(expArg === undefined ? {} : { selector: expArg }),
+                ...(extraPatterns.length === 0 ? {} : { evalPatterns: extraPatterns }),
+            }));
+            evals = listed.evals;
+            const selected = listed.selections;
+            availableExperimentPaths = (0, aggregate_ts_1.browsableExperimentPaths)(listed.experimentIds).join(", ") || (0, index_ts_5.t)("cli.none");
+            if (selected.length === 0) {
+                yield* writeStderr((0, index_ts_5.t)("cli.experiment.noMatch", {
+                    arg: expArg ?? (0, index_ts_5.t)("cli.all"),
+                    experiments: availableExperimentPaths,
+                }));
+                if (expArg === "show" || expArg === "view") {
+                    yield* writeStderr((0, index_ts_5.t)("cli.experiment.viewerCommandHint", {
+                        command: expArg,
+                        args: extraPatterns.length > 0 ? ` ${extraPatterns.join(" ")}` : "",
+                    }));
+                }
+                return 1;
+            }
+            const reminder = yield* (0, cli_commands_ts_1.keptSandboxReminderEffect)(cwd).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
+            if (reminder)
+                yield* writeStderr(reminder);
+            const orphans = yield* (0, cli_commands_ts_1.orphanReminderEffect)(cwd).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
+            if (orphans)
+                yield* writeStderr(orphans);
+            const teardownReminder = yield* (0, teardown_registry_ts_1.orphanedTeardownReminderEffect)(coordinationRoot, new Set(selected
+                .filter(({ experiment }) => experimentTeardownOf(experiment) !== undefined)
+                .map(({ experiment }) => experiment.id)), facts.hostname).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
+            if (teardownReminder)
+                yield* writeStderr(teardownReminder);
+            if (flags.teardown) {
+                if (extraPatterns.length > 0) {
+                    yield* writeStderr((0, index_ts_5.t)("cli.exp.teardownNoEvalPatterns"));
+                    return 1;
+                }
+                const niceevalRootForTeardown = coordinationRoot;
+                let selectedForTeardown = selected;
+                let explicitRecovery;
+                if (flags.recoverSharedState !== undefined) {
+                    // The input key is the recovery authority. Read its immutable
+                    // evidence before considering today's Experiment declaration: an
+                    // author may have renamed or removed sharedState after the holder
+                    // crashed, but must still have a public recovery path for that old
+                    // external state.
+                    const inspected = yield* effect_1.Effect.either((0, shared_state_lease_ts_1.readSharedStateLeaseRecoveryTargetEffect)(niceevalRootForTeardown, flags.recoverSharedState));
+                    if (effect_1.Either.isLeft(inspected)) {
+                        yield* writeStderr(`sharedState recovery inspection failed: ${errorMessage(inspected.left)}\n`);
+                        return 1;
+                    }
+                    if (inspected.right === undefined) {
+                        yield* writeStderr(`No recoverable sharedState ownership evidence exists for ${JSON.stringify(flags.recoverSharedState)}.\n`);
+                        return 1;
+                    }
+                    yield* writeStderr(renderSharedStateRecoveryTarget(inspected.right));
+                    if (selected.length !== 1) {
+                        yield* writeStderr("sharedState recovery requires an experiment selector that resolves to exactly one Experiment.\n");
+                        return 1;
+                    }
+                    const target = selected[0];
+                    if (inspected.right.experimentId !== target.experiment.id) {
+                        yield* writeStderr(`sharedState key ${JSON.stringify(flags.recoverSharedState)} belongs to experiment ${inspected.right.experimentId}, not ${target.experiment.id}; refusing recovery.\n`);
+                        return 1;
+                    }
+                    // Inspection intentionally precedes confirmation validation. The
+                    // immutable generation head retains the exact owner evidence even
+                    // after a crashed recovery attempt; this public command is the only
+                    // supported way to reveal it, never private-file manipulation.
+                    if (flags.ownerToken === undefined ||
+                        !flags.confirmOwnerTerminated ||
+                        !flags.confirmRemoteQuiesced) {
+                        yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryFlags"));
+                        return 1;
+                    }
+                    // Inspection is read-only and remains available without a teardown.
+                    // Only the uniquely selected target can reach this point. Validate
+                    // its teardown immediately before claiming a recovery generation.
+                    if (experimentTeardownOf(target.experiment) === undefined) {
+                        yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryTeardownRequired", {
+                            experimentId: target.experiment.id,
+                        }));
+                        return 1;
+                    }
+                    const begun = yield* effect_1.Effect.either((0, shared_state_lease_ts_1.beginExplicitSharedStateRecoveryEffect)({
+                        niceevalRoot: niceevalRootForTeardown,
+                        key: flags.recoverSharedState,
+                        ownerToken: flags.ownerToken,
+                        localHost: facts.hostname,
+                        confirmOwnerTerminated: flags.confirmOwnerTerminated,
+                        confirmRemoteQuiesced: flags.confirmRemoteQuiesced,
+                    }));
+                    if (effect_1.Either.isLeft(begun)) {
+                        yield* writeStderr(`sharedState recovery refused: ${errorMessage(begun.left)}\n`);
+                        return 1;
+                    }
+                    if (begun.right._tag === "AlreadyReleased") {
+                        const registrationWasPresent = yield* effect_1.Effect.either(inspectExactRecoveryTeardownRegistrationEffect({
+                            niceevalRoot: niceevalRootForTeardown,
+                            record: begun.right.record,
+                            currentHost: facts.hostname,
+                        }));
+                        if (effect_1.Either.isLeft(registrationWasPresent)) {
+                            yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryAlreadyReleasedRegistrationFailed", {
+                                key: begun.right.record.key,
+                                message: errorMessage(registrationWasPresent.left),
+                            }));
+                            return 1;
+                        }
+                        const cleared = yield* effect_1.Effect.either(clearExactRecoveryTeardownRegistrationEffect({
+                            niceevalRoot: niceevalRootForTeardown,
+                            record: begun.right.record,
+                            currentHost: facts.hostname,
+                            expectedRegistration: registrationWasPresent.right,
+                        }));
+                        if (effect_1.Either.isLeft(cleared)) {
+                            yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryAlreadyReleasedRegistrationFailed", {
+                                key: begun.right.record.key,
+                                message: errorMessage(cleared.left),
+                            }));
+                            return 1;
+                        }
+                        yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryAlreadyReleased", { key: begun.right.record.key }));
+                        yield* writeStderr((0, index_ts_5.t)("runner.sharedStateExplicitRecovered", {
+                            key: begun.right.record.key,
+                            experimentId: begun.right.record.experimentId,
+                            ownerToken: begun.right.record.ownerToken,
+                        }));
+                        return 0;
+                    }
+                    if (begun.right.record.experimentId !== target.experiment.id) {
+                        yield* writeStderr(`sharedState key ${JSON.stringify(flags.recoverSharedState)} changed Experiment ownership during recovery; refusing teardown.\n`);
+                        return 1;
+                    }
+                    const registrationWasPresent = yield* effect_1.Effect.either(inspectExactRecoveryTeardownRegistrationEffect({
+                        niceevalRoot: niceevalRootForTeardown,
+                        record: begun.right.record,
+                        currentHost: facts.hostname,
+                    }));
+                    if (effect_1.Either.isLeft(registrationWasPresent)) {
+                        yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryRegistrationFailed", {
+                            key: begun.right.record.key,
+                            message: errorMessage(registrationWasPresent.left),
+                        }));
+                        return 1;
+                    }
+                    explicitRecovery = {
+                        key: begun.right.record.key,
+                        ownerToken: begun.right.record.ownerToken,
+                        recoveryId: begun.right.recoveryId,
+                        experimentId: begun.right.record.experimentId,
+                        record: begun.right.record,
+                        registrationWasPresent: registrationWasPresent.right,
+                    };
+                    selectedForTeardown = [target];
+                }
+                else if (hasSharedStateRecoveryOptions(flags)) {
+                    yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryFlags"));
+                    return 1;
+                }
+                let anyFailed = false;
+                for (const { experiment, selectedEvalIds } of selectedForTeardown) {
+                    const teardown = experimentTeardownOf(experiment);
+                    if (teardown === undefined) {
+                        // Discovery normally reaches this branch only for an absent
+                        // teardown, because defineExperiment rejects non-functions. Keep
+                        // the CLI boundary equally strict for dynamically supplied
+                        // definitions: a truthy or null-ish impostor must never be
+                        // treated as a completed recovery hook.
+                        if (experiment.teardown !== undefined) {
+                            anyFailed = true;
+                            yield* writeStderr((0, index_ts_5.t)("define.experimentTeardownNotFunction"));
+                        }
+                        continue;
+                    }
+                    const ctx = {
+                        experimentId: experiment.id,
+                        selectedEvalIds,
+                        signal: new AbortController().signal,
+                        progress: () => { },
+                        diagnostic: (input) => cliOutput.writeStderrSync(`${input.message}\n`),
+                    };
+                    if (explicitRecovery !== undefined) {
+                        // The exact registration was inspected after the immutable
+                        // recovery marker was claimed. Do not re-scan by current
+                        // Experiment identity: its sharedState declaration can have
+                        // changed, and broad scans could claim another run's cleanup.
+                        const outcome = yield* effect_1.Effect.either(cliEffect("run experiment teardown", (0, cleanup_timeout_ts_1.cleanupCallback)(() => teardown(ctx))));
+                        if (effect_1.Either.isRight(outcome)) {
+                            yield* writeStderr((0, index_ts_5.t)("cli.exp.teardownDone", { experimentId: experiment.id }));
+                        }
+                        else {
+                            anyFailed = true;
+                            const error = outcome.left.cause;
+                            yield* writeStderr((0, index_ts_5.t)("cli.exp.teardownFailed", {
+                                experimentId: experiment.id,
+                                message: error instanceof Error ? error.message : String(error),
+                            }));
+                        }
+                        continue;
+                    }
+                    const registrations = yield* (0, teardown_registry_ts_1.readTeardownRegistrationsEffect)(niceevalRootForTeardown).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
+                    const matching = registrations.filter(({ entry }) => entry.experimentId === experiment.id);
+                    const orphaned = matching.filter(({ entry }) => (0, teardown_registry_ts_1.isOrphanedTeardownRegistration)(entry, facts.hostname));
+                    const executions = effect_1.Effect.all(orphaned.map(({ id }) => (0, teardown_registry_ts_1.removeTeardownRegistrationIfPresentEffect)(niceevalRootForTeardown, id).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(false)), effect_1.Effect.map((claimed) => claimed ? id : undefined))), { concurrency: "unbounded" }).pipe(effect_1.Effect.map((claimed) => matching.length === 0 ? [undefined] : claimed.filter((id) => id !== undefined)));
+                    for (const _ of yield* executions) {
+                        const outcome = yield* effect_1.Effect.either(cliEffect("run experiment teardown", (0, cleanup_timeout_ts_1.cleanupCallback)(() => teardown(ctx))));
+                        if (effect_1.Either.isRight(outcome)) {
+                            yield* writeStderr((0, index_ts_5.t)("cli.exp.teardownDone", { experimentId: experiment.id }));
+                        }
+                        else {
+                            anyFailed = true;
+                            const error = outcome.left.cause;
+                            yield* writeStderr((0, index_ts_5.t)("cli.exp.teardownFailed", {
+                                experimentId: experiment.id,
+                                message: error instanceof Error ? error.message : String(error),
+                            }));
+                        }
+                    }
+                }
+                if (!anyFailed && explicitRecovery !== undefined) {
+                    // A waiter may enter as soon as `complete...` publishes free. The
+                    // old durable teardown obligation must therefore be removed first.
+                    // Any read/claim failure leaves the immutable recovery marker
+                    // closed, so an operator can inspect and retry instead of replaying
+                    // old teardown after a new owner starts.
+                    const cleared = yield* effect_1.Effect.either(clearExactRecoveryTeardownRegistrationEffect({
+                        niceevalRoot: niceevalRootForTeardown,
+                        record: explicitRecovery.record,
+                        currentHost: facts.hostname,
+                        expectedRegistration: explicitRecovery.registrationWasPresent,
+                    }));
+                    if (effect_1.Either.isLeft(cleared)) {
+                        yield* writeStderr((0, index_ts_5.t)("cli.exp.sharedStateRecoveryRegistrationFailed", {
+                            key: explicitRecovery.key,
+                            message: errorMessage(cleared.left),
+                        }));
+                        return 1;
+                    }
+                    const completed = yield* effect_1.Effect.either((0, shared_state_lease_ts_1.completeExplicitSharedStateRecoveryEffect)({
+                        niceevalRoot: niceevalRootForTeardown,
+                        key: explicitRecovery.key,
+                        ownerToken: explicitRecovery.ownerToken,
+                        recoveryId: explicitRecovery.recoveryId,
+                        localHost: facts.hostname,
+                    }));
+                    if (effect_1.Either.isLeft(completed)) {
+                        yield* writeStderr(`sharedState recovery could not release its exact owner token: ${errorMessage(completed.left)}\n`);
+                        return 1;
+                    }
+                    yield* writeStderr((0, index_ts_5.t)("runner.sharedStateExplicitRecovered", {
+                        key: explicitRecovery.key,
+                        experimentId: explicitRecovery.experimentId,
+                        ownerToken: explicitRecovery.ownerToken,
+                    }));
+                }
+                return anyFailed ? 1 : 0;
+            }
+            const experimentScopeIds = new Set();
+            for (const { experiment, selectedEvalIds, selectorEvalIds } of selected) {
+                for (const evalId of selectorEvalIds)
+                    experimentScopeIds.add(evalId);
+                agentRuns.push(agentRunFromExperiment(experiment, selectedEvalIds, flags));
+            }
+            for (const pattern of extraPatterns) {
+                const matches = (0, aggregate_ts_1.evalPrefixPredicate)([pattern]);
+                if ([...experimentScopeIds].some((id) => matches(id)))
+                    continue;
+                yield* writeStderr((0, index_ts_5.t)("cli.experiment.noEvalPrefixMatch", {
+                    pattern,
+                    selection: expArg ?? (0, index_ts_5.t)("cli.all"),
+                }));
+                return 1;
+            }
+        }
+        else {
+            const listed = yield* cliEffect("list experiments", index_ts_1.experimentHost.list({
+                cwd,
+                ...(flags.tag === undefined ? {} : { tag: flags.tag }),
+            }));
+            const selectedByPattern = yield* effect_1.Effect.all(positionals.map((selector) => cliEffect("select experiments", index_ts_1.experimentHost.list({
+                cwd,
+                ...(flags.tag === undefined ? {} : { tag: flags.tag }),
+                selector,
+            }))));
+            const asExp = [...new Map(selectedByPattern
+                    .flatMap((selection) => selection.selections)
+                    .map(({ experiment }) => [experiment.id, experiment])).values()];
+            yield* writeStderr((0, index_ts_5.t)("cli.run.experimentRequired"));
+            if (asExp.length > 0) {
+                yield* writeStderr((0, index_ts_5.t)("cli.run.experimentRequiredHint", {
+                    pattern: positionals[0] ?? "",
+                    kind: asExp.length > 1 ? (0, index_ts_5.t)("cli.experimentGroup") : "",
+                }));
+            }
+            else {
+                yield* writeStderr((0, index_ts_5.t)("cli.run.experimentRequiredKnown", {
+                    experiments: listed.experimentIds.join(", ") || (0, index_ts_5.t)("cli.none"),
+                }));
+            }
+            return 1;
+        }
+        const outputForm = (0, index_ts_4.resolveOutputForm)({ json: flags.json, isTTY: facts.stderr.isTTY });
+        const matchedByRun = agentRuns.map((run) => (0, eval_selection_ts_1.selectedEvalsForRun)(evals, run));
+        const totalAttempts = agentRuns.reduce((sum, run, index) => sum + matchedByRun[index].length * run.attempts, 0);
+        const uniqueEvalIds = new Set(matchedByRun.flat().map((evalDefinition) => evalDefinition.id));
+        if (totalAttempts === 0) {
+            yield* writeStderr((0, index_ts_5.t)("cli.experiment.noEvalsSelected", {
+                selection: experimentSelection,
+                experiments: availableExperimentPaths,
+            }));
+            return 1;
+        }
+        if (command === "check") {
+            yield* cliEffect("link run sandboxes", (0, sandbox_selection_ts_1.linkRunSandboxes)(evals, agentRuns));
+            const pairCount = matchedByRun.reduce((sum, selected) => sum + selected.length, 0);
+            yield* writeStdout(`Sandbox layers linked: ${pairCount} pair${pairCount === 1 ? "" : "s"}.\n`);
+            return 0;
+        }
+        const recordTarget = yield* effect_1.Effect.try({
+            try: () => parseActualRecordRoot(path, cwd, flags.record),
+            catch: (cause) => cliFailure("parse experiment Record root", cause),
+        });
+        const experimentPlan = yield* cliEffect("plan Experiment", index_ts_1.experimentHost.plan({
+            evals,
+            agentRuns,
+            config,
+            recordRoot: recordTarget.root,
+            ...(flags.rerun === undefined ? {} : { rerun: flags.rerun }),
+            ...(flags.keepSandbox === undefined ? {} : { keepSandbox: flags.keepSandbox }),
+            ...(flags.dry ? { previewStartedAt: Date.now() } : {}),
+        }));
+        const targetPlan = experimentPlan.target;
+        if (flags.dry) {
+            const current = experimentPlan.current;
+            if (current === undefined) {
+                return yield* effect_1.Effect.fail(cliFailure("preview Experiment", new Error("Experiment Host did not return the requested dry plan.")));
+            }
+            const currentPlan = projectCurrentDryPlan(current);
+            const rows = currentDryPlanRows(currentPlan);
+            const now = Date.now();
+            const lockedFlags = yield* effect_1.Effect.all(rows.map((row) => (0, lock_ts_1.readCaseLockEffect)(coordinationRoot, row.experimentId, row.evalId).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)), effect_1.Effect.map((lock) => lock !== undefined && !(0, lock_ts_1.isCaseLockExpired)(lock, now)))), { concurrency: "unbounded" });
+            const evalGroupsByEvalId = new Map(evals.flatMap((evalDef) => evalDef.evalGroup === undefined ? [] : [[evalDef.id, {
+                        ...evalDef.evalGroup,
+                        index: evalDef.evalGroup.evalIds.indexOf(evalDef.id),
+                    }]]));
+            const rowsWithLocks = Object.freeze(rows.map((row, index) => {
+                const evalGroup = evalGroupsByEvalId.get(row.evalId);
+                return Object.freeze({
+                    ...row,
+                    ...(evalGroup === undefined ? {} : {
+                        evalGroupId: evalGroup.id,
+                        evalGroupIndex: evalGroup.index,
+                    }),
+                    ...(lockedFlags[index] ? { locked: true } : {}),
+                });
+            }));
+            const occurrenceAudits = new Map();
+            for (const pair of targetPlan.preparedPairsByKey.values()) {
+                for (const occurrence of pair.plugin.occurrences) {
+                    occurrenceAudits.set(JSON.stringify(occurrence.audit), occurrence.audit);
+                }
+            }
+            const pluginAudit = Object.freeze({
+                occurrences: Object.freeze([...occurrenceAudits.values()]),
+            });
+            const input = {
+                totalAttempts,
+                evals: uniqueEvalIds.size,
+                configs: agentRuns.length,
+                attempts: Math.max(1, ...agentRuns.map((run) => run.attempts)),
+                rows: rowsWithLocks,
+                pluginAudit,
+            };
+            if (outputForm === "json") {
+                yield* writeStdout(renderCurrentDryPlanJson(input));
+            }
+            else {
+                yield* writeStdout(renderCurrentDryPlan(input));
+            }
+            return 0;
+        }
+        const maxConcurrency = flags.maxConcurrency ?? config.maxConcurrency ?? (0, sandbox_selection_ts_1.recommendedConcurrencyForPreparedPairs)([...targetPlan.preparedPairsByKey.values()]);
+        const experimentConcurrency = {};
+        for (const run of agentRuns) {
+            if (run.experimentId !== undefined && run.maxConcurrency !== undefined)
+                experimentConcurrency[run.experimentId] = run.maxConcurrency;
+        }
+        const plan = {
+            shape: { evals: uniqueEvalIds.size, configs: agentRuns.length, totalAttempts, maxConcurrency },
+            ...(Object.keys(experimentConcurrency).length === 0 ? {} : { experimentConcurrency }),
+        };
+        const io = terminal.feedback;
+        const commandLabel = ["niceeval", command, ...positionals].join(" ").trim();
+        const renderer = outputForm === "human"
+            ? (0, index_ts_4.createHumanRenderer)({ io, command: commandLabel })
+            : (0, index_ts_4.createJsonRenderer)({ io });
+        const sessionTracker = new session_ts_1.SessionTracker(coordinationRoot);
+        const coordinator = (0, index_ts_4.createFeedbackCoordinator)({
+            profile: outputForm,
+            renderer,
+            io,
+            onEvent: (event, state) => sessionTracker.onFeedback(event, state),
+        });
+        let resourcesReleased = false;
+        const releaseResources = effect_1.Effect.suspend(() => {
+            if (resourcesReleased)
+                return effect_1.Effect.void;
+            resourcesReleased = true;
+            return releaseCliResources();
+        });
+        let sessionClosed = false;
+        const closeSession = (input) => sessionTracker.close(input).pipe(effect_1.Effect.tap(() => effect_1.Effect.sync(() => { sessionClosed = true; })));
+        yield* effect_1.Effect.addFinalizer(() => releaseResources);
+        yield* effect_1.Effect.addFinalizer(() => sessionClosed
+            ? effect_1.Effect.void
+            : closeSession({ status: "incomplete" }).pipe(effect_1.Effect.ignore));
+        yield* effect_1.Effect.addFinalizer(() => cliPromise("stop dynamic feedback", () => coordinator.stopDynamic()).pipe(effect_1.Effect.ignore));
+        yield* effect_1.Effect.acquireRelease(effect_1.Effect.sync(() => (0, index_ts_4.createInputGuard)({
+            stdin: terminal.stdin,
+            stderrIsTTY: io.stderr.isTTY,
+            coordinator,
+            onInterrupt: () => interruption?.requestInterrupt(),
+        })), (inputGuard) => effect_1.Effect.sync(() => inputGuard.stop()));
+        let invocationSummary;
+        const reporters = [];
+        if (flags.junit)
+            reporters.push({ reporter: (0, json_ts_1.JUnit)(flags.junit), name: "junit", required: true, target: flags.junit });
+        (config.reporters ?? []).forEach((reporter, index) => {
+            reporters.push({ reporter, name: `config-reporter-${index}`, required: false });
+        });
+        reporters.push({
+            name: "cli-summary",
+            required: false,
+            reporter: {
+                onInvocationComplete(summary) {
+                    invocationSummary = summary;
+                },
+            },
+        });
+        // This synchronous hand-off and the following Experiment Host yield have no
+        // asynchronous gap. A first signal therefore either interrupts the root
+        // before dispatch begins, or aborts this Invocation so it can close its
+        // durable interrupted receipt before the CLI returns.
+        const ownsGracefulDispatch = yield* effect_1.Effect.sync(() => interruption?.enterGracefulDispatch() ?? true);
+        if (!ownsGracefulDispatch)
+            yield* effect_1.Effect.interrupt;
+        // Runner remains Effect-native. During graceful dispatch the application
+        // edge translates SIGINT into this Invocation signal, letting dispatch
+        // settle and the receipt close before the process exits with 130.
+        const receipt = yield* cliEffect("run Experiment", index_ts_1.experimentHost.run({
+            config,
+            evals,
+            agentRuns,
+            reporters,
+            maxConcurrency,
+            maxBuildConcurrency,
+            keepSandbox: flags.keepSandbox,
+            rerun: flags.rerun,
+            coordinationRoot,
+            recordRoot: recordTarget.root,
+            session: sessionTracker,
+            onCurrentRecordReusePlan: (current) => effect_1.Effect.sync(() => coordinator.start({
+                ...plan,
+                shape: { ...plan.shape, runIds: current.runIds },
+                reused: current.reused,
+                ...(current.reusedFailures.length === 0 ? {} : { reusedFailures: current.reusedFailures }),
+            })),
+            ...(interruption === undefined ? {} : { signal: interruption.invocationSignal }),
+        }));
+        yield* releaseResources;
+        const summary = invocationSummary;
+        if (summary === undefined) {
+            return yield* effect_1.Effect.fail(cliFailure("collect invocation summary", new Error("Runner completed without an invocation summary.")));
+        }
+        const completion = assembleInvocationCompletion(coordinator.state);
+        yield* closeSession({ status: completion.status, completion, receipt, completedAt: receipt.completedAt });
+        yield* cliPromise("finish feedback", () => coordinator.finish({ summary, completion, receipt }));
+        const foldedStats = foldInvocationEvalStats(summary);
+        return (0, index_ts_4.computeExitCode)({ ...summary, failed: foldedStats.failed, errored: foldedStats.errored }, completion);
+    });
+}
+/** Resolve the CLI's one portable Record target without treating `.niceeval` as Record data. */
+function parseActualRecordRoot(path, cwd, rootText) {
+    if (rootText !== undefined && rootText.trim() === "") {
+        throw usageError("--record requires an actual Record root directory.\n");
+    }
+    const rootPath = path.resolve(cwd, rootText ?? ".niceeval/record");
+    const root = (0, index_ts_2.makeRecordRoot)(rootPath);
+    if (effect_1.Either.isLeft(root)) {
+        throw usageError(`Invalid --record root: ${root.left.code}.\n`);
+    }
+    return Object.freeze({ root: root.right, rootPath });
+}
+/**
+ * The CLI validates selection identity before Record I/O. It never turns a
+ * prefix, a path, or a directory entry into a Run / Experiment selection.
+ */
+function parseReportCliRequest(input) {
+    const unsupported = reportUnsupportedFlag(input.command, input.flags);
+    if (unsupported !== undefined) {
+        throw usageError(`niceeval ${input.command} does not accept ${unsupported}.\n`);
+    }
+    const runs = input.flags.run ?? [];
+    const { root, rootPath } = parseActualRecordRoot(input.path, input.cwd, input.flags.record);
+    const page = parseReportRoute(input.flags.page);
+    const evidenceReports = [
+        input.flags.source !== undefined ? "--source" : undefined,
+        input.flags.execution ? "--execution" : undefined,
+        input.flags.timing !== undefined ? "--timing" : undefined,
+    ].filter((flag) => flag !== undefined);
+    if (evidenceReports.length > 1) {
+        throw usageError(`niceeval show chooses one evidence Report at a time; remove all but one of ${evidenceReports.join(", ")}.\n`);
+    }
+    if (!input.flags.execution && input.flags.grep !== undefined) {
+        throw usageError("niceeval show --grep only combines with --execution.\n");
+    }
+    if (input.flags.execution) {
+        const report = (0, execution_ts_1.executionEvidenceReport)(executionEvidenceOptions(input.flags));
+        if (input.positionals.length !== 1) {
+            throw usageError("niceeval show --execution requires exactly one current Record Attempt locator.\n");
+        }
+        if (runs.length > 0 || input.flags.experiment !== undefined) {
+            throw usageError("niceeval show --execution uses its Attempt locator as the only selection; remove --run and --experiment.\n");
+        }
+        if (input.flags.report !== undefined) {
+            throw usageError("niceeval show --execution selects its built-in execution Report; remove --report.\n");
+        }
+        const locator = input.positionals[0];
+        if (locator === undefined) {
+            throw usageError("niceeval show --execution requires one current Record Attempt locator.\n");
+        }
+        const parsedLocator = parseCurrentAttemptLocator(locator);
+        return Object.freeze({
+            command: input.command,
+            cwd: input.cwd,
+            root,
+            rootPath,
+            target: Object.freeze({ kind: "attempt", locator: parsedLocator }),
+            reportSelection: Object.freeze({ kind: "fixed", report }),
+            themeSelection: themeSelection(input.path, input.reportPlatform, input.cwd, input.flags.theme),
+            ...(page === undefined ? {} : { page }),
+        });
+    }
+    if (input.flags.timing !== undefined) {
+        if (input.positionals.length !== 1) {
+            throw usageError("niceeval show --timing requires exactly one current Record Attempt locator.\n");
+        }
+        if (runs.length > 0 || input.flags.experiment !== undefined) {
+            throw usageError("niceeval show --timing uses its Attempt locator as the only selection; remove --run and --experiment.\n");
+        }
+        if (input.flags.report !== undefined) {
+            throw usageError("niceeval show --timing selects its built-in timing Report; remove --report.\n");
+        }
+        const locator = input.positionals[0];
+        if (locator === undefined) {
+            throw usageError("niceeval show --timing requires one current Record Attempt locator.\n");
+        }
+        const parsedLocator = parseCurrentAttemptLocator(locator);
+        return Object.freeze({
+            command: input.command,
+            cwd: input.cwd,
+            root,
+            rootPath,
+            target: Object.freeze({ kind: "attempt", locator: parsedLocator }),
+            reportSelection: Object.freeze({
+                kind: "fixed",
+                report: (0, execution_ts_1.timingEvidenceReport)({ mode: input.flags.timing }),
+            }),
+            themeSelection: themeSelection(input.path, input.reportPlatform, input.cwd, input.flags.theme),
+            ...(page === undefined ? {} : { page }),
+        });
+    }
+    if (input.flags.source !== undefined) {
+        if (input.positionals.length !== 1) {
+            throw usageError("niceeval show --source requires exactly one current Record Attempt locator.\n");
+        }
+        if (runs.length > 0 || input.flags.experiment !== undefined) {
+            throw usageError("niceeval show --source uses its Attempt locator as the only selection; remove --run and --experiment.\n");
+        }
+        if (input.flags.report !== undefined) {
+            throw usageError("niceeval show --source selects its built-in source Report; remove --report.\n");
+        }
+        const locator = input.positionals[0];
+        if (locator === undefined) {
+            throw usageError("niceeval show --source requires one current Record Attempt locator.\n");
+        }
+        const parsedLocator = parseCurrentAttemptLocator(locator);
+        const report = (0, source_ts_1.sourceEvidenceReport)({
+            ...(typeof input.flags.source === "string" ? { file: input.flags.source } : {}),
+        });
+        return Object.freeze({
+            command: input.command,
+            cwd: input.cwd,
+            root,
+            rootPath,
+            target: Object.freeze({ kind: "attempt", locator: parsedLocator }),
+            reportSelection: Object.freeze({ kind: "fixed", report }),
+            themeSelection: themeSelection(input.path, input.reportPlatform, input.cwd, input.flags.theme),
+            ...(page === undefined ? {} : { page }),
+        });
+    }
+    if (input.positionals.length > 0) {
+        if (input.positionals.length !== 1) {
+            throw usageError(`niceeval ${input.command} accepts one exact Attempt locator, the default current-project selection, or --run.\n`);
+        }
+        if (runs.length > 0 || input.flags.experiment !== undefined) {
+            throw usageError(`niceeval ${input.command} uses its Attempt locator as the only selection; remove --run and --experiment.\n`);
+        }
+        const locator = input.positionals[0];
+        if (locator === undefined || !locator.startsWith("@")) {
+            throw usageError(`niceeval ${input.command} selects Record data only with a canonical @1<12-character-body> locator, --run, or no selector for current-project results.\n`);
+        }
+        const parsedLocator = parseCurrentAttemptLocator(locator);
+        return Object.freeze({
+            command: input.command,
+            cwd: input.cwd,
+            root,
+            rootPath,
+            target: Object.freeze({ kind: "attempt", locator: parsedLocator }),
+            reportSelection: input.flags.report === undefined
+                ? Object.freeze({ kind: "fixed", report: attempt_overview_ts_1.defaultAttemptOverviewReport })
+                : reportSelection(input.path, input.reportPlatform, input.cwd, input.flags.report),
+            themeSelection: themeSelection(input.path, input.reportPlatform, input.cwd, input.flags.theme),
+            ...(page === undefined ? {} : { page }),
+        });
+    }
+    if (runs.length > 0 && input.flags.experiment !== undefined) {
+        throw usageError("--experiment narrows the default current-project selection; it cannot combine with explicit --run.\n");
+    }
+    const report = runs.length > 0 && input.flags.report === undefined
+        ? Object.freeze({ kind: "fixed", report: run_membership_overview_ts_1.defaultRunMembershipOverviewReport })
+        : reportSelection(input.path, input.reportPlatform, input.cwd, input.flags.report);
+    const theme = themeSelection(input.path, input.reportPlatform, input.cwd, input.flags.theme);
+    const target = runs.length > 0
+        ? Object.freeze({ kind: "selection", selection: explicitSelection(runs) })
+        : Object.freeze({
+            kind: "project-current",
+            ...(input.flags.experiment === undefined
+                ? {}
+                : { experimentSelectors: uniqueExperimentSelectors(input.flags.experiment) }),
+        });
+    return Object.freeze({
+        command: input.command,
+        cwd: input.cwd,
+        root,
+        rootPath,
+        target,
+        reportSelection: report,
+        themeSelection: theme,
+        ...(page === undefined ? {} : { page }),
+    });
+}
+function executionEvidenceOptions(flags) {
+    if (flags.grep === undefined)
+        return Object.freeze({});
+    try {
+        new RegExp(flags.grep);
+        return Object.freeze({ grep: flags.grep });
+    }
+    catch {
+        throw usageError(`--grep "${flags.grep}" is not a valid JavaScript regular expression.\n`);
+    }
+}
+function reportUnsupportedFlag(command, flags) {
+    const unsupported = [
+        ["--agent", flags.agent],
+        ["--model", flags.model],
+        ["--attempts", flags.attempts],
+        ["--max-concurrency", flags.maxConcurrency],
+        ["--max-build-concurrency", flags.maxBuildConcurrency],
+        ["--timeout", flags.timeout],
+        ["--budget", flags.budget],
+        ["--tag", flags.tag],
+        ["--junit", flags.junit],
+        ["--json", command === "view" && flags.json],
+        ["--smoke", flags.smoke],
+        ["--dry", flags.dry],
+        ["--force", flags.force],
+        ["--rerun", flags.rerun],
+        ["--early-exit/--no-early-exit", flags.earlyExit],
+        ["--open/--no-open", command === "show" ? flags.open : undefined],
+        ["--out", command === "show" ? flags.out : undefined],
+        ["--port", command === "show" ? flags.port : undefined],
+        ["--host", command === "show" ? flags.host : undefined],
+        ["--source", command === "show" ? undefined : flags.source],
+        ["--execution", command === "show" ? undefined : flags.execution],
+        ["--diff", flags.diff || flags.diffPath !== undefined],
+        ["--grep", command === "show" ? undefined : flags.grep],
+        ["--timing", command === "show" ? undefined : flags.timing],
+        ["--keep-sandbox", flags.keepSandbox],
+        ["--all", flags.all],
+        ["--window", flags.window],
+        ["--path", flags.sandboxPath],
+        ["--leave-running", flags.leaveRunning],
+        ["--history", flags.history],
+        ["--usage", flags.usage],
+        ["--stats", flags.stats],
+        ["--orphans", flags.orphans],
+        ["--teardown", flags.teardown],
+        ["--recover-shared-state", flags.recoverSharedState],
+        ["--owner-token", flags.ownerToken],
+        ["--confirm-owner-terminated", flags.confirmOwnerTerminated],
+        ["--confirm-remote-quiesced", flags.confirmRemoteQuiesced],
+        ["--yes", flags.yes],
+    ];
+    const found = unsupported.find(([, value]) => value !== undefined && value !== false && (!Array.isArray(value) || value.length > 0));
+    return found?.[0];
+}
+function parseReportRoute(value) {
+    return value;
+}
+function reportSelection(path, platform, cwd, value) {
+    if (value === undefined)
+        return Object.freeze({ kind: "config" });
+    if (value === "standard")
+        return Object.freeze({ kind: "built-in", name: "standard" });
+    if (isTrustedModulePath(path, value)) {
+        return Object.freeze({ kind: "module", path: platform.resolveModulePath(cwd, value) });
+    }
+    throw usageError("--report accepts built-in standard or an explicit trusted module path.\n");
+}
+function themeSelection(path, platform, cwd, value) {
+    if (value === undefined)
+        return Object.freeze({ kind: "config" });
+    if (value === "basalt" || value === "chalk") {
+        return Object.freeze({ kind: "built-in", name: value });
+    }
+    if (isTrustedModulePath(path, value)) {
+        return Object.freeze({ kind: "module", path: platform.resolveModulePath(cwd, value) });
+    }
+    throw usageError("--theme accepts built-in basalt/chalk or an explicit trusted module path.\n");
+}
+function isTrustedModulePath(path, value) {
+    return value.startsWith("./") || value.startsWith("../") || path.isAbsolute(value);
+}
+function explicitSelection(values) {
+    const runIds = uniqueExactRunIds(values);
+    const [first, ...rest] = runIds;
+    if (first === undefined) {
+        throw usageError("niceeval show/view requires one or more --run <run-id> values.\n");
+    }
+    const nonEmptyRunIds = [first, ...rest];
+    return Object.freeze({
+        policy: "explicit-runs",
+        runIds: nonEmptyRunIds,
+    });
+}
+function uniqueExactRunIds(values) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        const decoded = effect_1.Schema.decodeUnknownEither(index_ts_2.RunIdSchema)(value);
+        if (effect_1.Either.isLeft(decoded)) {
+            throw usageError(`Invalid --run value "${value}": expected one exact portable RunId.\n`);
+        }
+        if (!seen.has(decoded.right)) {
+            seen.add(decoded.right);
+            result.push(decoded.right);
+        }
+    }
+    return Object.freeze(result);
+}
+function uniqueExperimentSelectors(values) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.ExperimentIdSchema)(value);
+        if (effect_1.Either.isLeft(decoded)) {
+            throw usageError(`Invalid --experiment value "${value}": expected an Experiment selector.\n`);
+        }
+        if (!seen.has(decoded.right)) {
+            seen.add(decoded.right);
+            result.push(decoded.right);
+        }
+    }
+    return Object.freeze(result);
+}
+function selectedExperimentIds(slots) {
+    return Object.freeze([...new Set(slots.map((slot) => slot.experimentId))]
+        .sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right))));
+}
+/** Current Record locators use the strict scheme-1 short alias. */
+function parseCurrentAttemptLocator(value) {
+    const parsed = (0, attempt_locator_ts_1.parseAttemptLocator)(value);
+    if (!parsed.valid) {
+        throw usageError(`Invalid Attempt locator "${value}": expected @1 followed by 12 canonical uppercase Crockford characters.\n`);
+    }
+    return parsed.locator;
+}
+/**
+ * Config is deliberately fresh-read for every view rebuild even when CLI flags
+ * override its current Report or Theme. It is both a trusted boundary and a
+ * live input: an invalid config must not leave a stale hidden module graph.
+ */
+function loadCliReportInputs(request) {
+    return effect_1.Effect.gen(function* () {
+        const path = yield* application_ts_1.CliPath;
+        const reportPlatform = yield* application_ts_1.CliReportPlatform;
+        const config = yield* loadConfig(request.cwd);
+        const projectCurrent = request.target.kind === "project-current"
+            ? yield* cliEffect("load current project target", (0, project_current_ts_1.loadProjectCurrent)(request.cwd, {
+                config,
+                ...(request.target.experimentSelectors === undefined
+                    ? {}
+                    : { experiments: request.target.experimentSelectors }),
+                freshImport: true,
+            }))
+            : undefined;
+        const configured = yield* cliEffect("load trusted Report config", reportPlatform.loadConfig(request.cwd).pipe(effect_1.Effect.mapError((failure) => failure.cause)));
+        const selectedReport = yield* reportFromSelection(reportPlatform, request.reportSelection, configured.report, configured.watchInputs);
+        const selectedTheme = yield* themeFromSelection(reportPlatform, request.themeSelection, configured.theme);
+        const projectCurrentSelection = projectCurrent === undefined
+            ? undefined
+            : Object.freeze({
+                policy: "project-current",
+                currentSlots: projectCurrent.currentSlots,
+                ...(request.target.kind === "project-current" && request.target.experimentSelectors !== undefined
+                    ? { experimentIds: selectedExperimentIds(projectCurrent.currentSlots) }
+                    : {}),
+            });
+        const sourceWatchInputs = uniqueWatchInputs(path, [
+            ...(projectCurrent?.watchInputs ?? []),
+            ...configured.watchInputs,
+            ...selectedReport.watchInputs,
+            ...selectedTheme.watchInputs,
+        ]);
+        return Object.freeze({
+            report: selectedReport.value,
+            theme: selectedTheme.value,
+            reportWatchInputs: uniqueWatchInputs(path, selectedReport.watchInputs),
+            sourceWatchInputs,
+            ...(projectCurrentSelection === undefined ? {} : { projectCurrentSelection }),
+            watchInputs: uniqueWatchInputs(path, [
+                request.rootPath,
+                ...sourceWatchInputs,
+            ]),
+        });
+    });
+}
+function reportFromSelection(platform, selection, configured, configuredWatchInputs) {
+    switch (selection.kind) {
+        case "fixed":
+            return effect_1.Effect.succeed(Object.freeze({ value: selection.report, watchInputs: Object.freeze([]) }));
+        case "config":
+            return effect_1.Effect.succeed(Object.freeze({
+                value: configured ?? standard_tsx_1.standard,
+                watchInputs: configured === undefined ? Object.freeze([]) : configuredWatchInputs,
+            }));
+        case "built-in":
+            return effect_1.Effect.succeed(Object.freeze({ value: standard_tsx_1.standard, watchInputs: Object.freeze([]) }));
+        case "module":
+            return cliEffect("load trusted Report module", platform.loadReport(selection.path).pipe(effect_1.Effect.mapError((failure) => failure.cause))).pipe(effect_1.Effect.map((loaded) => Object.freeze({ value: loaded.report, watchInputs: loaded.watchInputs })));
+    }
+}
+function themeFromSelection(platform, selection, configured) {
+    switch (selection.kind) {
+        case "config":
+            return effect_1.Effect.succeed(Object.freeze({ value: configured ?? theme_ts_1.basalt, watchInputs: Object.freeze([]) }));
+        case "built-in":
+            return effect_1.Effect.succeed(Object.freeze({
+                value: selection.name === "chalk" ? theme_ts_1.chalk : theme_ts_1.basalt,
+                watchInputs: Object.freeze([]),
+            }));
+        case "module":
+            return cliEffect("load trusted Theme module", platform.loadTheme(selection.path).pipe(effect_1.Effect.mapError((failure) => failure.cause))).pipe(effect_1.Effect.map((loaded) => Object.freeze({ value: loaded.theme, watchInputs: loaded.watchInputs })));
+    }
+}
+function uniqueWatchInputs(pathService, paths) {
+    return Object.freeze([...new Set(paths.map((path) => pathService.resolve(path)))].sort());
+}
+function buildCliReportSite(request, inputs) {
+    const revision = request.target.kind === "attempt"
+        ? (0, from_record_ts_1.buildReportSiteFromRecord)({
+            root: request.root,
+            locator: request.target.locator,
+            report: inputs.report,
+            theme: inputs.theme,
+        })
+        : (0, from_record_ts_1.buildReportSiteFromRecord)({
+            root: request.root,
+            selection: request.target.kind === "selection"
+                ? request.target.selection
+                : inputs.projectCurrentSelection,
+            report: inputs.report,
+            theme: inputs.theme,
+        });
+    return revision.pipe(effect_1.Effect.mapError(reportExecutionFailure));
+}
+function reportExecutionFailure(error) {
+    switch (failureCode(error)) {
+        case "sample-run-not-found":
+            return usageError(`Run "${stringProperty(error, "runId") ?? "unknown"}" was not found in the selected Record.\n`);
+        case "sample-run-invalid":
+            return usageError(`Run "${stringProperty(error, "runId") ?? "unknown"}" is not a valid published Record Run.\n`);
+        case "sample-selection-invalid":
+            return usageError(`Invalid Record analysis selection: ${stringProperty(error, "field") ?? "selection"}.\n`);
+        case "sample-attempt-not-found":
+            return usageError(`Attempt "${stringProperty(error, "attemptId") ?? "unknown"}" was not found in the selected Record.\n`);
+        case "sample-attempt-ambiguous":
+            return usageError(`Attempt "${stringProperty(error, "attemptId") ?? "unknown"}" is ambiguous in the selected Record.\n`);
+        case "sample-attempt-locator-not-found":
+            return usageError(`Attempt locator "${stringProperty(error, "locator") ?? "unknown"}" was not found in the selected Record.\n`);
+        case "sample-attempt-locator-ambiguous":
+            return usageError(`Attempt locator "${stringProperty(error, "locator") ?? "unknown"}" is ambiguous in the selected Record.\n`);
+        case "record-migration-required":
+            return usageError("record-migration-required\nRun: niceeval migrate\n");
+        case "record-bootstrap-invalid":
+            return usageError("record-bootstrap-invalid\nPass --record <actual-record-root> or create a current NiceEval Record.\n");
+        case "record-format-unsupported":
+            return usageError("record-format-unsupported\nThis Record was created by a NiceEval version that is no longer supported. Remove .niceeval (for example, rm -rf .niceeval) and rerun the evaluation.\n");
+        case "record-migration-interrupted":
+            return usageError("record-migration-interrupted\nRestore the Record from Git or a backup before retrying.\n");
+        case "report-sample-empty":
+            return usageError("report-sample-empty\nRun an evaluation matching the current project, or select recorded results with --run.\n");
+        case "report-route-invalid":
+            return usageError(`Unknown Report route "${stringProperty(error, "route") ?? "unknown"}".\n`);
+        case "report-build-budget-exceeded":
+            return usageError(reportBuildBudgetExceededMessage(error));
+        case "report-site-execution-problem":
+            return usageError(reportSiteExecutionProblemMessage(error));
+        default:
+            return cliFailure("execute report from Record", error);
+    }
+}
+function automaticRecordMigrationFailure(error) {
+    const code = failureCode(error);
+    if (code === "record-auto-migration-git-save-required") {
+        return usageError("record-auto-migration-git-save-required\n" +
+            "Save every portable Record byte first (for example: git add .niceeval/record && git commit), then retry the same command.\n");
+    }
+    if (code === "record-maintenance-busy" || code === "record-writer-busy") {
+        return usageError(`${code}\nClose the command using this Record, then retry.\n`);
+    }
+    if (code === "record-format-unsupported") {
+        return usageError("record-format-unsupported\nUse the NiceEval version that wrote this future or unknown Record format.\n");
+    }
+    if (code === "record-migration-recovery-required" || code === "record-migration-interrupted") {
+        return usageError(`${code}\nRestore and verify the complete Record from Git before retrying.\n`);
+    }
+    return cliFailure("automatically migrate Record", error);
+}
+/** Preserve the actionable dimension and target from the Host's closed budget error. */
+function reportBuildBudgetExceededMessage(error) {
+    const budget = stringProperty(error, "budget");
+    const maximum = finiteNumberProperty(error, "maximum");
+    const observedAtLeast = finiteNumberProperty(error, "observedAtLeast");
+    if (budget === undefined || maximum === undefined || observedAtLeast === undefined) {
+        return "report-build-budget-exceeded\n";
+    }
+    const pageId = stringProperty(error, "pageId");
+    const route = stringProperty(error, "route");
+    const target = pageId === undefined && route === undefined
+        ? ""
+        : ` (${[
+            ...(pageId === undefined ? [] : [`page ${JSON.stringify(pageId)}`]),
+            ...(route === undefined ? [] : [`route ${JSON.stringify(route)}`]),
+        ].join(", ")})`;
+    return `report-build-budget-exceeded: ${budget} observed at least ${observedAtLeast}; maximum ${maximum}${target}\n`;
+}
+const REPORT_CLI_PROBLEMS_MAX = 20;
+const REPORT_CLI_PROBLEM_TEXT_MAX = 1024;
+/** Keep the concrete closed-problem reason while bounding author-controlled diagnostics. */
+function reportSiteExecutionProblemMessage(error) {
+    if (typeof error !== "object" || error === null)
+        return "report-site-execution-problem\n";
+    const problems = Reflect.get(error, "problems");
+    if (!Array.isArray(problems))
+        return "report-site-execution-problem\n";
+    const lines = problems
+        .slice(0, REPORT_CLI_PROBLEMS_MAX)
+        .flatMap((problem) => {
+        const code = boundedReportCliProblemText(stringProperty(problem, "code"));
+        const summary = boundedReportCliProblemText(stringProperty(problem, "summary"));
+        if (code === undefined && summary === undefined)
+            return [];
+        if (code === undefined)
+            return [summary];
+        return [summary === undefined ? code : `${code}: ${summary}`];
+    });
+    const omitted = Math.max(0, problems.length - REPORT_CLI_PROBLEMS_MAX);
+    return [
+        "report-site-execution-problem",
+        ...lines,
+        ...(omitted === 0 ? [] : [`${omitted} additional Report problem(s) omitted.`]),
+        "",
+    ].join("\n");
+}
+function boundedReportCliProblemText(value) {
+    if (value === undefined)
+        return undefined;
+    const bounded = value
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+        .slice(0, REPORT_CLI_PROBLEM_TEXT_MAX)
+        .trim();
+    return bounded === "" ? undefined : bounded;
+}
+function stringProperty(value, key) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const candidate = Reflect.get(value, key);
+    return typeof candidate === "string" ? candidate : undefined;
+}
+function finiteNumberProperty(value, key) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const candidate = Reflect.get(value, key);
+    return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : undefined;
+}
+function makeCliReportConsole(output) {
+    return Object.freeze({
+        write: (text) => effect_1.Effect.try({
+            try: () => {
+                output.writeStdoutSync(text);
+            },
+            catch: () => Object.freeze({
+                code: "report-console-write-failed",
+                operation: "write",
+            }),
+        }),
+    });
+}
+const reportHostPhaseLabels = Object.freeze({
+    "record-open": "Open Record",
+    "selection": "Select runs and attempts",
+    "sample-open": "Open analysis Sample",
+    "report-execution": "Execute Report and read requested facts",
+});
+function formatReportProgressDuration(durationMs) {
+    if (durationMs < 1000)
+        return `${Math.round(durationMs)}ms`;
+    return `${(durationMs / 1000).toFixed(1)}s`;
+}
+function writeReportProgress(output, text) {
+    try {
+        output.writeStderrSync(text);
+    }
+    catch {
+        // Progress is diagnostic only; it must never alter Report execution.
+    }
+}
+const cliProgressFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * Keeps interactive progress on one terminal line, while preserving plain
+ * line-oriented diagnostics when stderr is redirected to a file or CI log.
+ */
+class CliReportProgress {
+    stderrIsTTY;
+    output;
+    active;
+    constructor(stderrIsTTY, output) {
+        this.stderrIsTTY = stderrIsTTY;
+        this.output = output;
+    }
+    start(label) {
+        if (!this.stderrIsTTY) {
+            writeReportProgress(this.output, `⠋ ${label}…\n`);
+            return () => undefined;
+        }
+        if (this.active !== undefined)
+            clearInterval(this.active.timer);
+        let frame = 0;
+        const render = () => writeReportProgress(this.output, `\r\u001b[2K${cliProgressFrames[frame++ % cliProgressFrames.length]} ${label}…`);
+        render();
+        const timer = setInterval(render, 80);
+        const active = { label, timer };
+        this.active = active;
+        return () => {
+            if (this.active !== active)
+                return;
+            clearInterval(timer);
+            this.active = undefined;
+        };
+    }
+    complete(label, text) {
+        if (this.stderrIsTTY) {
+            if (this.active?.label === label) {
+                clearInterval(this.active.timer);
+                this.active = undefined;
+            }
+            writeReportProgress(this.output, `\r\u001b[2K${text}\n`);
+            return;
+        }
+        writeReportProgress(this.output, `${text}\n`);
+    }
+}
+function makeCliReportProgress(rootPath, progress) {
+    return Object.freeze({
+        report: (event) => {
+            const label = event.phase === "record-open"
+                ? `${reportHostPhaseLabels[event.phase]} (${rootPath})`
+                : reportHostPhaseLabels[event.phase];
+            if (event.type === "start") {
+                progress.start(label);
+                return;
+            }
+            const marker = event.outcome === "success" ? "✓" : "×";
+            const outcome = event.outcome === "success" ? "" : ` · ${event.outcome}`;
+            progress.complete(label, `${marker} ${label} (${formatReportProgressDuration(event.durationMs)}${outcome})`);
+        },
+    });
+}
+function cliPhaseOutcome(exit) {
+    if (effect_1.Exit.isSuccess(exit))
+        return "success";
+    if (effect_1.Cause.isInterruptedOnly(exit.cause))
+        return "interrupted";
+    return effect_1.Cause.defects(exit.cause).pipe((defects) => defects.length > 0) ? "defect" : "failure";
+}
+function withCliReportPhase(progress, label, effect) {
+    return effect_1.Effect.gen(function* () {
+        const startedAt = yield* effect_1.Clock.currentTimeNanos;
+        const stopProgress = yield* effect_1.Effect.sync(() => progress.start(label));
+        return yield* effect.pipe(effect_1.Effect.onExit((exit) => effect_1.Effect.gen(function* () {
+            const completedAt = yield* effect_1.Clock.currentTimeNanos;
+            const durationMs = Math.max(0, Number(completedAt - startedAt) / 1000000);
+            const outcome = cliPhaseOutcome(exit);
+            const marker = outcome === "success" ? "✓" : "×";
+            const detail = outcome === "success" ? "" : ` · ${outcome}`;
+            yield* effect_1.Effect.sync(() => {
+                stopProgress();
+                progress.complete(label, `${marker} ${label} (${formatReportProgressDuration(durationMs)}${detail})`);
+            });
+        })));
+    });
+}
+function runShowCommand(cwd, positionals, flags) {
+    return effect_1.Effect.gen(function* () {
+        const path = yield* application_ts_1.CliPath;
+        const reportPlatform = yield* application_ts_1.CliReportPlatform;
+        const facts = yield* invocationFacts;
+        const cliOutput = yield* application_ts_1.CliOutput;
+        const progress = new CliReportProgress(facts.stderr.isTTY, cliOutput);
+        const request = yield* effect_1.Effect.try({
+            try: () => parseReportCliRequest({ path, reportPlatform, command: "show", cwd, positionals, flags }),
+            catch: (cause) => cliFailure("parse show arguments", cause),
+        });
+        const inputs = yield* withCliReportPhase(progress, "Load project, config, Report, and Theme", loadCliReportInputs(request));
+        const textProjection = flags.json
+            ? undefined
+            : (0, panel_ts_1.panelCapabilityOf)({
+                isTTY: facts.stdout.isTTY,
+                width: facts.stdout.columns,
+            });
+        const show = request.target.kind === "attempt"
+            ? index_ts_3.reportHost.show({
+                root: request.root,
+                locator: request.target.locator,
+                report: inputs.report,
+                ...(request.page === undefined ? {} : { route: request.page }),
+                ...(textProjection === undefined ? {} : { textProjection: { width: textProjection.width, panelMode: textProjection.mode } }),
+                format: flags.json ? "json" : "text",
+            })
+            : index_ts_3.reportHost.show({
+                root: request.root,
+                selection: request.target.kind === "selection"
+                    ? request.target.selection
+                    : inputs.projectCurrentSelection,
+                report: inputs.report,
+                ...(request.page === undefined ? {} : { route: request.page }),
+                ...(textProjection === undefined ? {} : { textProjection: { width: textProjection.width, panelMode: textProjection.mode } }),
+                format: flags.json ? "json" : "text",
+            });
+        const output = yield* show.pipe(effect_1.Effect.provideService(progress_ts_1.ReportHostProgressObserver, makeCliReportProgress(request.rootPath, progress)), effect_1.Effect.mapError(reportExecutionFailure));
+        yield* makeCliReportConsole(cliOutput).write(output).pipe(effect_1.Effect.mapError((error) => cliFailure("render Report show output", error)));
+        return 0;
+    });
+}
+function runViewCommand(cwd, positionals, flags) {
+    return effect_1.Effect.gen(function* () {
+        const path = yield* application_ts_1.CliPath;
+        const reportPlatform = yield* application_ts_1.CliReportPlatform;
+        const facts = yield* invocationFacts;
+        const cliOutput = yield* application_ts_1.CliOutput;
+        const progress = new CliReportProgress(facts.stderr.isTTY, cliOutput);
+        const request = yield* effect_1.Effect.try({
+            try: () => parseReportCliRequest({ path, reportPlatform, command: "view", cwd, positionals, flags }),
+            catch: (cause) => cliFailure("parse view arguments", cause),
+        });
+        if (flags.out !== undefined) {
+            if (flags.out.trim() === "") {
+                return yield* effect_1.Effect.fail(usageError("--out requires a target directory.\n"));
+            }
+            if (flags.port !== undefined || flags.host !== undefined || flags.open === true) {
+                return yield* effect_1.Effect.fail(usageError("view --out does not start a server; remove --port, --host, and --open.\n"));
+            }
+            if (request.page !== undefined) {
+                return yield* effect_1.Effect.fail(usageError("view --out does not accept --page.\n"));
+            }
+            const inputs = yield* withCliReportPhase(progress, "Load project, config, Report, and Theme", loadCliReportInputs(request));
+            const revision = yield* buildCliReportSite(request, inputs).pipe(effect_1.Effect.provideService(progress_ts_1.ReportHostProgressObserver, makeCliReportProgress(request.rootPath, progress)));
+            const receipt = yield* withCliReportPhase(progress, "Export static report site", index_ts_3.reportHost.export({
+                revision,
+                out: path.resolve(cwd, flags.out),
+            }).pipe(effect_1.Effect.mapError((error) => staticExportFailure(error, path.resolve(cwd, flags.out)))));
+            yield* writeStdout(`Exported static report site: ${receipt.out}\n`);
+            return 0;
+        }
+        const initialInputs = yield* withCliReportPhase(progress, "Load project, config, Report, and Theme", loadCliReportInputs(request));
+        const initial = yield* buildCliReportSite(request, initialInputs).pipe(effect_1.Effect.provideService(progress_ts_1.ReportHostProgressObserver, makeCliReportProgress(request.rootPath, progress)));
+        const buildCache = yield* makeReportViewBuildCache(request, initialInputs, initial);
+        const { host, port } = yield* effect_1.Effect.try({
+            try: () => ({ host: viewHost(flags.host), port: viewPort(flags.port) }),
+            catch: (cause) => cliFailure("parse view server arguments", cause),
+        });
+        const server = yield* withCliReportPhase(progress, "Start HTTP server and file watcher", index_ts_3.reportHost.serve({
+            url: `http://${host.includes(":") ? `[${host}]` : host}:${port}/`,
+            watchInputs: initialInputs.watchInputs,
+            initial: effect_1.Effect.succeed(initial),
+            rebuild: () => rebuildReportView(request, buildCache),
+            host,
+            port,
+        }).pipe(effect_1.Effect.mapError((error) => cliFailure("open report view", error))));
+        const urls = server.urls.map((url) => {
+            if (request.page === undefined)
+                return url;
+            const target = new URL(url);
+            target.hash = `#${request.page}`;
+            return target.toString();
+        });
+        const url = urls[0];
+        if (!isLoopbackViewHost(host)) {
+            yield* writeStderr("Warning: niceeval view is listening beyond loopback without authentication or TLS; " +
+                "every reachable client can read report data, execution JSON, and downloads.\n");
+        }
+        yield* writeStdout(`niceeval view — open in a browser:\n${urls.join("\n")}\n`);
+        if (flags.open !== false) {
+            yield* openBrowser(url).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(false)));
+        }
+        return yield* effect_1.Effect.never;
+    });
+}
+function rebuildReportView(request, cache) {
+    return effect_1.Effect.gen(function* () {
+        const inputs = yield* loadCliReportInputs(request);
+        const revision = yield* buildCliReportSite(request, inputs);
+        cache.revision = revision;
+        cache.watchInputs = inputs.watchInputs;
+        return Object.freeze({
+            kind: "site",
+            site: revision,
+            watchInputs: inputs.watchInputs,
+        });
+    }).pipe(effect_1.Effect.catchAll((failure) => {
+        const problem = reportViewRebuildFailure(failure);
+        return writeStderr(`view rebuild failed: ${problem.summary}\n`).pipe(effect_1.Effect.ignore, effect_1.Effect.zipRight(effect_1.Effect.fail(problem)));
+    }));
+}
+function makeReportViewBuildCache(request, inputs, revision) {
+    void request;
+    return effect_1.Effect.succeed({ revision, watchInputs: inputs.watchInputs });
+}
+function staticExportFailure(error, out) {
+    if (failureCode(error) === "report-export-target-exists") {
+        return usageError(`report-export-target-exists\nRemove ${out} before retrying.\n`);
+    }
+    return cliFailure("export static Report", error);
+}
+function viewHost(value) {
+    const host = (value ?? "127.0.0.1").trim();
+    if (host.length === 0)
+        throw usageError("--host requires a non-empty address.\n");
+    return host;
+}
+function isLoopbackViewHost(host) {
+    return host === "127.0.0.1" || host === "::1" || host === "localhost";
+}
+function viewPort(value) {
+    const port = value ?? 0;
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw usageError(`--port must be an integer from 0 through 65535, got ${port}.\n`);
+    }
+    return port;
+}
+function reportViewRebuildFailure(failure) {
+    const summary = failure._tag === "CliUsageError"
+        ? failure.message
+        : failureCode(failure.cause) ?? "Report rebuild failed";
+    return Object.freeze({ summary });
+}
+const cliProgram = (interruption) => effect_1.Effect.gen(function* () {
+    const facts = yield* invocationFacts;
+    const cliArguments = yield* application_ts_1.CliArguments;
+    const cwd = facts.cwd;
+    const projectConfiguration = yield* project_configuration_ts_1.ProjectConfiguration;
+    const { command, positionals, flags, providedOptions } = yield* effect_1.Effect.try({
+        try: () => parseArgs([...facts.argv], cliArguments.parse),
+        catch: (cause) => cliFailure("parse CLI arguments", cause),
+    });
+    if (flags.help) {
+        yield* writeStdout((0, index_ts_5.t)("cli.help"));
+        return 0;
+    }
+    if (command === "exp" && positionals.length === 1 && positionals[0] === "help") {
+        yield* writeStdout((0, index_ts_5.t)("cli.help"));
+        return 0;
+    }
+    if (flags.version) {
+        yield* writeStdout((yield* packageVersion()) + "\n");
+        return 0;
+    }
+    // Help/version and Session / Docker profile queries are config-free paths.
+    // In particular, asking for usage must not read or mutate cwd/.env.
+    if (command !== "session" && command !== "docker") {
+        yield* projectConfiguration.prepare(cwd).pipe(effect_1.Effect.mapError((cause) => cliFailure("prepare project credentials", cause)));
+    }
+    if (command === "show" || command === "view" || command === "exp") {
+        const migrated = yield* (0, record_ts_1.ensureAutomaticRecordMigration)({
+            cwd,
+            ...(flags.record === undefined ? {} : { record: flags.record }),
+        }).pipe(effect_1.Effect.mapError(automaticRecordMigrationFailure));
+        if (migrated !== null) {
+            const droppedFacts = [...new Set(migrated.attachments.flatMap((attachment) => attachment.retention.droppedFacts))];
+            const rerunRecommendations = [...new Set(migrated.attachments.flatMap((attachment) => attachment.retention.rerunRecommendation === null
+                    ? []
+                    : [attachment.retention.rerunRecommendation]))];
+            yield* writeStderr(`Record automatically migrated ${migrated.attachments.length} attachment${migrated.attachments.length === 1 ? "" : "s"}; restore commit ${migrated.restoreCommit}.${droppedFacts.length === 0 ? "" : ` Dropped facts: ${droppedFacts.join(", ")}.`}${rerunRecommendations.length === 0 ? "" : ` ${rerunRecommendations.join(" ")}`}\n`);
+        }
+    }
+    if (command === "debug") {
+        const unsupported = providedOptions.find((name) => name !== "json" && name !== "help" && name !== "version");
+        if (unsupported !== undefined) {
+            yield* writeStderr((0, index_ts_5.t)("cli.debug.flagUnsupported", { flag: `--${unsupported}` }));
+            return 1;
+        }
+        return yield* runDebugCommand(cwd, positionals, flags);
+    }
+    if (command === "docker")
+        return yield* runDockerCommand(positionals, flags);
+    if (command === "accept") {
+        const locators = yield* effect_1.Effect.try({
+            try: () => parseAcceptLocators(positionals, flags),
+            catch: (cause) => cliFailure("parse acceptance locators", cause),
+        });
+        const outcome = yield* effect_1.Effect.either(runAcceptCommand(cwd, locators, flags.record));
+        if (effect_1.Either.isLeft(outcome)) {
+            yield* writeStderr((0, index_ts_5.t)("cli.accept.failed", { error: errorMessage(outcome.left.cause) }));
+            return 1;
+        }
+        return 0;
+    }
+    if (command === "view")
+        return yield* runViewCommand(cwd, positionals, flags);
+    if (command === "sandbox")
+        return yield* runSandboxCliCommand(cwd, positionals, flags);
+    if (command === "session")
+        return yield* runSessionCommand(cwd, positionals, flags);
+    if (command === "show")
+        return yield* runShowCommand(cwd, positionals, flags);
+    if (command === "clean" || command === "migrate") {
+        return yield* runRecordMaintenanceCommand(cwd, command, positionals, flags);
+    }
+    if (command === "init") {
+        const initialized = yield* initProject(cwd);
+        yield* writeStdout((0, index_ts_5.t)("cli.init.done"));
+        if (!initialized.prefersEsm)
+            yield* writeStdout((0, index_ts_5.t)("cli.init.esmHint"));
+        return 0;
+    }
+    if (command === "exp" && positionals[0] === "rename") {
+        return yield* runExperimentRenameCommand(cwd, positionals.slice(1), flags);
+    }
+    return yield* runEvaluationCommand(cwd, command, positionals, flags, interruption);
+}).pipe(
+// Every command boundary reports a typed CLI failure; defects and
+// interruption remain in the Cause channel for bootstrap to own.
+effect_1.Effect.mapError((cause) => cliFailure("run CLI command", cause)));
+exports.cliProgram = cliProgram;
+//# sourceMappingURL=program.cjs.map