humanish 0.111.2 → 0.111.3

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

@@ -0,0 +1,92 @@
+// Feedback candidates from what live participants reported. The computer-use bundles (single and
+// fan-out) and the shared-world bundle all build them here, so a participant's report becomes the
+// same candidate whichever route ran it.
+import { redactText } from "../../evidence/redaction.js";
+import { feedbackProofCommands } from "../../feedback/proof.js";
+import { resolveSelfReportedFriction } from "./self-report.js";
+/**
+ * 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 function participantFeedbackCandidates(args) {
+    const candidates = [];
+    for (const participant of args.participants) {
+        const session = participant.session;
+        if (session === undefined)
+            continue;
+        const friction = resolveSelfReportedFriction(session);
+        const abandoned = session.status === "abandoned";
+        if (friction === undefined && !abandoned)
+            continue;
+        const summary = friction !== undefined
+            ? `Participant ${participant.personaId} (${participant.participantId}) reported friction on the way through the study goal`
+            : `Participant ${participant.personaId} (${participant.participantId}) stopped before completing the study goal`;
+        const lastScreenshot = participant.screenshots[participant.screenshots.length - 1];
+        candidates.push({
+            schema: "humanish.feedback-candidate.v1",
+            id: `participant-report-${participant.participantId}`,
+            run_id: args.runId,
+            stream_id: participant.streamId,
+            adapter_id: args.adapterId,
+            scenario_id: args.scenarioId,
+            persona_id: participant.personaId,
+            actor: "computer-use",
+            substrate: args.substrate,
+            // The participant is reporting on the product: friction and abandonment are target-app
+            // findings by the three-roles rule. A harness failure never reaches this builder; it is
+            // not a participant report.
+            failure_owner: "target-app",
+            summary,
+            expected: participant.goal,
+            actual: redactText(friction ?? session.reason),
+            evidence: [
+                ...(participant.traceArtifactPath === undefined
+                    ? []
+                    : [
+                        {
+                            path: participant.traceArtifactPath,
+                            kind: "trace",
+                            note: "Full actor trace: turns, actions, and the participant's own report.",
+                        },
+                    ]),
+                ...(lastScreenshot === undefined
+                    ? []
+                    : [
+                        {
+                            path: lastScreenshot,
+                            kind: "screenshot",
+                            note: "Final screenshot at the moment the session ended.",
+                        },
+                    ]),
+                ...(participant.commsArtifactPath === undefined
+                    ? []
+                    : [
+                        {
+                            path: participant.commsArtifactPath,
+                            kind: "log",
+                            note: "Digest-only comms thread captured in-sandbox.",
+                        },
+                    ]),
+            ],
+            redaction: {
+                status: "passed",
+                notes: "Quoted participant text passed the loop's known-value scrub and pattern redaction before persisting, and redactText again here.",
+            },
+            idempotency_key: `humanish:${args.runId}:${participant.participantId}:participant-report`,
+            proposed_next_state: "study-quality-review",
+            acceptance_proof: [
+                feedbackProofCommands(args.runId).verify,
+                feedbackProofCommands(args.runId).observe,
+            ],
+        });
+    }
+    return candidates;
+}

package/dist/routes/computer-use/participant-model.d.ts

@@ -41,4 +41,15 @@ export declare function judgeParticipantSession(session: CuaLoopResult | undefin
     selfReportedBlocker: boolean;
     reportedFriction: boolean;
 };
+/**
+ * caps.maxUsd is enforced inside each participant's loop independently, so N participants can
+ * spend up to N × maxUsd before any of them stops, while the run cost summary reports the larger
+ * aggregate. The warning names that ceiling, unless the study declared a shared maxTotalUsd budget.
+ * `capped` names what the cap counts: shared world says model spend, because the external-public
+ * plane's lobby-code reads are not counted against it.
+ */
+export declare function participantCapWarning(caps: {
+    readonly maxUsd?: number;
+    readonly maxTotalUsd?: number;
+}, participantCount: number, capped?: string): string | undefined;
 export declare function makeCuaRunBudget(maxTotalUsd: number): CuaRunBudget;

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

@@ -257,6 +257,21 @@ export function judgeParticipantSession(session, deps, warnings) {
     }
     return { noEngagement, selfReportedBlocker, reportedFriction };
 }
