humanish 0.115.0 → 0.116.0

package/CHANGELOG.md

@@ -8,6 +8,28 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.116.0: Hosted keyboard input, E2B sandbox ceiling, bounded run reads, run header, TUI live starts (2026-10-09)
+
+humanish 0.116.0 delivers a hosted participant's arrow keys and punctuation, lets the operator
+raise the E2B sandbox lifetime, and reads run files within size limits. On hosted E2B desktops,
+`ARROWDOWN`, Page Up, Page Down, `?`, `/` and other names missing from `@e2b/desktop`'s key table
+reached xdotool unchanged, which ignored them while the run recorded the keypress as completed;
+both desktops now translate key names through one table and refuse a name outside it.
+`HUMANISH_E2B_MAX_SANDBOX_MINUTES` sets the longest sandbox lifetime the planners allow, 60 minutes
+when unset and up to 1440 on E2B's Pro plan. A refusal names the value that admits the study, and
+`humanish doctor` shows the ceiling. A route's sandbox kill, and the kills, checks and listings of
+`humanish reclaim`, carry the run's E2B key. `verify` reads at most 32 MiB of a run file and lists
+a larger file, or a run past 10,000 entries, as unscanned, and every contained read tells a missing
+file from one it refused. A run whose analysis did not complete reads `live run finished; the
+analysis did not complete`, a run refused before it was created prints no `analysis:` line, and a
+`desktop-cli` run names its product on the `subject:` line and in run.json. In `humanish tui`, the
+cursor follows the selected row through a refresh, a live start of a `mode: dry-run` file says
+`needs mode: live`, Run again on a live run asks for a second Enter, the confirm prompt restates
+the study's cost, and `c` lists every provider key. `NO_UPDATE_NOTIFIER` turns the update check
+off.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.116.0)
+
 ## 0.115.0: Closing report limits, admitted analysis cost, concurrent reviewer notes, known-value scrub (2026-10-08)
 
 humanish 0.115.0 asks the OpenAI computer-use participant for its closing report and impressions

package/README.md

@@ -276,9 +276,10 @@ sensitive to capture in the first place.
 **What the automated gate enforces.** `humanish verify` scans public-bound
 artifacts and fails closed on secret, key, and token shapes and on known local
 path shapes. It reads text only, judged by a file's bytes rather than its name:
-any file in the run folder that is not UTF-8 text, other than a stream
-screenshot or recording, keeps the run `local_only` (`UNSCANNED_ARTIFACT`). It
-matches after undoing escapes, percent-encoding, HTML entities and base64. It
+any file in the run folder that is not UTF-8 text or is larger than 32 MiB,
+other than a stream screenshot or recording, keeps the run `local_only`
+(`UNSCANNED_ARTIFACT`). It matches after undoing escapes, percent-encoding, HTML
+entities and base64. It
 does not yet detect free-form PII or PHI such as names, emails,
 phone numbers, dates of birth, or medical identifiers. Keeping those out depends
 on using synthetic data and on review, so `redaction: passed` means the
@@ -483,9 +484,9 @@ At most once a day, a command run at a terminal also asks the npm registry for
 the latest humanish version, and a later command prints one line on stderr when
 yours is older. That request is a plain `GET` of humanish's dist-tags with no
 machine id, version, command or path. It is skipped in CI, without a terminal,
