humanish 0.111.2 → 0.111.4

package/ARCHITECTURE.md

@@ -129,7 +129,7 @@ comments name an invariant by its rule.
 | The run bundle is the source of truth, and the Observer derives from it                                                  | `verifyRun` grades only `run.json` and its artifacts (`src/verify/verify.ts`). It reads `status.json` and the sandbox and reclaim receipts only for the `RUN_NOT_FINISHED` warning (`runNotFinished` in `src/verify/liveness.ts`), which changes no check and no grade. `buildObserverData` takes the bundle (`src/observer/data.ts`)                                                                                                                    | `tests/observer/data-contract.test.ts`; `tests/verify/run-not-finished.test.ts` checks that the grades are the same when `status.json` contradicts the bundle or is gone; `docs/decisions/0001-run-bundle-is-the-source-of-truth.md`                                                                                                                                                                                                                                             |
 | Unsupported execution is refused before side effects                                                                     | `parseStudy` (`src/study/config.ts`), `taskProtocolValidationReason` (`src/study/validation.ts`), `planComputerUseStudy` (`src/routes/computer-use/plan.ts`)                                                                                                                                                                                                                                                                                             | `tests/admission/library.test.ts` checks each library refusal for a run directory, a desktop module load, a caller executor or provider, and a subprocess; `tests/admission/cli.test.ts` checks each CLI refusal for a run directory, a started process and a scorer's host code; `tests/study/task-route-preflight.test.ts`; `pnpm cli:preflight:test` runs `scripts/task-route-preflight-proof.mjs` with `tests/fixtures/task-route-preflight/deny-side-effects.mjs` preloaded |
 | A sandbox id is recorded before any work runs in it                                                                      | `acquireE2BDesktopSandbox` and `acquireE2BShellSandbox` (`src/substrates/e2b/sandbox.ts`) tag the sandbox with its run's owner tags, register the create with `beginSandboxCreate` (`src/run/sandbox-creates.ts`) and write the receipt before they return the handle, and every route that creates a sandbox calls them; `reclaimRunSandboxes` (`src/run/reclaim.ts`) switches on the receipt's provider, kills by exact id and by the run's exact tags | `tests/substrates/e2b/sandbox.test.ts`, which also checks that `Sandbox.create` has one call site in `src/`, `tests/routes/terminal/acquisition-boundary.test.ts`, `tests/run/reclaim.test.ts`; `tests/routes/scripted/route.test.ts` checks create, receipt, then first work                                                                                                                                                                                                    |
-| Bundles carry no secrets                                                                                                 | `redactText` and `scrubLiterals` (`src/evidence/redaction.ts`); `scanRunPublicSafetyArtifacts` (`src/verify/artifacts.ts`); `buildShareSafety` (`src/verify/verify.ts`) grades `share_ready`, `local_only` or `blocked`                                                                                                                                                                                                                                  | `tests/evidence/redaction-hooks.test.ts`, `tests/run/transient-comms-secrets.test.ts`, `tests/verify/evidence-refs.test.ts`                                                                                                                                                                                                                                                                                                                                                      |
+| Bundles carry no secrets                                                                                                 | `redactText` and `scrubLiterals` (`src/evidence/redaction.ts`); `RunSecrets` (`src/run/secrets.ts`) holds the literal values each run scrubs; `scanRunPublicSafetyArtifacts` (`src/verify/artifacts.ts`); `buildShareSafety` (`src/verify/verify.ts`) grades `share_ready`, `local_only` or `blocked`                                                                                                                                                    | `tests/evidence/redaction-hooks.test.ts`, `tests/routes/known-secrets.test.ts`, `tests/run/transient-comms-secrets.test.ts`, `tests/verify/evidence-refs.test.ts`                                                                                                                                                                                                                                                                                                                |
 | Goldens pin route output                                                                                                 | `runDirSnapshot` (`tests/helpers/run-golden.ts`) snapshots a whole run folder                                                                                                                                                                                                                                                                                                                                                                            | `tests/golden/routes/`, `tests/golden/observer-data/`, `tests/golden/labs/`; `tests/study/plan-lab.test.ts` checks that every `StudyRoute` has a dry-run golden                                                                                                                                                                                                                                                                                                                  |
 | A run is closed on every exit, only a published run is analyzed, and `latest.json` moves only after its run is published | `runScope` and `FinishedRun` (`src/run/run.ts`); `completeAutomaticAnalysis` requires an issued `FinishedRun` for the result's run; `Run.finish` writes `latest.json` last through `writePreparedRunLatestPointer` (`src/run/contained-output.ts`)                                                                                                                                                                                                       | `tests/run/run-lifecycle.test.ts`, which also checks that `src/run/run.ts` is the pointer's one writer, `tests/analysis/automatic-analysis.test.ts`                                                                                                                                                                                                                                                                                                                              |
 

