niceeval 0.13.1 → 0.13.2

package/dist/cli.cjs

@@ -38,8 +38,8 @@ 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 overview_ts_1 = require("./report/built-in/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 model_ts_1 = require("./report/execution/model.cjs");
@@ -59,7 +59,7 @@ 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 gate_lease_ts_1 = require("./runner/gate-lease.cjs");
+const shared_state_lease_ts_1 = require("./runner/shared-state-lease.cjs");
 const cleanup_timeout_ts_1 = require("./runner/cleanup-timeout.cjs");
 const report_view_cache_ts_1 = require("./view/report-view-cache.cjs");
 const timeout_ts_1 = require("./runner/timeout.cjs");
@@ -110,6 +110,9 @@ function renderCliFailure(failure) {
         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) {
@@ -146,6 +149,16 @@ function failureCode(value) {
     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 模式报清晰错误，不会静默吞掉后面的位置参数。
@@ -219,7 +232,7 @@ const FLAG_OPTIONS = {
     record: { type: "string" },
     /** `show` / `view` 可重复传入 `--run`;每次按完整 RunId 增加一个显式 Run,重复 identity 去重。 */
     run: { type: "string", multiple: true },
-    /** `show` / `view` 命令专用：内建 `overview` 或受信任的 Report module 路径。 */
+    /** `show` / `view` 命令专用：内建 `standard` 或受信任的 Report module 路径。 */
     report: { type: "string" },
     /** `show` / `view` 命令专用：内建 Theme 或受信任的闭合 Theme module 路径。 */
     theme: { type: "string" },
@@ -227,6 +240,14 @@ const FLAG_OPTIONS = {
     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`。 */
@@ -240,7 +261,7 @@ const FLAG_OPTIONS = {
     /** `view` 命令专用:启动后自动打开浏览器(默认行为)。 */
     open: { type: "boolean" },
     "no-open": { type: "boolean" },
-    /** `clean` / `migrate` 专用：确认不可逆 maintenance 动作或没有 Git restore point 的 migration。 */
+    /** `clean` / `migrate` 专用：确认不可逆 maintenance 动作或在 clean Git restore point 下执行 migration。 */
     yes: { type: "boolean" },
     /** 打印用法说明并退出。 */
     help: { type: "boolean", short: "h" },
@@ -430,6 +451,10 @@ function parseArgs(argv) {
         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 };
 }
@@ -630,6 +655,10 @@ function firstRecordMaintenanceUnsupportedFlag(flags) {
         ["--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") {
@@ -688,6 +717,10 @@ function parseAcceptLocators(positionals, flags) {
         ["--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
@@ -787,6 +820,10 @@ function firstExperimentRenameUnsupportedFlag(flags) {
         ["--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],
@@ -1182,12 +1219,10 @@ function writeStderr(text) {
 }
 /** Idempotent application-level sweep for resources owned by this invocation. */
 function releaseCliResources() {
-    return effect_1.Effect.all([
-        cliPromise("stop remaining sandboxes", () => (0, registry_ts_1.stopAllSandboxes)()).pipe(effect_1.Effect.ignore),
-        (0, experiment_cleanup_registry_ts_1.drainExperimentTeardowns)().pipe(effect_1.Effect.ignore),
-        (0, lock_ts_1.drainHeldCaseLocksEffect)().pipe(effect_1.Effect.ignore),
-        (0, gate_lease_ts_1.drainHeldGateLeasesEffect)().pipe(effect_1.Effect.ignore),
-    ], { concurrency: "unbounded" }).pipe(effect_1.Effect.asVoid);
+    // 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);
@@ -1286,6 +1321,7 @@ function agentRunFromExperiment(experiment, selectedEvalIds, overrides = {}) {
         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,
@@ -1301,6 +1337,89 @@ function agentRunFromExperiment(experiment, selectedEvalIds, overrides = {}) {
         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",
@@ -1363,6 +1482,13 @@ function runDebugCommand(cwd, positionals, flags) {
 }
 function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
     return effect_1.Effect.gen(function* () {
+        // 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 = (0, node_path_1.resolve)(cwd, ".niceeval");
@@ -1389,6 +1515,10 @@ function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
         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;
@@ -1488,7 +1618,7 @@ function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
             if (orphans)
                 yield* writeStderr(orphans);
             const teardownReminder = yield* (0, teardown_registry_ts_1.orphanedTeardownReminderEffect)(coordinationRoot, new Set(selected
-                .filter(({ experiment }) => experiment.teardown)
+                .filter(({ experiment }) => experimentTeardownOf(experiment) !== undefined)
                 .map(({ experiment }) => experiment.id)), (0, node_os_1.hostname)()).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)));
             if (teardownReminder)
                 yield* writeStderr(teardownReminder);
@@ -1498,10 +1628,143 @@ function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
                     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: (0, node_os_1.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: (0, node_os_1.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: (0, node_os_1.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: (0, node_os_1.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 selected) {
-                    if (!experiment.teardown)
+                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,
@@ -1509,14 +1772,31 @@ function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
                         progress: () => { },
                         diagnostic: (input) => process.stderr.write(`${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 claimed = yield* effect_1.Effect.all(matching
-                        .filter(({ entry }) => (0, teardown_registry_ts_1.isOrphanedTeardownRegistration)(entry, (0, node_os_1.hostname)()))
-                        .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" });
-                    const executions = matching.length === 0 ? [undefined] : claimed.filter((id) => id !== undefined);
-                    for (const _ of executions) {
-                        const outcome = yield* effect_1.Effect.either(cliEffect("run experiment teardown", (0, cleanup_timeout_ts_1.cleanupCallback)(() => experiment.teardown(ctx))));
+                    const orphaned = matching.filter(({ entry }) => (0, teardown_registry_ts_1.isOrphanedTeardownRegistration)(entry, (0, node_os_1.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 }));
                         }
@@ -1530,6 +1810,42 @@ function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
                         }
                     }
                 }
+                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: (0, node_os_1.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: (0, node_os_1.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();
@@ -1738,6 +2054,7 @@ function runEvaluationCommand(cwd, command, positionals, flags, interruption) {
             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 }),
             })),
@@ -1913,7 +2230,7 @@ function parseReportCliRequest(input) {
             kind: "project-current",
             ...(input.flags.experiment === undefined
                 ? {}
-                : { experimentIds: uniqueExactExperimentIds(input.flags.experiment) }),
+                : { experimentSelectors: uniqueExperimentSelectors(input.flags.experiment) }),
         });
     return Object.freeze({
         command: input.command,
@@ -1973,6 +2290,10 @@ function reportUnsupportedFlag(command, flags) {
         ["--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));
@@ -1990,12 +2311,12 @@ function parseReportRoute(value) {
 function reportSelection(cwd, value) {
     if (value === undefined)
         return Object.freeze({ kind: "config" });
-    if (value === "overview")
-        return Object.freeze({ kind: "built-in", name: "overview" });
+    if (value === "standard")
+        return Object.freeze({ kind: "built-in", name: "standard" });
     if (isTrustedModulePath(value)) {
         return Object.freeze({ kind: "module", path: (0, node_ts_1.resolveTrustedModulePath)(cwd, value) });
     }
-    throw usageError("--report accepts built-in overview or an explicit trusted module path.\n");
+    throw usageError("--report accepts built-in standard or an explicit trusted module path.\n");
 }
 function themeSelection(cwd, value) {
     if (value === undefined)
@@ -2038,13 +2359,13 @@ function uniqueExactRunIds(values) {
     }
     return Object.freeze(result);
 }
-function uniqueExactExperimentIds(values) {
+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 one exact ExperimentId.\n`);
+            throw usageError(`Invalid --experiment value "${value}": expected an Experiment selector.\n`);
         }
         if (!seen.has(decoded.right)) {
             seen.add(decoded.right);
@@ -2053,6 +2374,10 @@ function uniqueExactExperimentIds(values) {
     }
     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);
@@ -2070,9 +2395,9 @@ function loadCliReportInputs(request) {
     return effect_1.Effect.gen(function* () {
         const projectCurrent = request.target.kind === "project-current"
             ? yield* cliEffect("load current project target", (0, project_current_ts_1.loadProjectCurrent)(request.cwd, {
-                ...(request.target.experimentIds === undefined
+                ...(request.target.experimentSelectors === undefined
                     ? {}
-                    : { experiments: request.target.experimentIds }),
+                    : { experiments: request.target.experimentSelectors }),
                 freshImport: true,
             }))
             : undefined;
@@ -2084,8 +2409,8 @@ function loadCliReportInputs(request) {
             : Object.freeze({
                 policy: "project-current",
                 currentSlots: projectCurrent.currentSlots,
-                ...(request.target.kind === "project-current" && request.target.experimentIds !== undefined
-                    ? { experimentIds: request.target.experimentIds }
+                ...(request.target.kind === "project-current" && request.target.experimentSelectors !== undefined
+                    ? { experimentIds: selectedExperimentIds(projectCurrent.currentSlots) }
                     : {}),
             });
         const sourceWatchInputs = uniqueWatchInputs([
@@ -2113,11 +2438,11 @@ function reportFromSelection(selection, configured, configuredWatchInputs) {
             return effect_1.Effect.succeed(Object.freeze({ value: selection.report, watchInputs: Object.freeze([]) }));
         case "config":
             return effect_1.Effect.succeed(Object.freeze({
-                value: configured ?? overview_ts_1.defaultOverviewReport,
+                value: configured ?? standard_tsx_1.standard,
                 watchInputs: configured === undefined ? Object.freeze([]) : configuredWatchInputs,
             }));
         case "built-in":
-            return effect_1.Effect.succeed(Object.freeze({ value: overview_ts_1.defaultOverviewReport, watchInputs: Object.freeze([]) }));
+            return effect_1.Effect.succeed(Object.freeze({ value: standard_tsx_1.standard, watchInputs: Object.freeze([]) }));
         case "module":
             return cliEffect("load trusted Report module", (0, node_ts_1.loadTrustedReportModule)(selection.path)).pipe(effect_1.Effect.map((loaded) => Object.freeze({ value: loaded.report, watchInputs: loaded.watchInputs })));
     }
@@ -2190,6 +2515,23 @@ function reportExecutionFailure(error) {
             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");
@@ -2722,10 +3064,23 @@ const cliProgram = (interruption) => effect_1.Effect.gen(function* () {
         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;
     }
+    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) {
+            yield* writeStderr(`Record automatically migrated to schemaVersion ${migrated.targetSchemaVersion}; restore commit ${migrated.restoreCommit}.\n`);
+        }
+    }
     if (command === "debug") {
         const unsupported = providedOptions.find((name) => name !== "json" && name !== "help" && name !== "version");
         if (unsupported !== undefined) {