humanish 0.107.0 → 0.108.0

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

@@ -2,7 +2,7 @@ import type { RunSubjectProvenance } from "../../run/bundle.js";
 import type { LocalTreeArchive } from "../../subject/local-tree-archive.js";
 /** Extract the in-sandbox port from the (loopback) serve.url so getHost can expose it. */
 export declare function servePort(serveUrl: string): number;
-/** A getHost URL must be tokenless (no userinfo and no query, so no authKey; invariant 1). */
+/** A getHost URL must be tokenless (no userinfo and no query, so no authKey reaches evidence). */
 export declare function isTokenlessHost(value: string): boolean;
 /** sha256-16 of a URL's origin: the publish-safe host identity persisted in the bundle (the raw
  *  getHost URL embeds the live sandbox id + matches the e2b-URL redaction, so it never lands raw). */
@@ -11,7 +11,7 @@ export declare function hostOriginDigest(url: string): string;
  *  entry path kept). Never contains the raw getHost URL. */
 export declare function publicSafeRouteLabel(entry: string | undefined): string;
 /**
- * Build the one subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
+ * Build the one subject sandbox's provenance: clone (repo + optional commit) or
  * local-tree (archiveSha256 + optional commit/dirty from the once-per-run host-packed archive -
  * archiveSha256 is the pin; there is only one archive, so no per-participant unanimity math applies,
  * unlike the cua fan-out route). Used for both the in-progress and final bundle: the archive

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

@@ -8,7 +8,7 @@ export function servePort(serveUrl) {
         return Number(url.port);
     return url.protocol === "https:" ? 443 : 80;
 }
-/** A getHost URL must be tokenless (no userinfo and no query, so no authKey; invariant 1). */
+/** A getHost URL must be tokenless (no userinfo and no query, so no authKey reaches evidence). */
 export function isTokenlessHost(value) {
     try {
         const url = new URL(value);
@@ -34,7 +34,7 @@ export function publicSafeRouteLabel(entry) {
     return `[provisioned-subject]${entry ?? "/"}`;
 }
 /**
- * Build the one subject sandbox's provenance (invariant 5): clone (repo + optional commit) or
+ * Build the one subject sandbox's provenance: clone (repo + optional commit) or
  * local-tree (archiveSha256 + optional commit/dirty from the once-per-run host-packed archive -
  * archiveSha256 is the pin; there is only one archive, so no per-participant unanimity math applies,
  * unlike the cua fan-out route). Used for both the in-progress and final bundle: the archive

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

@@ -1,7 +1,7 @@
 // The provisioned-getHost plane: the harness provisions one subject sandbox (clone or local-tree,
 // install/build, seed, serve on 0.0.0.0), exposes it through getHost, probes its state on a
-// cadence, and runs every seat against that one shared plane. All sandboxes are torn down by exact
-// id in the plane's finally, never through Sandbox.list.
+// cadence, and runs every participant against that one shared plane. All sandboxes are torn down by
+// exact id in the plane's finally, never through Sandbox.list.
 import { buildOriginMap } from "../../comms/capture-surface.js";
 import { deployCommsCatch, refreshInboxSurface, writeInboxSurface, } from "../../comms/sandbox-catch.js";
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
@@ -59,7 +59,7 @@ class SubjectPlane {
     subjectAllocation;
     subjectDesktop;
     subjectShell;
-    // The in-sandbox email catch on the one subject sandbox (#297); drained at teardown. Undefined
+    // The in-sandbox email catch on the one subject sandbox; drained at teardown. Undefined
     // unless a comms lab declared it.
     deployedComms;
     // Background prober dispose signal, cleared in teardown.
@@ -68,7 +68,7 @@ class SubjectPlane {
     disposeSignal;
     proberLoop;
     snapshotIndex = 0;
-    // Persona inbox surface (#297 slice B, shared-world): the serve->getHost origin-rewrite map
+    // Persona inbox surface: the serve->getHost origin-rewrite map
     // (required here so the app's loopback verify links resolve to a reachable host), and the
     // dedicated surface render loop.
     commsOriginMap = [];
@@ -103,8 +103,8 @@ class SubjectPlane {
         const { plan, deps, env, requestTimeoutMs, timeoutMs } = this.ctx;
         const { subjectEnvNames, commsEnv } = this.setup;
         const subjectModule = await (deps.desktopModule ?? loadE2BDesktopModule)();
-        // The one subject sandbox: headless service host (no GUI seat). The subject env is provisioned
-        // here; the actor sandboxes get none of it. A custom desktop template (image) is
+        // The one subject sandbox: headless service host (no GUI participant). The subject env is
+        // provisioned here; the actor sandboxes get none of it. A custom desktop template (image) is
         // honored on both the subject sandbox (here) and every actor sandbox (via runCuaParticipant, which
         // reads the same config); absent keeps the byte-stable Sandbox.create(opts) default. The
         // receipt is on disk before any work, so `humanish reclaim` can kill it by exact id.
@@ -122,8 +122,8 @@ class SubjectPlane {
                     labId: plan.labId,
                     topology: "shared-world",
                     topologyMode: "concurrent",
-                    role: "subject",
-                    roleCount: String(plan.plane.participants.length),
+                    kind: "subject",
+                    participantCount: String(plan.plane.participants.length),
                 },
                 ...(subjectEnvNames.length > 0 || Object.keys(commsEnv).length > 0
                     ? {
@@ -228,7 +228,7 @@ class SubjectPlane {
         }
         this.getHostUrl = hostUrl;
     }
-    // Persona inbox surface (#297 slice B, shared-world): getHost-expose the read-only inbox listener so
+    // Persona inbox surface: getHost-expose the read-only inbox listener so
     // a persona in another sandbox can open it; build the serve->getHost origin map (required here:
     // the app's loopback verify links must be rewritten to a reachable host); provision the surface
     // channel; write the empty inbox up front (so /inbox never 404s); and start a render loop that drains
@@ -263,7 +263,7 @@ class SubjectPlane {
         const surfaceCadenceMs = 2500;
         this.surfaceLoop = (async () => {
             // Full, idempotent rebuild each tick; surfaceRenderedCount advances only on a successful render,
-            // so a transient failure retries cleanly. Real timer (dispose-interruptible + cleared) — an
+            // so a transient failure retries cleanly. Real timer (dispose-interruptible + cleared): an
             // unbounded loop must not busy-spin on the injected instant clock.
             for (;;) {
                 try {
@@ -327,7 +327,7 @@ class SubjectPlane {
             await this.proberLoop.catch(() => undefined);
         }
         // Stop the inbox-surface render loop too (shares the prober's dispose signal), before the teardown
-        // evidence drain below — so the two in-sandbox reads never overlap and the surface state is final.
+        // evidence drain below, so the two in-sandbox reads never overlap and the surface state is final.
         if (this.surfaceLoop) {
             await this.surfaceLoop.catch(() => undefined);
         }
@@ -370,7 +370,8 @@ class SubjectPlane {
         };
     }
 }
-/** Writes the in-progress bundle, runs the caller's Observer gate and starts the seat flush. */
+/** Writes the in-progress bundle, runs the caller's Observer gate and starts the participants'
+ *  flush. */
 async function publishInProgress(plane, ctx, live, setup) {
     const { plan, input } = ctx;
     const { localTreeRoute, localTreeArchive } = setup;
@@ -435,7 +436,7 @@ function runParticipants(plane, ctx, live, setup) {
         // Tell this persona its (getHost-reachable) inbox URL, but only when comms is live and this participant
         // has a declared recipient it can actually receive mail into (else it would stall on an empty
         // inbox). Only the in-sandbox catch exists on this plane; the adopter-hosted catch is the
-        // external-public plane's (#387).
+        // external-public plane's.
         const actorSpec = commsEmail && plane.commsInboxUrl && participantHasInboxRecipient(commsEmail, spec.planned.id)
             ? withInboxMission(spec, plane.commsInboxUrl, inboxRecipientFor(commsEmail, spec.planned.id)?.address)
             : spec;

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

@@ -9,7 +9,8 @@ import { resolveSubjectState } from "../computer-use/subject-projection.js";
 import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, } from "./bundle.js";
 import { planeStateOf } from "./plan.js";
 import { buildSubjectProvenance, hostOriginDigest } from "./provenance.js";
-import { CONCURRENT_SHARED_WORLD_LAB_SCHEMA, } from "./types.js";
+import {} from "./types.js";
+import { studyResultIdentity } from "../../run/study-result.js";
 /** The results of a run whose plane did not run (a dry run) or has not reported yet. */
 export function emptyPlaneResults() {
     return {
@@ -65,7 +66,7 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
                 ? {}
                 : {
                     error: {
-                        code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+                        code: "HUMANISH_SHARED_WORLD_FAILED",
                         message: result.outcome.sessionError ??
                             (result.outcome.noEngagement
                                 ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
@@ -88,16 +89,16 @@ function concurrentLabError(args) {
     if (handoffTimedOut) {
         // Checked before the observer failure: the host never yielded a /lobby/CODE within the
         // deadline (followers failed closed without opening), which is the root cause, and it can
-        // itself make the Observer unable to render a coherent run. Report the distinct, honest
+        // itself make the Observer unable to render a coherent run. Report the distinct
         // handoff-timeout code rather than a generic observer/run failure.
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_HANDOFF_TIMEOUT",
+            code: "HUMANISH_SHARED_WORLD_HANDOFF_TIMEOUT",
             message: runError ??
                 "The host participant never produced a /lobby/CODE URL within the handoff deadline.",
         };
     }
     if (hostHandoffFailure !== undefined) {
-        return { code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED", message: hostHandoffFailure };
+        return { code: "HUMANISH_SHARED_WORLD_FAILED", message: hostHandoffFailure };
     }
     // The run's own failure before the Observer's: a run that stopped early (a desktop module that
     // failed to load, a plane that failed to start) leaves a bundle verify then refuses, and naming
@@ -105,34 +106,34 @@ function concurrentLabError(args) {
     // evidence).
     if (runError) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: observer.ok ? runError : `${runError} The run bundle it left failed verification.`,
         };
     }
     if (!observer.ok) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: observer.error?.message ?? "Observer failed for the concurrent shared-world run.",
         };
     }
     if (adapterFailure !== undefined) {
-        return { code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED", message: adapterFailure };
+        return { code: "HUMANISH_SHARED_WORLD_FAILED", message: adapterFailure };
     }
     const passed = participantResults.filter((result) => result.ok).length;
     if (passed === participantCount && args.shortfall !== undefined) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: `Concurrent shared-world run did not run coherently. ${args.shortfall}`,
         };
     }
     if (passed === participantCount && args.executionFailure !== undefined) {
         return {
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+            code: "HUMANISH_SHARED_WORLD_FAILED",
             message: `Concurrent shared-world run failed as an execution. ${args.executionFailure}`,
         };
     }
     return {
-        code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_FAILED",
+        code: "HUMANISH_SHARED_WORLD_FAILED",
         message: `Concurrent shared-world run did not run coherently: ${passed}/${participantCount} actor(s) reached a terminal, engaged passed session.`,
     };
 }
@@ -142,10 +143,9 @@ function concurrentLabError(args) {
  */
 export function concurrentLabFailure(envelope) {
     return (code, message, actorLabel) => ({
-        schema: CONCURRENT_SHARED_WORLD_LAB_SCHEMA,
+        ...studyResultIdentity("shared-world", envelope.labId),
         ok: false,
         cwd: envelope.cwd,
-        labId: envelope.labId,
         actor: actorLabel ?? envelope.actor,
         topology: "shared-world",
         topologyMode: "concurrent",
@@ -159,10 +159,10 @@ export function concurrentLabFailure(envelope) {
     });
 }
 /**
- * The run's execution failures: a run error (the handoff, the plane), each seat whose session
- * failed in the harness, each provider whose cleanup is unconfirmed or that reported a disallowed
- * item after its last request, each sandbox whose release is unconfirmed, and an Observer that
- * failed.
+ * The run's execution failures: a run error (the handoff, the plane), each participant whose
+ * session failed in the harness, each provider whose cleanup is unconfirmed or that reported a
+ * disallowed item after its last request, each sandbox whose release is unconfirmed, and an
+ * Observer that failed.
  */
 function sharedWorldExecutionFailures(args) {
     const { runId, runError, actorResults, subject, observer } = args;
@@ -288,8 +288,8 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
     if (observer.ok && live.observer) {
         attachObserverRuntimeStreamUrls(observer, live.streamUrls);
     }
-    // Concurrent "ok": every actor must produce a terminal, engaged, passed session, and the seats
-    // must show the concurrency verify requires of a pass (judgeSharedWorld). This is a
+    // Concurrent "ok": every actor must produce a terminal, engaged, passed session, and the
+    // participants must show the concurrency verify requires of a pass (judgeSharedWorld). This is a
     // harness/session-credibility gate, not mission-completion proof; a failed actor trace cannot
     // make the route green just because the harness got a terminal.
     const adapterFailure = adapterScoreFailureMessage(bundle);
@@ -311,10 +311,9 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
         executionFailure: execution.failures[0]?.message,
     });
     const result = {
-        schema: CONCURRENT_SHARED_WORLD_LAB_SCHEMA,
+        ...studyResultIdentity("shared-world", plan.labId),
         ok,
         cwd,
-        labId: plan.labId,
         actor: descriptor.id,
         topology: "shared-world",
         topologyMode: "concurrent",

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

@@ -1,14 +1,14 @@
-// The concurrent shared-world lab backend (#164 phase 2): N persona participants drive one shared,
+// The concurrent shared-world lab route: N persona participants drive one shared,
 // mutable service plane at the same time. A recomposition of shipped
 // pieces + the getHost wrapper:
 //
 //   - One subject sandbox: provisionCloneSubject once (clone+install+build+seed) + serve on
 //     0.0.0.0, exposed via getHost(port) → a tokenless reachable URL (the headless service host;
-//     no GUI seat).
+//     no GUI participant).
 //   - N actor desktop sandboxes: fan-out's runCuaParticipant machinery (per-participant device/persona, by-id
-//     teardown) bounded by execution.concurrency, each browser pointed at the getHost URL —
+//     teardown) bounded by execution.concurrency, each browser pointed at the getHost URL and
 //     driving the shared service at the same time. Independent: no pipeline gate, no
-//     fail-fast — one actor's failure must not block the swarm or corrupt the "M of N" outcomes.
+//     fail-fast: one actor's failure must not block the swarm or corrupt the "M of N" outcomes.
 //   - A background prober snapshots the subject DB checkpoint digests on a cadence → a stateSeries
 //     of the shared world evolving under load.
 //   - All N+1 sandboxes torn down by exact id in a finally, never through Sandbox.list.
@@ -20,10 +20,10 @@
 // `best-effort-causal-attribution`, `non-deterministic-shared-state`,
 // `window-and-snapshot-granularity`, `contention-observed-not-proven-safe`,
 // `state-change-not-isolated-to-actors`. laneWindows + stateSeries are independent series with no
-// per-delta→actor field — causation under concurrency is structurally inexpressible.
+// per-delta→actor field, so causation under concurrency is structurally inexpressible.
 //
-// Capability and proof: the deterministic $0 gate proves the plumbing + the honesty
-// contract — the real mapWithConcurrency produces genuinely overlapping laneWindows (a rendezvous
+// Capability and proof: the deterministic $0 gate proves the plumbing + the claims-match-mechanism
+// contract: the real mapWithConcurrency produces genuinely overlapping laneWindows (a rendezvous
 // latch in the fake session forces two participant fns in-flight while the real orchestrator clock
 // measures the windows). Every generated bundle describes only its own observations; no one run
 // establishes scale, repeatability, or adopter-harness replacement.
@@ -53,10 +53,10 @@ import {} from "./types.js";
 import { rosterOf } from "../../lab/parse/actors.js";
 /** The shared-world code for each local-agent refusal, kind for kind with computer-use. */
 const LOCAL_AGENT_REFUSAL_CODES = {
-    "agent-missing": "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_AGENT_MISSING",
-    "signin-required": "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_AGENT_SIGNIN_REQUIRED",
-    unsupported: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_ACTOR_UNSUPPORTED",
-    "unpriced-cap": "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_UNPRICED_CAP",
+    "agent-missing": "HUMANISH_SHARED_WORLD_AGENT_MISSING",
+    "signin-required": "HUMANISH_SHARED_WORLD_AGENT_SIGNIN_REQUIRED",
+    unsupported: "HUMANISH_SHARED_WORLD_ACTOR_UNSUPPORTED",
+    "unpriced-cap": "HUMANISH_SHARED_WORLD_UNPRICED_CAP",
 };
 /**
  * The library entry for a shared-world lab. It plans the config with planSharedWorldLab and runs
@@ -83,8 +83,8 @@ export function sharedWorldLabRefusal(options, refusal) {
         labId: config.id,
         actor: config.actors[0]?.type ?? "",
         participantCount: declared.length,
-        // The parser fills concurrency for multi-seat labs, so this fallback serves only library
-        // callers: every declared seat runs at once unless the author declared a cap (#350).
+        // The parser fills concurrency for multi-participant studies, so this fallback serves only
+        // library callers: every declared participant runs at once unless the author declared a cap.
         concurrency: config.execution?.concurrency ?? Math.max(1, declared.length),
         dryRun,
         runId: options.runId,
@@ -125,14 +125,15 @@ async function admitSharedWorldRun(plan, input) {
         return undefined;
     const env = input.env ?? process.env;
     const fail = (code, message) => completeSharedWorldAnalysis(plan, input, sharedWorldFailure(plan, input)(code, message, sharedWorldDescriptorOf(plan.actor).id), undefined);
-    // The plan lists OPENAI_API_KEY for an openai brain's seats and the external-public plane's
-    // lobby-code reader; a local-agent brain's seats run on the operator's signed-in agent instead.
+    // 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.
     const missing = missingKeys(plan.requirements, env);
     if (missing.length > 0) {
-        return fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_KEYS_MISSING", `Live concurrent shared-world labs need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}`);
+        return fail("HUMANISH_SHARED_WORLD_KEYS_MISSING", `Live concurrent shared-world labs need ${missing.join(" and ")} in the environment (values are never persisted). ${describeMissingKeys(missing, env)}`);
     }
     if (plan.brain.kind === "local-agent") {
-        // A missing or signed-out agent found after the seats' desktops are paid for is the same
+        // A missing or signed-out agent found after the participants' desktops are paid for is the same
         // news at the worst moment.
         const refusal = await localAgentRefusal({ agent: plan.brain.agent, env, caps: plan.caps });
         if (refusal)
@@ -140,7 +141,7 @@ async function admitSharedWorldRun(plan, input) {
     }
     const unsetSubjectEnv = missingSubjectEnv(plan.requirements, env);
     if (unsetSubjectEnv.length > 0) {
-        return fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_SUBJECT_ENV_MISSING", `subject.env declares ${unsetSubjectEnv.join(", ")} but the environment does not provide ${unsetSubjectEnv.length === 1 ? "it" : "them"} (pass via --env-file; values are never persisted).`);
+        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 --env-file; values are never persisted).`);
     }
     return undefined;
 }
@@ -232,13 +233,13 @@ async function runPlanInScope(plan, input, config, scope) {
     const { ctx, live, results } = prepared;
     const planeRan = await runPlane(ctx, live, results, prepared.plane);
     if (!planeRan) {
-        return fail("HUMANISH_CONCURRENT_SHARED_WORLD_LAB_INVALID", "the provisioned-getHost concurrent shared-world route requires `subject.serve`.", descriptor.id);
+        return fail("HUMANISH_SHARED_WORLD_INVALID", "the provisioned-getHost concurrent shared-world route requires `subject.serve`.", descriptor.id);
     }
     return finishConcurrentRun(ctx, live, results, prepared.finish);
 }
 /**
- * Runs the plane the lab declares, then finalizes email receiving and stops the seats' flush on
- * every exit. Returns false when a provisioned lab reaches it without `subject.serve`.
+ * Runs the plane the study declares, then finalizes email receiving and stops the participants'
+ * flush on every exit. Returns false when a provisioned study reaches it without `subject.serve`.
  */
 async function runPlane(ctx, live, results, plane) {
     const { dryRun } = ctx.plan;
@@ -266,7 +267,7 @@ async function runPlane(ctx, live, results, plane) {
         catch {
             ctx.warnings.push("Email finalization could not complete. Inspect humanish comms recover; provider cleanup remains unresolved.");
         }
-        // Stop the seats' flush timer on every exit, before the final write.
+        // Stop the participants' flush timer on every exit, before the final write.
         await live.flush?.stop();
     }
     return true;

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

@@ -8,8 +8,8 @@ import type { SharedWorldPlan } from "../../lab/plan-types.js";
 interface AdmittedLab {
     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. */
+    /** 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: LabConfig;
     requestedCwd: string;
     deps: LabDeps;
@@ -32,7 +32,7 @@ interface AdmittedLab {
     fail: (code: ConcurrentSharedWorldLabErrorCode, message: string, actorLabel?: string) => ConcurrentSharedWorldLabResult;
 }
 /**
- * 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<{

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";
@@ -61,7 +61,7 @@ function startConcurrentRun(lab, cwd, scope) {
     });
 }
 /**
- * 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) {
@@ -85,7 +85,7 @@ 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;
@@ -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,
             },
         };

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

@@ -18,7 +18,7 @@ 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 StudyResultIdentity } from "../../run/study-result.js";
 export declare const CONCURRENT_SHARED_WORLD_PROVIDER_METADATA: {
     readonly mode: "concurrent-shared-world-lab";
     readonly tool: "humanish";
@@ -40,7 +40,8 @@ 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"]>;
     /** Awaited after a participant's live stream starts, and again after its sandbox is gone. */
@@ -51,26 +52,26 @@ export interface RunConcurrentSharedWorldLabOptions {
     deps?: LabDeps;
     /** Scores the assembled evidence: `RunLabOptions.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"
+export type ConcurrentSharedWorldLabErrorCode = "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_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). */
@@ -101,11 +102,9 @@ export interface ConcurrentSharedWorldParticipantResult {
         message: string;
     };
 }
-export interface ConcurrentSharedWorldLabResult extends AutomaticAnalysisResult {
-    schema: typeof CONCURRENT_SHARED_WORLD_LAB_SCHEMA;
+export interface ConcurrentSharedWorldLabResult extends AutomaticAnalysisResult, StudyResultIdentity<"shared-world"> {
     ok: boolean;
     cwd: string;
-    labId: string;
     actor: string;
     topology: "shared-world";
     topologyMode: "concurrent";
@@ -124,10 +123,10 @@ 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;
@@ -158,8 +157,8 @@ 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. */
+    /** 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: LabConfig;
     descriptor: CuaActorDescriptor;
     /** The run's test seams; empty outside tests. */
@@ -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,7 +202,7 @@ 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;
@@ -229,15 +230,16 @@ export interface ConcurrentBundleArgs {
      *  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. */

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

@@ -3,13 +3,13 @@ import { type RunBundle, type RunScorerProvenance } from "../../run/bundle.js";
 import { type ScorerOutcome } from "../../lab/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
@@ -31,7 +31,7 @@ export declare function applyAdapterExtensionSeam(args: {
     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>;