package/CHANGELOG.md

@@ -8,6 +8,38 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.111.4: Encoded known values scrubbed, scripted traces scrubbed, a live command after a dry run (2026-10-06)
+
+humanish 0.111.4 scrubs a run's known values from more of its evidence and fixes three messages.
+Every route now also finds a known value, such as a provider key or a `subject.env` value, in its
+encoded forms: percent-encoded, JSON-escaped, base64, base64url and hex, and where a terminal color
+code or an output chunk boundary splits it. A scripted run scrubs its known values from the step
+trace in `traces/<surface>.json` and `actor-<surface>.json`, and from the app URL, scenario goal,
+title and step labels it records. Two places keep a known value: a scenario file name, and the
+path of a computer-use `subject.appUrl`. `humanish review` on a dry run names the command that
+starts a live run, so `next` in `review --json` holds a string where it held null. A terminal
+refusal for a missing runtime key no longer reads `runtimeAuth "undefined"`, and a refusal that
+names two signed-in coding agents reads "report".
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.111.4)
+
+## 0.111.3: Shared-world feedback candidates, scripted E2B key scrubbed, subject sandbox warnings (2026-10-06)
+
+humanish 0.111.3 gives shared-world runs feedback candidates and repairs seven places where one
+route's warnings, refusals, secret scrubbing or run directory checks differed from the other
+routes'. A shared-world participant who reports friction or gives up becomes a candidate that
+`humanish feedback` drafts, and each candidate from a run with several participants shows that
+participant's own instructions as `expected`. A scripted run scrubs the value of `E2B_API_KEY` from
+the errors and subject setup output it records, and writes `[REDACTED_SECRET]` where it wrote
+`[redacted]`. A shared-world study with `caps.maxUsd` and no `caps.maxTotalUsd` warns that the cap
+applies to each participant. The subject sandbox of a scripted clone study or a provisioned
+shared-world study warns when its create was retried or E2B reports no size. A scripted clone study
+missing a `subject.env` value, and a provisioned shared-world study missing `OPENAI_API_KEY`,
+refuse with the wording computer use gives. Computer-use and shared-world runs check the run
+directory again after a `prepareDesktop` hook and an Observer render.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.111.3)
+
 ## 0.111.2: A taller Observer frame, even grid cards, a notice when the server stops (2026-10-06)
 
 humanish 0.111.2 changes the Observer and nothing else. The focus view's heading line holds the

package/dist/actors/scripted-browser/actor.d.ts

@@ -24,6 +24,11 @@ export interface ScriptedBrowserSessionOptions {
     /** DI seam; production default is launchPlaywrightChromium. */
     launchBrowser?: (args: ScriptedBrowserLaunchArgs) => Promise<ScriptedBrowserLike>;
     now?: () => number;
+    /**
+     * The run's scrub of its known secret values. Each URL and text the session records passes
+     * through it before the trace is written or the capture returned.
+     */
+    scrubKnownValues?: (text: string) => string;
 }
 export interface ScriptedBrowserSessionResult extends ActorSessionResult {
     /** Native evidence incl. tracePath (humanish.browser-persona-trace.v1, written to disk). */

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

@@ -21,7 +21,7 @@ import { CHROMIUM_EVIDENCE_HYGIENE_FLAGS } from "../../evidence/browser-hygiene.
 import { redactText } from "../../evidence/redaction.js";
 import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, prepareContainedOutputDirectory, prepareContainedOutputFile, prepareSelectedOutputDirectory, writeContainedOutputFile, } from "../../run/contained-output.js";
 import { ACTOR_TRACE_SCHEMA, SCRIPTED_BROWSER_CAPABILITIES, } from "../contract.js";
