humanish 0.106.1 → 0.107.0

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

@@ -1,13 +1,14 @@
-import { adapterScoreFailureMessage, applyBrowserAdapterHooks, } from "../../lab/adapter-extension.js";
+import { adapterScoreFailureMessage, applyBrowserScorer } from "../../lab/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 } from "./participant-facts.js";
+import { participantFactsOf, participantOutcomeOk, unreleasedSandboxFailures, } from "./participant-facts.js";
 import { summarizeCuaDiagnostics } from "./diagnostics.js";
-import { toParticipantResult } from "./lanes.js";
+import { toParticipantResult } from "./participant-execution.js";
 import { buildCuaRunBundle, judgeComputerUseRun } from "./bundle.js";
 import { aggregateCuaSubject, projectParticipantSubjects, subjectProvenanceArg, } from "./subject-projection.js";
-import { CUA_ACTOR_LAB_SCHEMA, CUA_FANOUT_STRATEGY, } from "./types.js";
+import { CUA_ACTOR_LAB_SCHEMA, CUA_FANOUT_STRATEGY, participantSubjectEnv, } from "./types.js";
+import { plannedAppUrl } from "./plan.js";
 /** Aggregate participant counts for the result projection. */
 function buildParticipantSummary(outcomes, participantCount, participantPlan, dryRun) {
     if (dryRun || !outcomes) {
@@ -51,13 +52,14 @@ function buildParticipantSummary(outcomes, participantCount, participantPlan, dr
 }
 /**
  * The computer-use lab result for a finished run. The run passes only when the Observer rendered,
- * every lane passed (dry-run lanes pass as contracts), and no adapter score or declared scorer
+ * every participant passed (dry-run participants pass as contracts), and no adapter score or declared scorer
  * verdict failed; otherwise the error names the first reason.
  */
 function cuaLabResult(args) {
     const { labId, cwd, runId, appUrl, dryRun, participantRuns, outcomes, subjects, aggregateSubject, participantPlan, rerunLineage, bundle, observer, receivingWarnings, aggregateWarnings, adapterWarnings, } = args;
     const participantCount = participantRuns.length;
-    // Lane-level pass: dry-run lanes are contract-ok; live lanes need a passed, engaged session.
+    // Participant-level pass: dry-run participants are contract-ok; live ones need a passed,
+    // engaged session.
     const participantOk = (outcome) => participantOutcomeOk(outcome, dryRun);
     const adapterFailure = adapterScoreFailureMessage(bundle);
     const ok = resultOk({
@@ -81,10 +83,7 @@ function cuaLabResult(args) {
         if (ok)
             return undefined;
         if (adapterFailure !== undefined) {
-            return {
-                code: "HUMANISH_CUA_LAB_FAILED",
-                message: adapterFailure,
-            };
+            return { code: "HUMANISH_CUA_LAB_FAILED", message: adapterFailure };
         }
         if (participantCount === 1) {
             const outcome = firstOutcome;
@@ -92,9 +91,10 @@ function cuaLabResult(args) {
                 code: outcome?.failureCode ?? "HUMANISH_CUA_LAB_FAILED",
                 message: outcome?.sessionError ??
                     outcome?.providerCleanupError ??
+                    outcome?.providerPolicyError ??
                     (outcome?.noEngagement
                         ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
-                        : // The lane result (toParticipantResult) named this refusal; the N=1 envelope fell through to
+                        : // The participant result (toParticipantResult) named this refusal; the N=1 envelope fell through to
                             // "did not produce a terminal session", which is false — it produced one and refused it.
                             outcome?.selfReportedBlocker
                                 ? "Actor reported goal_satisfied while its final message described a blocker or asked for missing instructions; not a credible pass."
@@ -164,10 +164,11 @@ function cuaLabResult(args) {
     };
 }
 /**
- * The run's execution failures: each lane whose session failed in the harness, and an Observer
- * that failed.
+ * The run's execution failures: each participant whose session failed in the harness, each provider whose
+ * cleanup is unconfirmed or that reported a disallowed item after its last request, each sandbox
+ * whose release is unconfirmed, and an Observer that failed.
  */
-function computerUseExecutionFailures(outcomes, observer) {
+function computerUseExecutionFailures(outcomes, observer, runId) {
     return [
         ...(outcomes ?? [])
             .filter((outcome) => participantHarnessFailed(participantFactsOf(outcome)))
@@ -183,6 +184,15 @@ function computerUseExecutionFailures(outcomes, observer) {
                     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),
         ...(observer.ok
             ? []
             : [
@@ -194,33 +204,34 @@ function computerUseExecutionFailures(outcomes, observer) {
     ];
 }
 /**
- * execution.caps.maxUsd is enforced inside each lane's loop independently, so an N-lane fan-out can
- * spend up to N × maxUsd before any lane aborts, while the run cost summary reports the larger
+ * execution.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(config, participantCount) {
-    const capUsd = config.execution?.caps?.maxUsd;
+function participantCapWarning(caps, participantCount) {
+    const capUsd = caps.maxUsd;
     if (capUsd === undefined || participantCount <= 1)
         return undefined;
-    if (config.execution?.caps?.maxTotalUsd !== undefined)
+    if (caps.maxTotalUsd !== undefined)
         return undefined;
     return `execution.caps.maxUsd ($${capUsd}) is a PER-PARTICIPANT cap; ${participantCount} participants may spend up to ${participantCount} × $${capUsd} (~$${round6(capUsd * participantCount)} total) before any participant aborts. Set execution.caps.maxTotalUsd for a shared study budget.`;
 }
 /** 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, config, cwd, streams, descriptor, subjectRoute, run } = setup;
+    const { plan, input, cwd, streams, descriptor, run } = setup;
     const { participantRuns, participantPlan, scrubKnownValues, bundleBase } = setup;
-    const { hooks, rerunLineage, publicRepo, subjectArgs } = finish;
+    const { rerunLineage, publicRepo, subjectArgs } = finish;
     const { dryRun } = plan;
-    const { appUrl, subjectEnvNames } = subjectRoute;
+    const appUrl = plannedAppUrl(plan.runner.subject);
+    const subjectEnvNames = [...participantSubjectEnv(plan.runner.subject)];
     const { runId } = run;
     const participantCount = participantRuns.length;
     const { outcomes, failFastReason, receiving, receivingWarnings, externalCommsWarnings } = ran;
-    // Per-lane subject projections (invariant 5).
+    // Per-participant subject projections (invariant 5).
     const subjects = projectParticipantSubjects({ ...subjectArgs, outcomes, dryRun });
     const aggregate = aggregateCuaSubject({ subjects, outcomes, participantCount, dryRun });
     const aggregateSubject = aggregate.subject;
-    const capWarning = participantCapWarning(config, participantCount);
+    const capWarning = participantCapWarning(plan.caps, participantCount);
     const aggregateWarnings = [
         ...externalCommsWarnings,
         ...(capWarning === undefined ? [] : [capWarning]),
@@ -239,8 +250,8 @@ export async function finishCuaRun(setup, finish, ran) {
         ...(failFastReason === undefined ? {} : { failFastReason }),
     });
     const adapterWarnings = [];
-    const scorerResult = await applyBrowserAdapterHooks({
-        hooks,
+    const scorerResult = await applyBrowserScorer({
+        scorer: input.scorer,
         bundle,
         context: {
             bundle,
@@ -248,13 +259,12 @@ export async function finishCuaRun(setup, finish, ran) {
             labId: plan.labId,
             runId,
             actor: descriptor.id,
-            backend: "cua",
+            route: "computer-use",
             dryRun,
-            laneCount: participantCount,
+            participantCount,
         },
         sanitize: (text) => redactText(scrubKnownValues(text)),
         warnings: adapterWarnings,
-        hookLabel: "cuaHooks",
         ...(input.scorerProvenance === undefined ? {} : { scorerProvenance: input.scorerProvenance }),
     });
     // The one final verdict fold: scoring can only make the judged verdict stricter.
@@ -264,7 +274,7 @@ export async function finishCuaRun(setup, finish, ran) {
     const finished = await run.finish(bundle);
     const observer = await finished.renderObserver();
     streams.attachFinal(observer);
-    const execution = judgeExecution(computerUseExecutionFailures(outcomes, observer), OUTCOME_POLICIES["computer-use"]);
+    const execution = judgeExecution(computerUseExecutionFailures(outcomes, observer, runId), OUTCOME_POLICIES["computer-use"]);
     const result = cuaLabResult({
         labId: plan.labId,
         cwd,

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

@@ -11,7 +11,7 @@ import { type ComputerUseRunInput, type CuaActorLabResult, type RunCuaActorLabOp
 export declare function runCuaActorLab(options: RunCuaActorLabOptions): Promise<CuaActorLabResult>;
 /**
  * A refused computer-use lab'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 lane cap after
+ * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
  * the personas are read.
  */
 export declare function computerUseLabRefusal(options: RunCuaActorLabOptions, refusal: ComputerUseRefusal): Promise<CuaActorLabResult>;
@@ -26,8 +26,7 @@ export declare function admitComputerUsePlan(plan: ComputerUsePlan, input: Compu
  * Run a computer-use plan: its local checks, then the run. The run scope in runAdmittedCuaRun
  * finalizes any status record the run opened, on every exit, so a test or library caller does not
  * leave the 5 s status cadence writing into a directory something else is deleting (an unrelated
- * ENOTEMPTY). Participants and the brain (model and local agent) come from the plan. `config` is
- * still read for values the plan does not carry yet (persona ids, comms settings, the
- * per-participant cap) and by the compatibility hooks, which take the whole config.
+ * ENOTEMPTY). Participants, the brain, the subject, the caps and the residual config come from the
+ * plan. `config` is what the caller's createProvider and inProcess executor receive.
  */
 export declare function runComputerUsePlan(plan: ComputerUsePlan, input: ComputerUseRunInput, config: LabConfig): Promise<CuaActorLabResult>;

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

@@ -26,10 +26,11 @@ import path from "node:path";
 import { completeAutomaticAnalysis } from "../../analysis/automatic-completion.js";
 import { runScope } from "../../run/run.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
-import { computerUseInputWithScorer } from "../../lab/route-inputs.js";
-import { planComputerUseLab } from "./plan.js";
+import { browserRouteScorer } from "../../lab/adapter-scorer-loader.js";
+import { withLateScorer } from "../../lab/route-inputs.js";
+import { callerDrivingOf, planComputerUseLab } from "./plan.js";
 import { finishCuaRun } from "./result.js";
-import { runLabParticipants } from "./run-lanes.js";
+import { runLabParticipants } from "./live-phase.js";
 import { admitCuaRun, refuseCuaLab, startCuaRun } from "./setup.js";
 import { CUA_ACTOR_LAB_SCHEMA, } from "./types.js";
 /**
@@ -38,12 +39,12 @@ import { CUA_ACTOR_LAB_SCHEMA, } from "./types.js";
  * run and its analysis.
  */
 export async function runCuaActorLab(options) {
-    const { config, dryRun, lab, ...input } = options;
+    const { config, dryRun, ...input } = options;
     // planComputerUseLab makes every configuration refusal, in the order this route always has.
     const planned = planComputerUseLab(config, {
         dryRun,
-        ...(lab === undefined ? {} : { lab }),
-        ...(input.hooks === undefined ? {} : { hooks: input.hooks }),
+        hasRunSession: input.deps?.runSession !== undefined,
+        driving: callerDrivingOf(input),
         ...(input.countOverride === undefined ? {} : { countOverride: input.countOverride }),
         ...(input.rerun === undefined ? {} : { rerun: input.rerun }),
     });
@@ -53,7 +54,7 @@ export async function runCuaActorLab(options) {
 }
 /**
  * A refused computer-use lab'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 lane cap after
+ * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
  * the personas are read.
  */
 export async function computerUseLabRefusal(options, refusal) {
@@ -72,9 +73,9 @@ export async function computerUseLabRefusal(options, refusal) {
             warnings: [],
             error: { code: refusal.code, message: refusal.message },
         };
-    // The other refusals come after the cwd checks, and the lane cap after the personas are read.
+    // The other refusals come after the cwd checks, and the participant cap after the personas are read.
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
-    return completeAutomaticAnalysis(await refuseCuaLab(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options.automaticAnalysis, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+    return completeAutomaticAnalysis(await refuseCuaLab(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
 }
 /**
  * runLab's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
@@ -92,24 +93,22 @@ export async function admitComputerUsePlan(plan, input, config) {
     return {
         ok: true,
         run: async (scorer) => {
-            const running = computerUseInputWithScorer(input, scorer);
-            // The scorer's hooks wrap the admitted bag, so the runSession, provider and desktop the
-            // checks admitted stay the ones the run uses.
-            const admitted = { ...admission.admitted, hooks: running.hooks ?? admission.admitted.hooks };
-            return cuaOutcome(await runAdmittedCuaRun(plan, running, admitted));
+            // The scorer joins the input only; the runSession, provider and desktop the checks admitted
+            // stay the ones the run uses.
+            const running = withLateScorer(input, scorer, browserRouteScorer);
+            return cuaOutcome(await runAdmittedCuaRun(plan, running, admission.admitted));
         },
     };
 }
 function cuaOutcome(result) {
-    return { route: "computer-use", backend: "cua", result };
+    return { route: "computer-use", result };
 }
 /**
  * Run a computer-use plan: its local checks, then the run. The run scope in runAdmittedCuaRun
  * finalizes any status record the run opened, on every exit, so a test or library caller does not
  * leave the 5 s status cadence writing into a directory something else is deleting (an unrelated
- * ENOTEMPTY). Participants and the brain (model and local agent) come from the plan. `config` is
- * still read for values the plan does not carry yet (persona ids, comms settings, the
- * per-participant cap) and by the compatibility hooks, which take the whole config.
+ * ENOTEMPTY). Participants, the brain, the subject, the caps and the residual config come from the
+ * plan. `config` is what the caller's createProvider and inProcess executor receive.
  */
 export async function runComputerUsePlan(plan, input, config) {
     const admission = await admitCuaRun(plan, input, config);
@@ -129,9 +128,12 @@ function runAdmittedCuaRun(plan, input, admitted) {
     });
 }
 function completeCuaAnalysis(plan, input, result, finished) {
-    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input.automaticAnalysis, {
+    // A local VM study whose cleanup is unconfirmed records a skip instead of analyzing.
+    const refusal = input.localVm?.analysisRefusal;
+    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input, {
         ...(plan.analysis === undefined ? {} : { trigger: plan.analysis.trigger }),
         preferLargerOutput: plan.analysis?.preferLargerOutput === true,
+        ...(refusal === undefined ? {} : { refusal }),
     });
 }
 async function runPlanInScope(plan, input, admitted, scope) {

package/dist/routes/computer-use/self-report.d.ts

@@ -1,12 +1,12 @@
 import type { CuaLoopResult } from "../../actors/computer-use/loop.js";
 import { type SessionEnding } from "../../run/judge.js";
 /**
- * A goal_satisfied lane counts as a self-reported blocker ONLY when its final narrative contradicts
+ * A goal_satisfied participant counts as a self-reported blocker ONLY when its final narrative contradicts
  * the goal AND the run's own stop predicate did NOT fire. A matched stopWhen is independent,
  * structured completion evidence, so it overrides a text scan of the free-form narrative — which can
  * otherwise trip on the subject app's OWN quoted copy (e.g. a relayed "cannot be undone" banner).
  * Resolved-arc segments never block the verdict (#453). Returns the offending reason, or undefined
- * when the lane is a clean pass. Exported for testing.
+ * when the participant is a clean pass. Exported for testing.
  */
 export declare function resolveSelfReportedBlocker(session: CuaLoopResult | undefined): string | undefined;
 /** A session's ending, reduced to what the judge's engagement and blocker rules read. */

package/dist/routes/computer-use/self-report.js

@@ -20,7 +20,7 @@ function hasBlockerLanguage(text) {
 // Report-shaped language: what a participant writes when it finished AND has something to say.
 // Every one of the day's eleven drawDB reports (2026-09-01) opened a section "What confused me"
 // or "Accessibility defects:"; none contained a blocker word, so none became a feedback candidate
-// and a lane that had just replicated a keyboard-accessibility defect three times drafted "Live
+// and a participant that had just replicated a keyboard-accessibility defect three times drafted "Live
 // study completed without a participant-reported finding". Friction is the INCLUSIVE scan; a
 // false positive here adds a candidate a person then reads, which is the cheap direction.
 const REPORTED_DEFECT_LANGUAGE = /\b(defects?|bugs?|accessibilit(y|ies)|inaccessible|not (keyboard|screen.?reader)[- ]?accessible|confus(ed|ing)|hesitat(ed|ion)|unexpected(ly)?|unclear|hard to (find|tell|see|read|reach)|no (visible )?focus|overlap(ped|ping|s)?|truncat(ed|es|ion)|cut off|did nothing|nothing happened|no effect)\b/;
@@ -94,7 +94,7 @@ function completionReasonBlocksVerdict(reason) {
 // with a parser error. A simpler SQL import succeeded."). The lookahead demands the retry flavor
 // on purpose: unrelated praise ("Separately, the search box worked") must never launder an
 // unresolved failure. "Login failed so I gave up" has no recovery anywhere and stays a blocker.
-// (#453 — the run-1 false negative: a defect report after demonstrated success failed the lane,
+// (#453 — the run-1 false negative: a defect report after demonstrated success failed the participant,
 // an incentive inversion against exactly the participant behavior a study wants most.)
 const RESOLUTION_TERMS = /\b(succeed(?:ed|s)?|success(?:ful|fully)?|worked|works around|then worked|now works?|resolved|fixed|recovered|got it working|went through)\b/;
 const RETRY_RESOLUTION = /\b(simpler|simplified|retry(?:ing)?|retried|second (?:attempt|try)|another (?:attempt|try|approach)|different (?:approach|way|route)|instead|then|eventually|after that)\b[^.!?\n]{0,80}\b(succeed(?:ed|s)?|success(?:ful|fully)?|worked|went through|completed|passed)\b/;
@@ -152,12 +152,12 @@ function traceHasStopWhenMatch(session) {
         (item.title.startsWith("stopWhen matched") || item.title === "dwell window complete"));
 }
 /**
- * A goal_satisfied lane counts as a self-reported blocker ONLY when its final narrative contradicts
+ * A goal_satisfied participant counts as a self-reported blocker ONLY when its final narrative contradicts
  * the goal AND the run's own stop predicate did NOT fire. A matched stopWhen is independent,
  * structured completion evidence, so it overrides a text scan of the free-form narrative — which can
  * otherwise trip on the subject app's OWN quoted copy (e.g. a relayed "cannot be undone" banner).
  * Resolved-arc segments never block the verdict (#453). Returns the offending reason, or undefined
- * when the lane is a clean pass. Exported for testing.
+ * when the participant is a clean pass. Exported for testing.
  */
 export function resolveSelfReportedBlocker(session) {
     return session !== undefined && selfReportedBlocker(blockerFacts(session))

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

@@ -3,15 +3,15 @@ import type { CuaActorDescriptor } from "../../actors/registry.js";
 import type { LabCommsEmail, LabCommsExternal, LabConfig } from "../../lab/types.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
 import { type LocalTreeArchive } from "../../subject/local-tree-archive.js";
-import { type ComputerUseRefusal, type CuaSubjectRoute } from "./plan.js";
+import { type ComputerUseRefusal } from "./plan.js";
 import type { ComputerUsePlan } from "../../lab/plan-types.js";
 import { trackRuntimeStreams, type LiveTraceFlush } from "./live-flush.js";
 import { type CuaRunBundleBase } from "./bundle.js";
 import { projectParticipantSubjects } from "./subject-projection.js";
-import { type CuaActorLabErrorCode, type CuaActorLabHooks, type CuaActorLabResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput, type RunCuaActorLabOptions } from "./types.js";
+import { type CuaActorLabErrorCode, type CuaActorLabResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput, type RunCuaActorLabOptions } from "./types.js";
 /**
- * The envelope of a refusal the plan left for after the cwd checks. The lane cap and in-process
- * fan-out refusals come after the committed personas are read, so a persona-file error still wins.
+ * The envelope of a refusal the plan left for after the cwd checks. The participant cap and
+ * in-process fan-out refusals come after the committed personas are read, so a persona-file error still wins.
  */
 export declare function refuseCuaLab(options: RunCuaActorLabOptions, refusal: ComputerUseRefusal): Promise<CuaActorLabResult>;
 export type AdmittedCuaRun = Extract<Awaited<ReturnType<typeof admitCuaRun>>, {
@@ -24,13 +24,9 @@ type StartedRun = Extract<Awaited<ReturnType<RunScope["startRun"]>>, {
 export interface CuaRunSetup {
     plan: ComputerUsePlan;
     input: ComputerUseRunInput;
-    /** Read for values the plan does not carry yet, and by the compatibility hooks, which take the
-     *  whole config. Participants come from the plan. */
-    config: LabConfig;
     /** The physical project root. */
     cwd: string;
     descriptor: CuaActorDescriptor;
-    subjectRoute: CuaSubjectRoute;
     run: StartedRun;
     streams: ReturnType<typeof trackRuntimeStreams>;
     participantRuns: DesktopParticipantRun[];
@@ -66,7 +62,6 @@ export interface CuaParticipantsSetup {
 }
 /** What only finishCuaRun reads besides the participants' outcomes. */
 export interface CuaFinishFacts {
-    hooks: CuaActorLabHooks;
     rerunLineage: RunRerunLineage | undefined;
     publicRepo: string | undefined;
     subjectArgs: Omit<Parameters<typeof projectParticipantSubjects>[0], "outcomes" | "dryRun">;
@@ -95,16 +90,16 @@ export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRun
         config: LabConfig;
         dryRun: boolean;
         cwd: string;
-        hooks: CuaActorLabHooks;
+        seams: import("../../lab/lab-deps.js").LabDeps;
         streams: {
-            hooks: CuaActorLabHooks;
+            onStream: NonNullable<import("../../lab/run-lab-homes.js").RunLabHomes["onStream"]>;
             showIn: (observer: import("../../index.js").ObserverResult & {
                 ok: true;
             }) => void;
             attachFinal: (observer: import("../../index.js").ObserverResult) => void;
         };
-        env: NodeJS.ProcessEnv;
-        subjectRoute: CuaSubjectRoute;
+        env: Record<string, string | undefined>;
+        appUrl: string;
         fail: (code: CuaActorLabErrorCode, message: string, actorLabel?: string) => CuaActorLabResult;
         refuse: (code: CuaActorLabErrorCode, message: string, actorLabel?: string | undefined) => {
             ok: false;
@@ -123,7 +118,6 @@ export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRun
         knownSecretValues: string[];
         scrubKnownValues: (text: string) => string;
         publicRepo: string | undefined;
-        hasGithubToken: boolean;
         localTreeArchive: LocalTreeArchive | undefined;
         localTreeArchiveBuffer: ArrayBuffer | undefined;
     };