humanish 0.112.0 → 0.113.0

package/dist/actors/computer-use/openai-conversation.d.ts

@@ -1,6 +1,6 @@
 import type { CuaTurn, CuaTurnRequest } from "./loop.js";
 import type { ReasoningEffort } from "../reasoning-effort.js";
-import type { ActorConversation } from "../contract.js";
+import { type ActorConversation } from "../contract.js";
 import { type OpenAiReasoningSummary } from "./openai-wire.js";
 /** How a conversation starts. The model settings stay fixed for the whole session. */
 export interface OpenAiConversationSettings {
@@ -30,6 +30,11 @@ export interface ConversationRequest {
 }
 /** Which answer told the provider that the organization keeps no server-side conversation. */
 export type ZdrRejection = NonNullable<ActorConversation["rejection"]>;
+/**
+ * What a closing request asks for: the closing report after a harness-owned stop, or only
+ * impressions after the participant ended the session itself.
+ */
+export type ClosingRequest = "report" | "impressions";
 export declare class OpenAiConversation {
     private readonly settings;
     private lastResponseId;
@@ -46,9 +51,9 @@ export declare class OpenAiConversation {
     constructor(settings: OpenAiConversationSettings);
     /**
      * The next request, carrying `req`'s screen: the opening request, or the outputs the latest
-     * reply's computer calls are owed. A closing report asks for a strict JSON report and no tools.
+     * reply's computer calls are owed. A closing request asks for strict JSON and no tools.
      */
-    request(req: CuaTurnRequest, closing?: boolean): ConversationRequest;
+    request(req: CuaTurnRequest, closing?: ClosingRequest): ConversationRequest;
     /**
      * The organization rejected server-side state: carry the conversation on the client from the
      * request being sent, and record which answer made the switch. False when the conversation is
@@ -80,7 +85,7 @@ export declare class OpenAiConversation {
      * ahead of `sent`.
      */
     private turnBody;
-    /** The read-only closing report: no tools, a small output limit, a strict schema. */
+    /** A read-only closing request: no tools, its own output limit, a strict schema. */
     private closingBody;
     /**
      * Move the conversation on to a reply to a request that added `sent`. A participant reply cut

package/dist/actors/computer-use/openai-conversation.js

@@ -1,7 +1,51 @@
+import { PARTICIPANT_IMPRESSION_KINDS } from "../contract.js";
 import { CarriedConversation, estimateTokens } from "./openai-context.js";
 import { buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, openingMessage, parseOpenAiResponse, } from "./openai-wire.js";
-/** The closing report's output limit: its own cap, or the declared limit when that is lower. */
-const CLOSING_OUTPUT_LIMIT = 1024;
+/**
+ * The closing request's output limit: its own cap, or the declared limit when that is lower. It
+ * counts reasoning too, and leaves room for six impressions after the summary and friction reports.
+ */
+const CLOSING_OUTPUT_LIMIT = 3072;
+const IMPRESSIONS_SCHEMA = {
+    type: "array",
+    items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["kind", "text"],
+        properties: {
+            kind: { type: "string", enum: [...PARTICIPANT_IMPRESSION_KINDS] },
+            text: { type: "string" },
+        },
+    },
+};
+const CLOSING_FORMATS = {
+    report: {
+        type: "json_schema",
+        name: "participant_closing_report",
+        strict: true,
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["summary", "frictionReports", "impressions"],
+            properties: {
+                summary: { type: "string" },
+                frictionReports: { type: "array", items: { type: "string" } },
+                impressions: IMPRESSIONS_SCHEMA,
+            },
+        },
+    },
+    impressions: {
+        type: "json_schema",
+        name: "participant_impressions",
+        strict: true,
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["impressions"],
+            properties: { impressions: IMPRESSIONS_SCHEMA },
+        },
+    },
+};
 export class OpenAiConversation {
     settings;
     lastResponseId;
@@ -23,13 +67,13 @@ export class OpenAiConversation {
     }
     /**
      * The next request, carrying `req`'s screen: the opening request, or the outputs the latest
-     * reply's computer calls are owed. A closing report asks for a strict JSON report and no tools.
+     * reply's computer calls are owed. A closing request asks for strict JSON and no tools.
      */
-    request(req, closing = false) {
+    request(req, closing) {
         const sent = this.newItems(req);
         return {
-            body: () => (closing ? this.closingBody(req, sent) : this.turnBody(req, sent)),
-            accept: (reply) => this.accept(reply, closing, sent),
+            body: () => closing === undefined ? this.turnBody(req, sent) : this.closingBody(req, sent, closing),
+            accept: (reply) => this.accept(reply, closing !== undefined, sent),
         };
     }
     /**
@@ -110,28 +154,13 @@ export class OpenAiConversation {
             ...(this.mode === "explicit_context" ? { explicitContextItems: this.carried.carried() } : {}),
         });
     }
-    /** The read-only closing report: no tools, a small output limit, a strict schema. */
-    closingBody(req, sent) {
+    /** A read-only closing request: no tools, its own output limit, a strict schema. */
+    closingBody(req, sent, closing) {
         return {
             ...this.turnBody(req, sent),
             tool_choice: "none",
             max_output_tokens: Math.min(this.settings.maxOutputTokens ?? CLOSING_OUTPUT_LIMIT, CLOSING_OUTPUT_LIMIT),
-            text: {
-                format: {
-                    type: "json_schema",
-                    name: "participant_closing_report",
-                    strict: true,
-                    schema: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["summary", "frictionReports"],
-                        properties: {
-                            summary: { type: "string" },
-                            frictionReports: { type: "array", items: { type: "string" } },
-                        },
-                    },
-                },
-            },
+            text: { format: CLOSING_FORMATS[closing] },
         };
     }
     /**

package/dist/actors/computer-use/openai-provider.js

@@ -1,4 +1,4 @@
-import { validClosingReport } from "./loop.js";
+import { validClosingReport, validImpressionsReply } from "./loop.js";
 import { ComputerUseAdmissionLimitError, isComputerUseAdmissionLimitError, } from "./admission-limit.js";
 import { ComputerUsePromptRefusedError } from "./provider-error.js";
 import { OpenAiConversation, } from "./openai-conversation.js";
@@ -455,21 +455,24 @@ export function createOpenAiResponsesProvider(options) {
             }
         }
     };
-    const requestTurn = async (req, signal, closing = false, spend) => {
+    const requestTurn = async (req, signal, closing, spend) => {
         await capture.prepareNext();
         const request = conversation.request(req, closing);
-        // A closing report makes exactly one request: no HTTP or policy-latch retries.
-        const raw = closing
-            ? await post(request.body(), signal, 0, false)
-            : await postTurn(request, signal, spend);
+        // A closing request makes exactly one request: no HTTP or policy-latch retries.
+        const raw = closing === undefined
+            ? await postTurn(request, signal, spend)
+            : await post(request.body(), signal, 0, false);
         const turn = request.accept(raw);
-        if (closing) {
+        if (closing !== undefined) {
             // Refusals, incomplete output, malformed JSON, and invalid shapes remain no-report results.
             // Never promote raw JSON or a fallback paragraph into a structured finding.
             try {
-                const report = JSON.parse(turn.message ?? "");
-                if (asRecord(raw).status === "completed" && validClosingReport(report)) {
-                    return { ...turn, closingReport: report };
+                const reply = JSON.parse(turn.message ?? "");
+                if (asRecord(raw).status === "completed") {
+                    if (closing === "report" && validClosingReport(reply))
+                        return { ...turn, closingReport: reply };
+                    if (closing === "impressions" && validImpressionsReply(reply))
+                        return { ...turn, impressions: reply.impressions };
                 }
             }
             catch {
@@ -496,15 +499,18 @@ export function createOpenAiResponsesProvider(options) {
         get interactionUsageIncomplete() {
             return interactionUsageIncomplete;
         },
-        nextTurn: (req, signal, spend) => requestTurn(req, signal, false, spend),
+        nextTurn: (req, signal, spend) => requestTurn(req, signal, undefined, spend),
         get conversation() {
             return conversation.record();
         },
         // A retrospective report reads the session the server holds; see serverHoldsSession.
         get debrief() {
             return conversation.serverHoldsSession
-                ? (req, signal) => requestTurn(req, signal, true)
+                ? (req, signal) => requestTurn(req, signal, "report")
                 : undefined;
         },
+        // Offered in both modes. An explicit_context conversation carries its newest screens whole and
+        // earlier turns as text, which serves impressions; a closing report needs the whole session.
+        requestImpressions: (req, signal) => requestTurn(req, signal, "impressions"),
     };
 }

package/dist/actors/contract.d.ts

@@ -186,7 +186,37 @@ export declare function validActorProviderRequests(value: unknown): value is Act
 export interface ParticipantClosingReport {
     summary: string;
     frictionReports: string[];
+    /** Absent when the provider did not ask for impressions; empty when the participant had none. */
+    impressions?: ParticipantImpression[];
 }
+/**
+ * What a participant can say about the product at the end of a session, beyond friction.
+ * `unlike_my_work` compares the screen with how the persona does the same task in its own work or
+ * life.
+ */
+export declare const PARTICIPANT_IMPRESSION_KINDS: readonly ["unclear", "unfinished", "untrustworthy", "liked", "missing", "unlike_my_work"];
+type ParticipantImpressionKind = (typeof PARTICIPANT_IMPRESSION_KINDS)[number];
+/** One first-person impression about something the participant saw in the session. */
+export interface ParticipantImpression {
+    kind: ParticipantImpressionKind;
+    text: string;
+}
+/** An impression as the trace keeps it, with the message that quotes it. */
+interface RecordedImpression extends ParticipantImpression {
+    /** The trace message carrying the impression, which the analysis quotes and cites. */
+    messageId: string;
+}
+/**
+ * The impressions a session collected, or why it collected none. An empty `items` list means the
+ * participant had none to give.
+ */
+export type ParticipantImpressions = {
+    status: "collected";
+    items: RecordedImpression[];
+} | {
+    status: "not_collected";
+    reason: string;
+};
 /** Runtime declarations and executable-version observations; not provider request attestation. */
 export interface ActorRuntimeProvenance {
     schema: "humanish.actor-runtime.v1";
@@ -315,17 +345,27 @@ export interface ActorTrace {
      * each fixed a false refusal and each left the next shape unhandled.
      */
     declaredOutcome?: ParticipantDeclaredOutcome;
-    /** Closing report after a harness-owned stop. Does not change task outcomes or permit actions. */
+    /**
+     * The read-only closing request: a closing report after a harness-owned stop (`stop_when`,
+     * `dwell`), or impressions only after the participant ended the session itself
+     * (`participant_end`, never with `report`). Does not change task outcomes or permit actions.
+     */
     debrief?: {
-        trigger: "stop_when" | "dwell";
+        trigger: "stop_when" | "dwell" | "participant_end";
         status: "completed" | "skipped" | "failed";
         reason: string;
         /** Absent if no request was made; false means token accounting is incomplete. */
         usageReported?: boolean;
-        report?: ParticipantClosingReport;
+        /** The report's impressions are kept in `impressions`, with the messages that quote them. */
+        report?: Omit<ParticipantClosingReport, "impressions">;
         /** Links the readable projection so it is not heuristically classified a second time. */
         messageId?: string;
     };
+    /**
+     * What the participant said about the product at the end of a computer-use session, or why
+     * nothing was collected. Absent on other routes and on older traces.
+     */
+    impressions?: ParticipantImpressions;
     items: ActorTraceItem[];
     tokenUsage?: ActorTokenUsage;
     /** A stalled or adapter-reported ambiguous interaction may have additional unreported usage.

package/dist/actors/contract.js

@@ -168,6 +168,19 @@ export function validActorProviderRequests(value) {
                     usage.input));
     });
 }
+/**
+ * What a participant can say about the product at the end of a session, beyond friction.
+ * `unlike_my_work` compares the screen with how the persona does the same task in its own work or
+ * life.
+ */
+export const PARTICIPANT_IMPRESSION_KINDS = [
+    "unclear",
+    "unfinished",
+    "untrustworthy",
+    "liked",
+    "missing",
+    "unlike_my_work",
+];
 export const CODEX_APP_SERVER_CAPABILITIES = {
     headless: true,
     structuredTrace: true,

package/dist/analysis/evidence-sources.d.ts

@@ -20,4 +20,6 @@ export interface SourceEntry {
 export declare function sourceEntries(bundle: RunBundle, stream: RunStream, captureVersion?: CaptureVersion): SourceEntry[];
 /** Max-min allocation; stable ID order breaks a remainder tie by at most one slot. */
 export declare function fairShares(budget: number, capacities: number[]): number[];
-export declare function sourceOrder(entries: SourceEntry[], capturesOnly: boolean): SourceEntry[];
+/** The trace messages that carry a participant's closing impressions. */
+export declare function impressionEventIds(stream: RunStream): ReadonlySet<string>;
+export declare function sourceOrder(entries: SourceEntry[], capturesOnly: boolean, impressions?: ReadonlySet<string>): SourceEntry[];

package/dist/analysis/evidence-sources.js

@@ -204,7 +204,12 @@ function spreadOrder(entries) {
     }
     return result;
 }
-export function sourceOrder(entries, capturesOnly) {
+/** The trace messages that carry a participant's closing impressions. */
+export function impressionEventIds(stream) {
+    const impressions = stream.actor?.impressions;
+    return new Set(impressions?.status === "collected" ? impressions.items.map((item) => item.messageId) : []);
+}
+export function sourceOrder(entries, capturesOnly, impressions = new Set()) {
     const candidates = capturesOnly ? entries.filter((entry) => entry.capturePath !== null) : entries;
     const ordered = new Set();
     const admit = (entry) => {
@@ -214,6 +219,10 @@ export function sourceOrder(entries, capturesOnly) {
     // Actor endings precede appended run bookkeeping when text slots are scarce.
     if (!capturesOnly)
         admit(entries.findLast((entry) => !entry.kind.startsWith("run_event:")));
+    // The participant's closing impressions are its only opinions of the product; keep them all.
+    for (const entry of entries)
+        if (impressions.has(entry.eventId))
+            admit(entry);
     admit(candidates.at(-1));
     admit(candidates[0]);
     const afterCapture = [];

package/dist/analysis/evidence.js

@@ -6,7 +6,7 @@ import { isRecord } from "../run/type-guards.js";
 import { RUN_BUNDLE_FILE } from "../run/bundle.js";
 import { ACTION_CAPTURE_VERSION, } from "./types.js";
 import { digestAnalysisInput, hashAnalysisValue, validateAnalysisInputMetadata, } from "./validation.js";
-import { boundedText, fairShares, hasUnmappedCaptures, participantAssignment, participantSource, sourceEntries, sourceOrder, } from "./evidence-sources.js";
+import { boundedText, fairShares, hasUnmappedCaptures, participantAssignment, participantSource, sourceEntries, sourceOrder, impressionEventIds, } from "./evidence-sources.js";
 import { readBoundedFile, readBoundedFileResult } from "../run/evidence-files.js";
 export const EVIDENCE_LIMITS = Object.freeze({
     participants: 16,
@@ -312,7 +312,7 @@ function recordCaptureOmissions(packings, sel, omissions) {
             omissions.add("Some declared captures have no normalized trace reference.");
         for (const source of packing.captures.keys())
             packing.admitted.add(source);
-        for (const source of sourceOrder(packing.entries, false)) {
+        for (const source of sourceOrder(packing.entries, false, impressionEventIds(packing.stream))) {
             if (packing.admitted.size >= sel.evidenceShares[index])
                 break;
             packing.admitted.add(source);

package/dist/analysis/execute.d.ts

@@ -1,7 +1,7 @@
 import { type AnalysisArtifact, type AnalysisConfig, type AnalysisInput } from "./types.js";
 import { type AnalysisFetch, type AnalysisProvider } from "./provider.js";
 import type { RejectedAnalysisOutput } from "./diagnostics.js";
-export declare const ANALYSIS_PROMPT_VERSION = "study-evidence-7";
+export declare const ANALYSIS_PROMPT_VERSION = "study-evidence-8";
 export declare const isSupportedAnalysisModel: (model: string) => boolean;
 /** The OpenAI output limit when a study omits maxOutputTokens, and the most it may ask for. */
 export declare const DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS = 16384;

package/dist/analysis/execute.js

@@ -10,7 +10,7 @@ import { checkAnalysisResult, hashAnalysisValue, analysisResponseSchema, analysi
 import { EVIDENCE_LIMITS } from "./evidence.js";
 import { truncatedFrameWarning, unknownNotificationsWarning, } from "../actors/codex/restricted-notifications.js";
 import { protocolAdditionsWarning, protocolIncompatibilityMessage, } from "../actors/codex/protocol-compat.js";
-export const ANALYSIS_PROMPT_VERSION = "study-evidence-7";
+export const ANALYSIS_PROMPT_VERSION = "study-evidence-8";
 const SUPPORTED_ANALYSIS_MODELS = Object.freeze([
     "gpt-6-astra",
     "gpt-5.5",
@@ -61,6 +61,8 @@ Write for the person who will act on the report: a designer, product manager or
 
 Separately, review the supplied captures as an experienced product designer would and report designFindings: problems a designer would notice in what the screens show, whether or not any participant mentioned them. Look at the size of text and controls (too small to read or to hit comfortably at this window size), layout and density (spread too wide or packed too tight for the task), visual hierarchy, legibility and contrast, wording and labels, consistency between screens, feedback after actions, and anything that makes the product look unfinished or untrustworthy. Judge the screens as the participants' personas would meet them: who they are and what they came to do. Each design finding names the screen in plain words, says what a designer notices, why it matters to a person using the product, and one concrete suggestion. Each must cite at least one supplied capture that shows the problem, and seenByStreamIds lists only participants whose cited captures show it. Rate severity by the effect on a person using the product: major when it misleads or blocks, moderate when it slows or confuses, minor when it is polish. Report only what the captures show; no capture, no design finding. Use D1, D2, and so on as IDs. An empty designFindings array is correct when the captures show no design problem worth a designer's time. Write design findings in the same plain register as headlines.
 
+Messages that begin "Impression (kind):" are a participant's closing impressions of the product, where kind is unclear, unfinished, untrustworthy, liked, missing or unlike my work. They are that participant's own opinions: use them as participant statements and quote the words after the label. An unlike my work impression says where the screen differs from how the persona does the same task in its own work or life; with a capture of that screen it is a strong design finding, which cites both. Without such a capture, an impression supports only a finding about what the participant said.
+
 Order findings by observed task impact, replication among exposed participants, and recovery. Preserve severity and confidence as separate fields. Do not compute a numeric frustration score or universal priority score. Use F1, F2, and so on as local finding IDs. Explain ordering with concrete evidence. Provide a short, testable next check for each finding. Say when recovery was not observed rather than claiming it was impossible. Keep titles and summaries concise and specific. The overall summary must be grounded in participant reviews and observations, including successful outcomes and evidence limits.`;
 function instructions(config) {
     return `${INSTRUCTIONS}\n\nResearcher question (null means use the standard review): ${JSON.stringify(config.question)}`;

package/dist/cli/commands/runs.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { Command, Option } from "commander";
+import { Command, InvalidArgumentError, Option } from "commander";
 import { shellArg } from "../../substrates/shell.js";
 import { computeStats, formatStatsHuman } from "../../run/stats.js";
 import { DEFAULT_EXPORT_MAX_BYTES, exportRun, formatExportHuman } from "../../feedback/export.js";
@@ -8,7 +8,7 @@ import { verifyRun } from "../../verify/verify.js";
 import { reclaimPreflightSandboxes, reclaimRunSandboxes, } from "../../run/reclaim.js";
 import { runDisplay } from "../../run/display.js";
 import { addRunOptions, handleRun } from "./run-command.js";
-import { applyEnvFileOption, CWD_OPTION_DESCRIPTION, DOTENV_OPTION_DESCRIPTION, dotenvPathOf, envFileAliasOption, JSON_OPTION_DESCRIPTION, RUN_OPTION_DESCRIPTION, writeResult, humanError, } from "../io.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";
@@ -136,29 +136,52 @@ export function registerRunsCommand(parent, io) {
         io.setExitCode(result.ok ? 0 : 2);
     });
 }
+/** A whole number of GiB or CPUs above zero, for `runtime setup --memory` and `--cpus`. */
+function wholeNumber(flag) {
+    return (value) => {
+        const parsed = parsePositiveInteger(value);
+        if (parsed === null)
+            throw new InvalidArgumentError(`${flag} takes a whole number above zero, such as 8.`);
+        return parsed;
+    };
+}
 export function registerRuntimeCommands(parent, io) {
     const runtime = parent
         .command("runtime")
         .description("Prepare or inspect the local browser runtime.");
     for (const action of ["status", "setup"]) {
-        runtime
+        const command = runtime
             .command(action)
             .description(action === "status"
-            ? "Check local Docker, virtualization and the cached browser image without downloads."
+            ? "Check local Docker, virtualization and the cached browser image without downloads, and how many participant desktops fit."
             : "Download and install the local browser image. Does not start a study or use model quota.")
             .option("--json", JSON_OPTION_DESCRIPTION)
-            .option("--media", "Prepare or inspect the optional camera and speech runtime.")
-            .action(async (_options, command) => {
+            .option("--media", "Prepare or inspect the optional camera and speech runtime.");
+        if (action === "setup")
+            command
+                .option("--memory <GiB>", "Mac only: the humanish Lima VM's memory. Resizes an existing VM, which stops it first.", wholeNumber("--memory"))
+                .option("--cpus <n>", "Mac only: the humanish Lima VM's CPUs. Resizes an existing VM, which stops it first.", wholeNumber("--cpus"));
+        command.action(async (options, command) => {
             const { localRuntimeStatus, prepareLocalRuntime } = await import("../../substrates/local/runtime.js");
+            const { describeCapacity } = await import("../../substrates/local/capacity.js");
+            const media = options.media === true;
             try {
-                if (action === "setup")
+                if (action === "setup") {
+                    const size = {
+                        ...(options.memory === undefined ? {} : { memoryGiB: options.memory }),
+                        ...(options.cpus === undefined ? {} : { cpus: options.cpus }),
+                    };
                     await prepareLocalRuntime({
-                        media: _options.media === true,
+                        media,
+                        ...(Object.keys(size).length === 0 ? {} : { size }),
                         progress: (message) => io.writeErr(`${message}\n`),
                     });
-                const status = await localRuntimeStatus({ media: _options.media === true });
+                }
+                const status = await localRuntimeStatus({ media });
                 const result = { schema: "humanish.runtime-result.v1", ...status };
-                writeResult(command, io, result, () => `${status.message}\n`);
+                writeResult(command, io, result, () => [status.message, ...(status.capacity ? [describeCapacity(status.capacity)] : [])]
+                    .map((line) => `${line}\n`)
+                    .join(""));
                 io.setExitCode(status.ok ? 0 : 2);
             }
             catch (error) {

package/dist/cli/commands/setup.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { 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";
 import { buildPayload, disabledByEnvironment, readTelemetryState, telemetryStatePath, writeTelemetryState, } from "../telemetry.js";
@@ -177,20 +178,107 @@ async function readSecretValue(useStdin, promptLabel) {
         const text = Buffer.concat(chunks).toString("utf8").trim();
         return text.length > 0 ? text : null;
     }
-    return promptSecret(promptLabel, process.stdin, process.stderr);
+    // An empty line is no value here: only the walk over missing keys reads it as "skip".
+    return (await promptSecret(promptLabel, process.stdin, process.stderr)) || null;
+}
+/** `humanish keys` and `humanish keys status`: each provider key's source, never a value. */
+async function writeKeyStatus(command, io) {
+    const rows = await keyStatus({ cwd: process.cwd(), env: process.env });
+    const others = otherStoredKeys(process.env);
+    const missing = rows.filter((row) => row.source === null).length;
+    const result = {
+        schema: KEYS_RESULT_SCHEMA,
+        ok: true,
+        action: "status",
+        store: userKeyStorePath(process.env),
+        names: rows.filter((row) => row.source !== null).map((row) => row.name),
+        keys: rows.map(({ name, use, source, hint }) => ({
+            name,
+            use,
+            source,
+            ...(source === null ? { hint } : {}),
+        })),
+        ...(others.length > 0 ? { otherStored: others } : {}),
+        message: missing === 0
+            ? "Every provider key is set."
+            : `${plural(missing, "provider key")} ${missing === 1 ? "is" : "are"} missing.`,
+    };
+    writeResult(command, io, result, () => formatKeyStatus(rows, others));
+    io.setExitCode(0);
+}
+/** "A", "A and B", "A, B and C". */
+function listNames(names) {
+    return names.length < 2 ? names.join("") : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+}
+/**
+ * `humanish keys set` with no key named. On a terminal it asks for each missing provider key in
+ * turn; without one there is no one to ask, so it refuses and names the --stdin form.
+ */
+async function setMissingKeys(command, io, useStdin) {
+    const store = userKeyStorePath(process.env);
+    const finish = (ok, names, message) => {
+        const result = {
+            schema: KEYS_RESULT_SCHEMA,
+            ok,
+            action: "set",
+            store,
+            names,
+            message,
+        };
+        writeResult(command, io, result, formatKeysHuman);
+        io.setExitCode(ok ? 0 : 2);
+    };
+    if (useStdin || process.stdin.isTTY !== true || process.stderr.isTTY !== true) {
+        finish(false, [], `missing required argument 'vendor-or-name'. Without a terminal humanish cannot ask for each key, so name the key and pipe its value, for example: printf '%s' "$E2B_API_KEY" | ${cli("keys set e2b --stdin")}`);
+        return;
+    }
+    const rows = await keyStatus({ cwd: process.cwd(), env: process.env });
+    const missing = rows.filter((row) => row.source === null).length;
+    if (missing === 0) {
+        finish(true, [], `Every provider key is already set, so there is nothing to ask for. Replace one with \`${cli("keys set <vendor>")}\`.`);
+        return;
+    }
+    io.writeErr(`${plural(missing, "provider key")} ${missing === 1 ? "is" : "are"} missing. Paste each one when asked, or press Enter to skip it.\n`);
+    const outcome = await askForMissingKeys({
+        rows,
+        env: process.env,
+        prompt: (label) => promptSecret(label, process.stdin, process.stderr),
+    });
+    const sentences = [
+        outcome.stored.length > 0
+            ? `Stored ${listNames(outcome.stored)} (0600).`
+            : "Nothing was stored.",
+        ...(outcome.skipped.length > 0 ? [`Skipped ${listNames(outcome.skipped)}.`] : []),
+        ...(outcome.rejected ?? []).map((entry) => `${entry.name} was not stored: ${entry.message}`),
+        ...(outcome.stoppedAt === undefined
+            ? []
+            : [`Stopped at ${outcome.stoppedAt}; the keys after it were not asked for.`]),
+        `\`${cli("keys")}\` shows where each key comes from.`,
+    ];
+    // A cancel is the person's choice, so only a value the store refused fails the command.
+    finish(outcome.rejected === undefined, outcome.stored, sentences.join(" "));
 }
 export function registerKeysCommand(parent, io) {
     const keys = parent
         .command("keys")
-        .description("Manage the humanish user-level key store used by provider-key discovery.")
-        .summary("Store and manage your provider keys.");
+        .description("Show which provider keys are set and where each comes from, and manage the humanish user key store that provider-key discovery reads.")
+        .summary("Check and store your provider keys.");
+    keys
+        .command("status", { isDefault: true })
+        .description("Show each provider key humanish uses: where it comes from, or the command that adds it. Values are never printed.")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .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.")
-        .description("Store one provider key in the user store (0600), prompted with hidden input.")
+        .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.")
+        .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)
         .action(async (vendorOrName, options, command) => {
+        if (vendorOrName === undefined) {
+            await setMissingKeys(command, io, options.stdin === true);
+            return;
+        }
         const name = resolveKeyName(vendorOrName);
         const storePath = userKeyStorePath(process.env);
         if (name === null) {
@@ -294,11 +382,12 @@ export function registerKeysCommand(parent, io) {
 function formatDoctorHuman(result) {
     return ([
         `humanish doctor ${result.ok ? "ok" : "needs setup"}`,
+        ...(result.next === undefined ? [] : [`next: ${result.next}`]),
         `cwd: ${result.cwd}`,
         // "missing" is a verdict, and a row that never ran has none. A participant reading doctor on a
         // fresh desktop got `- missing package.json: package.json is present and safe to read`, which
         // contradicts itself in eleven words (labs/tui-self-study.yaml).
-        ...result.checks.map((check) => `- ${check.status.replace("_", " ")} ${check.name}: ${check.message}`),
+        ...result.checks.map((check) => `- ${check.status.replace("_", " ")} ${check.name}: ${check.message.replaceAll("\n", "\n    ")}`),
     ].join("\n") + "\n");
 }
 function formatInitHuman(result) {

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

@@ -1,3 +1,4 @@
+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. */
 function runHeader(result, route) {
@@ -39,17 +40,19 @@ export function formatConcurrentSharedWorldStudyHuman(result) {
         ...runHeader(result, "shared-world"),
         `run: ${result.runId}`,
         `actor: ${result.actor}`,
-        `topology: ${result.topology}/${result.topologyMode} (${result.roleCount} persona${result.roleCount === 1 ? "" : "s"}, concurrency ${result.concurrency})`,
+        `participants: ${result.roleCount}, up to ${result.concurrency} at once`,
         ...(result.host ? [`host: ${result.host}`] : []),
         ...(result.subject?.commit
-            ? [`plane: ${result.subject.repo}@${result.subject.commit.slice(0, 12)}`]
+            ? [`app: ${result.subject.repo}@${result.subject.commit.slice(0, 12)}`]
             : []),
         ...(result.overlapProven === undefined
             ? []
             : [
-                `overlap: ${result.overlapProven ? "proven" : "not observed"} (this run only; no scale or adoption claim)`,
+                result.overlapProven
+                    ? "Participants used the app at the same time (observed in this run only)."
+                    : "Participants were not observed using the app at the same time.",
             ]),
-        ...result.roles.map((participant) => `persona ${participant.id} (${participant.persona}): ${participantStatus(participant.status)}${participant.session ? ` (${participant.session.completionReason})` : ""}${participant.ok ? "" : ", not ok"}`),
+        ...result.roles.map((participant) => `${participantCaption({ id: participant.id, personaId: participant.persona })}: ${participantStatus(participant.status)}${participant.ok ? "" : ", not ok"}`),
         ...(result.subjectSandbox
             ? [
                 `subject sandbox: ${sandboxName(result.subjectSandbox)} killed=${result.subjectSandbox.killed ? "yes" : "no"}`,

package/dist/cli/commands/study.js

@@ -140,7 +140,7 @@ function formatStudyCheckHuman(result) {
         ...(result.sandbox.created
             ? [`sandbox: created=yes killed=${result.sandbox.killed === true ? "yes" : "no"}`]
             : []),
-        ...result.checks.map((check) => `- ${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`),
+        ...result.checks.map((check) => `- ${check.checked === false ? "not checked" : check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`),
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ].join("\n") + "\n";
     return result.error === undefined ? stdout : { stdout, error: result.error };

package/dist/cli/commands/tui.js

@@ -278,7 +278,7 @@ async function storeAgentmailKey(session) {
     const { cwd, runtime, sessionEnv } = session;
     // startTui has unmounted: only the host reads the credential, then remounts the view.
     const value = await runtime.promptSecret("AgentMail API key", runtime.stdin, runtime.stdout);
-    if (value === null)
+    if (value === null || value === "")
         return "Key entry cancelled. Nothing was changed.";
     try {
         setUserKey("AGENTMAIL_API_KEY", value, sessionEnv);