-import { buildBlockedBrowserPersonaSteps, buildBrowserTrace, captureBlockedStepScreenshot, compactBrowserError, executeBrowserPersonaStep, probeAppUrl, sanitizeBrowserEvidenceUrl, screenshotPathForBrowserStep, surfaceScreenshotPath, tracePathForBrowserSurface, } from "./steps.js";
+import { buildBlockedBrowserPersonaSteps, buildBrowserTrace, captureBlockedStepScreenshot, compactBrowserError, executeBrowserPersonaStep, probeAppUrl, sanitizeBrowserEvidenceUrl, screenshotPathForBrowserStep, scrubRecordedStep, surfaceScreenshotPath, tracePathForBrowserSurface, } from "./steps.js";
 import { LOOPBACK_EVIDENCE_URL_POLICY, } from "./types.js";
 import { chromeLaunchEnv, chromeLaunchError } from "./launch-env.js";
 /** Production default: lazy playwright-core import + chromium.launch, exactly as the driver
@@ -93,8 +93,10 @@ export async function runScriptedBrowserSessionInPreparedRoot(options, preparedA
     const browserCommand = options.browserCommand ?? (options.launchBrowser ? "injected-browser" : "");
     const evidenceAppUrl = options.evidenceAppUrl ?? options.appUrl;
     const urlPolicy = options.urlPolicy ?? LOOPBACK_EVIDENCE_URL_POLICY;
+    const scrub = options.scrubKnownValues ?? ((text) => text);
     const finish = async (args) => {
         const completedAtMs = now();
+        const reason = scrub(args.reason);
         const trace = await projectScriptedActorTrace({
             artifactRoot: preparedArtifactRoot,
             capture: args.capture,
@@ -104,14 +106,14 @@ export async function runScriptedBrowserSessionInPreparedRoot(options, preparedA
             executedSteps: args.executedSteps,
             journey: options.journey,
             persona: options.persona,
-            reason: args.reason,
+            reason,
             startedAt,
             status: args.status,
         });
         return {
             status: args.status,
             completionReason: args.completionReason,
-            reason: args.reason,
+            reason,
             capture: args.capture,
             trace,
         };
@@ -130,6 +132,7 @@ export async function runScriptedBrowserSessionInPreparedRoot(options, preparedA
             evidenceAppUrl,
             journey: options.journey,
             reason,
+            scrub,
             surface: options.surface,
             urlPolicy,
         });
@@ -155,6 +158,7 @@ export async function runScriptedBrowserSessionInPreparedRoot(options, preparedA
         browserCommand,
         evidenceAppUrl,
         journey: options.journey,
+        scrub,
         surface: options.surface,
         timeoutMs: options.timeoutMs,
         urlPolicy,
@@ -258,17 +262,18 @@ async function runScriptedJourney(args) {
     finally {
         await args.browser.close().catch(() => undefined);
     }
+    const recordedSteps = steps.map((step) => scrubRecordedStep(step, args.scrub));
     const completedAt = new Date().toISOString();
     const durationMs = Date.now() - started;
     const ok = !timedOut &&
         httpProbe.ok &&
-        steps.length === args.journey.steps.length &&
-        steps.every((step) => step.status === "passed");
-    const reason = ok
-        ? `${args.surface.label} completed ${steps.length}/${steps.length} scripted browser steps from ${args.evidenceAppUrl}${httpProbe.status === undefined ? "" : ` with HTTP ${httpProbe.status}`}.`
-        : `${args.surface.label} scripted browser journey blocked: ${steps.find((step) => step.status !== "passed")?.reason ?? httpProbe.reason}`;
-    const scriptedScreenshotPath = surfaceScreenshotPath(steps);
-    await writeContainedOutputFile(args.artifactRoot, tracePath, `${JSON.stringify(buildBrowserTrace({
+        recordedSteps.length === args.journey.steps.length &&
+        recordedSteps.every((step) => step.status === "passed");
+    const reason = args.scrub(ok
+        ? `${args.surface.label} completed ${recordedSteps.length}/${recordedSteps.length} scripted browser steps from ${args.evidenceAppUrl}${httpProbe.status === undefined ? "" : ` with HTTP ${httpProbe.status}`}.`
+        : `${args.surface.label} scripted browser journey blocked: ${recordedSteps.find((step) => step.status !== "passed")?.reason ?? httpProbe.reason}`);
+    const scriptedScreenshotPath = surfaceScreenshotPath(recordedSteps);
+    await writeBrowserTrace(args.artifactRoot, tracePath, {
         appUrl: args.evidenceAppUrl,
         browserCommand: path.basename(args.browserCommand || "injected-browser"),
         browserJourney: args.journey,
@@ -278,9 +283,9 @@ async function runScriptedJourney(args) {
         ok,
         reason,
         ...(scriptedScreenshotPath === undefined ? {} : { screenshotPath: scriptedScreenshotPath }),
-        steps,
+        steps: recordedSteps,
         surface: args.surface,
-    }), null, 2)}\n`, "utf8");
+    }, args.scrub);
     return {
         capture: {
             capturedAt: completedAt,
@@ -289,7 +294,7 @@ async function runScriptedJourney(args) {
             ok,
             reason,
             ...(scriptedScreenshotPath === undefined ? {} : { screenshotPath: scriptedScreenshotPath }),
-            steps,
+            steps: recordedSteps,
             surface: args.surface,
             tracePath,
         },
@@ -327,40 +332,56 @@ async function withJourneyDeadline(promise, deadline, timeoutMs) {
 async function persistScriptedFailureCapture(args) {
     const capturedAt = new Date().toISOString();
     const tracePath = tracePathForBrowserSurface(args.surface);
+    const reason = args.scrub(args.reason);
     const blockedSteps = buildBlockedBrowserPersonaSteps({
         browserJourney: args.journey,
         currentUrl: args.appUrl,
-        reason: args.reason,
+        reason,
         surface: args.surface,
         timestamp: capturedAt,
         urlPolicy: args.urlPolicy,
-    });
+    }).map((step) => scrubRecordedStep(step, args.scrub));
     // Pre-actuation failure: no screenshots were written, so the surface omits the
     // screenshot reference and the failure itself stands as the evidence.
     const screenshotPath = surfaceScreenshotPath(blockedSteps);
-    await writeContainedOutputFile(args.artifactRoot, tracePath, `${JSON.stringify(buildBrowserTrace({
+    await writeBrowserTrace(args.artifactRoot, tracePath, {
         appUrl: args.evidenceAppUrl,
         browserCommand: path.basename(args.browserCommand || "injected-browser"),
         browserJourney: args.journey,
         capturedAt,
         durationMs: 0,
         ok: false,
-        reason: args.reason,
+        reason,
         ...(screenshotPath === undefined ? {} : { screenshotPath }),
         steps: blockedSteps,
         surface: args.surface,
-    }), null, 2)}\n`, "utf8");
+    }, args.scrub);
     return {
         capturedAt,
         durationMs: 0,
         ok: false,
-        reason: args.reason,
+        reason,
         ...(screenshotPath === undefined ? {} : { screenshotPath }),
         steps: blockedSteps,
         surface: args.surface,
         tracePath,
     };
 }
+/**
+ * Writes one surface's native trace. Its steps and reason arrive scrubbed; the app URL and the
+ * scenario title pass through the same scrub here.
+ */
+async function writeBrowserTrace(artifactRoot, tracePath, trace, scrub) {
+    const recorded = buildBrowserTrace({
+        ...trace,
+        appUrl: scrub(trace.appUrl),
+        browserJourney: {
+            ...trace.browserJourney,
+            scenarioTitle: scrub(trace.browserJourney.scenarioTitle),
+        },
+    });
+    await writeContainedOutputFile(artifactRoot, tracePath, `${JSON.stringify(recorded, null, 2)}\n`, "utf8");
+}
 /** Project one surface capture into humanish.actor-trace.v1. screenshotRefs are attached only
  *  for frames that actually exist on disk (so counts match disk; blocked-not-executed steps name a
  *  path that was never written). */

