humanish 0.106.0 → 0.107.0

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

@@ -1,32 +1,39 @@
-// The model side of one computer-use lane: the provider a local agent brings, the session options
+// The model side of one computer-use participant: the provider a local agent brings, the session options
 // the loop runs with, the study's shared spend ledger, the provider cleanup, and the checks on the
-// finished session. The desktop side stays with the lane runner.
+// finished session. The desktop side stays with the participant runner.
 import { startClaudeSession } from "../../actors/local-agent/claude-session.js";
 import { createLocalAgentProvider } from "../../actors/local-agent/cli.js";
-import { DEFAULT_OPENAI_CU_MODEL } from "../../actors/computer-use/openai-provider.js";
+import { pricedModel } from "../../lab/plan-base.js";
 import { estimateActorCostForExecution, round6 } from "../../run/pricing.js";
 import { redactText } from "../../evidence/redaction.js";
-import { createRestrictedCodexParticipant } from "../../actors/codex/restricted-participant.js";
+import { createRestrictedCodexParticipant, } from "../../actors/codex/restricted-participant.js";
 import { writeContainedOutputFile } from "../../run/contained-output.js";
 import { withInboxMission } from "./participant-prompt.js";
 import { resolveSelfReportedBlocker, resolveSelfReportedFriction, sessionEnding, } from "./self-report.js";
 import { hollowCompletion } from "../../run/judge.js";
-import { legacyHookSpecOf } from "./legacy-lane-spec.js";
-/** Starts the lane's model: a caller's provider, the operator's Codex, a Claude session, or none. */
+// Caller providers backed by a native Codex session (the local study's), with their close report.
+const closeReports = new WeakMap();
+/**
+ * Registers a caller's provider as backed by a native Codex session: the participant runner reads the session's
+ * run warnings and a refusal no request reported from `report` when it closes the provider.
+ */
+export function withCloseReport(provider, report) {
+    closeReports.set(provider, report);
+    return provider;
+}
+/** Starts the participant's model: a caller's provider, the operator's Codex, a Claude session, or none. */
 export async function startParticipantModel(spec, deps, executor) {
-    const { config, env } = deps;
-    if (deps.hooks.buildProvider) {
-        return {
-            provider: await deps.hooks.buildProvider({
-                config,
-                actor: deps.descriptor,
-                lane: legacyHookSpecOf(spec),
-                laneCount: deps.participantCount,
-                executor,
-            }),
+    const { env, brain } = deps;
+    if (deps.createProvider) {
+        const participant = {
+            id: spec.planned.id,
+            index: spec.planned.index,
+            count: deps.participantCount,
         };
+        return { provider: await deps.createProvider(participant, executor) };
     }
-    if (deps.localAgent === "codex") {
+    const localAgent = brain.kind === "local-agent" ? brain.agent : undefined;
+    if (localAgent === "codex") {
         // Hosted local-agent studies use the same native participant engine as local desktops.
         // Operator auth deliberately retains the operator's Codex home, config and supported auth
         // stores instead of applying the isolated restricted-account profile used by local studies.
@@ -35,13 +42,13 @@ export async function startParticipantModel(spec, deps, executor) {
             ...(spec.planned.limits.reasoningEffort === undefined
                 ? {}
                 : { reasoningEffort: spec.planned.limits.reasoningEffort }),
-            ...(config.actors[0]?.model === undefined ? {} : { model: config.actors[0].model }),
+            ...(brain.declaredModel === undefined ? {} : { model: brain.declaredModel }),
             ...(executor.speechEnabled === true ? { speechEnabled: true } : {}),
             session: { env },
         });
         return { provider: codexParticipant.provider, codexParticipant };
     }
-    if (deps.localAgent === "claude") {
+    if (localAgent === "claude") {
         // One session for the whole run, like the codex thread above (#520). The one-shot
         // provider (createLocalAgentProvider) spawned `claude -p` per turn, and every turn
         // started with no memory of the last. HUMANISH_LOCAL_AGENT_ONE_SHOT=1 keeps that path
@@ -58,7 +65,7 @@ export async function startParticipantModel(spec, deps, executor) {
                     ...(spec.planned.limits.reasoningEffort === undefined
                         ? {}
                         : { reasoningEffort: spec.planned.limits.reasoningEffort }),
-                    ...(config.actors[0]?.model === undefined ? {} : { model: config.actors[0].model }),
+                    ...(brain.declaredModel === undefined ? {} : { model: brain.declaredModel }),
                 }),
             };
         }
@@ -66,22 +73,21 @@ export async function startParticipantModel(spec, deps, executor) {
             ...(spec.planned.limits.reasoningEffort === undefined
                 ? {}
                 : { reasoningEffort: spec.planned.limits.reasoningEffort }),
-            ...(config.actors[0]?.model === undefined ? {} : { model: config.actors[0].model }),
+            ...(brain.declaredModel === undefined ? {} : { model: brain.declaredModel }),
         });
         return { provider: claudeSession.provider, claudeSession };
     }
     return {};
 }
