humanish 0.110.0 → 0.110.1

package/dist/routes/computer-use/bundle.js

@@ -3,6 +3,7 @@
 // shape's arguments. renderCuaReviewMarkdown writes review.md. shared-world/bundle.ts holds the
 // same for that route.
 import { judgeOneParticipant, judgeParticipants, verdictText, } from "../../run/judge.js";
+import { reviewOutcome } from "../../run/display.js";
 import { desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { e2bDesktopTemplate } from "../../substrates/e2b/sandbox.js";
 import { providerResourcesForOutcome } from "./bundle-parts.js";
@@ -158,7 +159,8 @@ export function renderCuaReviewMarkdown(bundle) {
         "",
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
-        `- run gate: ${verdictText(bundle.review.verdict, bundle.mode)}`,
+        `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
+        `- outcome: ${reviewOutcome(bundle)}`,
         `- summary: ${bundle.review.summary}`,
         ...(provenance ? [`- subject: ${provenance.message}`] : []),
         ...(trace

package/dist/routes/computer-use/fanout-records.js

@@ -269,7 +269,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
             at: args.run.createdAt,
             level: "info",
             type: "cua-lab.contract.ready",
-            message: `Participant ${spec.planned.id}: dry-run participant ready; switch scenario.mode to live for a real desktop session.`,
+            message: `Participant ${spec.planned.id}: dry-run participant ready; switch mode to live for a real desktop session.`,
         });
     }
     for (const warning of desktopGeometry.warnings ?? []) {

package/dist/routes/computer-use/participant-execution.js

@@ -90,7 +90,9 @@ export async function runCuaParticipant(spec, deps) {
         if (closed.refusal !== undefined)
             providerPolicyError = redactText(deps.scrubKnownValues(closed.refusal === "codex_tool_call"
                 ? `Codex reported a disallowed item after the participant's last request (${closed.refusal}).`
-                : `Codex output after the participant's last request could not be checked against the item policy (${closed.refusal}).`));
+                : closed.refusal.startsWith("HUMANISH_CLAUDE_PARTICIPANT_")
+                    ? `Claude Code's stream showed a call the participant may not make after its last turn (${closed.refusal}); the participant was stopped.`
+                    : `Codex output after the participant's last request could not be checked against the item policy (${closed.refusal}).`));
         try {
             if (!provisioned)
                 signal(false);

package/dist/routes/computer-use/participant-model.js

@@ -66,10 +66,12 @@ export async function startParticipantModel(spec, deps, executor) {
                         ? {}
                         : { reasoningEffort: spec.planned.limits.reasoningEffort }),
                     ...(brain.declaredModel === undefined ? {} : { model: brain.declaredModel }),
+                    env,
                 }),
             };
         }
         const claudeSession = await startClaudeSession({
+            env,
             ...(spec.planned.limits.reasoningEffort === undefined
                 ? {}
                 : { reasoningEffort: spec.planned.limits.reasoningEffort }),
@@ -139,7 +141,7 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
                     const estimate = estimateActorCostForExecution(usage, provider?.version ?? capModelId, provider?.executionProfile).estimatedCostUsd;
                     const totalUsd = deps.runBudget.note(spec.planned.id, estimate);
                     return totalUsd > deps.runBudget.maxTotalUsd
-                        ? `study budget reached: the run's estimated model spend $${round6(totalUsd)} crossed execution.caps.maxTotalUsd=$${deps.runBudget.maxTotalUsd}; this lane stops here and sibling lanes stop at their next turn`
+                        ? `study budget reached: the run's estimated model spend $${round6(totalUsd)} crossed caps.maxTotalUsd=$${deps.runBudget.maxTotalUsd}; this lane stops here and sibling lanes stop at their next turn`
                         : null;
                 },
             }),
