humanish 0.107.0 → 0.109.0

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

@@ -1,43 +1,43 @@
 import type { CuaActorDescriptor } from "../../actors/registry.js";
-import type { LabConfig, LabSubjectServe, LabSubjectStateCheckpoint } from "../../lab/types.js";
+import type { StudyConfig, StudySubjectServe, StudySubjectStateCheckpoint } from "../../study/types.js";
 import type { RunScope } from "../../run/run.js";
-import type { ConcurrentSharedWorldLabErrorCode, ConcurrentSharedWorldLabResult, ConcurrentSharedWorldPlaneClass, FinishFacts, LiveParticipants, PlaneContext, PlaneResults, PlaneSelection, SharedWorldRunInput } from "./types.js";
-import type { LabDeps } from "../../lab/lab-deps.js";
-import type { SharedWorldPlan } from "../../lab/plan-types.js";
-/** What validation derived from the lab, which setup reads. */
-interface AdmittedLab {
+import type { ConcurrentSharedWorldStudyErrorCode, ConcurrentSharedWorldStudyResult, ConcurrentSharedWorldPlaneClass, FinishFacts, LiveParticipants, PlaneContext, PlaneResults, PlaneSelection, SharedWorldRunInput } from "./types.js";
+import type { StudyDeps } from "../../study/study-deps.js";
+import type { SharedWorldPlan } from "../../study/plan-types.js";
+/** What validation derived from the study, which setup reads. */
+interface AdmittedStudy {
     plan: SharedWorldPlan;
     input: SharedWorldRunInput;
-    /** Read for the subject's serve URL, which each seat's subject names. Seats, their count and
-     *  their host and entry come from the plan's participants. */
-    config: LabConfig;
+    /** Read for the subject's serve URL, which each participant's subject names. Participants, their
+     *  count and their host and entry come from the plan's participants. */
+    config: StudyConfig;
     requestedCwd: string;
-    deps: LabDeps;
+    deps: StudyDeps;
     env: Record<string, string | undefined>;
     descriptor: CuaActorDescriptor;
     planeClass: ConcurrentSharedWorldPlaneClass;
     runBudget: PlaneContext["runBudget"];
     runSession: PlaneContext["runSession"];
-    serve: LabSubjectServe | undefined;
+    serve: StudySubjectServe | undefined;
     localTreeRoute: boolean;
     subjectRepo: string;
     subjectEnvNames: string[];
-    checkpoints: LabSubjectStateCheckpoint[];
+    checkpoints: StudySubjectStateCheckpoint[];
     openaiApiKey: string;
     e2bApiKey: string;
     knownSecretValues: string[];
     scrubKnownValues: (text: string) => string;
     publicRepo: string;
     hasGithubToken: boolean;
-    fail: (code: ConcurrentSharedWorldLabErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldLabResult;
+    fail: (code: ConcurrentSharedWorldStudyErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldStudyResult;
 }
 /**
- * Starts the run and prepares what the planes read: the physical project, the run, the seat
+ * Starts the run and prepares what the planes read: the physical project, the run, the participant
  * specs, comms, the packed tree and email receiving. Returns the refusal when one of them fails.
  */
-export declare function prepareConcurrentRun(lab: AdmittedLab, scope: RunScope): Promise<{
+export declare function prepareConcurrentRun(study: AdmittedStudy, scope: RunScope): Promise<{
     ok: false;
-    result: ConcurrentSharedWorldLabResult;
+    result: ConcurrentSharedWorldStudyResult;
 } | {
     ok: true;
     ctx: PlaneContext;

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

@@ -1,5 +1,5 @@
 // Starts a concurrent shared-world run and prepares what its plane reads: the physical project,
-// the run, the seat specs, comms, the packed tree and email receiving.
+// the run, the participant specs, comms, the packed tree and email receiving.
 import { randomBytes } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { buildRunSource } from "../../run/bundle.js";
@@ -19,19 +19,19 @@ function makeRunId() {
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
     return `concurrent-shared-world-${stamp}-${randomBytes(4).toString("hex")}`;
 }
-/** The provisioned plane's setup, or undefined when the lab declares no `subject.serve`. */
-function provisionedSetup(lab, prepared) {
-    if (!lab.serve)
+/** The provisioned plane's setup, or undefined when the study declares no `subject.serve`. */
+function provisionedSetup(study, prepared) {
+    if (!study.serve)
         return undefined;
     const { subjectComms, ...rest } = prepared;
     return {
-        serve: lab.serve,
-        localTreeRoute: lab.localTreeRoute,
-        subjectRepo: lab.subjectRepo,
-        publicRepo: lab.publicRepo,
-        subjectEnvNames: lab.subjectEnvNames,
-        hasGithubToken: lab.hasGithubToken,
-        checkpoints: lab.checkpoints,
+        serve: study.serve,
+        localTreeRoute: study.localTreeRoute,
+        subjectRepo: study.subjectRepo,
+        publicRepo: study.publicRepo,
+        subjectEnvNames: study.subjectEnvNames,
+        hasGithubToken: study.hasGithubToken,
+        checkpoints: study.checkpoints,
         commsEmail: subjectComms.email,
         commsPort: subjectComms.port,
         commsEnv: subjectComms.env,
@@ -48,26 +48,26 @@ async function bindPhysicalProject(requestedCwd) {
     return (await prepareSelectedOutputDirectory(path.dirname(physicalCwd), physicalCwd))
         .physicalPath;
 }
-function startConcurrentRun(lab, cwd, scope) {
-    const { plan, input, deps } = lab;
+function startConcurrentRun(study, cwd, scope) {
+    const { plan, input, deps } = study;
     return scope.startRun({
         cwd,
         runId: input.runId,
         mintRunId: makeRunId,
         mode: plan.dryRun ? "dry-run" : "live",
-        lab: plan.lab,
+        study: plan.study,
         renderReview: renderConcurrentReviewMarkdown,
         observer: { open: input.open === true, render: deps.renderObserver },
     });
 }
 /**
- * Starts the run and prepares what the planes read: the physical project, the run, the seat
+ * Starts the run and prepares what the planes read: the physical project, the run, the participant
  * specs, comms, the packed tree and email receiving. Returns the refusal when one of them fails.
  */
-export async function prepareConcurrentRun(lab, scope) {
-    const { plan, input, config, requestedCwd, deps, env, descriptor, planeClass, fail } = lab;
-    const { runBudget, runSession, localTreeRoute, subjectEnvNames, publicRepo } = lab;
-    const { openaiApiKey, e2bApiKey, knownSecretValues, scrubKnownValues } = lab;
+export async function prepareConcurrentRun(study, scope) {
+    const { plan, input, config, requestedCwd, deps, env, descriptor, planeClass, fail } = study;
+    const { runBudget, runSession, localTreeRoute, subjectEnvNames, publicRepo } = study;
+    const { openaiApiKey, e2bApiKey, knownSecretValues, scrubKnownValues } = study;
     const { dryRun, concurrency } = plan;
     const cwd = await bindPhysicalProject(requestedCwd);
     const warnings = [];
@@ -85,12 +85,12 @@ export async function prepareConcurrentRun(lab, scope) {
     if (!packed.ok) {
         return {
             ok: false,
-            result: fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED", packed.message, descriptor.id),
+            result: fail("HUMANISH_SHARED_WORLD_FAILED", packed.message, descriptor.id),
         };
     }
     const localTreeArchive = packed.archive;
     const localTreeArchiveBuffer = packed.buffer;
-    const started = await startConcurrentRun(lab, cwd, scope);
+    const started = await startConcurrentRun(study, cwd, scope);
     if (!started.ok)
         return { ok: false, result: fail(started.code, started.message, descriptor.id) };
     const { run } = started;
@@ -131,7 +131,7 @@ export async function prepareConcurrentRun(lab, scope) {
         return {
             ok: false,
             result: {
-                ...fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_INVALID", email.message, descriptor.id),
+                ...fail("HUMANISH_SHARED_WORLD_INVALID", email.message, descriptor.id),
                 runId,
             },
         };
@@ -169,7 +169,7 @@ export async function prepareConcurrentRun(lab, scope) {
         receiving,
         warnings,
     };
-    const provisioned = provisionedSetup(lab, {
+    const provisioned = provisionedSetup(study, {
         localTreeArchive,
         localTreeArchiveBuffer,
         subjectComms,

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

@@ -1,12 +1,12 @@
-import type { LabDeps } from "../../lab/lab-deps.js";
-import type { LabEvent } from "../../lab/run-lab-events.js";
-import type { RunLabHomes } from "../../lab/run-lab-homes.js";
+import type { StudyDeps } from "../../study/study-deps.js";
+import type { StudyEvent } from "../../study/run-study-events.js";
+import type { RunStudyHomes } from "../../study/run-study-homes.js";
 import type { SharedWorldJudgment } from "../../run/judge.js";
-import type { BrowserScorer } from "../../lab/adapter-extension.js";
+import type { BrowserScorer } from "../../study/adapter-extension.js";
 import type { AutomaticAnalysisResult } from "../../analysis/automatic-completion.js";
 import type { CuaActorDescriptor } from "../../actors/registry.js";
 import type { CommsReceivingRun } from "../../comms/receiving.js";
-import type { LabCommsEmail, LabCommsExternal, LabConfig } from "../../lab/types.js";
+import type { StudyCommsEmail, StudyCommsExternal, StudyConfig } from "../../study/types.js";
 import type { DesktopResourceObservation } from "../../substrates/e2b/desktop-resources.js";
 import type { ObserverResult } from "../../observer/render.js";
 import type { ObserverRuntimeStreamUrl } from "../../observer/run-routes.js";
@@ -17,18 +17,18 @@ import type { LocalTreeArchive } from "../../subject/local-tree-archive.js";
 import type { LiveTraceFlush } from "../computer-use/live-flush.js";
 import type { CuaParticipantDeps, DesktopParticipantRun, CuaRunBudget, ParticipantRunOutcome } from "../computer-use/types.js";
 import type { ProvisionedPlaneSetup } from "./provisioned.js";
-import type { SharedWorldPlan } from "../../lab/plan-types.js";
-export declare const CONCURRENT_SHARED_WORLD_LAB_SCHEMA = "humanish.concurrent-shared-world-lab-result.v1";
+import type { SharedWorldPlan } from "../../study/plan-types.js";
+import { type StudyResultIdentity } from "../../run/study-result.js";
 export declare const CONCURRENT_SHARED_WORLD_PROVIDER_METADATA: {
     readonly mode: "concurrent-shared-world-lab";
     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 RunConcurrentSharedWorldLabOptions {
+export interface RunConcurrentSharedWorldStudyOptions {
     /** Cancels post-run analysis only. */
     analysisSignal?: AbortSignal;
     cwd: string;
-    config: LabConfig;
+    config: StudyConfig;
     /** Resolved upstream (scenario.mode + CLI override); defaults safe (dry-run). */
     dryRun: boolean;
     open?: boolean;
@@ -40,37 +40,38 @@ export interface RunConcurrentSharedWorldLabOptions {
     env?: Readonly<Record<string, string | undefined>>;
     /**
      * Runs after a sandbox exists and before anything is provisioned on it: the provisioned plane's
-     * subject sandbox, then each seat's desktop. The external-public plane has seats only.
+     * subject sandbox, then each participant's desktop. The external-public plane has participants
+     * only.
      */
-    prepareDesktop?: NonNullable<RunLabHomes["prepareDesktop"]>;
+    prepareDesktop?: NonNullable<RunStudyHomes["prepareDesktop"]>;
     /** Awaited after a participant's live stream starts, and again after its sandbox is gone. */
-    onStream?: NonNullable<RunLabHomes["onStream"]>;
-    /** Reports subject phases to onEvent; built by normalizeRunLabOptions. */
-    emit?: (event: LabEvent) => void;
+    onStream?: NonNullable<RunStudyHomes["onStream"]>;
+    /** Reports subject phases to onEvent; built by normalizeRunStudyOptions. */
+    emit?: (event: StudyEvent) => void;
     /** Test seams. */
-    deps?: LabDeps;
-    /** Scores the assembled evidence: `RunLabOptions.scorer`, or the scorer the CLI loads. */
+    deps?: StudyDeps;
+    /** Scores the assembled evidence: `RunStudyOptions.scorer`, or the scorer the CLI loads. */
     scorer?: BrowserScorer;
-    /** Present only when the scorer was CONFIG-DECLARED and loaded by the CLI (#316);
+    /** Present only when the scorer was config-declared and loaded by the CLI;
      *  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 lab. */
-export type SharedWorldRunInput = Omit<RunConcurrentSharedWorldLabOptions, "config" | "dryRun" | "lab">;
-export type ConcurrentSharedWorldLabErrorCode = "HUMANISH_LAB_ANALYSIS_INVALID" | "HUMANISH_LAB_TASKS_UNSUPPORTED" | "HUMANISH_LAB_OPTION_UNSUPPORTED" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_ACTOR_UNSUPPORTED" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_INVALID" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_KEYS_MISSING"
+/** 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_CONCURRENT_SHARED_WORLD_LAB_AGENT_MISSING"
+ | "HUMANISH_SHARED_WORLD_AGENT_MISSING"
 /** A local-agent brain's CLI is signed out, or could not report its sign-in status. */
- | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_AGENT_SIGNIN_REQUIRED"
+ | "HUMANISH_SHARED_WORLD_AGENT_SIGNIN_REQUIRED"
 /** A dollar cap that cannot be priced: an unpriced model, or a ChatGPT-account Codex brain. */
- | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_UNPRICED_CAP" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_SUBJECT_ENV_MISSING" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_GETHOST_UNAVAILABLE" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_HANDOFF_TIMEOUT" | "HUMANISH_RUN_ID_IN_USE"
-/** A declared adopter-hosted comms catch (#328) did not answer as a humanish catch — fail closed
+ | "HUMANISH_SHARED_WORLD_UNPRICED_CAP" | "HUMANISH_SHARED_WORLD_SUBJECT_ENV_MISSING" | "HUMANISH_SHARED_WORLD_GETHOST_UNAVAILABLE" | "HUMANISH_SHARED_WORLD_HANDOFF_TIMEOUT" | "HUMANISH_RUN_ID_IN_USE"
+/** A declared adopter-hosted comms catch did not answer as a humanish catch. Fail closed
  *  before any actor spend, since the funnel would silently collect nothing. */
- | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_COMMS_CATCH_UNREACHABLE"
+ | "HUMANISH_SHARED_WORLD_COMMS_CATCH_UNREACHABLE"
 /** comms.email.external.authTokenEnv names a token shorter than MIN_CATCH_TOKEN_LENGTH or not
  *  well-formed Unicode (src/comms/external-evidence.ts). Refused before the catch is probed. */
- | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_COMMS_TOKEN_INVALID";
-/** The two plane classes of the concurrent shared-world route (#164 phase 2). */
+ | "HUMANISH_SHARED_WORLD_COMMS_TOKEN_INVALID";
+/** The two plane classes of the concurrent shared-world route. */
 export type ConcurrentSharedWorldPlaneClass = "provisioned-getHost" | "external-public";
 export declare const EXTERNAL_PUBLIC_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", "external-public-plane", "operator-attested-target-not-harness-controlled", "no-synthetic-attestation", "no-authoritative-shared-state-proof", "concurrency-by-temporal-co-occupancy-only"];
 /** One persona's outcome against the contended world (the "M of N" headline). */
@@ -97,15 +98,13 @@ export interface ConcurrentSharedWorldParticipantResult {
         killed: boolean;
     };
     error?: {
-        code: ConcurrentSharedWorldLabErrorCode;
+        code: ConcurrentSharedWorldStudyErrorCode;
         message: string;
     };
 }
-export interface ConcurrentSharedWorldLabResult extends AutomaticAnalysisResult {
-    schema: typeof CONCURRENT_SHARED_WORLD_LAB_SCHEMA;
+export interface ConcurrentSharedWorldStudyResult extends AutomaticAnalysisResult, StudyResultIdentity<"shared-world"> {
     ok: boolean;
     cwd: string;
-    labId: string;
     actor: string;
     topology: "shared-world";
     topologyMode: "concurrent";
@@ -124,16 +123,16 @@ export interface ConcurrentSharedWorldLabResult extends AutomaticAnalysisResult
     };
     /** Whether ≥2 actor windows overlapped in time (proven concurrency; live only). */
     overlapProven?: boolean;
-    /** Max participants observed live at the same instant (live only) — the honest simultaneity number; a
-     *  6-participant run capped at 3 reports 3 here, never 6 (#350). */
+    /** Max participants observed live at the same instant (live only): the simultaneity number; a
+     *  6-participant run capped at 3 reports 3 here, never 6. */
     maxSimultaneousLanes?: number;
-    /** Subject provenance (invariant 5): the one shared plane. */
+    /** Subject provenance: the one shared plane. */
     subject?: RunSubjectProvenance;
     roles: ConcurrentSharedWorldParticipantResult[];
     observer?: ObserverResult;
     warnings: string[];
     error?: {
-        code: ConcurrentSharedWorldLabErrorCode;
+        code: ConcurrentSharedWorldStudyErrorCode;
         message: string;
     };
 }
@@ -158,12 +157,12 @@ type StartedRun = Extract<Awaited<ReturnType<RunScope["startRun"]>>, {
 export interface PlaneContext {
     plan: SharedWorldPlan;
     input: SharedWorldRunInput;
-    /** Read for the subject's serve URL, which each seat's subject names. Seats, their count and
-     *  their host and entry come from the plan's participants. */
-    config: LabConfig;
+    /** Read for the subject's serve URL, which each participant's subject names. Participants, their
+     *  count and their host and entry come from the plan's participants. */
+    config: StudyConfig;
     descriptor: CuaActorDescriptor;
     /** The run's test seams; empty outside tests. */
-    deps: LabDeps;
+    deps: StudyDeps;
     env: Record<string, string | undefined>;
     concurrency: number;
     runBudget: CuaRunBudget | undefined;
@@ -171,7 +170,8 @@ export interface PlaneContext {
     openaiApiKey: string;
     e2bApiKey: string;
     scrubKnownValues: (text: string) => string;
-    /** The values scrubKnownValues removes. Real email receiving adds its secrets before seats start. */
+    /** The values scrubKnownValues removes. Real email receiving adds its secrets before participants
+     *  start. */
     knownSecretValues: readonly string[];
     cwd: string;
     run: StartedRun;
@@ -191,8 +191,9 @@ export interface PlaneContext {
     warnings: string[];
 }
 /**
- * What the seats feed while they run. A plane sets the attached Observer and starts the trace
- * flush; each seat's onStream appends stream URLs; the orchestrator reads all three at finish.
+ * What the participants feed while they run. A plane sets the attached Observer and starts the
+ * trace flush; each participant's onStream appends stream URLs; the orchestrator reads all three at
+ * finish.
  */
 export interface LiveParticipants {
     observer?: ObserverResult & {
@@ -201,17 +202,17 @@ export interface LiveParticipants {
     flush?: LiveTraceFlush;
     readonly streamUrls: ObserverRuntimeStreamUrl[];
 }
-/** An adopter-hosted comms catch (#328) and the inbox its personas open. */
+/** An adopter-hosted comms catch and the inbox its personas open. */
 export interface ExternalCommsWiring {
-    external: LabCommsExternal;
-    email: LabCommsEmail;
+    external: StudyCommsExternal;
+    email: StudyCommsEmail;
     inboxUrl: string;
 }
 /** What buildConcurrentSharedWorldBundle projects into a run bundle. */
 export interface ConcurrentBundleArgs {
     /** The run's judgment (judgeSharedWorldRun over the other fields). */
     judgment: SharedWorldJudgment;
-    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and study. */
     run: BundleRun;
     plan: SharedWorldPlan;
     descriptor: CuaActorDescriptor;
@@ -225,19 +226,20 @@ export interface ConcurrentBundleArgs {
     seedDigest: string;
     subjectCommit?: string;
     hostDigest?: string;
-    /** Run-level digest-only comms-thread evidence path (humanish.comms-thread.v1), when a comms lab
+    /** Run-level digest-only comms-thread evidence path (humanish.comms-thread.v1), when a comms study
      *  captured mail into the subject sandbox's catch. Registered on the first persona stream (it is a
      *  property of the one shared app, and belongs to no single persona). */
     commsArtifactPath?: string;
-    /** #164 phase 2: the plane-class discriminator (default provisioned-getHost, byte-stable). */
+    /** The plane-class discriminator (default provisioned-getHost, byte-stable). */
     planeClass?: ConcurrentSharedWorldPlaneClass;
-    /** external-public only: sha256-16 of the observed origin the seats converged on (the convergence
-     *  proof — what the seats actually reached, tolerant of a declared->observed redirect). */
+    /** external-public only: sha256-16 of the observed origin the participants converged on (the
+     *  convergence proof: what the participants actually reached, tolerant of a declared->observed
+     *  redirect). */
     publicOriginDigest?: string;
-    /** external-public only: sha256-16 of the operator-DECLARED plane origin (evidence/reference only;
+    /** external-public only: sha256-16 of the operator-declared plane origin (evidence/reference only;
      *  never asserted equal to the observed origin, since a cross-origin redirect is normal). */
     declaredOriginDigest?: string;
-    /** external-public only: sha256-16 of the shared /lobby/CODE path all seats converged on. */
+    /** external-public only: sha256-16 of the /lobby/CODE path all participants converged on. */
     lobbyConvergenceDigest?: string;
     runError?: string;
     /** The provisioned plane's own desktop; absent on external-public planes and dry runs. */
@@ -263,7 +265,7 @@ export interface PlaneResults {
 /** Which plane runs, and the setup it needs beyond the plane context. */
 export interface PlaneSelection {
     planeClass: ConcurrentSharedWorldPlaneClass;
-    /** Undefined when the lab declares no `subject.serve`. */
+    /** Undefined when the study declares no `subject.serve`. */
     provisioned: ProvisionedPlaneSetup | undefined;
     externalWiring: ExternalCommsWiring | undefined;
 }

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

@@ -1,6 +1,6 @@
 // The concurrent shared-world route's schema constants, attribution limits, options and result
-// types, and the per-seat result the planes collect.
-export const CONCURRENT_SHARED_WORLD_LAB_SCHEMA = "humanish.concurrent-shared-world-lab-result.v1";
+// types, and the per-participant result the planes collect.
+import {} from "../../run/study-result.js";
 export const CONCURRENT_SHARED_WORLD_PROVIDER_METADATA = {
     mode: "concurrent-shared-world-lab",
     tool: "humanish",
@@ -15,8 +15,8 @@ export const CONCURRENT_ATTRIBUTION_LIMITS = [
     "contention-observed-not-proven-safe",
     "state-change-not-isolated-to-actors",
 ];
-// EXTERNAL-PUBLIC plane class: the honest-downgrade attribution ceiling. The concurrent family
-// (an honest ceiling) plus the mandatory external-public disclosures, mirrored in the required
+// External-public plane class: the downgraded attribution ceiling. The concurrent family
+// plus the mandatory external-public disclosures, mirrored in the required
 // set in verify/shared-world-concurrent.ts (CONCURRENT_ATTRIBUTION_LIMITS +
 // EXTERNAL_PUBLIC_EXTRA_LIMITS). Verify fails closed on a missing one.
 export const EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS = [

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

@@ -1,15 +1,15 @@
 import type { ActorTrace } from "../../actors/contract.js";
 import { type RunBundle, type RunScorerProvenance } from "../../run/bundle.js";
-import { type ScorerOutcome } from "../../lab/adapter-extension.js";
+import { type ScorerOutcome } from "../../study/adapter-extension.js";
 import type { TerminalLedgers, TerminalScorer } from "./types.js";
 /**
- * Run the layer-6 product-adapter extension seam (issue #154 acceptance #8) over the assembled
+ * Run the product-adapter extension seam over the assembled
  * evidence and attach its results to the bundle in place, without core knowing any product noun.
  * The review is not touched here: the returned failures are folded into it by the caller.
  *
  *  - `score`: when present, the returned namespaced `RunAdapterScore` lands on `bundle.adapterScore`.
  *    For a library caller (no `scorerProvenance`), the adapter score is additive and never a
- *    failure. For a config-declared scorer (#316; `scorerProvenance` present), a status:"fail" is a
+ *    failure. For a config-declared scorer (`scorerProvenance` present), a status:"fail" is a
  *    failure (the keystone route is the product's own definition of pass/fail), and so is a scorer
  *    that throws or returns a malformed value, so a crashed declared gate is never a silent green.
  *  - `deriveFeedback`: when present, the returned candidates are appended to
@@ -27,11 +27,11 @@ export declare function applyAdapterExtensionSeam(args: {
     ledgers: TerminalLedgers;
     transcript: string;
     product: string;
-    labId: string;
+    studyId: string;
     runId: string;
     sanitize: (text: string) => string;
     warnings: string[];
-    /** Present only when the scorer was CONFIG-DECLARED (#316) — the "declared" marker that opts the
+    /** Present only when the scorer was config-declared. It is the "declared" marker that opts the
      *  terminal route into flip-on-fail. Absent for library callers (additive, back-compat). */
     scorerProvenance?: RunScorerProvenance;
 }): Promise<ScorerOutcome>;

package/dist/routes/terminal/adapter.js

@@ -1,14 +1,14 @@
 import {} from "../../run/bundle.js";
 import { isRunAdapterScore } from "../../run/bundle-shape.js";
-import { adapterScoreFailureMessage, declaredScorerThrew, DECLARED_SCORER_MALFORMED, frozenBundleView, isAdapterFeedbackCandidate, } from "../../lab/adapter-extension.js";
+import { adapterScoreFailureMessage, declaredScorerThrew, DECLARED_SCORER_MALFORMED, frozenBundleView, isAdapterFeedbackCandidate, } from "../../study/adapter-extension.js";
 /**
- * Run the layer-6 product-adapter extension seam (issue #154 acceptance #8) over the assembled
+ * Run the product-adapter extension seam over the assembled
  * evidence and attach its results to the bundle in place, without core knowing any product noun.
  * The review is not touched here: the returned failures are folded into it by the caller.
  *
  *  - `score`: when present, the returned namespaced `RunAdapterScore` lands on `bundle.adapterScore`.
  *    For a library caller (no `scorerProvenance`), the adapter score is additive and never a
- *    failure. For a config-declared scorer (#316; `scorerProvenance` present), a status:"fail" is a
+ *    failure. For a config-declared scorer (`scorerProvenance` present), a status:"fail" is a
  *    failure (the keystone route is the product's own definition of pass/fail), and so is a scorer
  *    that throws or returns a malformed value, so a crashed declared gate is never a silent green.
  *  - `deriveFeedback`: when present, the returned candidates are appended to
@@ -20,7 +20,7 @@ import { adapterScoreFailureMessage, declaredScorerThrew, DECLARED_SCORER_MALFOR
  * re-checks the surviving shapes downstream, so the seam stays fail-closed end to end.
  */
 export async function applyAdapterExtensionSeam(args) {
-    const { scorer, bundle, trace, ledgers, transcript, product, labId, runId, sanitize, warnings, scorerProvenance, } = args;
+    const { scorer, bundle, trace, ledgers, transcript, product, studyId, runId, sanitize, warnings, scorerProvenance, } = args;
     if (!scorer?.score && !scorer?.deriveFeedback)
         return { failures: [] };
     const declared = scorerProvenance !== undefined;
@@ -28,17 +28,17 @@ export async function applyAdapterExtensionSeam(args) {
     // still loaded and attempted).
     if (scorerProvenance)
         bundle.scorerProvenance = scorerProvenance;
-    // The scorer sees a READ-ONLY view of the bundle so it cannot mutate noSpend/cost/review in place to
+    // The scorer sees a read-only view of the bundle so it cannot mutate noSpend/cost/review in place to
     // launder a verdict (a tamper attempt throws and is caught as a hook failure below). The seam stamps
     // the real bundle. The transcript is the same normalized, source-scrubbed text the run persists as
-    // terminal-transcript.txt — no new exposure beyond what disk already holds (#341).
+    // terminal-transcript.txt, so the scorer sees nothing beyond what disk already holds.
     const ctx = {
         bundle: frozenBundleView(bundle),
         trace,
         ledgers,
         transcript,
         product,
-        labId,
+        studyId,
         runId,
     };
     // Best-effort re-scrub of the adapter payload: round-trip the whole JSON through the run's denylist
@@ -46,7 +46,7 @@ export async function applyAdapterExtensionSeam(args) {
     // local paths, and misses encoded/split/custom secrets, DB passwords, PII, or abs paths outside
     // the denylist. A
     // payload from config-declared code is acceptable only because the trust boundary (the party who
-    // declares the scorer runs the lab) already permits direct exfiltration; the re-scrub is
+    // declares the scorer runs the study) already permits direct exfiltration; the re-scrub is
     // defense-in-depth, not a wall.
     const scrubValue = (value) => JSON.parse(sanitize(JSON.stringify(value)));
     // Set for a declared scorer that fails to render a pass verdict (status:"fail", malformed, or throw).
@@ -59,7 +59,7 @@ export async function applyAdapterExtensionSeam(args) {
             const cleaned = scrubValue(score);
             if (isRunAdapterScore(cleaned)) {
                 bundle.adapterScore = cleaned;
-                // A CONFIG-DECLARED terminal scorer owns the product verdict: a status:"fail" fails the
+                // A config-declared terminal scorer owns the product verdict: a status:"fail" fails the
                 // review and the run result. A library caller keeps the additive no-fail behavior.
                 const message = declared ? adapterScoreFailureMessage(bundle) : undefined;
                 if (message !== undefined)

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

@@ -1,27 +1,27 @@
 import type { ActorPersonaRef, ActorTrace } from "../../actors/contract.js";
-import type { LabScenarioCaps, LabRuntimeAuth } from "../../lab/types.js";
+import type { StudyScenarioCaps, StudyRuntimeAuth } from "../../study/types.js";
 import { type RunBundle, type RunCostSummary, type BundleRun } from "../../run/bundle.js";
-import type { Verdict } from "../../run/judge.js";
+import { type Verdict } from "../../run/judge.js";
 import type { TerminalLedgers } from "./types.js";
 /**
- * Project the terminal-product lab run into a humanish.run-bundle.v1 (no schema change — a new
- * producer only). DRY-RUN: a contract bundle. The terminal stream is a contract placeholder
+ * Project the terminal-product run into a humanish.run-bundle.v1 (no schema change: a new
+ * producer only). Dry run: a contract bundle. The terminal stream is a contract placeholder
  * (stdin disabled, no captured tail, because nothing ran), the subject is declared unpinned, and
  * the caps/policies/runtime-auth declarations are recorded without pretending that live ledgers
  * exist. The shipped live builder fills the same evidence contract. Exported for tests.
  */
 export declare function buildTerminalProductBundle(args: {
-    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and study. */
     run: BundleRun;
     actorId: string;
     dryRun: boolean;
-    labId: string;
-    labTitle?: string;
+    studyId: string;
+    studyTitle?: string;
     mission: string;
     persona: ActorPersonaRef;
     productName: string;
     publicSurfaces: string[];
-    caps?: LabScenarioCaps;
+    caps?: StudyScenarioCaps;
     runtimeAuth?: string;
     stdin: "disabled" | "planned" | "sent";
     policies: {
@@ -42,18 +42,18 @@ export declare function buildTerminalProductBundle(args: {
  * mode==="live") enforces the ledgers + proven cleanup + interventions-present over this bundle.
  */
 export declare function buildLiveTerminalProductBundle(args: {
-    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and study. */
     run: BundleRun;
     actorId: string;
-    labId: string;
-    labTitle?: string;
+    studyId: string;
+    studyTitle?: string;
     mission: string;
     persona: ActorPersonaRef;
     productName: string;
     publicSurfaces: string[];
-    caps?: LabScenarioCaps;
+    caps?: StudyScenarioCaps;
     runtimeAuthKeyName: string;
-    runtimeAuth?: LabRuntimeAuth;
+    runtimeAuth?: StudyRuntimeAuth;
     policies: {
         allowPrivateRepoAccess: boolean;
         allowProviderCredentials: boolean;