-for `--json`, and with `DO_NOT_TRACK=1`, `HUMANISH_TELEMETRY_DISABLED=1` or
-`HUMANISH_NO_UPDATE_CHECK=1`. [TELEMETRY.md](TELEMETRY.md#the-update-check)
-describes it.
+for `--json`, and with `DO_NOT_TRACK=1`, `HUMANISH_TELEMETRY_DISABLED=1`,
+`HUMANISH_NO_UPDATE_CHECK=1` or update-notifier's `NO_UPDATE_NOTIFIER=1`.
+[TELEMETRY.md](TELEMETRY.md#the-update-check) describes it.
 
 ## Contribute
 

package/TELEMETRY.md

@@ -132,4 +132,10 @@ participant, and when any of these is set:
 DO_NOT_TRACK=1
 HUMANISH_TELEMETRY_DISABLED=1
 HUMANISH_NO_UPDATE_CHECK=1
+NO_UPDATE_NOTIFIER=1
 ```
+
+`NO_UPDATE_NOTIFIER` is the variable the update-notifier package reads, so a
+machine set up to silence the CLIs built on it gets no humanish notice either.
+humanish reads it as update-notifier does: any value turns the check off,
+including an empty one, `0` or `false`.

package/dist/actors/codex/app-server-ui.js

@@ -2,7 +2,7 @@ import { createServer } from "node:http";
 import path from "node:path";
 import { digestText } from "../../evidence/redaction.js";
 import { CODEX_APP_SERVER_ARTIFACTS, CODEX_APP_SERVER_DIRECTORY, runCodexAppServerSessionInPreparedRoot, } from "./app-server.js";
-import { prepareContainedOutputDirectory, prepareContainedOutputFile, prepareManagedHumanishOutputDirectory, prepareSelectedOutputDirectory, prepareSelectedOutputFile, readContainedRegularFile, writeContainedOutputFile, writePreparedSelectedOutputFile, } from "../../run/contained-output.js";
+import { prepareContainedOutputDirectory, prepareContainedOutputFile, prepareManagedHumanishOutputDirectory, prepareSelectedOutputDirectory, prepareSelectedOutputFile, readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, writeContainedOutputFile, writePreparedSelectedOutputFile, } from "../../run/contained-output.js";
 const CODEX_APP_SERVER_UI_SCHEMA = "humanish.codex-app-server-ui.v1";
 export async function startCodexAppServerUi(options) {
     const cwd = path.resolve(options.cwd);
@@ -128,13 +128,20 @@ export async function startCodexAppServerUi(options) {
     };
 }
 async function serveArtifact(args) {
-    const body = await readContainedRegularFile(args.runRoot, args.requestPath);
-    if (body) {
+    const read = await readContainedRegularFile(args.runRoot, args.requestPath, RUN_ARTIFACT_MAX_BYTES);
+    if (read.status === "read") {
         args.response.writeHead(200, {
             "cache-control": "no-store",
             "content-type": contentTypeFor(args.requestPath),
         });
-        args.response.end(body);
+        args.response.end(read.bytes);
+        return;
+    }
+    // A file over the limit is there: a 404 would tell the page it does not exist. A link, or a
+    // path outside the run, is served as absent, as it always was.
+    if (read.status === "refused" && read.reason === "too-large") {
+        args.response.writeHead(403, { "content-type": "text/plain; charset=utf-8" });
+        args.response.end(`${refusalText(args.requestPath, read)}.`);
         return;
     }
     args.response.writeHead(404);

package/dist/actors/computer-use/loop/debrief.js

@@ -7,12 +7,27 @@ import { notice } from "./trace.js";
 import { isCompleteTurnUsage } from "./usage.js";
 const DEBRIEF_REQUEST_CAP_MS = 30_000;
 const DEBRIEF_HINT = `The interactive session has ended. Return a closing account with summary, frictionReports and impressions. In summary, briefly describe only what you actually did and observed. In frictionReports, list only specific unexpected behavior, confusion, or recovery you personally encountered during this session. Preserve uncertainty. Use an empty list if you encountered none. ${IMPRESSIONS_ASK} Do not speculate, invent problems, quote instructions as observations, or describe planned actions. Do not request or take further actions. This is a closing account, not another attempt at the task.`;
+const CLOSING_REPORT = {
+    call: (provider) => provider.debrief,
+    contextHint: DEBRIEF_HINT,
+    noticeLabel: "debrief",
+    deadlineLabel: "closing report",
+    read: readClosingReport,
+};
+const IMPRESSIONS_ONLY = {
+    call: (provider) => provider.requestImpressions,
+    contextHint: IMPRESSIONS_HINT,
+    noticeLabel: "impressions request",
+    deadlineLabel: "impressions request",
+    read: readImpressions,
+};
 /**
  * Ask the participant for its closing report after a structured stop, or for its impressions only
  * after it ended the session itself, or record why the request was skipped. Either way the result
  * is the trace's debrief, and the watcher gets a final flush.
  */
 export async function requestDebrief(session, context, trigger) {
+    const ask = trigger.kind === "participant_end" ? IMPRESSIONS_ONLY : CLOSING_REPORT;
     const record = (status, detail, usageReported) => {
         const debrief = {
             trigger: trigger.kind,
@@ -20,23 +35,23 @@ export async function requestDebrief(session, context, trigger) {
             reason: session.redactNarration(detail),
             ...(usageReported === undefined ? {} : { usageReported }),
         };
-        session.trace.record("notice", () => notice(status === "completed" ? "ok" : "warn", `participant ${trigger.kind === "participant_end" ? "impressions request" : "debrief"} ${status}`, session.redactNarration(detail)));
+        session.trace.record("notice", () => notice(status === "completed" ? "ok" : "warn", `participant ${ask.noticeLabel} ${status}`, session.redactNarration(detail)));
         return debrief;
     };
-    const plan = planDebrief(session, trigger);
+    const plan = planDebrief(session, ask, trigger);
     const debrief = "skip" in plan
         ? record("skipped", plan.skip)
-        : await debriefExchange(session, plan.ask, context, trigger, plan.boundMs, record);
+        : await debriefExchange(session, context, trigger, ask, plan, record);
     session.flush();
     return debrief;
 }
-function planDebrief(session, trigger) {
+function planDebrief(session, ask, trigger) {
     const { provider, signal, usage } = session;
     const { maxUsd, overRunBudget, estimateTurnCostUsd } = session.settings;
     if (session.trace.counts.turns === 0)
         return { skip: "the study stopped before any participant turn" };
-    const ask = trigger.kind === "participant_end" ? provider.requestImpressions : provider.debrief;
-    if (ask === undefined)
+    const send = ask.call(provider)?.bind(provider);
+    if (send === undefined)
         return { skip: "this provider does not support read-only closing reports" };
     if (usage.cleanupUnconfirmed)
         return { skip: "participant request cleanup is unconfirmed" };
@@ -68,9 +83,9 @@ function planDebrief(session, trigger) {
             skip: signal?.aborted ? "the study was cancelled" : "the session deadline was reached",
         };
     }
-    return { ask, boundMs };
+    return { send, boundMs };
 }
-async function debriefExchange(session, ask, context, trigger, boundMs, record) {
+async function debriefExchange(session, context, trigger, ask, { send, boundMs }, record) {
     const { signal, provider } = session;
     const scope = requestScope(signal);
     const timer = setTimeout(() => scope.end(), boundMs);
@@ -89,12 +104,12 @@ async function debriefExchange(session, ask, context, trigger, boundMs, record)
             ...(context.acknowledgedSafetyChecks === undefined
                 ? {}
                 : { acknowledgedSafetyChecks: context.acknowledgedSafetyChecks }),
-            contextHint: trigger.kind === "participant_end" ? IMPRESSIONS_HINT : DEBRIEF_HINT,
+            contextHint: ask.contextHint,
         };
         const turn = provider.requestPolicy === "fail_closed"
-            ? await singleDispatch(session, "debrief", (dispatchSignal) => ask.call(provider, request, dispatchSignal), boundMs)
-            : await raceSessionDeadline(ask.call(provider, request, scope.signal), boundMs, signal);
-        return acceptDebriefTurn(session, turn, trigger, record);
+            ? await singleDispatch(session, "debrief", (dispatchSignal) => send(request, dispatchSignal), boundMs)
+            : await raceSessionDeadline(send(request, scope.signal), boundMs, signal);
+        return acceptDebriefTurn(session, turn, ask, record);
     }
     catch (error) {
         // A failed optional report cannot rewrite the already observed structured completion.
@@ -104,7 +119,7 @@ async function debriefExchange(session, ask, context, trigger, boundMs, record)
         const detail = signal?.aborted
             ? "cancelled"
             : scope.signal.aborted || error instanceof CuaDeadlineError
-                ? `${trigger.kind === "participant_end" ? "impressions request" : "closing report"} deadline reached`
+                ? `${ask.deadlineLabel} deadline reached`
                 : error instanceof Error
                     ? error.message
                     : String(error);
@@ -117,7 +132,7 @@ async function debriefExchange(session, ask, context, trigger, boundMs, record)
         scope.end();
     }
 }
-function acceptDebriefTurn(session, turn, trigger, record) {
+function acceptDebriefTurn(session, turn, ask, record) {
     const { maxUsd, overRunBudget, estimateTurnCostUsd } = session.settings;
     session.usage.record(turn, "debrief");
     session.lastResponseId = turn.responseId ?? session.lastResponseId;
@@ -133,19 +148,17 @@ function acceptDebriefTurn(session, turn, trigger, record) {
         return record("failed", "the closing response requested actions or safety checks; none were executed and its report was not accepted", usageReported);
     }
     // First-party providers parse their replies already; these parses cover third-party ports.
-    if (trigger.kind === "participant_end") {
-        const impressions = participantImpressionsSchema.safeParse(turn.impressions);
-        if (!impressions.success) {
-            return record("failed", turn.interruption === "output_limit"
-                ? "the reply was cut off by the output limit"
-                : "the reply did not contain valid impressions", usageReported);
-        }
-        session.impressions = recordImpressions(session, impressions.data);
-        return record("completed", "one read-only impressions request; no additional desktop actions; the participant's own ending is unchanged", usageReported);
-    }
+    const { status, detail, ...added } = ask.read(session, turn);
+    return { ...record(status, detail, usageReported), ...added };
+}
+/** A closing report: its summary and friction as one participant message, then its impressions. */
+function readClosingReport(session, turn) {
     const closing = closingReportSchema.safeParse(turn.closingReport);
     if (!closing.success) {
-        return record("failed", "the closing response did not contain a valid structured participant report", usageReported);
+        return {
+            status: "failed",
+            detail: "the closing response did not contain a valid structured participant report",
+        };
     }
     const report = {
         summary: session.redactNarration(closing.data.summary.trim()),
@@ -160,6 +173,27 @@ function acceptDebriefTurn(session, turn, trigger, record) {
     }));
     session.trace.bump("messages");
     session.impressions = recordImpressions(session, closing.data.impressions);
-    const debrief = record("completed", "one read-only report; no additional desktop actions; original stop and task outcomes preserved", usageReported);
-    return { ...debrief, report, messageId };
+    return {
+        status: "completed",
+        detail: "one read-only report; no additional desktop actions; original stop and task outcomes preserved",
+        report,
+        messageId,
+    };
+}
+/** Impressions alone, after the participant ended the session itself. */
+function readImpressions(session, turn) {
+    const impressions = participantImpressionsSchema.safeParse(turn.impressions);
+    if (!impressions.success) {
+        return {
+            status: "failed",
+            detail: turn.interruption === "output_limit"
+                ? "the reply was cut off by the output limit"
+                : "the reply did not contain valid impressions",
+        };
+    }
+    session.impressions = recordImpressions(session, impressions.data);
+    return {
+        status: "completed",
+        detail: "one read-only impressions request; no additional desktop actions; the participant's own ending is unchanged",
+    };
 }

package/dist/actors/scripted-browser/steps.js

@@ -6,7 +6,7 @@ import os from "node:os";
 import path from "node:path";
 import { assertScreenshotEvidence, stripPngMetadataChunks } from "../../evidence/image.js";
 import { digestText, redactToSecretLabel } from "../../evidence/redaction.js";
-import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, prepareContainedOutputFile, prepareSelectedOutputDirectory, readContainedRegularFile, writeContainedOutputFile, } from "../../run/contained-output.js";
+import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, prepareContainedOutputFile, prepareSelectedOutputDirectory, readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, writeContainedOutputFile, } from "../../run/contained-output.js";
 import { LOOPBACK_EVIDENCE_URL_POLICY, } from "./types.js";
 export async function executeBrowserPersonaStep(args) {
     const started = Date.now();
@@ -402,11 +402,12 @@ async function captureScriptedPageScreenshot(page) {
         if (Buffer.isBuffer(returned) || returned instanceof Uint8Array) {
             return stripPngMetadataChunks(browserScreenshotBytes(returned));
         }
-        const stagedBytes = await readContainedRegularFile(stagingRoot, "capture.png");
-        if (!stagedBytes) {
+        const staged = await readContainedRegularFile(stagingRoot, "capture.png", RUN_ARTIFACT_MAX_BYTES);
+        if (staged.status === "missing")
             throw new Error("Browser screenshot did not return bytes or write a single-link staging file.");
-        }
-        return stripPngMetadataChunks(stagedBytes);
+        if (staged.status === "refused")
+            throw new Error(`Browser screenshot did not return bytes, and ${refusalText("its staging file capture.png", staged)}.`);
+        return stripPngMetadataChunks(staged.bytes);
     }
     finally {
         await assertPreparedSelectedOutputDirectory(stagingRoot)

package/dist/analysis/analysis-limits.d.ts

@@ -0,0 +1,35 @@
+/**
+ * How much an analysis result may hold, for the fields the Observer checks as well. Characters are
+ * counted as `String.length` counts them.
+ */
+export declare const ANALYSIS_LIMITS: Readonly<{
+    /** A label: a finding's title and headline, a design finding's headline and screen, or a name. */
+    labelChars: 240;
+    experienceChars: 1200;
+    noticeChars: 1500;
+    whyItMattersChars: 1000;
+    suggestionChars: 1000;
+    /** Evidence one observation or design finding may cite. */
+    evidenceRefs: 100;
+    findings: 100;
+    designFindings: 40;
+    concernReviews: 60;
+}>;
+/** Whether text holds a control character other than tab, line feed and carriage return. */
+export declare function hasControlCharacter(text: string): boolean;
+/** The parts of an analysis result the revision boundaries read. */
+interface RevisionFields {
+    readonly concernReviews?: unknown;
+    readonly designFindings?: unknown;
+    readonly findings: ReadonlyArray<{
+        readonly headline?: unknown;
+        readonly experience?: unknown;
+    }>;
+}
+/**
+ * Whether a result carries every field its prompt revision requires: concern reviews from
+ * study-evidence-5, and headlines, experiences and design findings from study-evidence-7. A prompt
+ * version without a study-evidence revision number requires none of them.
+ */
+export declare function hasRevisionFields(promptVersion: string, result: RevisionFields): boolean;
+export {};

package/dist/analysis/analysis-limits.js

@@ -0,0 +1,41 @@
+// The analysis result's limits and prompt revision boundaries, kept apart from the zod schemas in
+// validation.ts so the Observer can read them: it bundles this module, and zod stays out of its
+// page.
+/**
+ * How much an analysis result may hold, for the fields the Observer checks as well. Characters are
+ * counted as `String.length` counts them.
+ */
+export const ANALYSIS_LIMITS = Object.freeze({
+    /** A label: a finding's title and headline, a design finding's headline and screen, or a name. */
+    labelChars: 240,
+    experienceChars: 1200,
+    noticeChars: 1500,
+    whyItMattersChars: 1000,
+    suggestionChars: 1000,
+    /** Evidence one observation or design finding may cite. */
+    evidenceRefs: 100,
+    findings: 100,
+    designFindings: 40,
+    concernReviews: 60,
+});
+/** Whether text holds a control character other than tab, line feed and carriage return. */
+export function hasControlCharacter(text) {
+    return /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(text);
+}
+// The prompt revision from which a result must carry each field. A boundary stays where it is when
+// the prompt version advances, so a later prompt cannot bring back a legacy omission.
+const CONCERN_REVIEWS_FROM = 5;
+const HEADLINES_AND_DESIGN_FINDINGS_FROM = 7;
+/**
+ * Whether a result carries every field its prompt revision requires: concern reviews from
+ * study-evidence-5, and headlines, experiences and design findings from study-evidence-7. A prompt
+ * version without a study-evidence revision number requires none of them.
+ */
+export function hasRevisionFields(promptVersion, result) {
+    const revision = Number(/^study-evidence-(\d+)$/.exec(promptVersion)?.[1] ?? 0);
+    if (revision >= CONCERN_REVIEWS_FROM && result.concernReviews === undefined)
+        return false;
+    return (revision < HEADLINES_AND_DESIGN_FINDINGS_FROM ||
+        (result.designFindings !== undefined &&
+            result.findings.every((finding) => finding.headline !== undefined && finding.experience !== undefined)));
+}

package/dist/analysis/validation.js

@@ -2,12 +2,13 @@ import { validStoredCodexAnalysisConfig } from "./codex-config.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ACTOR_STATUSES, ACTOR_STOP_CAUSES } from "../actors/contract.js";
+import { ANALYSIS_LIMITS, hasControlCharacter, hasRevisionFields } from "./analysis-limits.js";
 import { SHA256_HEX_PATTERN, ACTION_CAPTURE_VERSION, ANALYSIS_SCHEMA, ANALYSIS_CORRECTION_SCHEMA, } from "./types.js";
 const text = (max) => z
     .string()
     .max(max)
-    .refine((value) => !/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value), "Invalid text.");
-const label = text(240).min(1);
+    .refine((value) => !hasControlCharacter(value), "Invalid text.");
+const label = text(ANALYSIS_LIMITS.labelChars).min(1);
 const id = z
     .string()
     .min(1)
@@ -17,7 +18,7 @@ const sourceId = text(256).min(1);
 const digest = z.string().regex(SHA256_HEX_PATTERN);
 const timestamp = z.string().datetime({ offset: true });
 const sourceIds = z.array(sourceId).max(128);
-const refs = z.array(id).min(1).max(100);
+const refs = z.array(id).min(1).max(ANALYSIS_LIMITS.evidenceRefs);
 const limitations = z.array(text(2000).min(1)).max(100);
 const observationSchema = z
     .object({
@@ -32,9 +33,9 @@ const designFindingSchema = z
     id,
     headline: label,
     screen: label,
-    notice: text(1500).min(1),
-    whyItMatters: text(1000).min(1),
-    suggestion: text(1000).min(1),
+    notice: text(ANALYSIS_LIMITS.noticeChars).min(1),
+    whyItMatters: text(ANALYSIS_LIMITS.whyItMattersChars).min(1),
+    suggestion: text(ANALYSIS_LIMITS.suggestionChars).min(1),
     severity: z.enum(["minor", "moderate", "major"]),
     confidence: z.enum(["low", "medium", "high"]),
     seenByStreamIds: sourceIds.min(1),
@@ -66,7 +67,7 @@ const analysisResultSchema = z
         id,
         title: label,
         headline: label.optional(),
-        experience: text(1200).min(1).optional(),
+        experience: text(ANALYSIS_LIMITS.experienceChars).min(1).optional(),
         summary: text(4000).min(1),
         impact: z.enum(["blocked_task", "friction", "recovery", "uncertain"]),
         affectedStreamIds: sourceIds.min(1),
@@ -79,8 +80,8 @@ const analysisResultSchema = z
         priorityReason: text(2000).min(1),
     })
         .strict())
-        .max(100),
-    designFindings: z.array(designFindingSchema).max(40).optional(),
+        .max(ANALYSIS_LIMITS.findings),
+    designFindings: z.array(designFindingSchema).max(ANALYSIS_LIMITS.designFindings).optional(),
     concernReviews: z
         .array(observationSchema
         .extend({
@@ -89,7 +90,7 @@ const analysisResultSchema = z
         reason: text(2000).min(1),
     })
         .strict())
-        .max(60)
+        .max(ANALYSIS_LIMITS.concernReviews)
         .optional(),
     limitations,
 })
@@ -100,8 +101,8 @@ export const analysisResponseSchema = analysisResultSchema
     .extend({
     findings: z
         .array(analysisResultSchema.shape.findings.element.required({ headline: true, experience: true }))
-        .max(100),
-    designFindings: z.array(designFindingSchema).max(40),
+        .max(ANALYSIS_LIMITS.findings),
+    designFindings: z.array(designFindingSchema).max(ANALYSIS_LIMITS.designFindings),
 })
     .required({ concernReviews: true });
 export const analysisResultJsonSchema = z.toJSONSchema(analysisResponseSchema);
@@ -469,15 +470,7 @@ export function validateAnalysisArtifact(value) {
         (artifact.status === "complete" && !coverage.complete))
         throw new Error("ANALYSIS_STATUS_INVALID");
     if (artifact.result !== null) {
-        // Concern accounting became required with revision 5, and headlines, experiences and design
-        // findings with revision 7. Keep each boundary stable when the prompt version advances; a later
-        // prompt must not regain legacy omissions.
-        const revision = Number(/^study-evidence-(\d+)$/.exec(artifact.promptVersion)?.[1] ?? 0);
-        const result = artifact.result;
-        if ((revision >= 5 && result.concernReviews === undefined) ||
-            (revision >= 7 &&
-                (result.designFindings === undefined ||
-                    result.findings.some((finding) => finding.headline === undefined || finding.experience === undefined))))
+        if (!hasRevisionFields(artifact.promptVersion, artifact.result))
             throw new Error("ANALYSIS_RESULT_SCHEMA_INVALID");
         validateAnalysisResult({ ...artifact, images: [] }, artifact.result);
     }

package/dist/cli/commands/analyze.js

@@ -6,7 +6,8 @@ import { listAnalyses } from "../../analysis/store.js";
 import { listAnalysisExecutions } from "../../analysis/store-executions.js";
 import { resolveRunPath } from "../../run/locate.js";
 import { CWD_OPTION_DESCRIPTION, discoverCliKeys, JSON_OPTION_DESCRIPTION, RUN_OPTION_DESCRIPTION, writeResult, humanError, wantsJson, } from "../io.js";
-import { analysisFindings, formatFindings, missingRunFindings, readRunAnalysis, } from "../findings.js";
+import { analysisFindings, missingRunFindings, readRunAnalysis, } from "../findings.js";
+import { formatFindings } from "../findings-text.js";
 import { resolvePhysicalCwd } from "../../run/paths.js";
 /** Commander may collect a shared flag on the parent; only explicit values override leaf defaults. */
 function analysisSelection(options, command) {

package/dist/cli/commands/notes.js

@@ -2,9 +2,10 @@ import { renderObserver } from "../../observer/render.js";
 import { loadRunBundlePrepared, resolveRunPath } from "../../run/locate.js";
 import { readRunNotes } from "../../run/note-files.js";
 import { byRunTime } from "../../run/note-shape.js";
-import { addRunNote, formatRunTime } from "../../run/notes.js";
+import { addRunNote } from "../../run/notes.js";
 import { runParticipantCaptions, streamParticipantIdOf } from "../../run/participant-records.js";
 import { resolvePhysicalCwd, runIdOf } from "../../run/paths.js";
+import { formatRunTime } from "../../run/run-clock.js";
 import { runNotFoundMessage } from "../../run/run-not-found.js";
 import { cli } from "../invocation.js";
 import { CWD_OPTION_DESCRIPTION, humanError, JSON_OPTION_DESCRIPTION, writeResult, } from "../io.js";

package/dist/cli/commands/run-signals.js

@@ -134,7 +134,11 @@ async function stopActiveRuns(io, signal, stopping, options) {
     // not swept; verify grades a file that names a receipt's id local_only.
     Promise.all(stopping
         .filter((stop) => stop.report !== null)
-        .map((stop) => scrubRunSandboxIds(stop.run.paths).catch(() => undefined))));
+        .map((stop) => scrubRunSandboxIds(stop.run.paths).catch((error) => {
+        // A file the sweep refused to read may still name a sandbox; say which.
+        if (error instanceof Error)
+            say(io, `humanish: ${signal}: ${error.message}`);
+    }))));
     const finished = await withDeadline(work, deadlineMs, options.deadline);
     for (const stop of stopping) {
         if (stop.report === null)

package/dist/cli/commands/runs.js

@@ -11,7 +11,8 @@ import { addRunOptions, handleRun } from "./run-command.js";
 import { applyEnvFileOption, CWD_OPTION_DESCRIPTION, DOTENV_OPTION_DESCRIPTION, dotenvPathOf, envFileAliasOption, JSON_OPTION_DESCRIPTION, parsePositiveInteger, RUN_OPTION_DESCRIPTION, writeResult, humanError, } from "../io.js";
 import { plural } from "../../run/text.js";
 import { warnAndQueue } from "../deprecations.js";
-import { formatFindings, readRunFindings } from "../findings.js";
+import { readRunFindings } from "../findings.js";
+import { formatFindings } from "../findings-text.js";
 import { cli } from "../invocation.js";
 export function registerRunCommand(parent, io) {
     addRunOptions(parent

package/dist/cli/commands/setup.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { listUserKeys, resolveKeyName, setUserKey, unsetUserKey, userKeyStorePath, } from "../../keys/key-resolution.js";
+import { KEY_VENDORS, listUserKeys, resolveKeyName, setUserKey, unsetUserKey, userKeyStorePath, } from "../../keys/key-resolution.js";
 import { askForMissingKeys, formatKeyStatus, keyStatus, otherStoredKeys, } from "../../keys/key-status.js";
 import { promptSecret } from "../secret-prompt.js";
 import { runInit } from "../../study/init.js";
@@ -270,7 +270,7 @@ export function registerKeysCommand(parent, io) {
         .action(async (_options, command) => writeKeyStatus(command, io));
     keys
         .command("set")
-        .argument("[vendor-or-name]", "A vendor alias (openai, e2b, anthropic, github, agentmail) or a raw ENV_NAME. Without one, a terminal asks for each missing key in turn.")
+        .argument("[vendor-or-name]", `A vendor alias (${KEY_VENDORS.join(", ")}) or a raw ENV_NAME. Without one, a terminal asks for each missing key in turn.`)
         .description("Store one provider key in the user store (0600), prompted with hidden input. With no key named, ask for each missing key in turn.")
         .option("--stdin", "Read the value from stdin instead of prompting (for agents/pipes).")
         .option("--json", JSON_OPTION_DESCRIPTION)
@@ -288,7 +288,7 @@ export function registerKeysCommand(parent, io) {
                 action: "set",
                 store: storePath,
                 names: [],
-                message: `Not a vendor alias or valid env name: ${vendorOrName}. Vendors: openai, e2b, anthropic, github, agentmail.`,
+                message: `Not a vendor alias or valid env name: ${vendorOrName}. Vendors: ${KEY_VENDORS.join(", ")}.`,
             };
             writeResult(command, io, result, formatKeysHuman);
             io.setExitCode(2);

package/dist/cli/commands/study-format.d.ts

@@ -3,7 +3,10 @@ import type { CuaActorStudyResult } from "../../routes/computer-use/types.js";
 import type { ScriptedBrowserStudyResult } from "../../routes/scripted/types.js";
 import type { TerminalProductStudyResult } from "../../routes/terminal/types.js";
 import type { ConcurrentSharedWorldStudyResult } from "../../routes/shared-world/types.js";
+import type { StudySubject } from "../../study/types.js";
 export declare function formatConcurrentSharedWorldStudyHuman(result: ConcurrentSharedWorldStudyResult): HumanOutput;
 export declare function formatTerminalStudyHuman(result: TerminalProductStudyResult): HumanOutput;
-export declare function formatScriptedStudyHuman(result: ScriptedBrowserStudyResult): HumanOutput;
-export declare function formatCuaStudyHuman(result: CuaActorStudyResult): HumanOutput;
+/** `subject` is the study's declared subject, which names it when the result has no URL. */
+export declare function formatScriptedStudyHuman(result: ScriptedBrowserStudyResult, subject: StudySubject): HumanOutput;
+/** `subject` is the study's declared subject, which names it when the result has no URL. */
+export declare function formatCuaStudyHuman(result: CuaActorStudyResult, subject: StudySubject): HumanOutput;

package/dist/cli/commands/study-format.js

@@ -1,12 +1,18 @@
 import { participantCaption } from "../../run/participant-caption.js";
 import { formatCuaDiagnostics, formatCuaStopCause } from "../../routes/computer-use/diagnostics.js";
-/** A run's first lines: the command that ran, whether it was a dry run, how it ended, and its route. */
+/**
+ * A run's first lines: the command that ran, whether it was a dry run, how it ended, and its route.
+ * `runOk` is the run's own ok, which automaticAnalysisEnvelope keeps when an analysis that did not
+ * complete turns `ok` false. That run finished, and the line says so.
+ */
 function runHeader(result, route) {
     const kind = result.dryRun === true ? "dry run" : result.dryRun === false ? "live run" : "run";
-    return [
-        `humanish run ${result.studyId}: ${kind} ${result.ok ? "finished" : "failed"}`,
-        `route: ${route}`,
-    ];
+    const ending = result.ok
+        ? "finished"
+        : result.runOk === true
+            ? "finished; the analysis did not complete"
+            : "failed";
+    return [`humanish run ${result.studyId}: ${kind} ${ending}`, `route: ${route}`];
 }
 /**
  * A run's human output: its lines on stdout and, when it failed with an error, that error on
@@ -31,6 +37,18 @@ function sandboxIdsLine(result) {
         ? [`sandbox ids: .humanish/runs/${result.runId}/sandbox-receipts.ndjson`]
         : [];
 }
+/**
+ * How a run's output names its subject: by the URL its participants open. A product studied at a
+ * desktop has no URL, so it is named with its source, as in `humanish (desktop-cli)`. A refusal
+ * made before the route resolved a URL has none either, so it names the URL the study declares.
+ */
+function subjectName(appUrl, subject) {
+    if (appUrl !== "")
+        return appUrl;
+    if (subject.product !== undefined)
+        return `${subject.product.name} (${subject.source})`;
+    return subject.appUrl ?? subject.serve?.url ?? subject.source;
+}
 /** A participant's status in words: a dry run's placeholder status says that nothing ran live. */
 function participantStatus(status) {
     return status === "contract_proof_only" ? "dry run, nothing ran live" : status;
@@ -83,12 +101,13 @@ export function formatTerminalStudyHuman(result) {
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ]);
 }
-export function formatScriptedStudyHuman(result) {
+/** `subject` is the study's declared subject, which names it when the result has no URL. */
+export function formatScriptedStudyHuman(result, subject) {
     return withError(result.error, [
         ...runHeader(result, "scripted"),
         `run: ${result.runId}`,
         `actor: ${result.actor}`,
-        `subject: ${result.appUrl}`,
+        `subject: ${subjectName(result.appUrl, subject)}`,
         ...(result.scenario
             ? [
                 `scenario: ${result.scenario.id} @ ${result.scenario.sourceDigest.slice(0, 12)} (${result.scenario.source}, ${result.scenario.steps} step${result.scenario.steps === 1 ? "" : "s"})`,
@@ -108,12 +127,13 @@ export function formatScriptedStudyHuman(result) {
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ]);
 }
-export function formatCuaStudyHuman(result) {
+/** `subject` is the study's declared subject, which names it when the result has no URL. */
+export function formatCuaStudyHuman(result, subject) {
     return withError(result.error, [
         ...runHeader(result, "computer-use"),
         `run: ${result.runId}`,
         `actor: ${result.actor}`,
-        `subject: ${result.appUrl}`,
+        `subject: ${subjectName(result.appUrl, subject)}`,
         ...(result.subject?.source === "clone"
             ? [
                 `repo: ${result.subject.repo}${result.subject.commit ? `@${result.subject.commit.slice(0, 12)}` : ""}${result.subject.envNames && result.subject.envNames.length > 0 ? ` env=[${result.subject.envNames.join(", ")}]` : ""}`,