-/** The options the lane's session runs with: prompt, model settings, spend caps and callbacks. */
+/** The options the participant's session runs with: prompt, model settings, spend caps and callbacks. */
 export function participantSessionOptions(spec, deps, ready, provider, writeScreenshot) {
-    const { config } = deps;
     const { executor, inbox } = ready;
     // The FAIL-CLOSED spend cap (execution.caps.maxUsd) is wired into the loop as maxUsd + an
     // injected pure per-turn estimator keyed on the resolved model. Preflight already refused a
     // cap on an unpriced model, so the estimate is measurable whenever a cap is in force. The
     // model id here matches provider.version (openai-responses-cu resolves the default when unset).
-    const capModelId = config.actors[0]?.model ?? DEFAULT_OPENAI_CU_MODEL;
-    const maxUsd = config.execution?.caps?.maxUsd;
+    const capModelId = pricedModel(deps.brain);
+    const maxUsd = deps.caps.maxUsd;
     return {
         instructions: inbox
             ? withInboxMission(spec, inbox.url, inbox.address, inbox.receiving).instructions
@@ -94,8 +100,9 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
         ...(provider === undefined ? {} : { provider: provider }),
         openai: {
             apiKey: deps.openaiApiKey,
-            ...(config.actors[0]?.model ? { model: config.actors[0].model } : {}),
-            // Per-LANE, not per-actor: two lanes at different efforts is the control this exists for.
+            ...(deps.brain.declaredModel ? { model: deps.brain.declaredModel } : {}),
+            // Per-participant, not per-actor: two participants at different efforts is the control this
+            // exists for.
             ...(spec.planned.limits.reasoningEffort === undefined
                 ? {}
                 : { reasoningEffort: spec.planned.limits.reasoningEffort }),
@@ -122,8 +129,9 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
             : { stopWhen: spec.planned.limits.stopWhen }),
         ...(spec.planned.limits.dwell === undefined ? {} : { dwell: spec.planned.limits.dwell }),
         ...(spec.planned.tasks === undefined ? {} : { tasks: spec.planned.tasks }),
-        // The STUDY budget (#299): this lane notes its own running estimate on the shared ledger
-        // and stops when the RUN total crosses the cap — independent of the per-lane maxUsd above.
+        // The STUDY budget (#299): this participant notes its own running estimate on the shared
+        // ledger and stops when the RUN total crosses the cap — independent of the per-participant
+        // maxUsd above.
         ...(deps.runBudget === undefined
             ? {}
             : {
@@ -141,18 +149,19 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
         ...(deps.onTrace === undefined
             ? {}
             : {
-                // Forwards the RUNNING usage as well: the lane is where both are known, and usage
+                // Forwards the RUNNING usage as well: the participant runner is where both are known, and usage
                 // without it never reaches the flush — which is how the live cost stayed unknown.
                 onTrace: (items, usage, metadata) => deps.onTrace?.(spec.planned.id, items, usage, metadata),
             }),
     };
 }
 /**
- * Closes the lane's model, in the order it was opened. Returns true when a provider's cleanup is
+ * Closes the participant's model, in the order it was opened. Returns true when a provider's cleanup is
  * unconfirmed; each failure also adds a warning.
  */
 export async function closeParticipantModel(model, warnings) {
     let unconfirmed = false;
+    let refusal;
     try {
         if (model.codexParticipant === undefined)
             await model.provider?.close?.();
@@ -163,6 +172,8 @@ export async function closeParticipantModel(model, warnings) {
     }
     try {
         const cleanup = await model.codexParticipant?.close();
+        warnings.push(...(cleanup?.warnings ?? []));
+        refusal = cleanup?.refusal;
         if (cleanup?.status === "unconfirmed") {
             warnings.push("Model provider cleanup is unconfirmed.");
             unconfirmed = true;
@@ -172,17 +183,31 @@ export async function closeParticipantModel(model, warnings) {
         warnings.push("Model provider cleanup is unconfirmed.");
         unconfirmed = true;
     }
+    const report = model.codexParticipant === undefined && model.provider !== undefined
+        ? closeReports.get(model.provider)
+        : undefined;
+    if (report) {
+        // The provider's own close reported cleanup above; this reads what its session found.
+        try {
+            const found = await report();
+            warnings.push(...(found.warnings ?? []));
+            refusal ??= found.refusal;
+        }
+        catch {
+            /* Cleanup was already reported through the provider's close. */
+        }
+    }
     try {
         await model.claudeSession?.close();
     }
     catch {
         warnings.push("Claude session cleanup failed; desktop cleanup will still run.");
     }
-    return unconfirmed;
+    return { unconfirmed, refusal };
 }
 /** Prices the finished session's tokens onto its trace, writes the trace, and warns on raw screenshots. */
 export async function recordParticipantTrace(spec, deps, session, warnings) {
-    // Per-lane model-token cost ESTIMATE, attached to the trace before it is persisted (the model
+    // Per-participant model-token cost ESTIMATE, attached to the trace before it is persisted (the model
     // id is authoritative here — provider.version). Kept at the lab boundary so the pure loop
     // never depends on the operator rate table. estimateActorCost declares absent (null) for an
     // unknown rate / missing usage rather than guessing.

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

@@ -15,8 +15,8 @@ export declare const DEFAULT_MISSION = "You are testing a web application. The b
 export declare const CLOSING_LINE_DIRECTIVE: string;
 /** The persona id a computer-use participant gets when neither it nor its actor names one. */
 export declare const FALLBACK_PERSONA_ID = "cua-operator";
-/** Compose one lane's actor prompt: persona line + device line + mission + per-lane steer.
- *  At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
+/** Compose one participant's actor prompt: persona line + device line + mission + per-participant
+ *  steer. At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
 export declare function composeParticipantInstructions(args: {
     mission: string;
     persona?: string;
@@ -46,7 +46,7 @@ export declare function composeParticipantInstructions(args: {
     instructions: string;
     persona: ActorPersonaRef;
 };
-/** Runtime-inject the persona inbox instruction into a lane's prompt (#297 slice B). The inbox URL is a
+/** Runtime-inject the persona inbox instruction into a participant's prompt (#297 slice B). The inbox URL is a
  *  runtime loopback/getHost address (not secret), so — mirroring the lobby-code runtime injection — this
  *  augments only the instructions the model receives; the authored prompt + its digest are unchanged.
  *  Returns a new spec (never mutates). Shared by the CUA + concurrent shared-world routes. */

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

@@ -19,8 +19,8 @@ export const CLOSING_LINE_DIRECTIVE = "When you stop, make the FIRST line of you
     "Then, from the next line, say what you did, what confused you, and where you hesitated.";
 /** The persona id a computer-use participant gets when neither it nor its actor names one. */
 export const FALLBACK_PERSONA_ID = "cua-operator";
-/** Compose one lane's actor prompt: persona line + device line + mission + per-lane steer.
- *  At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
+/** Compose one participant's actor prompt: persona line + device line + mission + per-participant
+ *  steer. At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
 export function composeParticipantInstructions(args) {
     const { name, preset } = args.device;
     const deviceLine = preset.isMobile
@@ -31,7 +31,7 @@ export function composeParticipantInstructions(args) {
     // be measured optimizes for the measurement instead of using the product (src/lab/tasks.ts).
     const taskLines = renderTaskPrompt(args.tasks ?? []);
     // A resolved persona contributes its compiled directives (friction tolerance, skill bias,
-    // accessibility behavior, constraints) through the SAME persona.ts compiler the terminal lane
+    // accessibility behavior, constraints) through the SAME persona.ts compiler the terminal route
     // uses, so one persona file means one behavior across every route.
     const personaLine = args.resolvedPersona
         ? renderPersonaPromptSection(args.resolvedPersona)
@@ -64,7 +64,7 @@ export function composeParticipantInstructions(args) {
         },
     };
 }
-/** Runtime-inject the persona inbox instruction into a lane's prompt (#297 slice B). The inbox URL is a
+/** Runtime-inject the persona inbox instruction into a participant's prompt (#297 slice B). The inbox URL is a
  *  runtime loopback/getHost address (not secret), so — mirroring the lobby-code runtime injection — this
  *  augments only the instructions the model receives; the authored prompt + its digest are unchanged.
  *  Returns a new spec (never mutates). Shared by the CUA + concurrent shared-world routes. */

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

@@ -5,8 +5,8 @@ import { type RunRerunLineage } from "../../run/bundle.js";
 import type { PreparedSelectedOutputDirectory } from "../../run/contained-output.js";
 import { type CuaActorLabErrorCode, type CuaParticipantPlan, type CuaParticipantPlanEntry, type DesktopParticipantRun } from "./types.js";
 export declare function defaultSessionTimeoutMs(config: LabConfig): number;
-/** Per-lane sandbox deadline (each lane owns its own desktop). Mirrors the single-lane formula
- *  verbatim so N=1 stays byte-stable: explicit sandboxTimeoutMs, else session budget + (clone
+/** Per-participant sandbox deadline (each one owns its own desktop). Mirrors the
+ *  single-participant formula verbatim so N=1 stays byte-stable: explicit sandboxTimeoutMs, else session budget + (clone
  *  or local-tree: provision budget + Σ state-step budgets) + the server-side
  *  reclamation buffer. Local-tree shares the clone route's provisioning budget: it swaps a
  *  git clone for an upload+extract, but the shared install/build/state/start/probe pipeline
@@ -21,8 +21,8 @@ export declare function resolveParticipantSandboxMs(config: LabConfig): number;
  */
 export declare function boundedConcurrency(declared: number | undefined, participantCount: number): number;
 /**
- * Pure pre-flight plan resolver (runs in dry-run AND live). Returns the lane table, the
- * effective concurrency, the wave count, the per-lane session budget, and the worst-case total
+ * Pure pre-flight plan resolver (runs in dry-run AND live). Returns the participant table, the
+ * effective concurrency, the wave count, the per-participant session budget, and the worst-case total
  * sandbox-minutes — BEFORE any sandbox or provider call. The same plan appears in dry-run,
  * marked $0 (dryRun: true).
  */
@@ -32,7 +32,7 @@ export declare function resolveCuaParticipantPlan(config: LabConfig, opts?: {
     dryRun?: boolean;
     personas?: Map<string, ResolvedPersona>;
 }): CuaParticipantPlan;
-/** Print the lane plan to stderr BEFORE any sandbox/provider call (public-safe: ids, devices,
+/** Print the participant plan to stderr BEFORE any sandbox/provider call (public-safe: ids, devices,
  *  digests, and budgets only — no prompt text, no secrets). */
 export declare function emitPreflightPlan(participantPlan: CuaParticipantPlan, labId: string): void;
 export declare function formatParticipantPlanEntry(entry: CuaParticipantPlanEntry): string;
@@ -63,5 +63,5 @@ export declare function loadCuaParticipants(args: {
     code: CuaActorLabErrorCode;
     message: string;
 }>;
-/** Scrub known secret values from each lane's declarative snapshot before any bundle uses it. */
+/** Scrub known secret values from each participant's declarative snapshot before any bundle uses it. */
 export declare function sanitizeParticipantRuns(runs: readonly DesktopParticipantRun[], scrub: (text: string) => string): void;

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

@@ -26,8 +26,8 @@ export function defaultSessionTimeoutMs(config) {
     const room = MAX_SANDBOX_MS - SUBJECT_PROVISION_BUDGET_MS - stateBudgetMs - SANDBOX_TIMEOUT_BUFFER_MS;
     return Math.max(MIN_DERIVED_SESSION_TIMEOUT_MS, Math.min(DEFAULT_APP_URL_SESSION_TIMEOUT_MS, room));
 }
-/** Per-lane sandbox deadline (each lane owns its own desktop). Mirrors the single-lane formula
- *  verbatim so N=1 stays byte-stable: explicit sandboxTimeoutMs, else session budget + (clone
+/** Per-participant sandbox deadline (each one owns its own desktop). Mirrors the
+ *  single-participant formula verbatim so N=1 stays byte-stable: explicit sandboxTimeoutMs, else session budget + (clone
  *  or local-tree: provision budget + Σ state-step budgets) + the server-side
  *  reclamation buffer. Local-tree shares the clone route's provisioning budget: it swaps a
  *  git clone for an upload+extract, but the shared install/build/state/start/probe pipeline
@@ -162,8 +162,8 @@ function participantRunsAndPlan(planned, opts = {}) {
     return { runs, participantPlan };
 }
 /**
- * Pure pre-flight plan resolver (runs in dry-run AND live). Returns the lane table, the
- * effective concurrency, the wave count, the per-lane session budget, and the worst-case total
+ * Pure pre-flight plan resolver (runs in dry-run AND live). Returns the participant table, the
+ * effective concurrency, the wave count, the per-participant session budget, and the worst-case total
  * sandbox-minutes — BEFORE any sandbox or provider call. The same plan appears in dry-run,
  * marked $0 (dryRun: true).
  */
@@ -171,11 +171,11 @@ export function resolveCuaParticipantPlan(config, opts = {}) {
     const { countOverride, ...rest } = opts;
     return participantRunsAndPlan(plannedParticipantsOf(config, countOverride), rest).participantPlan;
 }
-/** Print the lane plan to stderr BEFORE any sandbox/provider call (public-safe: ids, devices,
+/** Print the participant plan to stderr BEFORE any sandbox/provider call (public-safe: ids, devices,
  *  digests, and budgets only — no prompt text, no secrets). */
 export function emitPreflightPlan(participantPlan, labId) {
     const lines = [];
-    lines.push(`humanish cua fan-out plan (${labId}): ${participantPlan.laneCount} participant(s), strategy ${participantPlan.strategy}, concurrency ${participantPlan.concurrency}${participantPlan.envLoweredConcurrencyFrom === undefined ? "" : ` (lowered from ${participantPlan.envLoweredConcurrencyFrom} by ${CUA_MAX_CONCURRENCY_ENV})`}, ${participantPlan.waves} wave(s).`);
+    lines.push(`humanish computer-use fan-out plan (${labId}): ${participantPlan.laneCount} participant(s), strategy ${participantPlan.strategy}, concurrency ${participantPlan.concurrency}${participantPlan.envLoweredConcurrencyFrom === undefined ? "" : ` (lowered from ${participantPlan.envLoweredConcurrencyFrom} by ${CUA_MAX_CONCURRENCY_ENV})`}, ${participantPlan.waves} wave(s).`);
     lines.push(`  session budget ${Math.round(participantPlan.perLaneSessionBudgetMs / 1000)}s per participant; worst-case ~${participantPlan.worstCaseSandboxMinutes} sandbox-minutes total${participantPlan.dryRun ? " (dry-run: $0)" : ""}.`);
     for (const entry of participantPlan.lanes) {
         lines.push(`  - ${formatParticipantPlanEntry(entry)}`);
@@ -212,7 +212,7 @@ export async function compileParticipantPersonas(projectRoot, personaIds) {
 export async function loadCuaParticipants(args) {
     const { plan } = args;
     const { participants } = plan.runner;
-    // Compile any committed personas BEFORE planning, so the plan builder stays pure and each lane's
+    // Compile any committed personas BEFORE planning, so the plan builder stays pure and each participant's
     // prompt carries real behavioral directives rather than a bare `Persona: <id>.` label (#381).
     const personas = await compileParticipantPersonas(args.projectRoot, participants.map((participant) => participant.personaId));
     const { runs: participantRuns, participantPlan } = participantRunsAndPlan({
@@ -244,7 +244,7 @@ export async function loadCuaParticipants(args) {
         rerunLineage: selected.rerun,
     };
 }
-/** Scrub known secret values from each lane's declarative snapshot before any bundle uses it. */
+/** Scrub known secret values from each participant's declarative snapshot before any bundle uses it. */
 export function sanitizeParticipantRuns(runs, scrub) {
     for (const spec of runs) {
         if (spec.evidenceAssignment)

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

@@ -1,14 +1,13 @@
 import { type CuaActorDescriptor } from "../../actors/registry.js";
-import type { ComputerUsePlan, RoutePlanResult, RouteRefusal } from "../../lab/plan-types.js";
-import type { LabConfig, LabSubjectServe, LabSubjectState } from "../../lab/types.js";
-import type { RunLabProvenance } from "../../run/status.js";
-import { type CuaActorLabErrorCode, type CuaActorLabHooks, type RunCuaActorLabOptions } from "./types.js";
+import type { ComputerUsePlan, ComputerUseRunner, RoutePlanResult, RouteRefusal } from "../../lab/plan-types.js";
+import type { LabConfig, LabSubjectState } from "../../lab/types.js";
+import { type CuaActorLabErrorCode, type RunCuaActorLabOptions } from "./types.js";
 /** The error a computer-use lab returns before a run starts. */
 export interface ComputerUseRefusal extends RouteRefusal<"computer-use", CuaActorLabErrorCode> {
     /**
      * Where the route returns it. "before-scope": analysis and tasks, returned before the run scope
      * with no automatic-analysis record. "in-scope": after the cwd checks. "after-personas": after
-     * the route reads committed persona files, so a persona-file error still wins over the lane cap
+     * the route reads committed persona files, so a persona-file error still wins over the participant cap
      * and in-process fan-out.
      */
     readonly stage: "before-scope" | "in-scope" | "after-personas";
@@ -18,39 +17,32 @@ export interface ComputerUseRefusal extends RouteRefusal<"computer-use", CuaActo
 export type ComputerUsePlanResult = RoutePlanResult<ComputerUsePlan, ComputerUseRefusal>;
 /** The registered descriptor for a planned actor id; planComputerUseLab checked the registry. */
 export declare function cuaDescriptorOf(actor: string): CuaActorDescriptor;
-/** Which subject route a computer-use lab takes, derived once from its config and hooks. */
-export interface CuaSubjectRoute {
-    cloneRoute: boolean;
-    /** A CLI studied at a desktop: nothing cloned, no browser, a terminal instead. */
-    desktopCliRoute: boolean;
-    localTreeRoute: boolean;
-    /**
-     * Clone and local-tree both provision the subject in-sandbox (clone via git, local-tree via
-     * pack+upload) and share the install/build/state/start/probe pipeline, so every seam that gates
-     * on "does this route provision a subject" is keyed on this union.
-     */
-    provisionedRoute: boolean;
-    localAppSubject: boolean;
-    /** A caller-supplied executor drives the subject in-process; no desktop is created. */
-    inProcessRoute: boolean;
-    serve: LabSubjectServe | undefined;
-    appUrl: string;
-    subjectRepo: string | undefined;
-    subjectEnvNames: string[];
+/** Which of the caller's driving homes, createProvider and inProcess, a run has. */
+export interface CallerDriving {
+    readonly inProcess: boolean;
+    readonly createProvider: boolean;
 }
-export declare function cuaSubjectRoute(config: LabConfig, hooks: CuaActorLabHooks): CuaSubjectRoute;
+/** The driving a computer-use run's options carry. */
+export declare function callerDrivingOf(options: {
+    readonly inProcess?: unknown;
+    readonly createProvider?: unknown;
+}): CallerDriving;
 /** The state a planned run's provisioned subject declares. Other subjects declare none. */
 export declare function cuaDeclaredState(plan: ComputerUsePlan): LabSubjectState | undefined;
-/** The route facts a planned run takes: its runner's desktop and subject. */
-export declare function cuaSubjectRouteOf(plan: ComputerUsePlan): CuaSubjectRoute;
+/** The URL a refused lab's result names, from its declaration: a provisioned subject's serve URL. */
+export declare function declaredAppUrl(config: LabConfig): string;
+/** The URL a planned run's participants open: a provisioned subject's served URL, else its own. */
+export declare function plannedAppUrl(subject: ComputerUseRunner["subject"]): string;
 /**
  * Plan a computer-use lab. It is called for any config handed to the computer-use runner, not only
  * one routeOf sends here, so a config for another route gets this route's refusal.
  */
 export declare function planComputerUseLab(config: LabConfig, input: {
     readonly dryRun: boolean;
-    readonly lab?: RunLabProvenance;
-    readonly hooks?: CuaActorLabHooks;
+    /** Whether deps.runSession is set: a caller's session runner cannot enforce maxOutputTokens. */
+    readonly hasRunSession?: boolean;
+    /** Which of the caller's driving homes are set; neither when absent. */
+    readonly driving?: CallerDriving;
     readonly countOverride?: number;
     readonly rerun?: RunCuaActorLabOptions["rerun"];
 }): ComputerUsePlanResult;