package/dist/actors/scripted-browser/journey.d.ts

@@ -7,3 +7,5 @@ export declare function parseBrowserPersonaJourneyFromScenario(args: {
     failure?: string;
     journey?: BrowserPersonaJourney;
 };
+/** `value` lower-cased, with each run of other characters a `-`, cut to 80; else `fallback`. */
+export declare function publicSafeToken(value: string | undefined, fallback: string): string;

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

@@ -172,7 +172,8 @@ function stringValue(value) {
 function booleanValue(value) {
     return typeof value === "boolean" ? value : undefined;
 }
-function publicSafeToken(value, fallback) {
+/** `value` lower-cased, with each run of other characters a `-`, cut to 80; else `fallback`. */
+export function publicSafeToken(value, fallback) {
     const candidate = (value ?? fallback)
         .toLowerCase()
         .replace(/[^a-z0-9_.-]+/g, "-")

package/dist/actors/scripted-browser/steps.d.ts

@@ -18,6 +18,8 @@ export declare function buildBlockedBrowserPersonaSteps(args: {
     timestamp: string;
     urlPolicy?: ScriptedBrowserEvidenceUrlPolicy;
 }): BrowserPersonaStepCapture[];
+/** A step as the trace records it: its label, reason, URL and assertion reasons scrubbed. */
+export declare function scrubRecordedStep(step: BrowserPersonaStepCapture, scrub: (text: string) => string): BrowserPersonaStepCapture;
 export declare function screenshotPathForBrowserStep(surface: BrowserSurface, step: BrowserPersonaStepManifest | undefined): string;
 export declare function tracePathForBrowserSurface(surface: BrowserSurface): string;
 /**

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

@@ -191,6 +191,23 @@ export function buildBlockedBrowserPersonaSteps(args) {
         url: sanitizeBrowserEvidenceUrl(args.currentUrl, args.urlPolicy),
     }));
 }
+/** A step as the trace records it: its label, reason, URL and assertion reasons scrubbed. */
+export function scrubRecordedStep(step, scrub) {
+    return {
+        ...step,
+        ...(step.assertions === undefined
+            ? {}
+            : {
+                assertions: step.assertions.map((assertion) => ({
+                    ...assertion,
+                    reason: scrub(assertion.reason),
+                })),
+            }),
+        label: scrub(step.label),
+        reason: scrub(step.reason),
+        url: scrub(step.url),
+    };
+}
 export function screenshotPathForBrowserStep(surface, step) {
     assertSafeOutputPathSegment(surface.id, "Browser surface id");
     if (step) {

package/dist/cli/commands/study-route-computer-use.js

@@ -12,7 +12,7 @@ import { exposureRequestFromOptions, followDecision, followObserver, planObserve
 import { writeRunFindings } from "../findings.js";
 import { formatCuaStudyHuman } from "./study-format.js";
 import { resolveRouteShouldOpen } from "./study-route-open.js";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult } from "../../run/study-result.js";
 import { declaredParticipantCount } from "../../study/study-fields.js";
 /**
  * The computer-use route's CLI setup: its settings, the watch and exposure plan, the runStudyWith options
@@ -51,17 +51,12 @@ export function computerUseRouteRun(args) {
     };
 }
 function refuseCua(args, dryRun, code, message) {
-    const result = {
-        ...studyResultIdentity("computer-use", args.config.id),
-        ok: false,
-        cwd: args.options.cwd,
+    const result = refusedResult("computer-use", { studyId: args.config.id, cwd: args.options.cwd, error: { code, message } }, {
         actor: args.config.actor?.type ?? "",
         appUrl: "",
         dryRun,
         runId: args.options.runId ?? "not-created",
-        warnings: [],
-        error: { code, message },
-    };
+    });
     writeResult(args.command, args.io, result, formatCuaStudyHuman);
     args.io.setExitCode(2);
 }

package/dist/cli/commands/study-route-preview.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult } from "../../run/study-result.js";
 import { formatRunHuman, parseStudyCount, writeResult, } from "../io.js";
 import { planObserver, showObserver, staticObserverOpen } from "../observer-follow.js";
 import { declaredParticipantCount } from "../../study/study-fields.js";
@@ -10,16 +10,14 @@ import { declaredParticipantCount } from "../../study/study-fields.js";
 export function previewRouteRun(args) {
     const participantCount = parseStudyCount(args.options.count, declaredParticipantCount(args.config) ?? 4);
     if (participantCount === null) {
-        const result = {
-            ...studyResultIdentity("preview", args.config.id),
-            ok: false,
+        const result = refusedResult("preview", {
+            studyId: args.config.id,
             cwd: args.options.cwd,
-            warnings: [],
             error: {
                 code: "HUMANISH_INVALID_PARTICIPANT_COUNT",
                 message: "--count must be a positive integer.",
             },
-        };
+        }, {});
         writeResult(args.command, args.io, result, formatRunHuman);
         args.io.setExitCode(2);
         return undefined;

package/dist/cli/commands/study-route-shared-world.js

@@ -9,7 +9,7 @@ import { followDecision, followObserver, showObserver, staticObserverOpen, withO
 import { writeRunFindings } from "../findings.js";
 import { formatConcurrentSharedWorldStudyHuman } from "./study-format.js";
 import { resolveRouteShouldOpen, watchFinishedPlan } from "./study-route-open.js";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult } from "../../run/study-result.js";
 import { participantList } from "../../study/study-fields.js";
 /**
  * The shared-world route's CLI setup: dry run, open and follow semantics, the live Observer server
@@ -30,10 +30,11 @@ export function sharedWorldRouteRun(args) {
         followDecision({ wantsMachine, detach: args.options.detach, serve: args.options.serve }).follow;
     const port = parseObserverPort(args.options.port ?? "0");
     const failConcurrent = (message, runId) => {
-        const result = {
-            ...studyResultIdentity("shared-world", args.config.id),
-            ok: false,
+        const result = refusedResult("shared-world", {
+            studyId: args.config.id,
             cwd: args.options.cwd,
+            error: { code: "HUMANISH_SHARED_WORLD_FAILED", message },
+        }, {
             actor: args.config.actor?.type ?? "",
             topology: "shared-world",
             topologyMode: "concurrent",
@@ -42,9 +43,7 @@ export function sharedWorldRouteRun(args) {
             dryRun,
             runId: runId ?? args.options.runId ?? "not-created",
             roles: [],
-            warnings: [],
-            error: { code: "HUMANISH_SHARED_WORLD_FAILED", message },
-        };
+        });
         writeResult(args.command, args.io, result, formatConcurrentSharedWorldStudyHuman);
         args.io.setExitCode(2);
     };

package/dist/cli/findings.d.ts

@@ -48,7 +48,10 @@ export interface AnalysisFindings {
     /** The stable code behind a state other than ready, when one is recorded. */
     reason: string | null;
     message: string;
-    /** The command that gets findings for this run, or null when none can. */
+    /**
+     * The command that gets findings for this run, or for a dry run the command that starts a live
+     * one. Null when none can.
+     */
     next: string | null;
     analysisId: string | null;
     status: AnalysisArtifact["status"] | null;
@@ -80,6 +83,17 @@ interface FindingsSource {
      * false`, read when the view is built. Undefined when it does not, or cannot be read.
      */
     analysisOffIn?: string;
+    /** For a dry run, the study a live run can start from, read when the view is built. */
+    liveStudy?: LiveStudy;
+}
+/** A study `run` can start live after a dry run. */
+interface LiveStudy {
+    /** The study argument for `run`: its id, or its path when the run named it by path. */
+    run: string;
+    /** Its id, for the message. */
+    id: string;
+    /** The study file to set `mode: live` in first, when the file still starts as a dry run. */
+    setLiveIn?: string;
 }
 /** The findings view of a run's selected analysis, or why it has none. */
 export declare function analysisFindings(source: FindingsSource): AnalysisFindings;

package/dist/cli/findings.js

@@ -9,6 +9,7 @@ import { loadRunBundlePrepared, resolveRunPath } from "../run/locate.js";
 import { resolvePhysicalCwd, runIdOf } from "../run/paths.js";
 import { studyProvenanceOf } from "../run/study-provenance.js";
 import { resolveStudyManifest } from "../study/discover.js";
+import { routeOf } from "../study/routing.js";
 import { plural } from "../run/text.js";
 import { shellQuote } from "../substrates/shell.js";
 import { analysisOutcomeText, wantsJson } from "./io.js";
@@ -102,10 +103,21 @@ function withoutFindings(source, state, reason, message, next) {
         warnings: source.loaded.warnings,
     };
 }
+/** A dry run's view: nothing to analyze, and the command that starts a live run. */
+function dryRunFindings(source) {
+    const opening = "This is a dry run: no participant used the product, so there is nothing to analyze.";
+    const live = source.liveStudy;
+    if (live === undefined)
+        return withoutFindings(source, "dry_run", null, `${opening} Findings come from live runs. The next command lists this project's studies; a study with mode: live runs participants.`, cli(`study list${source.cwdFlag}`));
+    const howLive = live.setLiveIn === undefined
+        ? `the next command runs ${live.id} live.`
+        : `set mode: live in ${live.setLiveIn}, then run the next command.`;
+    return withoutFindings(source, "dry_run", null, `${opening} Findings come from live runs: ${howLive}`, cli(`run ${live.run}${source.cwdFlag}`));
+}
 /** The findings view of a run's selected analysis, or why it has none. */
 export function analysisFindings(source) {
     if (source.mode !== undefined && source.mode !== "live")
-        return withoutFindings(source, "dry_run", null, "This is a dry run: no participant used the product, so there is nothing to analyze. Findings come from live runs.", null);
+        return dryRunFindings(source);
     const loaded = projectShareCheckedAnalysis(source.loaded);
     const analysis = loaded.analysis;
     if (analysis?.result && (loaded.state === "ready" || loaded.state === "stale")) {
@@ -170,6 +182,30 @@ async function studyAnalysisOff(cwd, study) {
         return undefined;
     return resolved.config.review?.analysis === false ? study.path : undefined;
 }
+/**
+ * The study a live run can start from after a dry run: the run's own study when its file runs
+ * live, else the starter study try-live when this project has one that runs live, else the run's
+ * own study once its file is set live. A preview study only dry-runs. Undefined when none applies.
+ */
+async function liveStudyAfterDryRun(cwd, study) {
+    const resolve = async (ref) => {
+        const resolved = await resolveStudyManifest(cwd, ref).catch(() => null);
+        return resolved?.ok ? resolved.config : undefined;
+    };
+    const ownConfig = study === undefined
+        ? undefined
+        : await resolve(study.path ?? study.id).then((config) => config?.id === study.id ? config : undefined);
+    const own = study === undefined
+        ? undefined
+        : { run: study.origin === "explicit" ? (study.path ?? study.id) : study.id, id: study.id };
+    if (own !== undefined && ownConfig?.mode === "live")
+        return own;
+    if ((await resolve("try-live"))?.mode === "live")
+        return { run: "try-live", id: "try-live" };
+    if (own !== undefined && ownConfig !== undefined && study?.path !== undefined)
+        return routeOf(ownConfig) === "preview" ? undefined : { ...own, setLiveIn: study.path };
+    return undefined;
+}
 /**
  * The run's bundle mode and its selected analysis: `analysisId`, or the version `analyze show`
  * defaults to. Null when the run is missing or its storage is unsafe.
@@ -180,16 +216,18 @@ export async function readRunAnalysis(cwd, run, analysisId) {
     if (!prepared)
         return null;
     const bundle = await loadRunBundlePrepared(physical, prepared).catch(() => null);
-    const analysisOffIn = bundle?.bundle.mode === "live"
-        ? await studyAnalysisOff(physical, studyProvenanceOf(bundle.bundle))
-        : undefined;
+    const mode = bundle?.bundle.mode;
+    const study = bundle === null ? undefined : studyProvenanceOf(bundle.bundle);
+    const analysisOffIn = mode === "live" ? await studyAnalysisOff(physical, study) : undefined;
+    const liveStudy = mode !== undefined && mode !== "live" ? await liveStudyAfterDryRun(physical, study) : undefined;
     return {
         runId: runIdOf(prepared),
-        mode: bundle?.bundle.mode,
+        mode,
         runRoot: prepared.relativeRunRoot,
         loaded: await loadAnalysis(prepared, analysisId),
         cwdFlag: cwdFlag(cwd),
         ...(analysisOffIn === undefined ? {} : { analysisOffIn }),
+        ...(liveStudy === undefined ? {} : { liveStudy }),
     };
 }
 /** The view of a run that could not be found. */

package/dist/evidence/redaction.d.ts

@@ -112,11 +112,11 @@ export interface RedactionHooks {
 /** The default hooks wired into every actor: redaction.ts is the source of truth. */
 export declare const defaultRedactionHooks: RedactionHooks;
 /**
- * Replace each literal value with [REDACTED_SECRET]. For values that have no secret shape to
+ * Replace each literal value with `marker`. For values that have no secret shape to
  * pattern-match, such as provisioned keys and subject env values. `values` is read on each call,
  * so a value registered later is scrubbed too.
  */
-export declare function scrubLiterals(values: readonly string[]): (text: string) => string;
+export declare function scrubLiterals(values: readonly string[], marker?: string): (text: string) => string;
 /**
  * Coerce an unknown thrown value to its message string. Prefer this over the
  * inline `error instanceof Error ? error.message : String(error)` so error

package/dist/evidence/redaction.js

@@ -522,12 +522,12 @@ function blurPass(src, width, height, radius, horizontal) {
     return out;
 }
 /**
- * Replace each literal value with [REDACTED_SECRET]. For values that have no secret shape to
+ * Replace each literal value with `marker`. For values that have no secret shape to
  * pattern-match, such as provisioned keys and subject env values. `values` is read on each call,
  * so a value registered later is scrubbed too.
  */
-export function scrubLiterals(values) {
-    return (text) => values.reduce((current, value) => current.split(value).join("[REDACTED_SECRET]"), text);
+export function scrubLiterals(values, marker = "[REDACTED_SECRET]") {
+    return (text) => values.reduce((current, value) => current.split(value).join(marker), text);
 }
 /**
  * Coerce an unknown thrown value to its message string. Prefer this over the

package/dist/evidence/secret-scrub.d.ts

@@ -1,3 +1,10 @@
+/**
+ * A value as written, and percent-encoded, JSON-escaped once (also with non-ASCII characters as
+ * `\u` escapes) and twice, base64 at each byte offset, base64url and hex. Twice, because a JSON event can carry a command's JSON output as a string. An
+ * escaped form is searched for at any length, as the value is: it holds a backslash or a `%`, so it
+ * is not ordinary text.
+ */
+export declare function encodedForms(value: string): string[];
 /**
  * A scrub that replaces each non-empty value and its encoded forms with `[REDACTED_SECRET]`. Every
  * occurrence of every form is found on its own, and overlapping finds are merged into one span, so

package/dist/evidence/secret-scrub.js

@@ -25,25 +25,34 @@ function base64Middles(bytes, encoding) {
         return encoded.slice(start, end);
     });
 }
-/** A value as written, and percent-encoded, JSON-escaped, base64 at each byte offset, base64url and hex. */
-function encodedForms(value) {
+/**
+ * A value as written, and percent-encoded, JSON-escaped once (also with non-ASCII characters as
+ * `\u` escapes) and twice, base64 at each byte offset, base64url and hex. Twice, because a JSON event can carry a command's JSON output as a string. An
+ * escaped form is searched for at any length, as the value is: it holds a backslash or a `%`, so it
+ * is not ordinary text.
+ */
+export function encodedForms(value) {
     const bytes = Buffer.from(value, "utf8");
-    const encoded = [
-        JSON.stringify(value).slice(1, -1),
+    const json = JSON.stringify(value).slice(1, -1);
+    // A serializer that writes ASCII only, such as Python's json.dumps, spells é as \u00e9.
+    const asciiJson = json.replace(/[^\x00-\x7f]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+    const escaped = [json, asciiJson, JSON.stringify(json).slice(1, -1)];
+    // The encoders throw on a lone surrogate. Such a value is still found as written. encodeURI
+    // keeps a `/` or a `:` as written, as a URL path does.
+    try {
+        escaped.push(encodeURIComponent(value), encodeURI(value));
+    }
+    catch {
+        // no percent-encoded form
+    }
+    const binary = [
         bytes.toString("base64"),
         bytes.toString("base64url"),
         bytes.toString("hex"),
         ...base64Middles(bytes, "base64"),
         ...base64Middles(bytes, "base64url"),
     ];
-    // encodeURIComponent throws on a lone surrogate. Such a value is still found as written.
-    try {
-        encoded.push(encodeURIComponent(value));
-    }
-    catch {
-        // no percent-encoded form
-    }
-    return [value, ...encoded.filter((form) => form.length >= MIN_ENCODED_FORM)];
+    return [value, ...escaped, ...binary.filter((form) => form.length >= MIN_ENCODED_FORM)];
 }
 /** Every occurrence of every form, outside the markers, merged where they overlap or touch. */
 function secretSpans(text, forms) {

package/dist/routes/computer-use/bundle-parts.d.ts

@@ -1,39 +1,8 @@
-import type { CuaLoopResult } from "../../actors/computer-use/loop.js";
-import { type RunFeedbackCandidate, type RunProviderResource, type RunSubjectProvenance } from "../../run/bundle.js";
+import { type RunProviderResource, type RunSubjectProvenance } from "../../run/bundle.js";
 import { type ParticipantIds } from "../../run/participant-records.js";
 import { type CuaSubjectProvenanceArg, type ParticipantRunOutcome } from "./types.js";
 /** The human-readable state story appended to the provenance event (and review.md via it). */
 export declare function describeSubjectState(state: RunSubjectProvenance["state"], dryRun: boolean): string;
-/**
- * Feedback candidates derived from what live participants actually reported.
- *
- * A live run's feedback draft comes from these candidates, never from a dry-run template. The
- * candidate worth filing is the one the study produced: a participant
- * who reported friction on the way (the most valuable thing a run captures), or one who stopped
- * trying. A clean pass files nothing here: feedback exists to carry findings, and a run without
- * any falls back to a live summary in the draft layer instead of a template.
- *
- * Everything quoted is already scrub+redacted (participant messages and `session.reason` pass
- * through redactNarration in the loop) and passes redactText again here as defense-in-depth.
- */
-export declare function participantFeedbackCandidates(args: {
-    runId: string;
-    scenarioId: string;
-    adapterId: string;
-    /** The already-redacted study goal (what bundle.scenario.goal carries). */
-    goal: string;
-    substrate: RunFeedbackCandidate["substrate"];
-    participants: Array<{
-        /** The participant's plan id; it names the candidate and its idempotency key. */
-        participantId: string;
-        streamId: string;
-        personaId: string;
-        session?: CuaLoopResult;
-        traceArtifactPath?: string;
-        screenshots: string[];
-        commsArtifactPath?: string;
-    }>;
-}): RunFeedbackCandidate[];
 /** Human-readable provenance line for the single-participant subject.provenance event:
  *  claims "cloned/packed and served" only when it actually happened. */
 export declare function subjectProvenanceMessage(provenance: CuaSubjectProvenanceArg, publicAppUrl: string, dryRun: boolean, hasSession: boolean): string;