+/**
+ * caps.maxUsd is enforced inside each participant's loop independently, so N participants can
+ * spend up to N × maxUsd before any of them stops, while the run cost summary reports the larger
+ * aggregate. The warning names that ceiling, unless the study declared a shared maxTotalUsd budget.
+ * `capped` names what the cap counts: shared world says model spend, because the external-public
+ * plane's lobby-code reads are not counted against it.
+ */
+export function participantCapWarning(caps, participantCount, capped = "each participant") {
+    const capUsd = caps.maxUsd;
+    if (capUsd === undefined || participantCount <= 1)
+        return undefined;
+    if (caps.maxTotalUsd !== undefined)
+        return undefined;
+    return `caps.maxUsd ($${capUsd}) caps ${capped}, so ${participantCount} participants may spend up to ${participantCount} × $${capUsd} (about $${round6(capUsd * participantCount)}) before any of them stops. Set caps.maxTotalUsd for one budget across the study.`;
+}
 export function makeCuaRunBudget(maxTotalUsd) {
     const participantEstimates = new Map();
     return {

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

@@ -1,11 +1,7 @@
 import { pricedModel } from "../../study/plan-base.js";
-import { missingKeys, missingSubjectEnv } from "../../study/requirements.js";
-import { detectLocalAgents } from "../../actors/local-agent/cli.js";
-import { localAgentRefusal } from "../../actors/local-agent/readiness.js";
-import { describeMissingKeys } from "../../keys/key-resolution.js";
+import { firstLiveRefusal, keysCheck, localAgentCheck, subjectEnvCheck, unpricedCapCheck, } from "../../study/requirements.js";
 import { catchTokenOf, catchTokenRefusal } from "../../comms/external-evidence.js";
 import { externalCatchHealthy } from "../../comms/sandbox-catch.js";
-import { MODEL_RATES, unpricedCapMessage } from "../../run/pricing.js";
 /** The computer-use code for each local-agent refusal; shared-world keeps the same kinds. */
 const LOCAL_AGENT_REFUSAL_CODES = {
     "agent-missing": "HUMANISH_COMPUTER_USE_AGENT_MISSING",
@@ -21,69 +17,41 @@ const LOCAL_AGENT_REFUSAL_CODES = {
  */
 export async function liveCuaRejection(args) {
     const { caps, brain, env, requirements, externalCommsConfig } = args;
-    // The plan lists OPENAI_API_KEY only for an openai brain (a signed-in local agent or the
-    // caller's provider needs none) and E2B_API_KEY only when this run creates hosted desktops.
-    const localAgent = brain.kind === "local-agent" ? brain.agent : undefined;
-    const missing = missingKeys(requirements, env);
-    if (missing.length > 0) {
-        // The moment someone new actually hits the wall. If a signed-in coding agent is sitting
-        // right there, say so here rather than making them go and find an API key; that detour is
-        // where most people trying humanish stop.
-        const suggestion = missing.includes("OPENAI_API_KEY")
-            ? await (async () => {
-                const ready = (await detectLocalAgents({ env })).filter((agent) => agent.authStatus === "authenticated");
-                return ready.length === 0
-                    ? ""
-                    : ` ${ready.map((agent) => agent.label).join(" and ")} reports authenticated on this machine` +
-                        `. Set actor.type: local-agent to use ${ready.length === 1 ? "it" : "one"} instead of a key.`;
-            })()
-            : "";
-        return {
+    return firstLiveRefusal([
+        // The plan lists OPENAI_API_KEY only for an openai brain (a signed-in local agent or the
+        // caller's provider needs none) and E2B_API_KEY only when this run creates hosted desktops.
+        () => keysCheck({
+            requirements,
+            env,
             code: "HUMANISH_COMPUTER_USE_KEYS_MISSING",
-            message: `Live computer-use studies need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}${suggestion}`,
-        };
-    }
-    // A caller's createProvider makes the brain `caller`, so only the study's own local agent is checked.
-    if (localAgent) {
-        // Refuse here, before a sandbox exists. "codex is not installed" discovered after the
-        // machine is paid for is the same information delivered at the worst possible moment.
-        const refusal = await localAgentRefusal({ agent: localAgent, env, caps });
-        if (refusal)
-            return { code: LOCAL_AGENT_REFUSAL_CODES[refusal.kind], message: refusal.message };
-    }
-    const unsetSubjectEnv = missingSubjectEnv(requirements, env);
-    if (unsetSubjectEnv.length > 0) {
-        return {
-            code: "HUMANISH_COMPUTER_USE_SUBJECT_ENV_MISSING",
-            message: `subject.env declares ${unsetSubjectEnv.join(", ")} but the environment does not provide ${unsetSubjectEnv.length === 1 ? "it" : "them"} (pass via --dotenv; values are never persisted).`,
-        };
-    }
-    // Fail-closed cap: a maxUsd cap needs a measurable per-turn estimate.
-    // If the operator set caps.maxUsd but src/run/pricing.ts has no rate for the resolved
-    // model, the loop could not enforce the cap, and silently running uncapped would break the
-    // runaway-retry protection. Refuse at preflight (before any sandbox/spend) rather than run
-    // uncapped: an unenforceable cap is more dangerous than none. The operator picks a priced model
-    // or removes the cap; a source checkout can also add a rate to src/run/pricing.ts.
-    if (caps.maxUsd !== undefined || caps.maxTotalUsd !== undefined) {
-        const model = pricedModel(brain);
-        const capModelId = model.trim().toLowerCase();
-        if (!MODEL_RATES[capModelId]) {
-            return {
-                code: "HUMANISH_COMPUTER_USE_UNPRICED_CAP",
-                message: unpricedCapMessage(model),
-            };
-        }
-    }
-    // Adopter-hosted comms catch: fail closed before any sandbox is created, because a comms study
-    // whose catch is unreachable collects nothing while every participant still spends. The probe asserts
-    // humanish's own service marker in /health, so an adopter's proxy answering 200 for everything cannot
-    // pass for a catch.
-    const tokenRefusal = externalCommsConfig === undefined
-        ? undefined
-        : catchTokenRefusal(catchTokenOf(externalCommsConfig, env));
+            need: (names) => `Live computer-use studies need ${names} in the environment (values are never persisted).`,
+            suggestLocalAgent: true,
+        }),
+        // A caller's createProvider makes the brain `caller`, so only the study's own local agent is
+        // checked.
+        () => localAgentCheck({ brain, env, caps, codes: LOCAL_AGENT_REFUSAL_CODES }),
+        () => subjectEnvCheck({ requirements, env, code: "HUMANISH_COMPUTER_USE_SUBJECT_ENV_MISSING" }),
+        () => unpricedCapCheck({
+            caps,
+            model: pricedModel(brain),
+            code: "HUMANISH_COMPUTER_USE_UNPRICED_CAP",
+        }),
+        () => externalCatchCheck(externalCommsConfig, env),
+    ]);
+}
+/**
+ * Adopter-hosted comms catch: refused before any sandbox is created, because a comms study whose
+ * catch is unreachable collects nothing while every participant still spends. The probe asserts
+ * humanish's own service marker in /health, so an adopter's proxy answering 200 for everything
+ * cannot pass for a catch.
+ */
+async function externalCatchCheck(externalCommsConfig, env) {
+    if (externalCommsConfig === undefined)
+        return undefined;
+    const tokenRefusal = catchTokenRefusal(catchTokenOf(externalCommsConfig, env));
     if (tokenRefusal !== undefined)
         return { code: "HUMANISH_COMPUTER_USE_COMMS_TOKEN_INVALID", message: tokenRefusal };
-    if (externalCommsConfig && !(await externalCatchHealthy(externalCommsConfig))) {
+    if (!(await externalCatchHealthy(externalCommsConfig))) {
         return {
             code: "HUMANISH_COMPUTER_USE_COMMS_CATCH_UNREACHABLE",
             message: "The external comms catch or inbox is unreachable or incompatible (GET /health must identify humanish-comms-catch and advertise recipient-inbox-v1). Update humanish on the catch host and restart it with `humanish comms catch` on that host, or drop comms.email to run without the inbox funnel.",

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

@@ -1,8 +1,9 @@
 import { adapterScoreFailureMessage, applyBrowserScorer } from "../../study/adapter-extension.js";
 import { redactText } from "../../evidence/redaction.js";
-import { round6 } from "../../run/pricing.js";
-import { foldScorerFailures, judgeExecution, OUTCOME_POLICIES, participantHarnessFailed, resultOk, } from "../../run/judge.js";
-import { participantFactsOf, participantOutcomeOk, unreleasedSandboxFailures, } from "./participant-facts.js";
+import { foldScorerFailures, judgeExecution, OUTCOME_POLICIES, resultOk, } from "../../run/judge.js";
+import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
+import { participantExecutionFailures, participantOutcomeOk } from "./participant-facts.js";
+import { participantCapWarning } from "./participant-model.js";
 import { summarizeCuaDiagnostics } from "./diagnostics.js";
 import { toParticipantResult } from "./participant-execution.js";
 import { buildCuaRunBundle, judgeComputerUseRun } from "./bundle.js";
@@ -159,56 +160,10 @@ function cuaStudyResult(args) {
         ...(errorResult === undefined ? {} : { error: errorResult }),
     };
 }
-/**
- * The run's execution failures before the Observer renders: each participant whose session failed
- * in the harness, each provider whose cleanup is unconfirmed or that reported a disallowed item
- * after its last request, and each sandbox whose release is unconfirmed. FinishedRun.renderObserver
- * adds an Observer that did not render.
- */
-function computerUseExecutionFailures(outcomes, runId) {
-    return [
-        ...(outcomes ?? [])
-            .filter((outcome) => participantHarnessFailed(participantFactsOf(outcome)))
-            .map((outcome) => ({
-            kind: "harness",
-            message: `${outcome.spec.planned.id}: ${outcome.sessionError ?? outcome.session?.reason ?? "harness error"}`,
-        })),
-        ...(outcomes ?? []).flatMap((outcome) => outcome.providerCleanupError === undefined
-            ? []
-            : [
-                {
-                    kind: "provider-cleanup",
-                    message: `${outcome.spec.planned.id}: ${outcome.providerCleanupError}`,
-                },
-            ]),
-        ...(outcomes ?? []).flatMap((outcome) => outcome.providerPolicyError === undefined
-            ? []
-            : [
-                {
-                    kind: "provider-policy",
-                    message: `${outcome.spec.planned.id}: ${outcome.providerPolicyError}`,
-                },
-            ]),
-        ...unreleasedSandboxFailures(outcomes, runId),
-    ];
-}
-/**
- * caps.maxUsd is enforced inside each participant's loop independently, so an
- * N-participant fan-out can spend up to N × maxUsd before any participant aborts, while the run cost summary reports the larger
- * aggregate. The warning names that ceiling, unless the study declared a shared maxTotalUsd budget.
- */
-function participantCapWarning(caps, participantCount) {
-    const capUsd = caps.maxUsd;
-    if (capUsd === undefined || participantCount <= 1)
-        return undefined;
-    if (caps.maxTotalUsd !== undefined)
-        return undefined;
-    return `caps.maxUsd ($${capUsd}) caps each participant, so ${participantCount} participants may spend up to ${participantCount} × $${capUsd} (about $${round6(capUsd * participantCount)}) before any of them stops. Set caps.maxTotalUsd for one budget across the study.`;
-}
 /** Builds and publishes the final bundle, runs the adapter hooks, renders the Observer and returns the result. */
 export async function finishCuaRun(setup, finish, ran) {
     const { plan, input, cwd, streams, descriptor, run } = setup;
-    const { participantRuns, participantPlan, scrubKnownValues, bundleBase } = setup;
+    const { participantRuns, participantPlan, bundleBase } = setup;
     const { rerunLineage, publicRepo, subjectArgs } = finish;
     const { dryRun } = plan;
     const appUrl = plannedAppUrl(plan.runner.subject);
@@ -252,7 +207,7 @@ export async function finishCuaRun(setup, finish, ran) {
             dryRun,
             participantCount,
         },
-        sanitize: (text) => redactText(scrubKnownValues(text)),
+        sanitize: (text) => redactText(run.secrets.scrub(text)),
         warnings: adapterWarnings,
         ...(input.scorerProvenance === undefined ? {} : { scorerProvenance: input.scorerProvenance }),
     });
@@ -261,13 +216,19 @@ export async function finishCuaRun(setup, finish, ran) {
     if (receiving)
         bundle.commsReceiving = receiving.snapshot();
     const policy = OUTCOME_POLICIES["computer-use"];
-    const execution = judgeExecution(computerUseExecutionFailures(outcomes, runId), policy);
+    // FinishedRun.renderObserver adds an Observer that did not render.
+    const execution = judgeExecution(participantExecutionFailures(outcomes, runId), policy);
     const finished = await run.finish(bundle, {
         ok: resultOk({ judgment, execution, scorerFailures: scorerResult.failures, policy }),
         execution,
         policy,
     });
     const observer = await finished.renderObserver();
+    // A caller's renderer runs with this process's file access, so after one that reports success
+    // the run directory is checked again before the result points anyone at it. A failed render is
+    // already an evidence failure, and its error code stays the run's diagnosis.
+    if (observer.ok)
+        await validatePreparedRunArtifactPaths(finished.paths);
     streams.attachFinal(observer);
     return cuaStudyResult({
         studyId: plan.studyId,

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

@@ -31,7 +31,7 @@ import { finishCuaRun } from "./result.js";
 import { runStudyParticipants } from "./live-phase.js";
 import { admitCuaRun, refuseCuaStudy, startCuaRun } from "./setup.js";
 import {} from "./types.js";
-import { studyResultIdentity } from "../../run/study-result.js";
+import { refusedResult } from "../../run/study-result.js";
 /**
  * A refused computer-use study's result, at the refusal's stage: a before-scope refusal has its own
  * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
@@ -40,18 +40,17 @@ import { studyResultIdentity } from "../../run/study-result.js";
 export async function computerUseStudyRefusal(options, refusal) {
     const { config, dryRun } = options;
     if (refusal.stage === "before-scope")
-        return {
-            ...studyResultIdentity("computer-use", config.id),
-            ok: false,
+        return refusedResult("computer-use", {
+            studyId: config.id,
             cwd: path.resolve(options.cwd),
+            error: { code: refusal.code, message: refusal.message },
+        }, {
             actor: config.actor?.type ?? "",
             dryRun,
             runId: options.runId ?? "not-created",
             appUrl: config.subject.appUrl ?? config.subject.serve?.url ?? "",
             lanes: [],
-            warnings: [],
-            error: { code: refusal.code, message: refusal.message },
-        };
+        });
     // The other refusals come after the cwd checks, and the participant cap after the personas are read.
     return completeRefusalAnalysis(await refuseCuaStudy(options, refusal), config, options);
 }

package/dist/routes/computer-use/setup.d.ts

@@ -1,5 +1,6 @@
 import { type RunScope } from "../../run/run.js";
 import type { RefusedStudy } from "../../run/route-shell.js";
+import { RunSecrets } from "../../run/secrets.js";
 import type { CuaActorDescriptor } from "../../actors/registry.js";
 import type { StudyCommsEmail, StudyCommsExternal, StudyConfig } from "../../study/types.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
@@ -32,15 +33,11 @@ export interface CuaRunSetup {
     streams: ReturnType<typeof trackRuntimeStreams>;
     participantRuns: DesktopParticipantRun[];
     participantPlan: CuaParticipantPlan;
-    scrubKnownValues: (text: string) => string;
     bundleBase: CuaRunBundleBase;
 }
 /** What only runStudyParticipants reads. */
 export interface CuaParticipantsSetup {
     env: Record<string, string | undefined>;
-    /** The array scrubKnownValues reads at each call. Email receiving appends the values it
-     *  provisions before the participants run. */
-    knownSecretValues: string[];
     deps: Omit<CuaParticipantDeps, "signalProvisioned">;
     /** Filled by runStudyParticipants on a live run; deps.onTrace reads it. */
     liveTrace: {
@@ -116,8 +113,7 @@ export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRun
         participantCount: number;
         openaiApiKey: string;
         e2bApiKey: string;
-        knownSecretValues: string[];
-        scrubKnownValues: (text: string) => string;
+        secrets: RunSecrets;
         publicRepo: string | undefined;
         localTreeArchive: LocalTreeArchive | undefined;
         localTreeArchiveBuffer: ArrayBuffer | undefined;