humanish 0.106.1 → 0.108.0

package/dist/run/costs.js

@@ -2,11 +2,11 @@ import { round6 } from "./pricing.js";
 import { bindExistingRunArtifactPaths } from "./paths.js";
 import { contradictsAccountBilling } from "../verify/costs.js";
 import { EVIDENCE_LIMITS } from "../analysis/evidence.js";
-import { readBoundedStudyFile } from "./study-files.js";
-import { readAutomaticStudyAnalysisAccounting } from "../analysis/job.js";
-import { readStudyAnalysisAccountingRecords } from "../analysis/store-executions.js";
+import { readBoundedFile } from "./evidence-files.js";
+import { readAutomaticAnalysisAccounting } from "../analysis/job.js";
+import { readAnalysisAccountingRecords } from "../analysis/store-executions.js";
 import { RUN_BUNDLE_FILE } from "./bundle.js";
-export function emptyStudyCosts() {
+export function emptyCostTotals() {
     return {
         estimatedTotalUsd: null,
         runEstimatedUsd: null,
@@ -24,7 +24,7 @@ const isKnownUsd = (value) => typeof value === "number" && Number.isFinite(value
 function sumKnown(a, b) {
     return a === null && b === null ? null : round6((a ?? 0) + (b ?? 0));
 }
-export function addStudyCosts(into, next) {
+export function addCostTotals(into, next) {
     for (const key of ["estimatedTotalUsd", "runEstimatedUsd", "analysisEstimatedUsd"]) {
         into[key] = sumKnown(into[key], next[key]);
     }
@@ -41,16 +41,22 @@ export function addStudyCosts(into, next) {
     }
 }
 /** A read-only, bounded accounting pass. Never validates findings, dispatches, repairs or writes. */
-export async function readStudyCosts(cwd, entry) {
-    const costs = emptyStudyCosts();
+export async function readCostTotals(cwd, entry) {
+    const costs = emptyCostTotals();
     // Run-cost and analysis-history warnings stay apart: only the second kind makes the history
     // uncertain, whatever a run-cost warning is named.
     const runWarnings = [];
     const analysisWarnings = [];
-    costs.runEstimatedUsd = isKnownUsd(entry.estimatedCostUsd) ? entry.estimatedCostUsd : null;
+    // A dry run makes no model request and creates no desktop, so with no figure it costs $0. A
+    // recorded unknown (null) figure stays unknown.
+    costs.runEstimatedUsd = isKnownUsd(entry.estimatedCostUsd)
+        ? entry.estimatedCostUsd
+        : entry.estimatedCostUsd === undefined && entry.mode === "dry-run"
+            ? 0
+            : null;
     try {
         const prepared = await bindExistingRunArtifactPaths(cwd, entry.runId);
-        const bytes = await readBoundedStudyFile(prepared, RUN_BUNDLE_FILE, EVIDENCE_LIMITS.sourceBytes);
+        const bytes = await readBoundedFile(prepared, RUN_BUNDLE_FILE, EVIDENCE_LIMITS.sourceBytes);
         let bundle = null;
         try {
             bundle = bytes ? JSON.parse(bytes.toString("utf8")) : null;
@@ -82,8 +88,8 @@ export async function readStudyCosts(cwd, entry) {
             runWarnings.push("RUN_COST_COMPLETENESS_UNKNOWN");
         }
         const [history, automatic] = await Promise.all([
-            readStudyAnalysisAccountingRecords(prepared),
-            readAutomaticStudyAnalysisAccounting(prepared),
+            readAnalysisAccountingRecords(prepared),
+            readAutomaticAnalysisAccounting(prepared),
         ]);
         analysisWarnings.push(...history.warnings);
         const records = new Map(history.records.map((record) => [record.id, record]));

package/dist/run/detail.d.ts

@@ -9,19 +9,19 @@ interface RunThought {
     at?: string;
 }
 export interface RunParticipant {
-    /** Stream id — stable within a run, and what distinguishes lanes of one study. */
+    /** Stream id: stable within a run, and what distinguishes participants of one study. */
     id: string;
-    /** What to call them on screen: the lane's own label, else the persona id. */
+    /** What to call them on screen: the participant's own label, else the persona id. */
     label: string;
     /** The persona id, when the trace recorded one. */
     personaId?: string;
     /**
      * The persona's declared traits (`patience:medium`, `skill:medium`, …). This is the abbreviated
-     * persona a reader actually wants beside a live thought — it says who is struggling, which a
+     * persona a reader actually wants beside a live thought. It says who is struggling, which a
      * name alone does not.
      */
     traits: string[];
-    /** `running`, `passed`, `failed`, `contract_proof_only` — the lane's own word for itself. */
+    /** `running`, `passed`, `failed`, `contract_proof_only`: the participant's own word for itself. */
     status?: string;
     /** Why the actor stopped, when it has. */
     completionReason?: string;
@@ -29,8 +29,8 @@ export interface RunParticipant {
     turns?: number;
     actions?: number;
     /**
-     * Thoughts recorded so far. The mid-run flush carries the trace ITEMS but not the `counts` block,
-     * so a live participant has no turn count to show — but the thoughts can be counted directly, and
+     * Thoughts recorded so far. The mid-run flush carries the trace items but not the `counts` block,
+     * so a live participant has no turn count to show, but the thoughts can be counted directly, and
      * "8 thoughts" is a true statement about progress rather than an inferred turn number.
      */
     thoughts?: number;
@@ -49,13 +49,13 @@ export interface RunDetail {
     observerPath?: string;
 }
 /**
- * Read one run's participants. Returns null when the run has no readable bundle yet — an ordinary
+ * Read one run's participants. Returns null when the run has no readable bundle yet, an ordinary
  * state for a run that has just started, not a failure.
  *
- * Reads the bundle NARROWLY rather than through `loadRunBundle`, which applies the strict
+ * Reads the bundle narrowly rather than through `loadRunBundle`, which applies the strict
  * evidence-of-record guard. That guard is right for verification and wrong here: a mid-run flush is
  * a partial document by definition, so validating it as a complete bundle would make the live view
- * — the only view that needs this — the one case that never renders. Nothing read here is treated
+ * (the only view that needs this) the one case that never renders. Nothing read here is treated
  * as a claim about what a participant did; it is what to put on a screen.
  */
 export declare function readRunDetail(cwdInput: string, runId: string): Promise<RunDetail | null>;

package/dist/run/detail.js

@@ -1,4 +1,4 @@
-// What ONE run is doing right now: who is in it, what they are thinking, how far they have got.
+// What one run is doing right now: who is in it, what they are thinking, how far they have got.
 // Unlike the run index, it opens the bundle, which is affordable for the one run someone is
 // looking at.
 //
@@ -7,7 +7,7 @@
 //   - `stream.actor` once it has finished.
 // Reading both means the same screen renders a run the whole way through rather than going blank
 // at the moment it completes.
-import { readAutomaticStudyAnalysis } from "../analysis/automatic.js";
+import { readAutomaticAnalysis } from "../analysis/automatic.js";
 import path from "node:path";
 import { estimateActorCostForExecution } from "./pricing.js";
 import { resolveRunPath } from "./locate.js";
@@ -18,9 +18,9 @@ const RUN_DETAIL_SCHEMA = "humanish.run-detail.v1";
 /**
  * The latest reasoning a participant has recorded.
  *
- * Takes the LAST reasoning item rather than the newest by timestamp: the trace is append-ordered by
+ * Takes the last reasoning item rather than the newest by timestamp: the trace is append-ordered by
  * construction, and half of a live flush may not carry `at` yet. An item still in flight is skipped
- * — a partial thought read mid-write would be quoted as though the participant had finished it.
+ * because a partial thought read mid-write would be quoted as though the participant had finished it.
  */
 function latestThought(trace) {
     const items = trace.items ?? [];
@@ -68,9 +68,9 @@ function participantFrom(stream, index) {
 /**
  * What a participant has spent, priced the same way whether the run is finished or in flight.
  *
- * A finished trace carries its own `estimatedCost`. A live one carries the RUNNING usage and the
+ * A finished trace carries its own `estimatedCost`. A live one carries the running usage and the
  * model it prices at, so the same estimator gives a figure mid-run instead of the screen reporting
- * the cost as unknown until the moment the run ends — which is the half of a run where knowing what
+ * the cost as unknown until the moment the run ends. That is the half of a run where knowing what
  * it is costing actually changes what you do.
  */
 function costOf(trace) {
@@ -95,13 +95,13 @@ function costOf(trace) {
     }
 }
 /**
- * Read one run's participants. Returns null when the run has no readable bundle yet — an ordinary
+ * Read one run's participants. Returns null when the run has no readable bundle yet, an ordinary
  * state for a run that has just started, not a failure.
  *
- * Reads the bundle NARROWLY rather than through `loadRunBundle`, which applies the strict
+ * Reads the bundle narrowly rather than through `loadRunBundle`, which applies the strict
  * evidence-of-record guard. That guard is right for verification and wrong here: a mid-run flush is
  * a partial document by definition, so validating it as a complete bundle would make the live view
- * — the only view that needs this — the one case that never renders. Nothing read here is treated
+ * (the only view that needs this) the one case that never renders. Nothing read here is treated
  * as a claim about what a participant did; it is what to put on a screen.
  */
 export async function readRunDetail(cwdInput, runId) {
@@ -126,7 +126,7 @@ export async function readRunDetail(cwdInput, runId) {
     }
     const streams = Array.isArray(bundle.streams) ? bundle.streams : [];
     const observerAbsolute = path.join(runPaths.absoluteRunRoot, "observer", "index.html");
-    const automaticAnalysis = await readAutomaticStudyAnalysis(cwd, runId);
+    const automaticAnalysis = await readAutomaticAnalysis(cwd, runId);
     return {
         ...(automaticAnalysis === undefined ? {} : { automaticAnalysis }),
         schema: RUN_DETAIL_SCHEMA,

package/dist/run/dry-run-inputs.js

@@ -12,7 +12,7 @@ const builtinPersona = {
 const builtinScenario = {
     id: "builtin-first-run-smoke",
     title: "Built-in First-Run Smoke",
-    goal: "Create a public-safe dry-run contract bundle from built-in defaults.",
+    goal: "Write a public-safe dry-run bundle from built-in defaults.",
     source: "builtin:first-run-smoke",
     sourceDigest: "builtin",
 };

package/dist/run/dry-run.js

@@ -9,7 +9,7 @@ import {} from "./streams.js";
 import { participantEvent, participantIdsOf, participantRecord, participantStream, } from "./participant-records.js";
 import { implicitProjectDirectoryExists, readPackageName, validateCwd } from "./project.js";
 import { loadDryRunInputs } from "./dry-run-inputs.js";
-import { judgeExecution, judgePreview, OUTCOME_POLICIES, resultOk } from "./judge.js";
+import { judgeExecution, judgePreview, OUTCOME_POLICIES, resultOk, verdictText, } from "./judge.js";
 /**
  * The preview route's run. The run scope closes the run it started on every exit, including
  * the fail-closed ones. It renders an Observer only when `options.observer` asks for one.
@@ -33,11 +33,11 @@ async function runDryRunInScope(options, scope) {
     const warnings = [];
     if (cwdError)
         return refused(requestedCwd, warnings, cwdError);
-    const participants = normalizeParticipantCount(options.simCount);
+    const participants = normalizeParticipantCount(options.participantCount);
     if (participants === null) {
         return refused(requestedCwd, warnings, {
-            code: "HUMANISH_INVALID_SIM_COUNT",
-            message: "--sims must be a positive integer.",
+            code: "HUMANISH_INVALID_PARTICIPANT_COUNT",
+            message: "--count must be a positive integer.",
         });
     }
     // Bind the physical project, as the lab routes do: a symlinked cwd retargeted mid-run cannot
@@ -48,7 +48,7 @@ async function runDryRunInScope(options, scope) {
     if (!options.dryRun) {
         return refused(requestedCwd, warnings, {
             code: "HUMANISH_LIVE_RUN_UNIMPLEMENTED",
-            message: "Only run --dry-run is implemented here. Run a lab for a live study.",
+            message: "humanish run needs a study. List studies with humanish study list, or run humanish run --dry-run for a sample bundle.",
         });
     }
     const createdAt = new Date().toISOString();
@@ -66,6 +66,8 @@ async function runDryRunInScope(options, scope) {
         mode: options.dryRun ? "dry-run" : "live",
         lab: options.lab,
         renderReview: renderReviewMarkdown,
+        // The run starts at the time its id and source were stamped with.
+        now: () => Date.parse(createdAt),
         ...(options.observer === undefined ? {} : { observer: { open: options.observer.open } }),
     });
     if (!started.ok)
@@ -85,23 +87,14 @@ async function runDryRunInScope(options, scope) {
     });
     const judgment = judgePreview();
     const bundle = {
-        ...bundleHead({
-            runId,
-            mode: "dry-run",
-            participants,
-            createdAt,
-            cwd,
-            artifactRoot,
-            ...(options.lab === undefined ? {} : { lab: options.lab }),
-            source,
-        }),
+        ...bundleHead(run, { participants, cwd, artifactRoot, source }),
         persona: inputs.persona,
         scenario: inputs.scenario,
         lifecycle: [
             {
                 at: createdAt,
                 event: "run.created",
-                message: `Synthetic dry-run contract bundle created with ${participants} simulated participant${participants === 1 ? "" : "s"}.`,
+                message: `Synthetic dry-run bundle created with ${participants} simulated participant${participants === 1 ? "" : "s"}.`,
             },
             {
                 at: createdAt,
@@ -124,7 +117,7 @@ async function runDryRunInScope(options, scope) {
         events: observerFixtures.events,
         redaction: {
             status: "passed",
-            notes: "Dry-run bundle contains synthetic contract proof only.",
+            notes: "Dry-run bundle: synthetic data only, nothing from a product.",
         },
         artifacts: bundleArtifacts(),
         review: createReviewSummary(judgment.verdict),
@@ -157,14 +150,14 @@ async function runDryRunInScope(options, scope) {
     };
 }
 /**
- * The preview's review, with the verdict judgePreview gave it. It claims artifact plumbing only,
- * never product behavior.
+ * The preview's review, with the verdict judgePreview gave it. It claims only that the run's
+ * files were written, never product behavior.
  */
 function createReviewSummary(verdict) {
     return {
         schema: REVIEW_SCHEMA,
         verdict,
-        summary: "Synthetic dry-run bundle was generated. This proves humanish artifact plumbing, not product behavior.",
+        summary: "Dry run: humanish wrote a synthetic run bundle. No product behavior was tested.",
         gaps: [
             "No browser was launched.",
             "No product state was verified.",
@@ -180,7 +173,7 @@ Run: ${bundle.runId}
 
 Mode: ${bundle.mode}
 
-Verdict: ${bundle.review.verdict}
+Verdict: ${verdictText(bundle.review.verdict, bundle.mode)}
 
 ${bundle.review.summary}
 
@@ -211,13 +204,13 @@ async function renderPreviewObserver(finished, warnings) {
         return undefined;
     }
 }
-/** One synthetic stream per lane kind; the preview cycles through them. */
+/** One synthetic stream per stream kind (UI, terminal and the rest); the preview cycles through them. */
 const SYNTHETIC_STREAM_TEMPLATES = [
     {
         kind: "ui",
         mode: "browser-sim",
         label: "UI journey",
-        currentStep: "Route and viewport contract captured",
+        currentStep: "Route and viewport recorded",
         summary: "Simulated browser participant reserved for VNC playback, screenshots, route state, and interaction trace.",
         tail: "open target app\nresolve first-run route\ncapture viewport state\nrecord interaction trace",
         viewport: { width: 1440, height: 960, deviceScaleFactor: 1 },
@@ -226,19 +219,19 @@ const SYNTHETIC_STREAM_TEMPLATES = [
         kind: "terminal",
         mode: "cli-sim",
         label: "CLI actor",
-        currentStep: "Command transcript contract captured",
+        currentStep: "Command transcript recorded",
         summary: "Simulated CLI participant reserved for command-by-command persona runs with stdout/stderr and artifact links.",
         // Every command in a shipped sample tail must be one the CLI actually accepts: participants
         // read and run them. tests/surface/shipped-command-strings.test.ts checks this against the
         // command table.
-        tail: "$ humanish doctor\nok target cwd\nok humanish source\n$ humanish run first-run\ncontract proof emitted",
+        tail: "$ humanish doctor\nok target cwd\nok humanish source\n$ humanish run first-run\nhumanish run dry-run",
         viewport: undefined,
     },
     {
         kind: "tui",
         mode: "tui-sim",
         label: "TUI actor",
-        currentStep: "Terminal UI frame contract captured",
+        currentStep: "Terminal UI frame recorded",
         summary: "Simulated TUI participant reserved for PTY bytes, ANSI rendering, focus replay, and optional assisted attach.",
         tail: "\u001b[2mhumanish TUI frame\u001b[0m\n> persona: skeptical-power-user\n> scenario: onboarding-regression\nstatus: awaiting live PTY transport",
         viewport: undefined,
@@ -247,9 +240,9 @@ const SYNTHETIC_STREAM_TEMPLATES = [
         kind: "codex-ui",
         mode: "codex-app-sim",
         label: "Codex UI",
-        currentStep: "App-server embed contract captured",
+        currentStep: "App-server embed recorded",
         summary: "Simulated Codex UI participant reserved for app-server sessions that can be watched beside terminal evidence.",
-        tail: "codex-app-server session contract\nstate: not_connected\nembed: pending provider URL\nreceipts: planned",
+        tail: "codex-app-server session (dry run)\nstate: not_connected\nembed: pending provider URL\nreceipts: planned",
         viewport: { width: 1280, height: 900, deviceScaleFactor: 1 },
     },
 ];
@@ -262,7 +255,7 @@ function buildSyntheticObserverFixtures(args) {
             at: args.createdAt,
             level: "info",
             type: "observer.contract.created",
-            message: "Created public-safe observer stream contract.",
+            message: "Created the public-safe Observer streams.",
         },
     ];
     for (let index = 0; index < args.count; index += 1) {
@@ -331,7 +324,7 @@ function buildSyntheticObserverFixtures(args) {
             at: args.createdAt,
             level: "info",
             type: "sim.contract.ready",
-            message: `${template.label} stream contract ready.`,
+            message: `${template.label} stream ready.`,
         }), participantEvent(ids, {
             id: `event-${String(index + 1).padStart(3, "0")}-b`,
             at: args.createdAt,

package/dist/run/{study-files.d.ts → evidence-files.d.ts}

@@ -4,7 +4,7 @@ import { type PreparedOutputRoot } from "./contained-output.js";
  * percent-decoded up to five times, and each round must still be a plain relative path, so an
  * encoded `..` or separator cannot survive into a later decode.
  */
-export declare function isStudyEvidencePath(value: string): boolean;
+export declare function isEvidencePath(value: string): boolean;
 /**
  * True when `value` (at most `maxLength` characters) stays a plain relative path through up to five
  * rounds of percent-decoding: no round may match `unsafe`, have an empty, `.` or `..` segment, or
@@ -16,13 +16,13 @@ export declare function decodesToPlainRelativePath(value: string, maxLength: num
  * not turn an analysis budget into an unbounded read. No returned bytes have
  * authority to select another file or initiate a network request.
  */
-export declare function readBoundedStudyFile(root: PreparedOutputRoot, relativePath: string, maxBytes: number): Promise<Buffer | null>;
+export declare function readBoundedFile(root: PreparedOutputRoot, relativePath: string, maxBytes: number): Promise<Buffer | null>;
 /**
  * After a bounded read returned nothing: true when the file is absent, false when something is
  * there that could not be read. Errors other than ENOENT propagate.
  */
 export declare function pathMissing(filePath: string): Promise<boolean>;
-export type BoundedStudyFileResult = {
+export type BoundedFileResult = {
     state: "read";
     bytes: Buffer;
 } | {
@@ -32,4 +32,4 @@ export type BoundedStudyFileResult = {
     state: "unavailable";
 };
 /** Size refusals are distinguished only after the same contained regular-file checks. */
-export declare function readBoundedStudyFileResult(root: PreparedOutputRoot, relativePath: string, maxBytes: number): Promise<BoundedStudyFileResult>;
+export declare function readBoundedFileResult(root: PreparedOutputRoot, relativePath: string, maxBytes: number): Promise<BoundedFileResult>;

package/dist/run/{study-files.js → evidence-files.js}

@@ -12,7 +12,7 @@ import { isNodeError } from "./type-guards.js";
  * percent-decoded up to five times, and each round must still be a plain relative path, so an
  * encoded `..` or separator cannot survive into a later decode.
  */
-export function isStudyEvidencePath(value) {
+export function isEvidencePath(value) {
     return decodesToPlainRelativePath(value, 1024, /[\\:\x00-\x1f\x7f]|^\//);
 }
 /**
@@ -54,8 +54,8 @@ export function decodesToPlainRelativePath(value, maxLength, unsafe) {
  * not turn an analysis budget into an unbounded read. No returned bytes have
  * authority to select another file or initiate a network request.
  */
-export async function readBoundedStudyFile(root, relativePath, maxBytes) {
-    const result = await readBoundedStudyFileResult(root, relativePath, maxBytes);
+export async function readBoundedFile(root, relativePath, maxBytes) {
+    const result = await readBoundedFileResult(root, relativePath, maxBytes);
     return result.state === "read" ? result.bytes : null;
 }
 /**
@@ -89,8 +89,8 @@ export async function pathMissing(filePath) {
 }
 const unavailable = { state: "unavailable" };
 /** Size refusals are distinguished only after the same contained regular-file checks. */
-export async function readBoundedStudyFileResult(root, relativePath, maxBytes) {
-    if (!isStudyEvidencePath(relativePath) || !Number.isSafeInteger(maxBytes) || maxBytes < 1)
+export async function readBoundedFileResult(root, relativePath, maxBytes) {
+    if (!isEvidencePath(relativePath) || !Number.isSafeInteger(maxBytes) || maxBytes < 1)
         return unavailable;
     const validateRoot = async () => {
         if ("physicalRunRoot" in root) {

package/dist/run/feedback-shape.js

@@ -31,7 +31,7 @@ export function isRunFeedbackCandidate(value) {
         isFeedbackNextState(value.proposed_next_state) &&
         Array.isArray(value.acceptance_proof) &&
         value.acceptance_proof.every((item) => typeof item === "string") &&
-        // Optional, adapter-namespaced product-noun block: when present, validate only its SHAPE
+        // Optional, adapter-namespaced product-noun block: when present, validate only its shape
         // (a non-empty namespace + a data record). Core never inspects the keys inside `data`.
         (value.adapter === undefined || isFeedbackAdapterBlock(value.adapter)));
 }

package/dist/run/judge.d.ts

@@ -6,7 +6,7 @@ export interface BlockerFacts {
     completionReason: ActorCompletionReason;
     /** A harness-owned stop condition ended the session: a matched stopWhen or a completed dwell window. */
     stopConditionMatched: boolean;
-    /** What the participant declared in a field, when its provider has one (#570). */
+    /** What the participant declared in a field, when its provider has one. */
     declaredOutcome?: ParticipantDeclaredOutcome;
     /** The route's reading of the closing report: it describes a blocker or asks for instructions. */
     closingReportReadsBlocked: boolean;
@@ -23,7 +23,7 @@ export interface SessionEnding extends BlockerFacts {
 export declare function hollowCompletion(ending: SessionEnding): boolean;
 /**
  * The participant said it reached the goal but reported a blocker. A declared outcome is its own
- * word and wins (#570). Without one, the closing report is read, unless a stop condition ended the
+ * word and wins. Without one, the closing report is read, unless a stop condition ended the
  * session: a matched stopWhen is structured completion evidence and overrides the text.
  */
 export declare function selfReportedBlocker(ending: BlockerFacts): boolean;
@@ -60,12 +60,18 @@ export declare function participantHarnessFailed(participant: ParticipantFacts):
  * goal_satisfied claim with zero engagement is a session that ran out before anything happened;
  * one whose final message describes a blocker is a participant who could not proceed and said so.
  * Both keep their trace status (the claim is evidence); neither is a participant who reached the
- * goal. One rule for the single lane and the fan-out roll-up (#476).
+ * goal. One rule for the single participant and the fan-out roll-up.
  */
 export declare function participantStatus(status: ActorStatus, judgments: {
     noEngagement: boolean;
     selfReportedBlocker: boolean;
 } | undefined): ActorStatus;
+/**
+ * A verdict as review.md prints it. The schema keeps `contract_proof_only`, which a dry run always
+ * gets and a live run gets while it is in progress or when no participant result came back, so
+ * the reader sees "dry run" or "no verdict" by the run's mode.
+ */
+export declare function verdictText(verdict: Verdict, mode: "dry-run" | "live"): string;
 /** The review verdict for one participant's status. */
 export declare function verdictForStatus(status: ActorStatus): Verdict;
 declare const judged: unique symbol;
@@ -77,7 +83,7 @@ export interface Judgment {
     readonly verdict: Verdict;
     /**
      * The run met its route's pass rule: every expected participant passed and, on shared-world,
-     * the seats showed the concurrency verify requires. A dry run passes as a contract.
+     * the participants showed the concurrency verify requires. A dry run passes as a contract.
      */
     readonly passed: boolean;
     /** A type-only mark that judgmentOf made this judgment; it does not exist at runtime. */
@@ -86,7 +92,7 @@ export interface Judgment {
 /** The judgment for a verdict: a run passes when its verdict is pass, and a dry run passes. */
 export declare function judgmentOf(verdict: Verdict, dryRun: boolean): Judgment;
 /** What kind of execution failure a run recorded. */
-type ExecutionFailureKind = "harness" | "provider-cleanup" | "sandbox-cleanup" | "evidence" | "cap" | "run";
+type ExecutionFailureKind = "harness" | "provider-cleanup" | "provider-policy" | "sandbox-cleanup" | "evidence" | "cap" | "run";
 /** One way the run failed as an execution. The message is scrubbed; status.json shows it. */
 export interface ExecutionFailure {
     kind: ExecutionFailureKind;
@@ -98,7 +104,19 @@ export interface ExecutionOutcome {
     succeeded: boolean;
     /** The failures the policy counts, in the order the route recorded them. */
     failures: ExecutionFailure[];
+    /**
+     * The failures the policy lets warn, such as a sandbox whose release is unconfirmed on a route
+     * whose evidence stands. They leave `succeeded` and the result's ok alone but stay visible in
+     * status.json. Omitted when there are none.
+     */
+    warnings?: ExecutionFailure[];
 }
+/**
+ * The execution failure for one sandbox whose release is unconfirmed. `warning` is the route's
+ * release warning, already scrubbed. `recovery` says how to release it by hand; without one,
+ * reclaim kills by the id the run recorded at create time.
+ */
+export declare function sandboxCleanupFailure(owner: string, warning: string | undefined, runId: string, recovery?: string): ExecutionFailure;
 /**
  * How a route turns the facts into its result's ok. A gate route needs every participant to
  * pass. On an evidence route a participant that failed, was blocked or timed out is captured
@@ -114,13 +132,13 @@ export interface OutcomePolicy {
 export type JudgedRoute = "computer-use" | "shared-world" | "terminal" | "scripted" | "preview";
 /** Each route's outcome policy, in one place. */
 export declare const OUTCOME_POLICIES: Readonly<Record<JudgedRoute, OutcomePolicy>>;
-/** What a shared-world run observed about its one world, beside how each seat ended. */
+/** What a shared-world run observed about its one world, beside how each participant ended. */
 export interface SharedWorldFacts {
-    /** Two or more seats were live at the same time. */
+    /** Two or more participants were live at the same time. */
     overlap: boolean;
     /** Provisioned plane only: the shared state changed at or after the first overlap started. */
     stateChangedUnderOverlap?: boolean;
-    /** External-public plane only: every seat reached one lobby. */
+    /** External-public plane only: every participant reached one lobby. */
     lobbyConvergence?: boolean;
 }
 /** A shared-world run's judgment, with the world facts its review and result also report. */
@@ -131,7 +149,7 @@ export interface SharedWorldJudgment extends Judgment {
  * A run with one participant: its tallied status is the verdict, so a hollow pass fails and a
  * self-reported blocker reads as blocked. Without a session, a harness failure fails the run and
  * a dry run is a contract. A run still in progress is a contract until it finishes. Computer-use
- * calls it for one lane with no rerun, and terminal calls it through judgeTerminal.
+ * calls it for one participant with no rerun, and terminal calls it through judgeTerminal.
  */
 export declare function judgeOneParticipant(args: {
     dryRun: boolean;
@@ -150,15 +168,15 @@ export declare function judgeParticipants(args: {
     participants: ParticipantFacts[];
 }): Judgment;
 /**
- * Why a shared-world run whose seats all passed still fails, or undefined when its world facts
- * meet what verify's shared-world check requires of a pass: two seats live at the same time and,
- * on the provisioned plane, a shared-state change at or after the first overlap started.
+ * Why a shared-world run whose participants all passed still fails, or undefined when its world
+ * facts meet what verify's shared-world check requires of a pass: two participants live at the same
+ * time and, on the provisioned plane, a shared-state change at or after the first overlap started.
  */
 export declare function sharedWorldShortfall(world: SharedWorldFacts): string | undefined;
 /**
- * A shared-world run: it passes only when every expected seat passed and the world facts have no
- * shortfall, and otherwise fails (this route has no timed_out verdict). A dry run and a run still
- * in progress are contracts. Lobby convergence is recorded but not read.
+ * A shared-world run: it passes only when every expected participant passed and the world facts
+ * have no shortfall, and otherwise fails (this route has no timed_out verdict). A dry run and a run
+ * still in progress are contracts. Lobby convergence is recorded but not read.
  */
 export declare function judgeSharedWorld(args: {
     dryRun: boolean;
@@ -195,7 +213,7 @@ export declare function judgePreview(): Judgment;
  * stays as it was, so scoring can never improve a verdict. No failures returns the review as is.
  */
 export declare function foldScorerFailures(review: ReviewSummary, failures: readonly string[]): ReviewSummary;
-/** The run's execution outcome under its route's policy. A failure of a kind the policy lets warn is dropped. */
+/** The run's execution outcome under its route's policy. A failure of a kind the policy lets warn is a warning. */
 export declare function judgeExecution(failures: readonly ExecutionFailure[], policy: OutcomePolicy): ExecutionOutcome;
 /**
  * The result's ok: the run worked as an execution, no scorer failed it, and on a gate route every