humanish 0.111.3 → 0.111.4

package/CHANGELOG.md

@@ -8,6 +8,21 @@ 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

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/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/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/scripted/route.js

@@ -121,6 +121,7 @@ async function runScriptedPlanInScope(plan, input, scope) {
                 persona: setup.persona,
                 timeoutMs: setup.timeoutMs,
                 artifactRoot,
+                scrubKnownValues: run.secrets.scrub,
             }, {
                 surfaces: setup.surfaces,
                 deps: setup.deps,

package/dist/routes/scripted/setup.js

@@ -5,6 +5,7 @@ import { realpath } from "node:fs/promises";
 import { firstLiveRefusal, keysCheck, subjectEnvCheck } from "../../study/requirements.js";
 import path from "node:path";
 import { resolveBrowserCommand } from "../../actors/scripted-browser/browser-command.js";
+import { publicSafeToken } from "../../actors/scripted-browser/journey.js";
 import { prepareSelectedOutputDirectory } from "../../run/contained-output.js";
 import { RunSecrets } from "../../run/secrets.js";
 import { evidenceAppUrlOf } from "./plan.js";
@@ -26,7 +27,16 @@ export async function prepareScriptedRun(plan, input) {
     const deps = input.deps ?? {};
     const warnings = [];
     const clone = plan.subject.kind === "clone" ? plan.subject : undefined;
-    const evidenceAppUrl = evidenceAppUrlOf(plan.subject);
+    const subjectEnvNames = [...(clone?.env ?? [])];
+    const env = input.env ?? process.env;
+    const e2bApiKey = env.E2B_API_KEY?.trim() ?? "";
+    const secrets = new RunSecrets([
+        e2bApiKey,
+        ...(clone ? [clone.repo] : []),
+        ...subjectEnvNames.map((name) => env[name] ?? ""),
+    ]);
+    // An app-url run records the URL it was given, in the bundle and every summary.
+    const evidenceAppUrl = secrets.scrub(evidenceAppUrlOf(plan.subject));
     const failed = (code, message) => refusedResult("scripted", { studyId: plan.studyId, cwd, warnings, error: { code, message } }, {
         actor: plan.actor,
         appUrl: evidenceAppUrl,
@@ -37,16 +47,8 @@ export async function prepareScriptedRun(plan, input) {
     const urlPolicy = clone
         ? { kind: "provisioned-subject", evidenceOrigin: evidenceAppUrl }
         : { kind: "loopback" };
-    const subjectEnvNames = [...(clone?.env ?? [])];
-    const env = input.env ?? process.env;
-    const e2bApiKey = env.E2B_API_KEY?.trim() ?? "";
     const hasGithubToken = subjectEnvNames.includes("GITHUB_TOKEN");
     const redactRepoLabel = plan.residual.policies?.redactRepos ?? hasGithubToken;
-    const secrets = new RunSecrets([
-        e2bApiKey,
-        ...(clone ? [clone.repo] : []),
-        ...subjectEnvNames.map((name) => env[name] ?? ""),
-    ]);
     // A clone's URL is replaced by its getHost URL once it is served.
     let appUrl = plan.subject.kind === "clone" ? plan.subject.serve.url : plan.subject.appUrl;
     const scenario = await resolveScriptedScenario(projectRoot, plan.scenarioRef);
@@ -56,7 +58,17 @@ export async function prepareScriptedRun(plan, input) {
             result: failed("HUMANISH_SCRIPTED_SCENARIO_INVALID", scenario.message),
         };
     }
-    const journey = scenario.journey;
+    // The goal, title and step labels are recorded; a step's path, selector, value and expected text
+    // drive the browser and stay as written.
+    const journey = {
+        ...scenario.journey,
+        scenarioId: idHoldsKnownValue(scenario.journey.scenarioId, secrets)
+            ? "scenario"
+            : scenario.journey.scenarioId,
+        goal: secrets.scrub(scenario.journey.goal),
+        scenarioTitle: secrets.scrub(scenario.journey.scenarioTitle),
+        steps: recordedStepIds(scenario.journey.steps, secrets),
+    };
     // The plan lists E2B_API_KEY and the subject env only for a live clone.
     const { requirements } = plan;
     const refusal = await firstLiveRefusal([
@@ -118,3 +130,34 @@ export async function prepareScriptedRun(plan, input) {
         },
     };
 }
+/**
+ * Whether an id holds a known value as written or as the parser's id token of it, lower-cased with
+ * other characters as `-`, which the scrub would not find.
+ */
+function idHoldsKnownValue(id, secrets) {
+    return (secrets.scrub(id) !== id ||
+        secrets.values().some((value) => {
+            const token = publicSafeToken(value, "");
+            return token.length > 0 && id.includes(token);
+        }));
+}
+/**
+ * The steps with their labels scrubbed and their ids safe to record. A step id names the step's
+ * screenshot file and is recorded beside it, and the parser derives an omitted id from the label,
+ * lower-cased and cut to 80 characters, so the scrub may not find a value in it. A step whose
+ * label or id holds a known value is renamed by its position instead.
+ */
+function recordedStepIds(steps, secrets) {
+    const taken = new Set(steps.map((step) => step.id));
+    return steps.map((step, index) => {
+        const label = secrets.scrub(step.label);
+        if (label === step.label && !idHoldsKnownValue(step.id, secrets))
+            return { ...step, label };
+        const position = `step-${String(index + 1).padStart(2, "0")}`;
+        let id = position;
+        for (let suffix = 2; taken.has(id); suffix += 1)
+            id = `${position}-${suffix}`;
+        taken.add(id);
+        return { ...step, id, label };
+    });
+}

package/dist/routes/scripted/surface-sessions.d.ts

@@ -3,7 +3,7 @@ import type { ScriptedPlan } from "../../study/plan-types.js";
 import { type PreparedRunArtifactPaths } from "../../run/paths.js";
 import type { StudyDeps } from "../../study/study-deps.js";
 /** One session per surface, in parallel. */
-export declare function runScriptedSessions(session: Required<Pick<ScriptedBrowserSessionOptions, "appUrl" | "evidenceAppUrl" | "urlPolicy" | "journey" | "persona" | "timeoutMs" | "artifactRoot">>, run: {
+export declare function runScriptedSessions(session: Required<Pick<ScriptedBrowserSessionOptions, "appUrl" | "evidenceAppUrl" | "urlPolicy" | "journey" | "persona" | "timeoutMs" | "artifactRoot" | "scrubKnownValues">>, run: {
     surfaces: ScriptedPlan["surfaces"];
     deps: StudyDeps;
     browserCommand: string | undefined;

package/dist/routes/scripted/surface-sessions.js

@@ -7,6 +7,7 @@ import { validateScriptedSessionResult } from "./session-result.js";
 /** One session per surface, in parallel. */
 export function runScriptedSessions(session, run) {
     const { appUrl, evidenceAppUrl, urlPolicy, journey, persona, timeoutMs, artifactRoot } = session;
+    const { scrubKnownValues } = session;
     const { surfaces, deps, browserCommand, runPaths, onSessionStart } = run;
     const runSession = deps.runScriptedSession;
     return Promise.all(surfaces.map((surface) => {
@@ -20,6 +21,7 @@ export function runScriptedSessions(session, run) {
             persona,
             timeoutMs,
             artifactRoot,
+            scrubKnownValues,
             ...(browserCommand === undefined ? {} : { browserCommand }),
             ...(deps.launchBrowser === undefined ? {} : { launchBrowser: deps.launchBrowser }),
             ...(deps.now === undefined ? {} : { now: deps.now }),

package/dist/routes/terminal/credentials.js

@@ -1,5 +1,18 @@
 import { DEFAULT_RUNTIME_AUTH, E2B_SYSTEM_CA_BUNDLE, OPENAI_EGRESS_PLACEHOLDER, } from "./runtime-auth.js";
 import { TERMINAL_PRODUCT_STUDY_PROVIDER_METADATA } from "./types.js";
+/**
+ * Where the study's runtime auth puts the key, as a sentence for the missing-key refusal. Typed
+ * `unknown` because a config that skipped the planner may hold a mode the type does not list.
+ */
+function keyPlacement(runtimeAuth) {
+    if (runtimeAuth === undefined)
+        return ` \`execution.runtimeAuth\` is unset, so the default ${DEFAULT_RUNTIME_AUTH} keeps the key outside the sandbox in an E2B header transform.`;
+    if (runtimeAuth === "openai-egress")
+        return " `execution.runtimeAuth: openai-egress` keeps the key outside the sandbox in an E2B header transform.";
+    if (runtimeAuth === "openai-env")
+        return " `execution.runtimeAuth: openai-env` passes the key to the codex command only.";
+    return "";
+}
 /**
  * Resolve the runtime key on the host. openai-egress, the default, returns an inert command env
  * while retaining the actual value for the external transform and literal redaction; openai-env
@@ -38,7 +51,7 @@ export function buildRuntimeAuth(args) {
         return {
             ok: false,
             code: "HUMANISH_TERMINAL_RUNTIME_AUTH_MISSING",
-            message: `Live terminal-product studies declare runtimeAuth "${String(args.runtimeAuth)}" and need ${ALLOWED_RUNTIME_KEY_NAMES.join(" or ")} in the environment (pass via --dotenv; the selected auth mode places the value in command-scoped env or an external E2B header transform; the value is never persisted).`,
+            message: `Live terminal-product studies need ${ALLOWED_RUNTIME_KEY_NAMES.join(" or ")} in the environment, and neither is set.${keyPlacement(args.runtimeAuth)} Pass one with --dotenv; the value is never persisted.`,
         };
     }
     const keyValue = args.env[keyName];

package/dist/routes/terminal/live-finish.js

@@ -19,14 +19,17 @@ function buildLiveTrace(inputs) {
     const { session } = inputs;
     const { createdAt } = inputs.run;
     const { terminalEvents, commandLog, discardedPrefixes } = inputs.recorder;
-    // Prefix reconciliation may cut through a known key. Scrub literal values across the retained
-    // chunks before any transcript/trace/event artifact is persisted. Check both each stream and
+    // Prefix reconciliation may cut through a known key. Scrub the known values, as written and in
+    // each encoded form, across the retained chunks before any transcript/trace/event artifact is
+    // persisted. Check both each stream and
     // the combined event order that the transcript uses; either view can assemble a split value.
-    scrubSplitKnownValues(terminalEvents, inputs.run.secrets.values(), discardedPrefixes);
+    scrubSplitKnownValues(terminalEvents, (text) => inputs.run.secrets.spans(text), discardedPrefixes);
     // Build the actor trace first (the cost ledger reads its tokenUsage). A session past the cap
     // ends its transcript with what was not stored, and its trace says the same.
     const cut = inputs.recorder.transcriptCut();
-    const normalizedTranscript = `${normalizeLocalActorTranscript(terminalEvents.map((e) => e.chunk).join(""))}${cut ? `\n[humanish] ${cut.notice}` : ""}`;
+    // Normalizing removes terminal escape sequences, which rejoins a value one of them split, so the
+    // transcript is sanitized again after it.
+    const normalizedTranscript = `${sanitize(normalizeLocalActorTranscript(terminalEvents.map((e) => e.chunk).join("")))}${cut ? `\n[humanish] ${cut.notice}` : ""}`;
     // Parsed from the full stream: usage records arrive once per turn, and the tail
     // would drop all but the last. Records past the cap were kept as they arrived.
     const terminalTokenUsage = parseTerminalTokenUsage([normalizedTranscript, ...(cut?.usage ?? [])].join("\n"));

package/dist/routes/terminal/session.js

@@ -70,7 +70,7 @@ export async function runLiveTerminalSession(args) {
     const recorder = createTerminalRecorder({
         nowIso,
         sanitize,
-        knownSecretValues: run.secrets.values(),
+        knownSecretValues: run.secrets.forms(),
         verdictNonce,
     });
     const { version, model, modelSource, reasoningEffort } = plan.runtime;

package/dist/routes/terminal/trace.d.ts

@@ -5,9 +5,11 @@ import { type CommandLogRecord, type TerminalEventRecord } from "./types.js";
 /**
  * Per-chunk sanitization cannot recognize a value split across deliveries. Redact those complete
  * known values before persistence without collapsing events or changing stdout/stderr ordering.
- * Work backwards through matches so edits to later text leave earlier offsets valid.
+ * `spansOf` finds them in the joined text: RunSecrets.spans, which also finds a value in an
+ * encoded form or split by a terminal escape sequence. Work backwards through the spans so edits
+ * to later text leave earlier offsets valid.
  */
-export declare function scrubSplitKnownValues(events: TerminalEventRecord[], knownValues: readonly string[], discardedPrefixes: Record<"stdout" | "stderr" | "combined", string>): void;
+export declare function scrubSplitKnownValues(events: TerminalEventRecord[], spansOf: (text: string) => ReadonlyArray<readonly [number, number]>, discardedPrefixes: Record<"stdout" | "stderr" | "combined", string>): void;
 /** Redacted, ellipsis-prefixed tail of a captured stream/log for a message field. */
 export declare function tailOf(text: string): string;
 /**

package/dist/routes/terminal/trace.js

@@ -4,50 +4,45 @@ import { TAIL_CHARS } from "./types.js";
 /**
  * Per-chunk sanitization cannot recognize a value split across deliveries. Redact those complete
  * known values before persistence without collapsing events or changing stdout/stderr ordering.
- * Work backwards through matches so edits to later text leave earlier offsets valid.
+ * `spansOf` finds them in the joined text: RunSecrets.spans, which also finds a value in an
+ * encoded form or split by a terminal escape sequence. Work backwards through the spans so edits
+ * to later text leave earlier offsets valid.
  */
-export function scrubSplitKnownValues(events, knownValues, discardedPrefixes) {
+export function scrubSplitKnownValues(events, spansOf, discardedPrefixes) {
     for (const order of ["stdout", "stderr", "combined"]) {
         const chunks = order === "combined" ? [...events] : events.filter((event) => event.stream === order);
         // A virtual final chunk makes a key crossing the capture cap recognizable. Edits to retained
         // events redact evidence; the raw overlap and this virtual chunk are never persisted.
         if (discardedPrefixes[order])
             chunks.push({ chunk: discardedPrefixes[order] });
-        for (const value of knownValues) {
-            if (!value)
+        let offset = 0;
+        const starts = chunks.map((event) => {
+            const start = offset;
+            offset += event.chunk.length;
+            return start;
+        });
+        const text = chunks.map((event) => event.chunk).join("");
+        for (const [at, end] of [...spansOf(text)].reverse()) {
+            let first = 0;
+            while (first + 1 < starts.length && (starts[first + 1] ?? Infinity) <= at)
+                first += 1;
+            let last = first;
+            while (last + 1 < starts.length && (starts[last + 1] ?? Infinity) < end)
+                last += 1;
+            const firstChunk = chunks[first];
+            const lastChunk = chunks[last];
+            if (!firstChunk || !lastChunk)
                 continue;
-            let offset = 0;
-            const starts = chunks.map((event) => {
-                const start = offset;
-                offset += event.chunk.length;
-                return start;
-            });
-            const text = chunks.map((event) => event.chunk).join("");
-            const matches = [];
-            for (let at = text.indexOf(value); at !== -1; at = text.indexOf(value, at + value.length))
-                matches.push(at);
-            for (const at of matches.reverse()) {
-                let first = 0;
-                while (first + 1 < starts.length && (starts[first + 1] ?? Infinity) <= at)
-                    first += 1;
-                let last = first;
-                while (last + 1 < starts.length && (starts[last + 1] ?? Infinity) < at + value.length)
-                    last += 1;
-                const firstChunk = chunks[first];
-                const lastChunk = chunks[last];
-                if (!firstChunk || !lastChunk)
-                    continue;
-                const before = firstChunk.chunk.slice(0, at - (starts[first] ?? 0));
-                const after = lastChunk.chunk.slice(at + value.length - (starts[last] ?? 0));
-                firstChunk.chunk = `${before}[REDACTED_SECRET]${first === last ? after : ""}`;
-                for (let index = first + 1; index < last; index += 1) {
-                    const middle = chunks[index];
-                    if (middle)
-                        middle.chunk = "";
-                }
-                if (first !== last)
-                    lastChunk.chunk = after;
+            const before = firstChunk.chunk.slice(0, at - (starts[first] ?? 0));
+            const after = lastChunk.chunk.slice(end - (starts[last] ?? 0));
+            firstChunk.chunk = `${before}[REDACTED_SECRET]${first === last ? after : ""}`;
+            for (let index = first + 1; index < last; index += 1) {
+                const middle = chunks[index];
+                if (middle)
+                    middle.chunk = "";
             }
+            if (first !== last)
+                lastChunk.chunk = after;
         }
     }
 }

package/dist/run/secrets.d.ts

@@ -8,8 +8,10 @@ interface RunSecretsOptions {
 export declare class RunSecrets {
     #private;
     /**
-     * Replaces every held value with the marker. It reads the values on each call, so a value added
-     * after the scrub was handed to a participant or a subject is scrubbed from then on.
+     * Replaces every held value with the marker, as written, in each encoded form, and where a URL
+     * carries it partly percent-encoded or a terminal escape sequence splits it. It reads the values
+     * on each call, so a value added after the scrub was handed to a participant or a subject is
+     * scrubbed from then on.
      */
     readonly scrub: (text: string) => string;
     /** `seed` keeps its order; values shorter than the floor are dropped. */
@@ -18,5 +20,16 @@ export declare class RunSecrets {
     add(values: readonly string[]): void;
     /** The held values, seed first, in one array that later `add` calls extend. */
     values(): readonly string[];
+    /**
+     * Every held value as written and in each encoded form, longest first, in one array that later
+     * `add` calls extend. The terminal recorder sizes the output it keeps past its cap from these.
+     */
+    forms(): readonly string[];
+    /**
+     * Where `text` holds a held value: each encoded form as written, and each form in the text's
+     * view without terminal escape sequences and with percent escapes decoded. Sorted, with
+     * overlapping spans merged. A scrub that replaces across chunk boundaries reads these.
+     */
+    spans(text: string): Array<[number, number]>;
 }
 export {};

package/dist/run/secrets.js

@@ -1,33 +1,158 @@
 // The literal values one run scrubs from what it writes: the provider keys and subject env values
 // its route reads, and the values the run provisions while it runs, such as the addresses email
 // receiving registers. These have no secret shape for pattern redaction to find, so each is
-// replaced as written; redactText runs after the scrub and finds secrets by shape.
+// replaced as written and in the encoded forms a URL, a JSON body or a log line gives it;
+// redactText runs after the scrub and finds secrets by shape.
 import { scrubLiterals } from "../evidence/redaction.js";
+import { encodedForms } from "../evidence/secret-scrub.js";
 export class RunSecrets {
     // Private fields stay out of JSON.stringify and object spread, so a Run that reaches a writer
     // whole cannot carry the values with it.
-    #held;
+    #held = [];
+    /** Every held value as written and encoded, longest first. */
+    #forms = [];
     #minLength;
     /**
-     * Replaces every held value with the marker. It reads the values on each call, so a value added
-     * after the scrub was handed to a participant or a subject is scrubbed from then on.
+     * Replaces every held value with the marker, as written, in each encoded form, and where a URL
+     * carries it partly percent-encoded or a terminal escape sequence splits it. It reads the values
+     * on each call, so a value added after the scrub was handed to a participant or a subject is
+     * scrubbed from then on.
      */
     scrub;
     /** `seed` keeps its order; values shorter than the floor are dropped. */
     constructor(seed, options = {}) {
         // An empty value would match between every character.
         this.#minLength = Math.max(1, options.minLength ?? 4);
-        this.#held = seed.filter((value) => value.length >= this.#minLength);
-        this.scrub = scrubLiterals(this.#held, options.marker);
+        this.add(seed);
+        const marker = options.marker ?? "[REDACTED_SECRET]";
+        // Longest first, so a form that holds a shorter one, such as a JSON-escaped value ending in a
+        // backslash, is replaced whole and leaves no stray escape behind.
+        const literal = scrubLiterals(this.#forms, marker);
+        this.scrub = (text) => {
+            const scrubbed = literal(text);
+            return replaceSpans(scrubbed, viewSpans(scrubbed, this.#forms), marker);
+        };
     }
     /** Holds each value the run learns while it runs, unless it is under the floor or already held. */
     add(values) {
-        for (const value of values)
-            if (value.length >= this.#minLength && !this.#held.includes(value))
-                this.#held.push(value);
+        for (const value of values) {
+            if (value.length < this.#minLength || this.#held.includes(value))
+                continue;
+            this.#held.push(value);
+            for (const form of encodedForms(value))
+                if (!this.#forms.includes(form))
+                    this.#forms.push(form);
+        }
+        this.#forms.sort((left, right) => right.length - left.length);
     }
     /** The held values, seed first, in one array that later `add` calls extend. */
     values() {
         return this.#held;
     }
+    /**
+     * Every held value as written and in each encoded form, longest first, in one array that later
+     * `add` calls extend. The terminal recorder sizes the output it keeps past its cap from these.
+     */
+    forms() {
+        return this.#forms;
+    }
+    /**
+     * Where `text` holds a held value: each encoded form as written, and each form in the text's
+     * view without terminal escape sequences and with percent escapes decoded. Sorted, with
+     * overlapping spans merged. A scrub that replaces across chunk boundaries reads these.
+     */
+    spans(text) {
+        const found = viewSpans(text, this.#forms);
+        for (const form of this.#forms)
+            for (let at = text.indexOf(form); at !== -1; at = text.indexOf(form, at + form.length))
+                found.push([at, at + form.length]);
+        return mergeSpans(found);
+    }
+}
+// What a terminal draws with (operating-system commands, control sequences and two-byte escapes,
+// as written or JSON-escaped, as a JSON event carries a command's colored output) and what a URL
+// encodes with (runs of percent escapes). The view a value is looked for in drops the first and
+// decodes the second.
+const VIEW_SEQUENCE = new RegExp([
+    "\\x1b\\][^\\x07]*(?:\\x07|\\x1b\\\\)",
+    "\\x1b\\[[0-?]*[ -/]*[@-~]",
+    "\\x1b[78=>]",
+    "\\\\u001b\\][^\\\\]*(?:\\\\u0007|\\\\u001b\\\\\\\\)",
+    "\\\\u001b\\[[0-?]*[ -/]*[@-~]",
+    "(?:%[0-9A-Fa-f]{2})+",
+].join("|"), "g");
+/**
+ * Where a value is found in the text's view. A browser encodes a space or a quote in a URL path
+ * and leaves a `/` or a `:` as written, so a value with both matches no single encoded form, and a
+ * color code inside a value splits it. Each found value maps back to the span of `text` it came
+ * from, so the text keeps every other character as written.
+ */
+function viewSpans(text, values) {
+    if (!text.includes("%") && !text.includes("\x1b") && !text.includes("\\u001b"))
+        return [];
+    // The view, and for each of its characters the span of `text` it came from. A character decoded
+    // from an escape run maps to the whole run.
+    let view = "";
+    const starts = [];
+    const ends = [];
+    const copy = (from, to) => {
+        for (let at = from; at < to; at += 1) {
+            starts.push(at);
+            ends.push(at + 1);
+        }
+        view += text.slice(from, to);
+    };
+    let cursor = 0;
+    let changed = false;
+    for (const sequence of text.matchAll(VIEW_SEQUENCE)) {
+        let plain = "";
+        if (sequence[0].startsWith("%")) {
+            try {
+                plain = decodeURIComponent(sequence[0]);
+            }
+            catch {
+                // Not UTF-8: the run stays as written and is copied with the text after it.
+                continue;
+            }
+        }
+        copy(cursor, sequence.index);
+        cursor = sequence.index + sequence[0].length;
+        for (let unit = 0; unit < plain.length; unit += 1) {
+            starts.push(sequence.index);
+            ends.push(cursor);
+        }
+        view += plain;
+        changed = true;
+    }
+    if (!changed)
+        return [];
+    copy(cursor, text.length);
+    const spans = [];
+    for (const value of values)
+        for (let at = view.indexOf(value); at !== -1; at = view.indexOf(value, at + value.length))
+            spans.push([starts[at] ?? 0, ends[at + value.length - 1] ?? text.length]);
+    return spans;
+}
+/** Sorted, with overlapping spans merged; spans that only touch stay apart. */
+function mergeSpans(spans) {
+    const merged = [];
+    for (const [from, to] of [...spans].sort((left, right) => left[0] - right[0])) {
+        const last = merged.at(-1);
+        if (last !== undefined && from < last[1])
+            last[1] = Math.max(last[1], to);
+        else
+            merged.push([from, to]);
+    }
+    return merged;
+}
+function replaceSpans(text, spans, marker) {
+    if (spans.length === 0)
+        return text;
+    let replaced = "";
+    let written = 0;
+    for (const [from, to] of mergeSpans(spans)) {
+        replaced += `${text.slice(written, from)}${marker}`;
+        written = to;
+    }
+    return `${replaced}${text.slice(written)}`;
 }

package/dist/study/requirements.js

@@ -100,7 +100,8 @@ async function signedInAgentSuggestion(env) {
     if (ready.length === 0)
         return "";
     const labels = ready.map((agent) => agent.label).join(" and ");
-    return ` ${labels} reports authenticated on this machine. Set actor.type: local-agent to use ${ready.length === 1 ? "it" : "one"} instead of a key.`;
+    const one = ready.length === 1;
+    return ` ${labels} ${one ? "reports" : "report"} authenticated on this machine. Set actor.type: local-agent to use ${one ? "it" : "one"} instead of a key.`;
 }
 /**
  * Refuses a local-agent brain whose CLI is missing, signed out, too old, or cannot honor the

package/docs/contracts/study-analysis.md

@@ -308,7 +308,7 @@ analysis record and its corrections, as before. Reading findings never starts an
 | `state`                                                                        | `ready`, `stale`, `running`, `none`, `skipped`, `failed`, `dry_run` or `unavailable`. Only `ready` and `stale` carry findings.                                                                                                                                                                                                                |
 | `reason`                                                                       | The stable code behind a state other than `ready`, or null: an automatic analysis reason such as `AUTOMATIC_ANALYSIS_KEY_MISSING`, a failed attempt's error code, or a load warning such as `ANALYSIS_SOURCE_CHANGED`.                                                                                                                        |
 | `message`                                                                      | What happened, in words.                                                                                                                                                                                                                                                                                                                      |
-| `next`                                                                         | The command that gets findings for this run, or null when no command can, as for a dry run or a run whose participants left no evidence.                                                                                                                                                                                                      |
+| `next`                                                                         | The command that gets findings for this run, or for a dry run the command that starts a live one. Null when no command can, as for a run whose participants left no evidence.                                                                                                                                                                 |
 | `analysisId`, `status`, `provider`, `model`, `completedAt`, `estimatedCostUsd` | The analysis version `analyze show` selects: the newest ready one, else the newest stale one. Null without one.                                                                                                                                                                                                                               |
 | `runPath`, `path`                                                              | The run directory and the version's `analysis.json`, relative to the project directory.                                                                                                                                                                                                                                                       |
 | `summary`, `limitations`                                                       | The analysis's own summary and limitations.                                                                                                                                                                                                                                                                                                   |
@@ -328,7 +328,11 @@ The states without findings:
   reruns it with the same analyst, `--provider codex` for the Codex account analyst.
 - `none`: no analysis ran for this live run and nothing records why, for example a run that
   started from a library call, or one whose study file has moved or changed id.
-- `dry_run`: a dry run has no participant evidence to analyze.
+- `dry_run`: a dry run has no participant evidence to analyze. `next` is `run` with the run's own
+  study when its file sets `mode: live`, else `run try-live` when the project has that starter study
+  with `mode: live`, else `run` with the run's own study, and the message says to set `mode: live`
+  in its file first. A preview study only dry-runs, and a run with none of these names
+  `study list`.
 - `unavailable`: the run or its analysis records could not be read or checked, or the analysis
   text matched a sensitive-text pattern (`ANALYSIS_SENSITIVE_TEXT_QUARANTINED`), which the
   Observer withholds too.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.111.3",
+  "version": "0.111.4",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",