humanish 0.110.2 → 0.110.3

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

@@ -21,39 +21,17 @@
 //   harness errors are redacted at this boundary; the bundle's `stream.actor` carries the
 //   conformant humanish.actor-trace.v1 projection, whose `redaction.screenshots` records the
 //   run's actual mode ("raw" | "blurred" | "n/a"), and every label downstream derives from it.
-import { withTransientCommsSecrets } from "../../run/transient-comms-secrets.js";
 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 {} from "../../run/run.js";
+import { admitRoute, completeRefusalAnalysis } from "../../run/route-shell.js";
 import { browserRouteScorer } from "../../study/adapter-scorer-loader.js";
 import { withLateScorer } from "../../study/route-inputs.js";
-import { callerDrivingOf, planComputerUseStudy } from "./plan.js";
+import {} from "./plan.js";
 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";
-/**
- * Plans and runs a computer-use study in one call. It is not exported from src/index.ts; tests call
- * it. It plans the config with planComputerUseStudy and runs
- * the plan with runComputerUsePlan, whose run scope and withTransientCommsSecrets wrapper cover the
- * run and its analysis.
- */
-export async function runCuaActorStudy(options) {
-    const { config, dryRun, ...input } = options;
-    // planComputerUseStudy makes every configuration refusal, in the order this route always has.
-    const planned = planComputerUseStudy(config, {
-        dryRun,
-        hasRunSession: input.deps?.runSession !== undefined,
-        driving: callerDrivingOf(input),
-        ...(input.countOverride === undefined ? {} : { countOverride: input.countOverride }),
-        ...(input.rerun === undefined ? {} : { rerun: input.rerun }),
-    });
-    if (planned.ok)
-        return runComputerUsePlan(planned.plan, input, config);
-    return computerUseStudyRefusal(options, planned.refusal);
-}
 /**
  * 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
@@ -75,66 +53,27 @@ export async function computerUseStudyRefusal(options, refusal) {
             error: { code: refusal.code, message: refusal.message },
         };
     // 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 refuseCuaStudy(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+    return completeRefusalAnalysis(await refuseCuaStudy(options, refusal), config, options);
 }
 /**
  * runStudyWith's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
  * participants, the preflight plan, the keys, the local agent, subject env and caps, and the
  * local-tree archive) before any run scope opens, so the CLI can present their refusal before it
- * loads a declared scorer, and returns the run that continues from them with that scorer.
- */
-export async function admitComputerUsePlan(plan, input, config) {
-    const admission = await admitCuaRun(plan, input, config);
-    if (!admission.ok)
-        return {
-            ok: false,
-            outcome: cuaOutcome(await completeCuaAnalysis(plan, input, admission.result, undefined)),
-        };
-    return {
-        ok: true,
-        run: async (scorer) => {
-            // 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", 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, 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);
-    if (!admission.ok)
-        return completeCuaAnalysis(plan, input, admission.result, undefined);
-    return runAdmittedCuaRun(plan, input, admission.admitted);
-}
-/**
- * Runs an admitted plan in its own run scope, then its automatic analysis. The
- * withTransientCommsSecrets wrapper scopes any email secret the run registers to this run and its
- * analysis.
+ * loads a declared scorer, and returns the run that continues from them with that scorer. The
+ * run and its analysis share one scope for the email secrets it registers.
  */
-function runAdmittedCuaRun(plan, input, admitted) {
-    return withTransientCommsSecrets(async () => {
-        const { result, finished } = await runScope((scope) => runPlanInScope(plan, input, admitted, scope));
-        return completeCuaAnalysis(plan, input, result, finished);
-    });
-}
-function completeCuaAnalysis(plan, input, result, finished) {
+export function admitComputerUsePlan(plan, input, config) {
     // 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 }),
+    const analysisRefusal = input.localVm?.analysisRefusal;
+    return admitRoute({
+        route: "computer-use",
+        analysis: plan.analysis,
+        input,
+        admit: () => admitCuaRun(plan, input, config),
+        withScorer: (base, scorer) => withLateScorer(base, scorer, browserRouteScorer),
+        runInScope: (admitted, running, scope) => runPlanInScope(plan, running, admitted, scope),
+        ...(analysisRefusal === undefined ? {} : { analysisRefusal }),
+        commsSecrets: true,
     });
 }
 async function runPlanInScope(plan, input, admitted, scope) {

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

@@ -1,4 +1,5 @@
 import { type RunScope } from "../../run/run.js";
+import type { RefusedStudy } from "../../run/route-shell.js";
 import type { CuaActorDescriptor } from "../../actors/registry.js";
 import type { StudyCommsEmail, StudyCommsExternal, StudyConfig } from "../../study/types.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
@@ -8,12 +9,12 @@ import type { ComputerUsePlan } from "../../study/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 CuaActorStudyErrorCode, type CuaActorStudyResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput, type RunCuaActorStudyOptions } from "./types.js";
+import { type CuaActorStudyErrorCode, type CuaActorStudyResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput } from "./types.js";
 /**
  * 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 refuseCuaStudy(options: RunCuaActorStudyOptions, refusal: ComputerUseRefusal): Promise<CuaActorStudyResult>;
+export declare function refuseCuaStudy(options: ComputerUseRunInput & RefusedStudy, refusal: ComputerUseRefusal): Promise<CuaActorStudyResult>;
 export type AdmittedCuaRun = Extract<Awaited<ReturnType<typeof admitCuaRun>>, {
     ok: true;
 }>["admitted"];

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

@@ -19,7 +19,7 @@ import { type E2BDesktopModule } from "../../substrates/e2b/sdk.js";
 import { type DesktopResourceObservation } from "../../substrates/e2b/desktop-resources.js";
 import { type DetachedTimers } from "../../substrates/detached.js";
 import type { Brain, ComputerUsePlan, ComputerUseRunner, ResidualConfig } from "../../study/plan-types.js";
-import { type StudyCommsEmail, type StudyConfig } from "../../study/types.js";
+import { type StudyCommsEmail } from "../../study/types.js";
 import { type ObserverResult } from "../../observer/render.js";
 import { type BundleRun, type RunBundle, type RunRerunLineage, type RunScorerProvenance, type RunSubjectProvenance, type RunSubjectStateStepRecord } from "../../run/bundle.js";
 import { type RunDesktopGeometry } from "../../run/streams.js";
@@ -31,11 +31,6 @@ export declare const CUA_FANOUT_STRATEGY: "per-lane-worlds";
 export declare const CUA_MAX_CONCURRENCY_ENV = "HUMANISH_CUA_MAX_CONCURRENCY";
 export declare const DEFAULT_APP_URL_SESSION_TIMEOUT_MS: number;
 export declare const MIN_DERIVED_SESSION_TIMEOUT_MS: number;
-/**
- * What a computer-use run takes besides its plan and config. The count override and rerun go to
- * participant building with the config.
- */
-export type ComputerUseRunInput = Omit<RunCuaActorStudyOptions, "config" | "dryRun">;
 /**
  * What runStudyWith's local VM study gives a computer-use run: the desktop each participant runs on, the
  * reason automatic analysis must not run (the study's cleanup is unconfirmed), and the signal its
@@ -47,13 +42,14 @@ export interface LocalVmInput {
     readonly analysisRefusal: () => AutomaticAnalysisRefusal | undefined;
     readonly signal?: AbortSignal;
 }
-export interface RunCuaActorStudyOptions {
+/**
+ * What a computer-use run takes besides its plan and config. The count override and rerun go to
+ * participant building with the config.
+ */
+export interface ComputerUseRunInput {
     /** Cancels post-run analysis only. */
     analysisSignal?: AbortSignal;
     cwd: string;
-    config: StudyConfig;
-    /** Resolved upstream (scenario.mode + CLI override); defaults safe (dry-run). */
-    dryRun: boolean;
     open?: boolean;
     runId?: string;
     /** CLI `--count` override for the homogeneous fan-out participant count (ignored when a `lanes`

package/dist/routes/scripted/route.d.ts

@@ -1,28 +1,15 @@
 import type { ScriptedPlan } from "../../study/plan-types.js";
 import type { AdmittedPlan } from "../../run-study.js";
+import { type RefusedStudy } from "../../run/route-shell.js";
 import { type ScriptedRefusal } from "./plan.js";
-import { type RunScriptedBrowserStudyOptions, type ScriptedBrowserStudyResult, type ScriptedRunInput } from "./types.js";
-/**
- * The config-taking entry point. It plans, returns a refusal with the envelope the route has always
- * returned at that refusal's stage, and otherwise runs the plan.
- */
-export declare function runScriptedBrowserStudy(options: RunScriptedBrowserStudyOptions): Promise<ScriptedBrowserStudyResult>;
+import { type ScriptedBrowserStudyResult, type ScriptedRunInput } from "./types.js";
 /**
  * A refused scripted study's result, at the refusal's stage: a before-scope refusal has its own field
  * order and no analysis record; the others come after the output directory checks.
  */
-export declare function scriptedStudyRefusal(options: RunScriptedBrowserStudyOptions, refusal: ScriptedRefusal): Promise<ScriptedBrowserStudyResult>;
+export declare function scriptedStudyRefusal(options: ScriptedRunInput & RefusedStudy, refusal: ScriptedRefusal): Promise<ScriptedBrowserStudyResult>;
 /**
  * runStudyWith's step for a scripted plan. It takes no scorer, and its local checks (keys, a browser)
  * run inside the run, so it returns the run.
  */
-export declare function admitScriptedPlan(plan: ScriptedPlan, input: ScriptedRunInput): AdmittedPlan<"scripted">;
-/**
- * Run a scripted plan. The run scope gives a direct library caller the same status-record lifetime
- * the CLI gets: returning from this function finalizes any record the run opened, whichever of its
- * fail-closed exits it took. Each route opens its own scope; `runStudyWith` opens none. Without this a
- * test or an adopter calling the route directly leaves
- * the 5s cadence ticking into a directory something else is deleting, which surfaces as an
- * unrelated ENOTEMPTY.
- */
-export declare function runScriptedPlan(plan: ScriptedPlan, input: ScriptedRunInput): Promise<ScriptedBrowserStudyResult>;
+export declare function admitScriptedPlan(plan: ScriptedPlan, input: ScriptedRunInput): Promise<AdmittedPlan<"scripted">>;

package/dist/routes/scripted/route.js

@@ -17,14 +17,13 @@
 import { randomBytes } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import path from "node:path";
-import { completeAutomaticAnalysis } from "../../analysis/automatic-completion.js";
-import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
 import { buildRunSource } from "../../run/bundle.js";
 import { prepareSelectedOutputDirectory } from "../../run/contained-output.js";
-import { runScope } from "../../run/run.js";
+import {} from "../../run/run.js";
+import { admitRoute, completeRefusalAnalysis } from "../../run/route-shell.js";
 import { renderScriptedReviewMarkdown } from "./bundle.js";
-import { injectedBrowser, planScriptedStudy } from "./plan.js";
+import {} from "./plan.js";
 import { finishScriptedRun } from "./result.js";
 import { UnsafeScriptedSessionResultError } from "./session-result.js";
 import { prepareScriptedRun } from "./setup.js";
@@ -32,21 +31,6 @@ import { ScriptedSubject } from "./subject.js";
 import { runScriptedSessions, writeSurfaceTraces } from "./surface-sessions.js";
 import {} from "./types.js";
 import { studyResultIdentity } from "../../run/study-result.js";
-/**
- * The config-taking entry point. It plans, returns a refusal with the envelope the route has always
- * returned at that refusal's stage, and otherwise runs the plan.
- */
-export async function runScriptedBrowserStudy(options) {
-    const { config, dryRun, ...input } = options;
-    // planScriptedStudy makes every configuration refusal, in the order this route always has.
-    const planned = planScriptedStudy(config, {
-        dryRun,
-        injectedBrowser: injectedBrowser(input.deps),
-    });
-    if (planned.ok)
-        return runScriptedPlan(planned.plan, input);
-    return scriptedStudyRefusal(options, planned.refusal);
-}
 /**
  * A refused scripted study's result, at the refusal's stage: a before-scope refusal has its own field
  * order and no analysis record; the others come after the output directory checks.
@@ -83,35 +67,19 @@ export async function scriptedStudyRefusal(options, refusal) {
         warnings: [],
         error: { code: refusal.code, message: refusal.message },
     };
-    const analysis = resolveAutomaticAnalysis(config.review?.analysis);
-    return completeAutomaticAnalysis(refused, undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+    return completeRefusalAnalysis(refused, config, options);
 }
 /**
  * runStudyWith's step for a scripted plan. It takes no scorer, and its local checks (keys, a browser)
  * run inside the run, so it returns the run.
  */
 export function admitScriptedPlan(plan, input) {
-    return {
-        ok: true,
-        run: async () => ({
-            route: "scripted",
-            result: await runScriptedPlan(plan, input),
-        }),
-    };
-}
-/**
- * Run a scripted plan. The run scope gives a direct library caller the same status-record lifetime
- * the CLI gets: returning from this function finalizes any record the run opened, whichever of its
- * fail-closed exits it took. Each route opens its own scope; `runStudyWith` opens none. Without this a
- * test or an adopter calling the route directly leaves
- * the 5s cadence ticking into a directory something else is deleting, which surfaces as an
- * unrelated ENOTEMPTY.
- */
-export async function runScriptedPlan(plan, input) {
-    const { result, finished } = await runScope((scope) => runScriptedPlanInScope(plan, input, scope));
-    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input, {
-        ...(plan.analysis === undefined ? {} : { trigger: plan.analysis.trigger }),
-        preferLargerOutput: plan.analysis?.preferLargerOutput === true,
+    return admitRoute({
+        route: "scripted",
+        analysis: plan.analysis,
+        input,
+        admit: () => ({ ok: true, admitted: plan }),
+        runInScope: runScriptedPlanInScope,
     });
 }
 async function runScriptedPlanInScope(plan, input, scope) {

package/dist/routes/scripted/types.d.ts

@@ -1,23 +1,18 @@
 import type { ActorCompletionReason, ActorStatus } from "../../actors/contract.js";
 import type { StudyEvent } from "../../study/run-study-events.js";
 import type { AutomaticAnalysisResult } from "../../analysis/automatic-completion.js";
-import type { StudyConfig } from "../../study/types.js";
 import type { ObserverResult } from "../../observer/render.js";
 import type { RunSubjectProvenance } from "../../run/bundle.js";
 import type { StudyDeps } from "../../study/study-deps.js";
 import type { RunStudyHomes } from "../../study/run-study-homes.js";
 import { type StudyResultIdentity } from "../../run/study-result.js";
 /** What a scripted run takes besides its plan. The plan carries the config, dry run and study. */
-export type ScriptedRunInput = Omit<RunScriptedBrowserStudyOptions, "config" | "dryRun">;
-export interface RunScriptedBrowserStudyOptions {
+export interface ScriptedRunInput {
     /** Cancels post-run analysis only. */
     analysisSignal?: AbortSignal;
     /** Reports the analysis window to onEvent; built by normalizeRunStudyOptions. */
     emit?: (event: StudyEvent) => void;
     cwd: string;
-    config: StudyConfig;
-    /** Resolved upstream (scenario.mode + CLI override); defaults safe (dry-run). */
-    dryRun: boolean;
     open?: boolean;
     runId?: string;
     /** Keys and subject env for the run. Defaults to process.env. Values are scrubbed; names persist. */

package/dist/routes/shared-world/route.d.ts

@@ -1,21 +1,15 @@
+import { type RefusedStudy } from "../../run/route-shell.js";
 import { type SharedWorldRefusal } from "./plan.js";
 import type { SharedWorldPlan } from "../../study/plan-types.js";
 import type { AdmittedPlan } from "../../run-study.js";
 import type { StudyConfig } from "../../study/types.js";
-import { type ConcurrentSharedWorldStudyResult, type SharedWorldRunInput, type RunConcurrentSharedWorldStudyOptions } from "./types.js";
-/**
- * The library entry for a shared-world study. It plans the config with planSharedWorldStudy and runs
- * the plan with runSharedWorldPlan, whose run scope and withTransientCommsSecrets wrapper cover the
- * run and its analysis.
- */
-export declare function runConcurrentSharedWorld(options: RunConcurrentSharedWorldStudyOptions): Promise<ConcurrentSharedWorldStudyResult>;
+import { type ConcurrentSharedWorldStudyResult, type SharedWorldRunInput } from "./types.js";
 /** A refused shared-world study's result: the route's envelope, and a refusal's analysis record. */
-export declare function sharedWorldStudyRefusal(options: RunConcurrentSharedWorldStudyOptions, refusal: SharedWorldRefusal): Promise<ConcurrentSharedWorldStudyResult>;
+export declare function sharedWorldStudyRefusal(options: SharedWorldRunInput & RefusedStudy, refusal: SharedWorldRefusal): Promise<ConcurrentSharedWorldStudyResult>;
 /**
  * runStudyWith's step for a shared-world plan. It runs a live plan's local checks (the keys, a local
  * agent's sign-in and the subject env) before any run scope opens, so the CLI can present their refusal before it loads a
- * declared scorer, and returns the run that continues from them with that scorer.
+ * declared scorer, and returns the run that continues from them with that scorer. The run and its
+ * analysis share one scope for the email secrets it registers.
  */
 export declare function admitSharedWorldPlan(plan: SharedWorldPlan, input: SharedWorldRunInput, config: StudyConfig): Promise<AdmittedPlan<"shared-world">>;
-/** Run a shared-world plan: its local checks, then the run. */
-export declare function runSharedWorldPlan(plan: SharedWorldPlan, input: SharedWorldRunInput, config: StudyConfig): Promise<ConcurrentSharedWorldStudyResult>;

package/dist/routes/shared-world/route.js

@@ -34,15 +34,13 @@
 // gate; humanish cannot tell synthetic from real data, so it makes no claim about real data.
 import path from "node:path";
 import { missingKeys, missingSubjectEnv } from "../../study/requirements.js";
-import { completeAutomaticAnalysis } from "../../analysis/automatic-completion.js";
-import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { scrubLiterals } from "../../evidence/redaction.js";
 import { describeMissingKeys } from "../../keys/key-resolution.js";
-import { withTransientCommsSecrets } from "../../run/transient-comms-secrets.js";
-import { runScope } from "../../run/run.js";
+import {} from "../../run/run.js";
+import { admitRoute, completeRefusalAnalysis, } from "../../run/route-shell.js";
 import { makeCuaRunBudget } from "../computer-use/participant-model.js";
 import { runExternalPublicPlane } from "./external-public.js";
-import { planSharedWorldStudy, sharedWorldDescriptorOf } from "./plan.js";
+import { sharedWorldDescriptorOf } from "./plan.js";
 import { localAgentRefusal } from "../../actors/local-agent/readiness.js";
 import { runProvisionedPlane } from "./provisioned.js";
 import { concurrentStudyFailure, finishConcurrentRun } from "./result.js";
@@ -58,22 +56,6 @@ const LOCAL_AGENT_REFUSAL_CODES = {
     unsupported: "HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED",
     "unpriced-cap": "HUMANISH_SHARED_WORLD_UNPRICED_CAP",
 };
-/**
- * The library entry for a shared-world study. It plans the config with planSharedWorldStudy and runs
- * the plan with runSharedWorldPlan, whose run scope and withTransientCommsSecrets wrapper cover the
- * run and its analysis.
- */
-export async function runConcurrentSharedWorld(options) {
-    const { config, dryRun, ...input } = options;
-    // planSharedWorldStudy makes every configuration refusal, in the order this route always has.
-    const planned = planSharedWorldStudy(config, {
-        dryRun,
-        hasRunSession: input.deps?.runSession !== undefined,
-    });
-    if (planned.ok)
-        return runSharedWorldPlan(planned.plan, input, config);
-    return sharedWorldStudyRefusal(options, planned.refusal);
-}
 /** A refused shared-world study's result: the route's envelope, and a refusal's analysis record. */
 export function sharedWorldStudyRefusal(options, refusal) {
     const { config, dryRun } = options;
@@ -89,42 +71,38 @@ export function sharedWorldStudyRefusal(options, refusal) {
         dryRun,
         runId: options.runId,
     });
-    // A refusal starts no run, so a declared or default analysis is recorded as skipped.
-    const analysis = resolveAutomaticAnalysis(config.review?.analysis);
-    return completeAutomaticAnalysis(fail(refusal.code, refusal.message, refusal.actor), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+    return completeRefusalAnalysis(fail(refusal.code, refusal.message, refusal.actor), config, options);
 }
 /**
  * runStudyWith's step for a shared-world plan. It runs a live plan's local checks (the keys, a local
  * agent's sign-in and the subject env) before any run scope opens, so the CLI can present their refusal before it loads a
- * declared scorer, and returns the run that continues from them with that scorer.
+ * declared scorer, and returns the run that continues from them with that scorer. The run and its
+ * analysis share one scope for the email secrets it registers.
  */
-export async function admitSharedWorldPlan(plan, input, config) {
-    const refused = await admitSharedWorldRun(plan, input);
-    if (refused)
-        return { ok: false, outcome: sharedWorldOutcome(refused) };
-    return {
-        ok: true,
-        run: async (scorer) => sharedWorldOutcome(await runAdmittedSharedWorldRun(plan, withLateScorer(input, scorer, browserRouteScorer), config)),
-    };
-}
-function sharedWorldOutcome(result) {
-    return { route: "shared-world", result };
-}
-/** Run a shared-world plan: its local checks, then the run. */
-export async function runSharedWorldPlan(plan, input, config) {
-    const refused = await admitSharedWorldRun(plan, input);
-    return refused ?? runAdmittedSharedWorldRun(plan, input, config);
+export function admitSharedWorldPlan(plan, input, config) {
+    return admitRoute({
+        route: "shared-world",
+        analysis: plan.analysis,
+        input,
+        admit: () => admitSharedWorldRun(plan, input),
+        withScorer: (base, scorer) => withLateScorer(base, scorer, browserRouteScorer),
+        runInScope: (_admitted, running, scope) => runPlanInScope(plan, running, config, scope),
+        commsSecrets: true,
+    });
 }
 /**
  * A live plan's local checks, made outside any run scope: the keys, a local agent's sign-in, then
- * the subject env. A refusal is the result runSharedWorldPlan returns for it, with the analysis
- * record of a run that never started.
+ * the subject env.
  */
 async function admitSharedWorldRun(plan, input) {
+    const admitted = { ok: true, admitted: undefined };
     if (plan.dryRun)
-        return undefined;
+        return admitted;
     const env = input.env ?? process.env;
-    const fail = (code, message) => completeSharedWorldAnalysis(plan, input, sharedWorldFailure(plan, input)(code, message, sharedWorldDescriptorOf(plan.actor).id), undefined);
+    const fail = (code, message) => ({
+        ok: false,
+        result: sharedWorldFailure(plan, input)(code, message, sharedWorldDescriptorOf(plan.actor).id),
+    });
     // The plan lists OPENAI_API_KEY for an openai brain's participants and the external-public
     // plane's lobby-code reader; a local-agent brain's participants run on the operator's signed-in
     // agent instead.
@@ -143,24 +121,7 @@ async function admitSharedWorldRun(plan, input) {
     if (unsetSubjectEnv.length > 0) {
         return fail("HUMANISH_SHARED_WORLD_SUBJECT_ENV_MISSING", `subject.env declares ${unsetSubjectEnv.join(", ")} but the environment does not provide ${unsetSubjectEnv.length === 1 ? "it" : "them"} (pass via --dotenv; values are never persisted).`);
     }
-    return undefined;
-}
-/**
- * Runs an admitted plan in its own run scope, then its automatic analysis. The
- * withTransientCommsSecrets wrapper scopes any email secret the run registers to this run and its
- * analysis.
- */
-function runAdmittedSharedWorldRun(plan, input, config) {
-    return withTransientCommsSecrets(async () => {
-        const { result, finished } = await runScope((scope) => runPlanInScope(plan, input, config, scope));
-        return completeSharedWorldAnalysis(plan, input, result, finished);
-    });
-}
-function completeSharedWorldAnalysis(plan, input, result, finished) {
-    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input, {
-        ...(plan.analysis === undefined ? {} : { trigger: plan.analysis.trigger }),
-        preferLargerOutput: plan.analysis?.preferLargerOutput === true,
-    });
+    return admitted;
 }
 /** The route's envelope for a run that stops before its bundle. */
 function sharedWorldFailure(plan, input) {

package/dist/routes/shared-world/types.d.ts

@@ -24,13 +24,11 @@ export declare const CONCURRENT_SHARED_WORLD_PROVIDER_METADATA: {
     readonly tool: "humanish";
 };
 export declare const CONCURRENT_ATTRIBUTION_LIMITS: readonly ["concurrent", "best-effort-causal-attribution", "non-deterministic-shared-state", "window-and-snapshot-granularity", "contention-observed-not-proven-safe", "state-change-not-isolated-to-actors"];
-export interface RunConcurrentSharedWorldStudyOptions {
+/** What a shared-world run takes besides its plan. The plan carries the config, dry run and study. */
+export interface SharedWorldRunInput {
     /** Cancels post-run analysis only. */
     analysisSignal?: AbortSignal;
     cwd: string;
-    config: StudyConfig;
-    /** Resolved upstream (scenario.mode + CLI override); defaults safe (dry-run). */
-    dryRun: boolean;
     open?: boolean;
     runId?: string;
     onObserverReady?: (observer: ObserverResult & {
@@ -56,8 +54,6 @@ export interface RunConcurrentSharedWorldStudyOptions {
      *  core-stamped onto the bundle as evidence. Absent for library callers. */
     scorerProvenance?: RunScorerProvenance;
 }
-/** What a shared-world run takes besides its plan. The plan carries the config, dry run and study. */
-export type SharedWorldRunInput = Omit<RunConcurrentSharedWorldStudyOptions, "config" | "dryRun">;
 export type ConcurrentSharedWorldStudyErrorCode = "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_STUDY_V2_UNSUPPORTED" | "HUMANISH_SHARED_WORLD_FAILED" | "HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED" | "HUMANISH_SHARED_WORLD_INVALID" | "HUMANISH_SHARED_WORLD_KEYS_MISSING"
 /** A local-agent brain's CLI is not on `PATH`. */
  | "HUMANISH_SHARED_WORLD_AGENT_MISSING"

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

@@ -1,20 +1,10 @@
+import { type RefusedStudy } from "../../run/route-shell.js";
 import { type TerminalRefusal } from "./plan.js";
 import type { TerminalPlan } from "../../study/plan-types.js";
 import type { AdmittedPlan } from "../../run-study.js";
-import { type RunTerminalProductStudyOptions, type TerminalProductStudyResult, type TerminalRunInput } from "./types.js";
-/**
- * The config-taking entry point. It plans, returns a refusal with the same envelope and analysis
- * record the route has always returned, and otherwise runs the plan.
- */
-export declare function runTerminalProductStudy(options: RunTerminalProductStudyOptions): Promise<TerminalProductStudyResult>;
+import { type TerminalProductStudyResult, type TerminalRunInput } from "./types.js";
 /** A refused terminal study's result: the route's envelope, and the analysis record a refusal gets. */
-export declare function terminalStudyRefusal(options: RunTerminalProductStudyOptions, refusal: TerminalRefusal): Promise<TerminalProductStudyResult>;
-/**
- * Run a terminal plan. The run scope gives a direct library caller the same run lifetime the CLI
- * gets: whichever of its fail-closed exits the run takes, the run it started is closed, and only a
- * run that published its final bundle reaches automatic analysis.
- */
-export declare function runTerminalPlan(plan: TerminalPlan, input: TerminalRunInput): Promise<TerminalProductStudyResult>;
+export declare function terminalStudyRefusal(options: TerminalRunInput & RefusedStudy, refusal: TerminalRefusal): Promise<TerminalProductStudyResult>;
 /**
  * runStudyWith's step for a terminal plan. It runs a live plan's local checks (checkLiveTerminalMachine)
  * before any run scope opens, so the CLI can present their refusal before it loads a declared