@@ -198,7 +200,8 @@ export async function closeParticipantModel(model, warnings) {
         }
     }
     try {
-        await model.claudeSession?.close();
+        const closed = await model.claudeSession?.close();
+        refusal ??= closed?.refusal;
     }
     catch {
         warnings.push("Claude session cleanup failed; desktop cleanup will still run.");

package/dist/routes/computer-use/plan.js

@@ -148,8 +148,8 @@ function entryTargetReason(config, subjectRoute) {
     return {
         code: "HUMANISH_COMPUTER_USE_SUBJECT_UNSAFE",
         message: provisionedRoute || localAppSubject || !allowPublicTargets
-            ? "subject.appUrl and any actors[0].lanes[].target entries must be loopback (127.0.0.1 or localhost) unless policies.allowPublicTargets is set for an app-url subject."
-            : "subject.appUrl and actors[0].lanes[].target entries must be valid http(s) URLs.",
+            ? "subject.appUrl and any participants[].target entries must be loopback (127.0.0.1 or localhost) unless policies.allowPublicTargets is set for an app-url subject."
+            : "subject.appUrl and participants[].target entries must be valid http(s) URLs.",
     };
 }
 /** Something to drive the subject: the caller's executor with its provider. */
@@ -218,7 +218,7 @@ export function planComputerUseStudy(config, input) {
     const actorType = config.actors[0]?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
-        return refuse("in-scope", "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered computer-use actor.`);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered computer-use actor.`);
     const actor = descriptor.id;
     const rejection = cuaStudyRejection(config, hasRunSession, driving, declaredSubjectRoute(config, driving));
     if (rejection)
@@ -227,7 +227,7 @@ export function planComputerUseStudy(config, input) {
     // participants. It comes after the rules above, so a shared-world config that breaks one of them,
     // which runStudyWith sends here, still gets that rule's message.
     if (config.subject.topology === "shared-world")
-        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "subject.topology: shared-world studies run every participant against one shared app on the shared-world route; this route runs independent participants. Run the study with runStudy or runConcurrentSharedWorld.", actor);
+        return refuse("in-scope", "HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "route: shared-world studies run every participant against one shared app on the shared-world route; this route runs independent participants. Run the study with runStudy or runConcurrentSharedWorld.", actor);
     // The in-process route drives subject.appUrl on this machine and creates no desktop, so it would
     // skip the subject a clone, local-tree or desktop-cli study declares.
     const source = config.subject.source;

package/dist/routes/computer-use/preflight.js

@@ -35,7 +35,7 @@ export async function liveCuaRejection(args) {
                 return ready.length === 0
                     ? ""
                     : ` ${ready.map((agent) => agent.label).join(" and ")} reports authenticated on this machine` +
-                        `. Set actors[0].type: local-agent to use ${ready.length === 1 ? "it" : "one"} instead of a key.`;
+                        `. Set actor.type: local-agent to use ${ready.length === 1 ? "it" : "one"} instead of a key.`;
             })()
             : "";
         return {

package/dist/routes/computer-use/result.js

@@ -64,12 +64,7 @@ function cuaStudyResult(args) {
     // engaged session.
     const participantOk = (outcome) => participantOutcomeOk(outcome, dryRun);
     const adapterFailure = adapterScoreFailureMessage(bundle);
-    const ok = resultOk({
-        judgment: args.judgment,
-        execution: args.execution,
-        scorerFailures: args.scorerFailures,
-        policy: OUTCOME_POLICIES["computer-use"],
-    });
+    const { ok } = args.outcome;
     const participantWarnings = (outcomes ?? []).flatMap((outcome) => outcome.warnings);
     const warnings = [
         ...receivingWarnings,
@@ -115,7 +110,7 @@ function cuaStudyResult(args) {
         return {
             code,
             message: observer.ok
-                ? `Fan-out run failed: ${summary.passed}/${plural(participantCount, "participant")} passed (${summary.skipped} skipped, ${plural(summary.harnessErrors, "harness error")}, ${summary.hollow} without engagement)${failing?.sessionError !== undefined ? `; first failure: ${failing.sessionError}` : failing === undefined && args.execution.failures[0] !== undefined ? `; ${args.execution.failures[0].message}` : ""}.`
+                ? `Fan-out run failed: ${summary.passed}/${plural(participantCount, "participant")} passed (${summary.skipped} skipped, ${plural(summary.harnessErrors, "harness error")}, ${summary.hollow} without engagement)${failing?.sessionError !== undefined ? `; first failure: ${failing.sessionError}` : failing === undefined && args.outcome.execution.failures[0] !== undefined ? `; ${args.outcome.execution.failures[0].message}` : ""}.`
                 : (observer.error?.message ?? "Observer failed for the computer-use fan-out run."),
         };
     })();
@@ -165,11 +160,12 @@ function cuaStudyResult(args) {
     };
 }
 /**
- * The run's execution failures: each participant whose session failed in the harness, each provider whose
- * cleanup is unconfirmed or that reported a disallowed item after its last request, each sandbox
- * whose release is unconfirmed, and an Observer that failed.
+ * The run's execution failures before the Observer renders: each participant whose session failed
+ * in the harness, each provider whose cleanup is unconfirmed or that reported a disallowed item
+ * after its last request, and each sandbox whose release is unconfirmed. FinishedRun.renderObserver
+ * adds an Observer that did not render.
  */
-function computerUseExecutionFailures(outcomes, observer, runId) {
+function computerUseExecutionFailures(outcomes, runId) {
     return [
         ...(outcomes ?? [])
             .filter((outcome) => participantHarnessFailed(participantFactsOf(outcome)))
@@ -194,14 +190,6 @@ function computerUseExecutionFailures(outcomes, observer, runId) {
                 },
             ]),
         ...unreleasedSandboxFailures(outcomes, runId),
-        ...(observer.ok
-            ? []
-            : [
-                {
-                    kind: "evidence",
-                    message: observer.error?.message ?? "Observer failed for the computer-use run.",
-                },
-            ]),
     ];
 }
 /**
@@ -215,7 +203,7 @@ function participantCapWarning(caps, participantCount) {
         return undefined;
     if (caps.maxTotalUsd !== undefined)
         return undefined;
-    return `execution.caps.maxUsd ($${capUsd}) caps each participant, so ${participantCount} participants may spend up to ${participantCount} × $${capUsd} (about $${round6(capUsd * participantCount)}) before any of them stops. Set execution.caps.maxTotalUsd for one budget across the study.`;
+    return `caps.maxUsd ($${capUsd}) caps each participant, so ${participantCount} participants may spend up to ${participantCount} × $${capUsd} (about $${round6(capUsd * participantCount)}) before any of them stops. Set caps.maxTotalUsd for one budget across the study.`;
 }
 /** Builds and publishes the final bundle, runs the adapter hooks, renders the Observer and returns the result. */
 export async function finishCuaRun(setup, finish, ran) {
@@ -272,11 +260,16 @@ export async function finishCuaRun(setup, finish, ran) {
     bundle.review = foldScorerFailures(bundle.review, scorerResult.failures);
     if (receiving)
         bundle.commsReceiving = receiving.snapshot();
-    const finished = await run.finish(bundle);
+    const policy = OUTCOME_POLICIES["computer-use"];
+    const execution = judgeExecution(computerUseExecutionFailures(outcomes, runId), policy);
+    const finished = await run.finish(bundle, {
+        ok: resultOk({ judgment, execution, scorerFailures: scorerResult.failures, policy }),
+        execution,
+        policy,
+    });
     const observer = await finished.renderObserver();
     streams.attachFinal(observer);
-    const execution = judgeExecution(computerUseExecutionFailures(outcomes, observer, runId), OUTCOME_POLICIES["computer-use"]);
-    const result = cuaStudyResult({
+    return cuaStudyResult({
         studyId: plan.studyId,
         cwd,
         runId,
@@ -290,14 +283,10 @@ export async function finishCuaRun(setup, finish, ran) {
         participantPlan,
         rerunLineage,
         bundle,
-        judgment,
-        execution,
+        outcome: finished.outcome,
         observer,
-        scorerFailures: scorerResult.failures,
         receivingWarnings,
         aggregateWarnings,
         adapterWarnings,
     });
-    await finished.recordOutcome({ ok: result.ok, execution });
-    return result;
 }

package/dist/routes/computer-use/single-bundle.js

@@ -100,6 +100,11 @@ function singleSimulation(args, view) {
 }
 function singleStream(args, view) {
     const { publicAppUrl, status, reason, lastScreenshot, desktopGeometry, screenshotMode } = view;
+    // The judge's status for a finished session, as the review counts it, so the Observer shows
+    // the participant the way the verdict judged it.
+    const judged = args.session === undefined || args.inProgress === true
+        ? undefined
+        : participantStatusFor(args.session.status, args.credibility);
     return participantStream(SINGLE, {
         ...(args.assignment === undefined
             ? {}
@@ -110,6 +115,7 @@ function singleStream(args, view) {
         kind: "browser",
         label: `${args.participantId ?? "lane-01"} · browser`,
         status,
+        ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
         updatedAt: args.run.createdAt,
         embed: lastScreenshot
@@ -221,7 +227,7 @@ function singleEvents(args, view) {
                         at: args.run.createdAt,
                         level: "info",
                         type: "cua-lab.contract.ready",
-                        message: "Dry-run bundle ready; switch scenario.mode to live for a real desktop session.",
+                        message: "Dry-run bundle ready; switch mode to live for a real desktop session.",
                     }),
     ];
     const record = (event) => events.push(participantEvent(SINGLE, event));

package/dist/routes/scripted/bundle.js

@@ -1,6 +1,7 @@
 // Assemble the scripted-browser study's run bundle from its sessions, and the review summary and
 // markdown that ship with it.
 import { verdictText } from "../../run/judge.js";
+import { reviewOutcome } from "../../run/display.js";
 import { redactText } from "../../evidence/redaction.js";
 import { buildRunCostSummary, desktopSpanToMinutes, spendFreeCostSummary, } from "../../run/cost-summary.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
@@ -90,7 +91,7 @@ function scriptedEvents(args) {
             type: "scripted-lab.spend",
             message: args.subject
                 ? "Scripted participant steps make no model requests; post-run analysis has a separate budget unless disabled. Live provisioned runs may spend E2B sandbox minutes to clone/serve the synthetic subject."
-                : "Scripted participant steps make no model requests and use no sandbox on this route; post-run analysis has a separate budget unless disabled. scenario.mode: live gates real browser actuation against the declared app.",
+                : "Scripted participant steps make no model requests and use no sandbox on this route; post-run analysis has a separate budget unless disabled. mode: live gates real browser actuation against the declared app.",
         },
     ];
     if (args.sessionResults.length > 0) {
@@ -119,7 +120,7 @@ function scriptedEvents(args) {
             at: args.run.createdAt,
             level: "info",
             type: "scripted-lab.contract.ready",
-            message: `Dry-run bundle ready: scenario ${args.journey.scenarioId} @ ${args.scenarioSourceDigest} (${args.scenarioSource}, ${args.journey.steps.length} step${args.journey.steps.length === 1 ? "" : "s"}) parsed and digest-pinned; switch scenario.mode to live to actuate a real browser.`,
+            message: `Dry-run bundle ready: scenario ${args.journey.scenarioId} @ ${args.scenarioSourceDigest} (${args.scenarioSource}, ${args.journey.steps.length} step${args.journey.steps.length === 1 ? "" : "s"}) parsed and digest-pinned; switch mode to live to actuate a real browser.`,
         });
     }
     return events;
@@ -179,6 +180,7 @@ export function renderScriptedReviewMarkdown(bundle) {
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
         `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
+        `- outcome: ${reviewOutcome(bundle)}`,
         `- summary: ${bundle.review.summary}`,
         `- scenario: ${bundle.scenario.id} @ ${bundle.scenario.sourceDigest} (${bundle.scenario.source})`,
         ...(subject ? [`- subject: ${subject.message}`] : []),

package/dist/routes/scripted/plan.js

@@ -45,7 +45,7 @@ export function planScriptedStudy(config, input) {
     const actorType = config.actors[0]?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isScriptedBrowserActorDescriptor(descriptor))
-        return refuse("HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered scripted-browser actor.`);
+        return refuse("HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered scripted-browser actor.`);
     const actor = descriptor.id;
     // The parser checks the loopback entry too; a library caller skips the parser. A clone's URL is
     // minted by getHost during the run, and its evidence names only the placeholder.
@@ -65,7 +65,7 @@ export function planScriptedStudy(config, input) {
     // The steps are the actor, so there is no built-in journey to fall back on.
     const scenarioRef = config.scenario?.ref;
     if (!scenarioRef?.trim())
-        return refuse("HUMANISH_SCRIPTED_SCENARIO_INVALID", "A scripted-browser study needs `scenario.ref`: the actor runs the browser steps in that scenario file.", { actor, appUrl: evidenceAppUrlOf(subject) });
+        return refuse("HUMANISH_SCRIPTED_SCENARIO_INVALID", "A scripted-browser study needs `scenario`: the actor runs the browser steps in that scenario file.", { actor, appUrl: evidenceAppUrlOf(subject) });
     const requirements = [];
     if (!input.dryRun && subject.kind === "clone") {
         requirements.push({ kind: "key", name: "E2B_API_KEY" });

package/dist/routes/scripted/result.d.ts

@@ -5,7 +5,6 @@ import type { ScriptedPlan } from "../../study/plan-types.js";
 import type { RunBundle } from "../../run/bundle.js";
 import type { RunScope } from "../../run/run.js";
 import { type ExecutionFailure } from "../../run/judge.js";
-import type { ObserverResult } from "../../observer/render.js";
 import type { ScriptedSubject } from "./subject.js";
 import { type ScriptedBrowserStudyResult } from "./types.js";
 /** What the finish reads from the run. */
@@ -35,9 +34,9 @@ export interface ScriptedFinishInputs {
     scriptedSubject: ScriptedSubject | undefined;
 }
 /**
- * The scripted run's execution failures: the session's own error, a live surface that never
- * returned, a surface that ended in a harness error, a subject sandbox whose release is
- * unconfirmed, and an Observer that failed.
+ * The scripted run's execution failures before the Observer renders: the session's own error, a
+ * live surface that never returned, a surface that ended in a harness error, and a subject sandbox
+ * whose release is unconfirmed. FinishedRun.renderObserver adds an Observer that did not render.
  */
 export declare function scriptedExecutionFailures(args: {
     dryRun: boolean;
@@ -46,6 +45,5 @@ export declare function scriptedExecutionFailures(args: {
     expected: number;
     sessionResults: readonly Pick<ScriptedBrowserSessionResult, "completionReason" | "reason">[];
     subject: Pick<ScriptedSubject, "sandboxId" | "killed" | "releaseWarning"> | undefined;
-    observer: Pick<ObserverResult, "ok" | "error">;
 }): ExecutionFailure[];
 export declare function finishScriptedRun(inputs: ScriptedFinishInputs): Promise<ScriptedBrowserStudyResult>;

package/dist/routes/scripted/result.js

@@ -16,12 +16,12 @@ function scriptedSurfaceFacts(result) {
     };
 }
 /**
- * The scripted run's execution failures: the session's own error, a live surface that never
- * returned, a surface that ended in a harness error, a subject sandbox whose release is
- * unconfirmed, and an Observer that failed.
+ * The scripted run's execution failures before the Observer renders: the session's own error, a
+ * live surface that never returned, a surface that ended in a harness error, and a subject sandbox
+ * whose release is unconfirmed. FinishedRun.renderObserver adds an Observer that did not render.
  */
 export function scriptedExecutionFailures(args) {
-    const { sessionError, sessionResults, observer } = args;
+    const { sessionError, sessionResults } = args;
     const harnessErrorSession = sessionResults.find((result) => result.completionReason === "harness_error");
     return [
         ...(sessionError === undefined ? [] : [{ kind: "harness", message: sessionError }]),
@@ -44,14 +44,6 @@ export function scriptedExecutionFailures(args) {
         ...(args.subject?.sandboxId === undefined || args.subject.killed
             ? []
             : [sandboxCleanupFailure("subject", args.subject.releaseWarning, args.runId)]),
-        ...(observer.ok
-            ? []
-            : [
-                {
-                    kind: "evidence",
-                    message: observer.error?.message ?? "Observer failed for the scripted run.",
-                },
-            ]),
     ];
 }
 export async function finishScriptedRun(inputs) {
@@ -114,13 +106,6 @@ export async function finishScriptedRun(inputs) {
             : { desktopTemplate: plan.residual.execution.desktop.template }),
         ...(hostDigest === undefined ? {} : { hostDigest }),
     });
-    const finished = await run.finish(bundle);
-    // Surface the local-fidelity posture so the operator knows the bundle is not publish-safe as-is.
-    if (sessionResults.some((result) => result.trace.redaction.screenshots === "raw")) {
-        warnings.push("Screenshots are unblurred for local use: the bundle stays in the gitignored .humanish/ folder and nothing scans these pixels, so review them before sharing. policies.redactScreenshots is not supported on the scripted route yet.");
-    }
-    const observer = await finished.renderObserver();
-    await validatePreparedRunArtifactPaths(runPaths);
     // A failing surface is captured evidence on this route: only the execution fails ok.
     const policy = OUTCOME_POLICIES.scripted;
     const execution = judgeExecution(scriptedExecutionFailures({
@@ -130,10 +115,19 @@ export async function finishScriptedRun(inputs) {
         expected: surfaces.length,
         sessionResults,
         subject: scriptedSubject,
-        observer,
     }), policy);
-    const ok = resultOk({ judgment, execution, scorerFailures: [], policy });
-    await finished.recordOutcome({ ok, execution });
+    const finished = await run.finish(bundle, {
+        ok: resultOk({ judgment, execution, scorerFailures: [], policy }),
+        execution,
+        policy,
+    });
+    // Surface the local-fidelity posture so the operator knows the bundle is not publish-safe as-is.
+    if (sessionResults.some((result) => result.trace.redaction.screenshots === "raw")) {
+        warnings.push("Screenshots are unblurred for local use: the bundle stays in the gitignored .humanish/ folder and nothing scans these pixels, so review them before sharing. policies.redactScreenshots is not supported on the scripted route yet.");
+    }
+    const observer = await finished.renderObserver();
+    await validatePreparedRunArtifactPaths(runPaths);
+    const { ok } = finished.outcome;
     const harnessErrorSession = sessionResults.find((result) => result.completionReason === "harness_error");
     return {
         ...studyResultIdentity("scripted", plan.studyId),

package/dist/routes/scripted/scenario.js

@@ -26,7 +26,7 @@ export async function resolveScriptedScenario(projectRoot, ref) {
         if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
             return {
                 ok: false,
-                message: `scenario.ref must stay inside the project directory, and "${trimmed}" does not: the run records it relative to the project.`,
+                message: `scenario must stay inside the project directory, and "${trimmed}" does not: the run records it relative to the project.`,
             };
         }
         source = relative.split(path.sep).join("/");
@@ -35,7 +35,7 @@ export async function resolveScriptedScenario(projectRoot, ref) {
         if (!SCENARIO_REF_ID_PATTERN.test(trimmed)) {
             return {
                 ok: false,
-                message: `scenario.ref must be a public-safe scenario id or a .yaml path inside the repo (got "${trimmed}").`,
+                message: `scenario must be a public-safe scenario id or a .yaml path inside the repo (got "${trimmed}").`,
             };
         }
         const candidates = [
@@ -46,7 +46,7 @@ export async function resolveScriptedScenario(projectRoot, ref) {
         if (!found) {
             return {
                 ok: false,
-                message: `scenario.ref "${trimmed}" was not found (looked for ${candidates.join(", ")}).`,
+                message: `scenario "${trimmed}" was not found (looked for ${candidates.join(", ")}).`,
             };
         }
         source = found;
@@ -55,7 +55,7 @@ export async function resolveScriptedScenario(projectRoot, ref) {
     const relativeScenarioPath = path.relative(projectRoot.physicalPath, absolutePath);
     const scenarioBytes = await readContainedRegularFile(projectRoot, relativeScenarioPath);
     if (!scenarioBytes) {
-        return { ok: false, message: `scenario.ref "${trimmed}" could not be read (${source}).` };
+        return { ok: false, message: `scenario "${trimmed}" could not be read (${source}).` };
     }
     const text = scenarioBytes.toString("utf8");
     let raw;

package/dist/routes/shared-world/bundle-records.js

@@ -3,7 +3,9 @@
 // running).
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { participantEvent, participantRecord, participantStream, } from "../../run/participant-records.js";
+import { judgedStatus } from "../../run/judge.js";
 import { declaredScreenForRender } from "../../substrates/e2b/desktop-geometry.js";
+import { participantFactsOf } from "../computer-use/participant-facts.js";
 import { publicSafeRouteLabel } from "./provenance.js";
 import { participantTaxonomyLabel } from "./participant-specs.js";
 function participantView(ctx, spec, index) {
@@ -88,6 +90,8 @@ function sharedWorldSimulation(ctx, spec, index, view) {
 function sharedWorldStream(ctx, spec, index, view) {
     const { args } = ctx;
     const { taxonomy, session, screenshots, lastScreenshot, desktopGeometry, screenshotMode } = view;
+    // The judge's status for the participant, so the Observer shows it the way the verdict judged it.
+    const judged = view.outcome === undefined ? undefined : judgedStatus(participantFactsOf(view.outcome));
     return participantStream(spec, {
         ...(spec.evidenceAssignment === undefined
             ? {}
@@ -95,6 +99,7 @@ function sharedWorldStream(ctx, spec, index, view) {
         kind: "browser",
         label: `Concurrent persona ${spec.planned.id}${taxonomy} · ${args.plan.studyId}`,
         status: view.status,
+        ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
         updatedAt: args.run.createdAt,
         embed: lastScreenshot
@@ -198,7 +203,7 @@ function sharedWorldEvents(ctx, spec, view) {
             at: createdAt,
             level: "info",
             type: "concurrent-shared-world.contract.ready",
-            message: `Persona ${spec.planned.id}: dry-run actor ready; switch scenario.mode to live for a real concurrent session.`,
+            message: `Persona ${spec.planned.id}: dry-run actor ready; switch mode to live for a real concurrent session.`,
         });
     }
     return events;

package/dist/routes/shared-world/bundle.js

@@ -9,6 +9,7 @@ import { commandDigestOf } from "../../subject/state.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { participantFactsOf } from "../computer-use/participant-facts.js";
 import { judgeSharedWorld, participantPassed, sharedWorldShortfall, verdictText, } from "../../run/judge.js";
+import { reviewOutcome } from "../../run/display.js";
 import { combineCheckpointDigest } from "./checkpoints.js";
 import { hostOriginDigest } from "./provenance.js";
 import { participantEvent, participantIds } from "../../run/participant-records.js";
@@ -433,6 +434,7 @@ export function renderConcurrentReviewMarkdown(bundle) {
         `- topology: ${sw?.topology ?? "(none)"} / ${sw?.topologyMode ?? "(none)"}`,
         `- personas: ${sw?.roleCount ?? 0}`,
         `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
+        `- outcome: ${reviewOutcome(bundle)}`,
         `- summary: ${bundle.review.summary}`,
         ...(plane ? [`- plane: ${plane.message}`] : []),
         ...(concurrency ? [`- concurrency: ${concurrency.message}`] : []),

package/dist/routes/shared-world/plan.js

@@ -40,7 +40,7 @@ export function planSharedWorldStudy(config, input) {
     const actorType = config.actors[0]?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isCuaActorDescriptor(descriptor))
-        return refuse("HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered computer-use actor.`);
+        return refuse("HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered computer-use actor.`);
     const actor = descriptor.id;
     // An app-url subject is the external-public plane (a real operator-owned deployment used
     // directly, with no getHost, clone, subject sandbox or seed); every other subject is the

package/dist/routes/shared-world/result.js

@@ -160,13 +160,13 @@ export function concurrentStudyFailure(envelope) {
     });
 }
 /**
- * The run's execution failures: a run error (the handoff, the plane), each participant whose
- * session failed in the harness, each provider whose cleanup is unconfirmed or that reported a
- * disallowed item after its last request, each sandbox whose release is unconfirmed, and an
- * Observer that failed.
+ * The run's execution failures before the Observer renders: a run error (the handoff, the plane),
+ * each participant whose session failed in the harness, each provider whose cleanup is unconfirmed
+ * or that reported a disallowed item after its last request, and each sandbox whose release is
+ * unconfirmed. FinishedRun.renderObserver adds an Observer that did not render.
  */
 function sharedWorldExecutionFailures(args) {
-    const { runId, runError, actorResults, subject, observer } = args;
+    const { runId, runError, actorResults, subject } = args;
     return [
         ...(runError === undefined ? [] : [{ kind: "run", message: runError }]),
         ...actorResults
@@ -195,14 +195,6 @@ function sharedWorldExecutionFailures(args) {
         ...(subject.subjectSandboxId === undefined || subject.subjectKilled
             ? []
             : [sandboxCleanupFailure("subject", subject.subjectReleaseWarning, runId)]),
-        ...(observer.ok
-            ? []
-            : [
-                {
-                    kind: "evidence",
-                    message: observer.error?.message ?? "Observer failed for the concurrent shared-world run.",
-                },
-            ]),
     ];
 }
 /** Builds and publishes the bundle, renders the Observer and returns the study result. */
@@ -284,19 +276,28 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
     bundle.review = foldScorerFailures(bundle.review, scorerResult.failures);
     if (receiving)
         bundle.commsReceiving = receiving.snapshot();
-    const finished = await run.finish(bundle);
-    const observer = await finished.renderObserver();
-    if (observer.ok && live.observer) {
-        attachObserverRuntimeStreamUrls(observer, live.streamUrls);
-    }
     // Concurrent "ok": every actor must produce a terminal, engaged, passed session, and the
     // participants must show the concurrency verify requires of a pass (judgeSharedWorld). This is a
     // harness/session-credibility gate, not mission-completion proof; a failed actor trace cannot
     // make the route green just because the harness got a terminal.
-    const adapterFailure = adapterScoreFailureMessage(bundle);
     const policy = OUTCOME_POLICIES["shared-world"];
-    const execution = judgeExecution(sharedWorldExecutionFailures({ runId, runError, actorResults, subject: results, observer }), policy);
-    const ok = resultOk({ judgment, execution, scorerFailures: scorerResult.failures, policy });
+    const preRender = judgeExecution(sharedWorldExecutionFailures({ runId, runError, actorResults, subject: results }), policy);
+    const finished = await run.finish(bundle, {
+        ok: resultOk({
+            judgment,
+            execution: preRender,
+            scorerFailures: scorerResult.failures,
+            policy,
+        }),
+        execution: preRender,
+        policy,
+    });
+    const observer = await finished.renderObserver();
+    if (observer.ok && live.observer) {
+        attachObserverRuntimeStreamUrls(observer, live.streamUrls);
+    }
+    const adapterFailure = adapterScoreFailureMessage(bundle);
+    const { ok, execution } = finished.outcome;
     const overlapProven = !dryRun && judgment.world.overlap;
     const participantResults = concurrentParticipantResults(actorSpecs, actorResults, dryRun);
     const errorResult = concurrentStudyError({
@@ -334,6 +335,5 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
         warnings: [...warnings, ...adapterWarnings, ...observer.warnings],
         ...(errorResult === undefined ? {} : { error: errorResult }),
     };
-    await finished.recordOutcome({ ok, execution });
     return result;
 }

package/dist/routes/terminal/bundle.js

@@ -2,6 +2,7 @@ import { redactText } from "../../evidence/redaction.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import { verdictText } from "../../run/judge.js";
+import { reviewOutcome } from "../../run/display.js";
 import {} from "../../run/streams.js";
 import { participantEvent, participantIds, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { TERMINAL_EVENTS_ARTIFACT, TERMINAL_LEDGERS_ARTIFACT, TERMINAL_TRANSCRIPT_ARTIFACT, } from "../../run/terminal-contract.js";
@@ -72,7 +73,7 @@ export function buildTerminalProductBundle(args) {
             at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.contract.ready",
-            message: "Dry-run bundle ready. Switch scenario.mode to live with the required runtime auth and caps to exercise the in-sandbox agent route, captured exec stream, and declared runtime-auth placement.",
+            message: "Dry-run bundle ready. Switch mode to live with the required runtime auth and caps to exercise the in-sandbox agent route, captured exec stream, and declared runtime-auth placement.",
         }),
     ];
     const review = {
@@ -172,7 +173,7 @@ export function buildLiveTerminalProductBundle(args) {
             // so a green run never silently over-claims a fully-proven $0.
             ...(noSpend.unmeasuredLines.length > 0
                 ? [
-                    `${noSpendLineMeasured(noSpend) ? noSpendNotEstablished(noSpend.maxUsd ?? 0) : "No-spend proof is partial."} ${describeMeasuredSpend(args.ledgers.cost, args.trace.tokenUsage)} An adapter may supply the missing signals through costProbe.`,
+                    `${noSpendLineMeasured(noSpend) ? noSpendNotEstablished(noSpend.maxUsd ?? 0) : "No-spend proof is partial."} ${describeMeasuredSpend(args.ledgers.cost, args.trace.tokenUsage)} humanish has no source for the missing lines, and a study cannot supply one.`,
                 ]
                 : []),
         ],
@@ -283,6 +284,7 @@ export function renderTerminalReviewMarkdown(bundle) {
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
         `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
+        `- outcome: ${reviewOutcome(bundle)}`,
         `- summary: ${bundle.review.summary}`,
         `- mission: ${bundle.scenario.goal}`,
         ...(subject ? [`- subject: ${subject.message}`] : []),

package/dist/routes/terminal/dry-run.js

@@ -68,20 +68,16 @@ export async function runDryTerminalStudy(args) {
         verdict: judgment.verdict,
     });
     bundle.events.push(runtimeDeclaredEvent(plan.runtime, createdAt));
-    const finished = await run.finish(bundle);
+    const policy = OUTCOME_POLICIES.terminal;
+    const execution = judgeExecution([], policy);
+    const finished = await run.finish(bundle, {
+        ok: resultOk({ judgment, execution, scorerFailures: [], policy }),
+        execution,
+        policy,
+    });
     const observer = await finished.renderObserver();
     await validatePreparedRunArtifactPaths(finished.paths);
-    const policy = OUTCOME_POLICIES.terminal;
-    const execution = judgeExecution(observer.ok
-        ? []
-        : [
-            {
-                kind: "evidence",
-                message: observer.error?.message ?? "Observer failed for the terminal-product run.",
-            },
-        ], policy);
-    const ok = resultOk({ judgment, execution, scorerFailures: [], policy });
-    await finished.recordOutcome({ ok, execution });
+    const { ok } = finished.outcome;
     return {
         ...studyResultIdentity("terminal", plan.studyId),
         ok,