humanish 0.107.0 → 0.108.0

package/dist/routes/scripted/setup.js

@@ -9,7 +9,8 @@ import { describeMissingKeys } from "../../keys/key-resolution.js";
 import { prepareSelectedOutputDirectory } from "../../run/contained-output.js";
 import { evidenceAppUrlOf } from "./plan.js";
 import { resolveScriptedScenario } from "./scenario.js";
-import { SCRIPTED_BROWSER_LAB_SCHEMA, } from "./types.js";
+import {} from "./types.js";
+import { studyResultIdentity } from "../../run/study-result.js";
 // Journey wall-clock budget per surface: 5 minutes. A scripted surface has zero model cost and
 // sandbox-seconds are pennies; a short default only truncated slow-loading subjects.
 const DEFAULT_SESSION_TIMEOUT_MS = 300_000;
@@ -27,10 +28,9 @@ export async function prepareScriptedRun(plan, input) {
     const clone = plan.subject.kind === "clone" ? plan.subject : undefined;
     const evidenceAppUrl = evidenceAppUrlOf(plan.subject);
     const failed = (code, message) => ({
-        schema: SCRIPTED_BROWSER_LAB_SCHEMA,
+        ...studyResultIdentity("scripted", plan.labId),
         ok: false,
         cwd,
-        labId: plan.labId,
         actor: plan.actor,
         appUrl: evidenceAppUrl,
         dryRun,
@@ -58,7 +58,7 @@ export async function prepareScriptedRun(plan, input) {
     if (!scenario.ok) {
         return {
             ok: false,
-            result: failed("HUMANISH_SCRIPTED_LAB_SCENARIO_INVALID", scenario.message),
+            result: failed("HUMANISH_SCRIPTED_SCENARIO_INVALID", scenario.message),
         };
     }
     const journey = scenario.journey;
@@ -67,14 +67,14 @@ export async function prepareScriptedRun(plan, input) {
     if (missing.length > 0) {
         return {
             ok: false,
-            result: failed("HUMANISH_SCRIPTED_LAB_KEYS_MISSING", `Live clone scripted-browser labs require ${missing.join(" and ")} (dry-run remains $0 and does not provision a subject). ${describeMissingKeys(missing, env)}`),
+            result: failed("HUMANISH_SCRIPTED_KEYS_MISSING", `Live clone scripted-browser labs require ${missing.join(" and ")} (dry-run remains $0 and does not provision a subject). ${describeMissingKeys(missing, env)}`),
         };
     }
     const unsetSubjectEnv = missingSubjectEnv(plan.requirements, env);
     if (unsetSubjectEnv.length > 0) {
         return {
             ok: false,
-            result: failed("HUMANISH_SCRIPTED_LAB_SUBJECT_ENV_MISSING", `Subject env values missing for live clone scripted-browser lab: ${unsetSubjectEnv.join(", ")}.`),
+            result: failed("HUMANISH_SCRIPTED_SUBJECT_ENV_MISSING", `Subject env values missing for live clone scripted-browser lab: ${unsetSubjectEnv.join(", ")}.`),
         };
     }
     const surfaces = plan.surfaces;
@@ -93,7 +93,7 @@ export async function prepareScriptedRun(plan, input) {
         if (!resolved) {
             return {
                 ok: false,
-                result: failed("HUMANISH_SCRIPTED_LAB_BROWSER_MISSING", "No Chrome/Chromium browser command was found for the scripted-browser actor. Set HUMANISH_BROWSER_COMMAND to a browser binary playwright-core can launch."),
+                result: failed("HUMANISH_SCRIPTED_BROWSER_MISSING", "No Chrome/Chromium browser command was found for the scripted-browser actor. Set HUMANISH_BROWSER_COMMAND to a browser binary playwright-core can launch."),
             };
         }
         browserCommand = resolved;

package/dist/routes/scripted/subject.js

@@ -75,7 +75,7 @@ export class ScriptedSubject {
                     mode: "scripted-browser-lab",
                     tool: "humanish",
                     labId: plan.labId,
-                    role: "subject",
+                    kind: "subject",
                     actor: plan.actor,
                 },
                 ...(subjectEnvNames.length > 0

package/dist/routes/scripted/surface-records.js

@@ -18,7 +18,7 @@ export function scriptedSurfaceRecords(context, surface, index, result, screensh
             : "contract_proof_only";
     const reason = result?.reason ??
         context.sessionError ??
-        "Contract bundle only: dry-run pinned the scenario contract without launching a browser or touching the subject app.";
+        "Dry run: the scenario was pinned without launching a browser or touching the subject app.";
     const simulation = participantRecord(ids, index + 1, {
         personaId: context.persona.id,
         scenarioId: context.journey.scenarioId,
@@ -31,13 +31,13 @@ export function scriptedSurfaceRecords(context, surface, index, result, screensh
             ? `Scripted-browser actor (${context.actorId}) replayed ${context.journey.scenarioId} on the ${surface.id} surface; ${result.completionReason}.`
             : context.sessionError !== undefined
                 ? `Scripted lab failed before a terminal session verdict: ${context.sessionError}`
-                : `Contract participant for the scripted-browser actor (${context.actorId}) against ${context.appUrl}.`,
+                : `Scripted-browser actor (${context.actorId}) against ${context.appUrl}; no session ran.`,
         startedAt: context.createdAt,
         updatedAt: result?.capture.capturedAt ?? context.createdAt,
     });
     const stream = participantStream(ids, {
         kind: "browser",
-        label: `${surface.label} — ${context.labId}`,
+        label: `${surface.label} · ${context.labId}`,
         status,
         transport: "snapshot",
         updatedAt: result?.capture.capturedAt ?? context.createdAt,

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

@@ -6,7 +6,7 @@ import type { ObserverResult } from "../../observer/render.js";
 import type { RunSubjectProvenance } from "../../run/bundle.js";
 import type { LabDeps } from "../../lab/lab-deps.js";
 import type { RunLabHomes } from "../../lab/run-lab-homes.js";
-export declare const SCRIPTED_BROWSER_LAB_SCHEMA = "humanish.scripted-lab-result.v1";
+import { type StudyResultIdentity } from "../../run/study-result.js";
 /** What a scripted run takes besides its plan. The plan carries the config, dry run and lab. */
 export type ScriptedRunInput = Omit<RunScriptedBrowserLabOptions, "config" | "dryRun" | "lab">;
 export interface RunScriptedBrowserLabOptions {
@@ -34,14 +34,12 @@ interface ScriptedBrowserLabSession {
     reason: string;
     screenshots: number;
 }
-export interface ScriptedBrowserLabResult extends AutomaticAnalysisResult {
-    schema: typeof SCRIPTED_BROWSER_LAB_SCHEMA;
+export interface ScriptedBrowserLabResult extends AutomaticAnalysisResult, StudyResultIdentity<"scripted"> {
     /** True when the bundle verified and (dry-run, or every session reached a terminal verdict
      * without a harness error). The subject failing the script is successful evidence, and the lab
      * does not fail for it. */
     ok: boolean;
     cwd: string;
-    labId: string;
     /** The registry-resolved actor id that ran (or would run) the sessions. */
     actor: string;
     appUrl: string;
@@ -64,7 +62,7 @@ export interface ScriptedBrowserLabResult extends AutomaticAnalysisResult {
     observer?: ObserverResult;
     warnings: string[];
     error?: {
-        code: "HUMANISH_LAB_ANALYSIS_INVALID" | "HUMANISH_LAB_TASKS_UNSUPPORTED" | "HUMANISH_LAB_OPTION_UNSUPPORTED" | "HUMANISH_SCRIPTED_LAB_FAILED" | "HUMANISH_SCRIPTED_LAB_ACTOR_UNSUPPORTED" | "HUMANISH_SCRIPTED_LAB_SCENARIO_INVALID" | "HUMANISH_SCRIPTED_LAB_SUBJECT_UNSAFE" | "HUMANISH_SCRIPTED_LAB_BROWSER_MISSING" | "HUMANISH_SCRIPTED_LAB_KEYS_MISSING" | "HUMANISH_SCRIPTED_LAB_SUBJECT_ENV_MISSING" | "HUMANISH_SCRIPTED_LAB_GETHOST_UNAVAILABLE" | "HUMANISH_RUN_ID_IN_USE";
+        code: "HUMANISH_STUDY_ANALYSIS_INVALID" | "HUMANISH_STUDY_TASKS_UNSUPPORTED" | "HUMANISH_STUDY_OPTION_UNSUPPORTED" | "HUMANISH_SCRIPTED_FAILED" | "HUMANISH_SCRIPTED_ACTOR_UNSUPPORTED" | "HUMANISH_SCRIPTED_SCENARIO_INVALID" | "HUMANISH_SCRIPTED_SUBJECT_UNSAFE" | "HUMANISH_SCRIPTED_BROWSER_MISSING" | "HUMANISH_SCRIPTED_KEYS_MISSING" | "HUMANISH_SCRIPTED_SUBJECT_ENV_MISSING" | "HUMANISH_SCRIPTED_GETHOST_UNAVAILABLE" | "HUMANISH_RUN_ID_IN_USE";
         message: string;
     };
 }

package/dist/routes/scripted/types.js

@@ -1,2 +1,2 @@
 // The scripted-browser lab's schema constant, options and result types.
-export const SCRIPTED_BROWSER_LAB_SCHEMA = "humanish.scripted-lab-result.v1";
+import {} from "../../run/study-result.js";

package/dist/routes/shared-world/bundle-records.js

@@ -14,7 +14,8 @@ function participantView(ctx, spec, index) {
     const session = outcome?.session;
     const screenshots = outcome?.screenshots ?? [];
     const lastScreenshot = screenshots[screenshots.length - 1];
-    // public-safe (origin redacted): external-public seats open the public plane; getHost seats a seat path.
+    // public-safe (origin redacted): external-public participants open the public plane; getHost
+    // participants open their own path.
     const route = external
         ? "[external-public-plane]"
         : publicSafeRouteLabel(args.plan.plane.participants[index]?.entry);
@@ -29,7 +30,7 @@ function participantView(ctx, spec, index) {
         outcome?.sessionError ??
         (inProgress
             ? "Actor desktop is running; the attached Observer hydrates the runtime stream URL without persisting it."
-            : "Contract actor only: dry-run produced the evidence shape without launching a desktop or spending provider tokens.");
+            : "Dry run: the evidence shape was written without launching a desktop or spending provider tokens.");
     const traceScreenshotMode = session?.trace.redaction.screenshots;
     // Include `declared` on the no-outcome fallback too (dry-run, skipped participant): otherwise an
     // absent `declared` means either "the preset rendered faithfully" or "there was no live
@@ -79,7 +80,7 @@ function sharedWorldSimulation(ctx, spec, index, view) {
                 ? `Persona ${spec.planned.id}${taxonomy} failed before a terminal session verdict: ${outcome.sessionError}`
                 : inProgress
                     ? `Persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) is running against the shared plane.`
-                    : `Contract persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) for ${args.descriptor.id} against the shared plane at ${ctx.appUrl}.`,
+                    : `Persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) for ${args.descriptor.id} against the shared plane at ${ctx.appUrl}; no session ran.`,
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
     });
@@ -92,7 +93,7 @@ function sharedWorldStream(ctx, spec, index, view) {
             ? {}
             : { assignment: participantAssignment(spec.evidenceAssignment) }),
         kind: "browser",
-        label: `Concurrent persona ${spec.planned.id}${taxonomy} — ${args.plan.labId}`,
+        label: `Concurrent persona ${spec.planned.id}${taxonomy} · ${args.plan.labId}`,
         status: view.status,
         transport: "snapshot",
         updatedAt: args.run.createdAt,
@@ -116,7 +117,7 @@ function sharedWorldStream(ctx, spec, index, view) {
         desktopGeometry,
         ui: {
             route: view.route,
-            intent: `Watch persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) drive the SHARED plane concurrently with the other personas.`,
+            intent: `Watch persona ${spec.planned.id}${taxonomy} (${spec.persona.id}) use the shared app at the same time as the other personas.`,
             state: view.reason,
             ...(session ? { actorStatus: session.status } : {}),
             ...(lastScreenshot ? { screenshotUrl: lastScreenshot } : {}),
@@ -137,7 +138,7 @@ function sharedWorldStream(ctx, spec, index, view) {
                 : []),
             // Run-level comms evidence belongs to the one shared app, and to no persona: register it once, on
             // the first stream, so the bundle's existence-verify + public-safety scan cover it without
-            // double-counting across seats.
+            // double-counting across participants.
             ...(index === 0 && args.commsArtifactPath
                 ? [{ label: "comms thread", path: args.commsArtifactPath, kind: "log" }]
                 : []),
@@ -170,7 +171,7 @@ function sharedWorldEvents(ctx, spec, view) {
             at: createdAt,
             level: session.status === "passed" ? "info" : "warn",
             type: `concurrent-shared-world.session.${session.completionReason}`,
-            message: `Persona ${spec.planned.id}: ${session.status} — ${session.reason}`,
+            message: `Persona ${spec.planned.id}: ${session.status} (${session.reason})`,
         });
     }
     else if (outcome?.sessionError !== undefined) {
@@ -197,7 +198,7 @@ function sharedWorldEvents(ctx, spec, view) {
             at: createdAt,
             level: "info",
             type: "concurrent-shared-world.contract.ready",
-            message: `Persona ${spec.planned.id}: dry-run contract actor ready; switch scenario.mode to live for a real concurrent session.`,
+            message: `Persona ${spec.planned.id}: dry-run actor ready; switch scenario.mode to live for a real concurrent session.`,
         });
     }
     return events;

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

@@ -1,17 +1,17 @@
 import { type RunBundle } from "../../run/bundle.js";
 import { type SharedWorldJudgment } from "../../run/judge.js";
 import { type ActorRunResult, type ConcurrentBundleArgs } from "./types.js";
-/** Max windows live at the same instant (sweep over start/end points). The honest simultaneity
+/** Max windows live at the same instant (sweep over start/end points). The simultaneity
  *  count: the participant count says how many existed; this says how many ever ran at once. */
 export declare function maxSimultaneousWindows(windows: Array<{
     startedAt: number;
     endedAt: number;
 }>): number;
 /**
- * The judgment for a shared-world bundle's inputs: how each seat ended, plus what the run observed
- * about its world: overlap, a state change under overlap on the provisioned plane, and lobby
- * convergence on the external-public plane. The bundle's verdict and the lab result's ok both read
- * it.
+ * The judgment for a shared-world bundle's inputs: how each participant ended, plus what the run
+ * observed about its world: overlap, a state change under overlap on the provisioned plane, and
+ * lobby convergence on the external-public plane. The bundle's verdict and the study result's ok
+ * both read it.
  */
 export declare function judgeSharedWorldRun(args: Omit<ConcurrentBundleArgs, "judgment">): SharedWorldJudgment;
 export declare function actorRunPassed(result: ActorRunResult | undefined): boolean;

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

@@ -1,4 +1,4 @@
-// Builds the run bundle for a concurrent shared-world run: per-seat simulations, streams and
+// Builds the run bundle for a concurrent shared-world run: per-participant simulations, streams and
 // events, the sharedWorld evidence block and the review summary.
 import { receivingPublication } from "../../comms/receiving-runtime.js";
 import { redactText } from "../../evidence/redaction.js";
@@ -8,13 +8,13 @@ import { SHARED_WORLD_SCHEMA, concurrencyFacts, sharedWorldParticipantKeys, } fr
 import { commandDigestOf } from "../../subject/state.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { participantFactsOf } from "../computer-use/participant-facts.js";
-import { judgeSharedWorld, participantPassed, sharedWorldShortfall, } from "../../run/judge.js";
+import { judgeSharedWorld, participantPassed, sharedWorldShortfall, verdictText, } from "../../run/judge.js";
 import { combineCheckpointDigest } from "./checkpoints.js";
 import { hostOriginDigest } from "./provenance.js";
 import { participantEvent, participantIds } from "../../run/participant-records.js";
 import { sharedWorldParticipantRecords } from "./bundle-records.js";
 import { CONCURRENT_ATTRIBUTION_LIMITS, EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS, } from "./types.js";
-/** Max windows live at the same instant (sweep over start/end points). The honest simultaneity
+/** Max windows live at the same instant (sweep over start/end points). The simultaneity
  *  count: the participant count says how many existed; this says how many ever ran at once. */
 export function maxSimultaneousWindows(windows) {
     const points = windows
@@ -34,10 +34,10 @@ export function maxSimultaneousWindows(windows) {
     return max;
 }
 /**
- * The judgment for a shared-world bundle's inputs: how each seat ended, plus what the run observed
- * about its world: overlap, a state change under overlap on the provisioned plane, and lobby
- * convergence on the external-public plane. The bundle's verdict and the lab result's ok both read
- * it.
+ * The judgment for a shared-world bundle's inputs: how each participant ended, plus what the run
+ * observed about its world: overlap, a state change under overlap on the provisioned plane, and
+ * lobby convergence on the external-public plane. The bundle's verdict and the study result's ok
+ * both read it.
  */
 export function judgeSharedWorldRun(args) {
     const external = (args.planeClass ?? "provisioned-getHost") === "external-public";
@@ -68,7 +68,7 @@ export function actorRunPassed(result) {
  *
  * None of those is adopter-scored proof that the mission text was completed. In particular, a
  * productive `budget_reached` session can coexist with lobby convergence without becoming a
- * `goal_satisfied` result (#364).
+ * `goal_satisfied` result.
  */
 function formatSharedWorldActorOutcomes(outcomes, expectedCount) {
     const passedSessions = outcomes.filter((outcome) => outcome.ok).length;
@@ -97,7 +97,7 @@ function planeEvents(args, external) {
         at: createdAt,
         level: "info",
         type: "concurrent-shared-world.run.created",
-        message: `Created CONCURRENT shared-world run for ${plan.labId} (actor ${descriptor.id}, ${actorSpecs.length} persona(s) vs ONE shared plane, max ${plan.concurrency} concurrent).`,
+        message: `Created a concurrent shared-world run for ${plan.labId} (actor ${descriptor.id}, ${actorSpecs.length} persona(s) on one shared app, at most ${plan.concurrency} at once).`,
     });
     // Human-readable plane label, byte-stable for the clone route. local-tree has no repo slug: it
     // labels the packed archive instead (archiveSha256 + dirty/clean when the packed root was a git
@@ -120,19 +120,21 @@ function planeEvents(args, external) {
         level: "info",
         type: "concurrent-shared-world.plane.provenance",
         message: external
-            ? `Shared plane: an EXTERNAL-PUBLIC deployment (operator-attested owner ${externalPlaneOwner}, authorized) used DIRECTLY as the shared plane, with NO getHost, clone, subject sandbox, or seed. The harness OBSERVES that each participant reached the operator-declared origin (publicOriginDigest); it did NOT mint or control the plane. Author-trust ownership attestation, NOT a synthetic-data claim.`
+            ? `Shared app: a public deployment the operator declares they own (${externalPlaneOwner}, authorized), used as it is, with no sandbox, clone or seed. humanish observed that each participant reached the declared origin (publicOriginDigest); it did not create or control the app. Ownership is the lab's declaration, and the data is not claimed to be synthetic.`
             : dryRun
-                ? `Shared plane declared: ${dryRunPlaneLabel}, served + getHost-exposed in-sandbox (dry-run contract; nothing ${args.subject.source === "local-tree" ? "packed" : "cloned"}). Seed recipe ${args.seedDigest}; SYNTHETIC subject (author-attested); env names: ${args.subject.envNames?.join(", ") || "none"} (values never persisted).`
-                : `Shared plane: ${livePlaneLabel}, served + exposed at the harness-minted getHost URL; seed recipe ${args.seedDigest}; SYNTHETIC subject (author-attested); env names: ${args.subject.envNames?.join(", ") || "none"} (values never persisted).`,
+                ? `Shared app declared: ${dryRunPlaneLabel}, to be served in the sandbox at a public sandbox URL (dry run: nothing ${args.subject.source === "local-tree" ? "packed" : "cloned"}). Seed recipe ${args.seedDigest}; synthetic subject, as the study declares; env names: ${args.subject.envNames?.join(", ") || "none"} (values never stored).`
+                : `Shared app: ${livePlaneLabel}, served at a public sandbox URL humanish created; seed recipe ${args.seedDigest}; synthetic subject, as the study declares; env names: ${args.subject.envNames?.join(", ") || "none"} (values never stored).`,
     }));
     return events;
 }
-/** The sharedWorld block: seat windows, the state series, seat outcomes and the plane. */
+/** The sharedWorld block: participant windows, the state series, participant outcomes and the
+ *  plane. */
 function sharedWorldEvidence(args, external, inProgress, planeCommit) {
     const { plan, dryRun, actorSpecs, actorResults } = args;
     // Build the concurrent shared-world evidence block. routeHostDigest is sha256-16 of the origin each
-    // seat reached: on getHost the seat URL the actor drove (verify confirms == plane.hostDigest); on
-    // external-public the seat's CDP-OBSERVED URL origin (verify confirms == plane.publicOriginDigest).
+    // participant reached: on getHost the participant URL the actor drove (verify confirms ==
+    // plane.hostDigest); on external-public the participant's CDP-observed URL origin (verify
+    // confirms == plane.publicOriginDigest).
     const fallbackHostDigest = external
         ? (args.publicOriginDigest ?? commandDigestOf("[external-public-plane]"))
         : (args.hostDigest ?? commandDigestOf("[provisioned-subject]"));
@@ -189,7 +191,7 @@ function sharedWorldEvidence(args, external, inProgress, planeCommit) {
             seedDigest: args.seedDigest,
             envNames: [],
             // publicOriginDigest is the observed convergence origin; declaredOriginDigest records the
-            // operator-declared origin for reference (a redirect makes them differ — not a failure).
+            // operator-declared origin for reference (a redirect that makes them differ is no failure).
             ...(args.publicOriginDigest === undefined
                 ? {}
                 : { publicOriginDigest: args.publicOriginDigest }),
@@ -226,8 +228,8 @@ function sharedWorldEvidence(args, external, inProgress, planeCommit) {
     return { sharedWorld, windows, stateSeries, outcomes };
 }
 /**
- * A finished run's gaps: each seat that did not pass, or, when every seat passed, the world
- * shortfall that failed the run.
+ * A finished run's gaps: each participant that did not pass, or, when every participant passed, the
+ * world shortfall that failed the run.
  */
 function finishedGaps(actorResults, shortfall) {
     const participantGaps = actorResults
@@ -249,10 +251,10 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
         ? "stateSeries omitted (no authoritative shared-state proof on the external-public plane)"
         : `stateSeries ${(stateSeries ?? []).length} snapshot(s), ${deltas} delta(s)`;
     const convergenceLabel = external
-        ? `; lobby convergence ${args.lobbyConvergenceDigest ? "PROVEN (all participants reached one /lobby/CODE)" : "not observed"}`
+        ? `; lobby convergence ${args.lobbyConvergenceDigest ? "shown (all participants reached one /lobby/CODE)" : "not observed"}`
         : "";
     // The count that matters is how many participants were live at once, which can be fewer than exist:
-    // a 6-participant run capped at 3 must never read as 6-wide concurrency (#350, the field failure).
+    // a 6-participant run capped at 3 must never read as 6-wide concurrency.
     const capForReport = plan.concurrency;
     const maxLive = maxSimultaneousWindows(windows);
     events.push({
@@ -260,11 +262,11 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
         at: createdAt,
         level: "info",
         type: "concurrent-shared-world.concurrency",
-        message: `Concurrency: ${windows.length} participant(s)${dryRun ? " (dry-run contract; $0)" : `, up to ${maxLive} live at once (cap ${capForReport}), overlap ${overlaps ? "PROVEN" : "not observed"}`}; ${stateSeriesLabel}${convergenceLabel}. Attribution ceiling: ${sharedWorld.attributionLimits.join(", ")}. ${dryRun ? "This contract-only run proves no live concurrency, scale, or adoption." : "This run reports only its own observed overlap and state changes; it does not prove scale, repeatability, or adopter-harness replacement."}`,
+        message: `Concurrency: ${windows.length} participant(s)${dryRun ? " (dry run; $0)" : `, up to ${maxLive} live at once (cap ${capForReport}), overlap ${overlaps ? "shown" : "not observed"}`}; ${stateSeriesLabel}${convergenceLabel}. Attribution ceiling: ${sharedWorld.attributionLimits.join(", ")}. ${dryRun ? "This dry run proves nothing about live concurrency, scale, or adoption." : "This run reports only its own observed overlap and state changes; it does not prove scale, repeatability, or adopter-harness replacement."}`,
     });
-    // The judge's verdict (judgeSharedWorld): every seat produced a terminal, engaged, passed session.
-    // Mission endpoint and completion reasons are reported separately below; `outcomes[].ok` is not
-    // renamed into mission success (#364).
+    // The judge's verdict (judgeSharedWorld): every participant produced a terminal, engaged, passed
+    // session. Mission endpoint and completion reasons are reported separately below; `outcomes[].ok`
+    // is not renamed into mission success.
     const verdict = args.judgment.verdict;
     const actorOutcomeSummary = formatSharedWorldActorOutcomes(outcomes, actorSpecs.length);
     const review = {
@@ -272,19 +274,19 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
         verdict,
         // Plane-class-aware: the external-public plane has no getHost/clone/seed and carries no
         // authoritative state series, so its summary must not claim a getHost-exposed plane (dry-run) nor
-        // report "state delta(s) under load" (live) — it reports lobby convergence instead.
+        // report "state delta(s) under load" (live). It reports lobby convergence instead.
         summary: dryRun
             ? external
-                ? `Dry-run concurrent shared-world contract: ${actorSpecs.length} persona(s) declared against ONE external-public shared plane (a real public deployment used directly; no getHost/clone/seed); no sandboxes launched, $0 spend.`
-                : `Dry-run concurrent shared-world contract: ${actorSpecs.length} persona(s) declared against ONE getHost-exposed plane (${descriptor.id}); no sandboxes launched, $0 spend.`
+                ? `Concurrent shared-world dry run: ${actorSpecs.length} persona(s) declared against one public deployment, used as it is (no sandbox, clone or seed); no sandboxes launched, $0 spent.`
+                : `Concurrent shared-world dry run: ${actorSpecs.length} persona(s) declared against one app served at a public sandbox URL (${descriptor.id}); no sandboxes launched, $0 spent.`
             : inProgress
-                ? `In-progress concurrent shared-world Observer snapshot: ${actorSpecs.length} persona(s) running against ONE shared plane; final verification is pending.`
+                ? `In-progress concurrent shared-world Observer snapshot: ${actorSpecs.length} persona(s) running against one shared app; final verification is pending.`
                 : external
-                    ? `Concurrent shared-world (ONE external-public plane, ${actorSpecs.length} simultaneous personas): swarm ${verdict === "pass" ? "ran coherently" : "did not run coherently"}; ${actorOutcomeSummary}; overlap ${overlaps ? "proven" : "not observed"}; ${args.lobbyConvergenceDigest ? `${actorSpecs.length} participants converged on one lobby` : "lobby convergence not observed"}.`
-                    : `Concurrent shared-world (ONE plane, ${actorSpecs.length} simultaneous personas): swarm ${verdict === "pass" ? "ran coherently" : "did not run coherently"}; ${actorOutcomeSummary}; overlap ${overlaps ? "proven" : "not observed"}; ${deltas} state delta(s) under load.`,
+                    ? `Concurrent shared-world (one public deployment, ${actorSpecs.length} personas at once): swarm ${verdict === "pass" ? "ran coherently" : "did not run coherently"}; ${actorOutcomeSummary}; overlap ${overlaps ? "proven" : "not observed"}; ${args.lobbyConvergenceDigest ? `${actorSpecs.length} participants converged on one lobby` : "lobby convergence not observed"}.`
+                    : `Concurrent shared-world (one shared app, ${actorSpecs.length} personas at once): swarm ${verdict === "pass" ? "ran coherently" : "did not run coherently"}; ${actorOutcomeSummary}; overlap ${overlaps ? "proven" : "not observed"}; ${deltas} state delta(s) under load.`,
         gaps: dryRun
             ? [
-                "This dry-run launched no concurrent shared-world session; it proves contract shape only, not live behavior, scale, or adopter-harness replacement.",
+                "This dry run launched no concurrent shared-world session; it checks the evidence shape only, not live behavior, scale, or adopter-harness replacement.",
             ]
             : inProgress
                 ? [
@@ -301,7 +303,7 @@ export function buildConcurrentSharedWorldBundle(args) {
     const external = (args.planeClass ?? "provisioned-getHost") === "external-public";
     const simulations = [];
     const streams = [];
-    // Public-safe label only — neither the raw getHost URL (provisioned) nor the raw public origin
+    // Public-safe label only: neither the raw getHost URL (provisioned) nor the raw public origin
     // (external-public) lands in the bundle. The plane identity is a digest (plane.hostDigest on
     // getHost; plane.publicOriginDigest on external-public).
     const appUrl = external ? "[external-public-plane]" : "[provisioned-subject]";
@@ -331,7 +333,7 @@ export function buildConcurrentSharedWorldBundle(args) {
         persona: {
             id: actorSpecs[0]?.persona.id ?? "concurrent-persona",
             name: `Concurrent shared-world swarm (${actorSpecs.length} personas)`,
-            source: `lab:${plan.labId}`,
+            source: `study:${plan.labId}`,
             sourceDigest: actorSpecs[0]?.persona.promptDigest ?? args.seedDigest,
         },
         scenario: {
@@ -340,14 +342,14 @@ export function buildConcurrentSharedWorldBundle(args) {
             goal: redactText(actorSpecs[0]?.evidenceInstructions ??
                 actorSpecs[0]?.instructions ??
                 "Concurrent shared-world interaction."),
-            source: `lab:${plan.labId}`,
+            source: `study:${plan.labId}`,
             sourceDigest: actorSpecs[0]?.persona.promptDigest ?? args.seedDigest,
         },
         lifecycle: [
             {
                 at: createdAt,
                 event: "concurrent-shared-world.run.created",
-                message: `Created concurrent shared-world run with ONE shared plane and ${actorSpecs.length} simultaneous participants (actor ${descriptor.id}).`,
+                message: `Created a concurrent shared-world run with one shared app and ${actorSpecs.length} participants at once (actor ${descriptor.id}).`,
             },
         ],
         simulations,
@@ -357,11 +359,11 @@ export function buildConcurrentSharedWorldBundle(args) {
             status: "passed",
             notes: ranLive
                 ? anyRaw
-                    ? "Typed text recorded as length only and reasoning/messages pass through text redaction. Some personas captured FULL-FIDELITY (raw) screenshots, retained for local use — NOT redacted for publishing; set policies.redactScreenshots: true to blur a share-as-is bundle. stateSeries persists digest-only."
+                    ? "Typed text is recorded as its length only, and reasoning and messages pass through text redaction. Some personas captured unblurred screenshots, kept for local use and not redacted for publishing. Set policies.redactScreenshots: true to blur screenshots in a bundle you plan to share. stateSeries stores digests only."
                     : "Typed text recorded as length only and reasoning/messages pass through text redaction. Screenshots are blurred at capture (policies.redactScreenshots: true) for a share-as-is bundle. stateSeries persists digest-only."
                 : inProgress
                     ? "In-progress live Observer snapshot: runtime stream auth URLs are process-local only and are not persisted. Final typed text, traces, and screenshots are pending. stateSeries persists digest-only."
-                    : "Dry-run concurrent shared-world contract bundle: no sandboxes launched and no screenshots captured. Typed text is recorded as length only and reasoning/messages pass through text redaction whenever a session runs. stateSeries persists digest-only.",
+                    : "Concurrent shared-world dry-run bundle: no sandboxes launched and no screenshots captured. Typed text is recorded as length only and reasoning/messages pass through text redaction whenever a session runs. stateSeries persists digest-only.",
         },
         artifacts: bundleArtifacts(),
         review,
@@ -429,7 +431,7 @@ export function renderConcurrentReviewMarkdown(bundle) {
         `- attribution class: ${bundle.attributionClass ?? "isolated"}`,
         `- topology: ${sw?.topology ?? "(none)"} / ${sw?.topologyMode ?? "(none)"}`,
         `- personas: ${sw?.roleCount ?? 0}`,
-        `- verdict: ${bundle.review.verdict}`,
+        `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
         `- summary: ${bundle.review.summary}`,
         ...(plane ? [`- plane: ${plane.message}`] : []),
         ...(concurrency ? [`- concurrency: ${concurrency.message}`] : []),

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

@@ -8,7 +8,7 @@ export declare function combineCheckpointDigest(parts: string[]): string;
  * Run one checkpoint snapshot live: each declared probe runs read-only via the detached
  * primitive; its stdout is literal-scrubbed (provisioned values + the probe's declared redact
  * literals, folded into `scrub`) then pattern-redacted, then digested. Only the combined digest
- * persists — never the raw value (the seed-step lockdown). Unique step names per snapshot prevent
+ * persists, never the raw value (the seed-step lockdown). Unique step names per snapshot prevent
  * stale-status reuse across snapshots.
  */
 export declare function runCheckpointSnapshot(args: {

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

@@ -14,7 +14,7 @@ export function combineCheckpointDigest(parts) {
  * Run one checkpoint snapshot live: each declared probe runs read-only via the detached
  * primitive; its stdout is literal-scrubbed (provisioned values + the probe's declared redact
  * literals, folded into `scrub`) then pattern-redacted, then digested. Only the combined digest
- * persists — never the raw value (the seed-step lockdown). Unique step names per snapshot prevent
+ * persists, never the raw value (the seed-step lockdown). Unique step names per snapshot prevent
  * stale-status reuse across snapshots.
  */
 export async function runCheckpointSnapshot(args) {

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

@@ -14,7 +14,7 @@ export interface SubjectComms {
 }
 export declare function subjectCommsOf(config: Pick<LabConfig, "comms">, planeClass: ConcurrentSharedWorldPlaneClass): SubjectComms;
 /**
- * Adopter-hosted ingress (#328): on the external-public plane the harness provisions nothing, so
+ * Adopter-hosted ingress: on the external-public plane the harness provisions nothing, so
  * it cannot host a catch. The operator can, and then humanish still does every other part of
  * the funnel: it tells each persona its address and inbox URL, drains the declared catch over
  * HTTP at teardown, and writes the same digest-only evidence. Declaring `external` is what turns
@@ -26,11 +26,11 @@ export declare function prepareExternalComms(config: Pick<LabConfig, "comms">, p
     wiring: ExternalCommsWiring | undefined;
 } | {
     ok: false;
-    code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_COMMS_TOKEN_INVALID" | "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_COMMS_CATCH_UNREACHABLE";
+    code: "HUMANISH_SHARED_WORLD_COMMS_TOKEN_INVALID" | "HUMANISH_SHARED_WORLD_COMMS_CATCH_UNREACHABLE";
     message: string;
 }>;
 /**
- * Off-app comms evidence (#297): drain everything the in-sandbox catch captured, route it into a
+ * Off-app comms evidence: drain everything the in-sandbox catch captured, route it into a
  * host fake inbox addressed to the declared recipients, and write the run-level digest-only thread
  * artifact while the subject is still alive, before it is killed. Wrapped so a drain error
  * never blocks teardown (invariant: all sandboxes torn down by id in the plane's finally). Returns
@@ -38,8 +38,8 @@ export declare function prepareExternalComms(config: Pick<LabConfig, "comms">, p
  */
 export declare function drainSubjectComms(ctx: PlaneContext, commsEmail: LabCommsEmail, subjectShell: Shell, deployedComms: DeployedCommsCatch): Promise<string | undefined>;
 /**
- * Adopter-hosted drain (#328/#387): same routing and digest-only artifact as the in-sandbox
- * catch — only the transport differs (HTTP GET /deliveries against the catch the operator
+ * Adopter-hosted drain: same routing and digest-only artifact as the in-sandbox
+ * catch. Only the transport differs (HTTP GET /deliveries against the catch the operator
  * runs). Called in the plane's finally so the evidence survives a failed run; a drain error never
  * masks the run's own outcome. Returns the thread's path when one was written.
  */

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

@@ -1,5 +1,5 @@
 // Off-app comms for the concurrent shared-world route: which email catch a plane gets (in the
-// subject sandbox, or adopter-hosted), and the drains that match captured mail to the seats'
+// subject sandbox, or adopter-hosted), and the drains that match captured mail to the participants'
 // declared inboxes and write the digest-only thread.
 import { catchTokenOf, catchTokenRefusal, collectExternalCommsEvidence, } from "../../comms/external-evidence.js";
 import { FakeInbox } from "../../comms/fake-inbox.js";
@@ -8,9 +8,9 @@ import { DEFAULT_SANDBOX_CATCH_PORT, collectCommsThread, externalCatchHealthy, e
 import { redactText, toErrorMessage } from "../../evidence/redaction.js";
 import { writeContainedOutputFile } from "../../run/contained-output.js";
 import { addressedRecipients } from "../../lab/parse/comms.js";
-// Off-app comms (#297): on the provisioned-getHost plane the harness owns the one subject sandbox, so
+// Off-app comms: on the provisioned-getHost plane the harness owns the one subject sandbox, so
 // it can redirect the app's email-API sends into an in-sandbox catch and evidence them. Gated entirely
-// on config.comms — no comms declared → zero change. The base-URL env is injected into the subject
+// on config.comms: no comms declared → zero change. The base-URL env is injected into the subject
 // sandbox at create (fixed port known up front); the catch is deployed before serve; the drain + digest
 // evidence run at subject teardown, then register run-level in the bundle. Unavailable on the
 // external-public plane (the app is an operator-owned deployment the harness never provisions).
@@ -19,7 +19,7 @@ export function subjectCommsOf(config, planeClass) {
         ? config.comms.email
         : undefined;
     const commsPort = commsEmail ? (commsEmail.port ?? DEFAULT_SANDBOX_CATCH_PORT) : undefined;
-    // injectEnv is absent on an adopter-hosted plane (#328): there is no subject env to inject
+    // injectEnv is absent on an adopter-hosted plane: there is no subject env to inject
     // because the operator points their own app at their own catch.
     const commsEnv = commsEmail?.injectEnv !== undefined && commsPort !== undefined
         ? { [commsEmail.injectEnv]: `http://127.0.0.1:${commsPort}` }
@@ -27,7 +27,7 @@ export function subjectCommsOf(config, planeClass) {
     return { email: commsEmail, port: commsPort, env: commsEnv };
 }
 /**
- * Adopter-hosted ingress (#328): on the external-public plane the harness provisions nothing, so
+ * Adopter-hosted ingress: on the external-public plane the harness provisions nothing, so
  * it cannot host a catch. The operator can, and then humanish still does every other part of
  * the funnel: it tells each persona its address and inbox URL, drains the declared catch over
  * HTTP at teardown, and writes the same digest-only evidence. Declaring `external` is what turns
@@ -40,7 +40,7 @@ export async function prepareExternalComms(config, planeClass, dryRun, warnings,
     if (config.comms?.email?.kind === "fake" &&
         planeClass === "external-public" &&
         externalComms === undefined) {
-        warnings.push("comms.email is declared but this is the external-public plane (the shared plane is an operator-owned public deployment the harness does not provision) — the in-sandbox email catch cannot be deployed and no comms evidence is collected. Declare `comms.email.external` to host the catch yourself (#328).");
+        warnings.push("comms.email is declared, but this study drives a public deployment that humanish does not provision, so the email catch cannot run in a sandbox and no email evidence is collected. Run the catch yourself with `humanish comms catch` and declare `comms.email.external`.");
     }
     if (!externalComms || !externalCommsEmail)
         return { ok: true, wiring: undefined };
@@ -49,7 +49,7 @@ export async function prepareExternalComms(config, planeClass, dryRun, warnings,
     if (tokenRefusal !== undefined)
         return {
             ok: false,
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_COMMS_TOKEN_INVALID",
+            code: "HUMANISH_SHARED_WORLD_COMMS_TOKEN_INVALID",
             message: tokenRefusal,
         };
     // Fail closed before any actor sandbox is created: a comms lab whose catch is unreachable
@@ -58,14 +58,14 @@ export async function prepareExternalComms(config, planeClass, dryRun, warnings,
     if (!dryRun && !(await externalCatchHealthy(externalComms))) {
         return {
             ok: false,
-            code: "HUMANISH_CONCURRENT_SHARED_WORLD_LAB_COMMS_CATCH_UNREACHABLE",
+            code: "HUMANISH_SHARED_WORLD_COMMS_CATCH_UNREACHABLE",
             message: `The external comms catch or inbox is unreachable or incompatible (GET /health must identify humanish-comms-catch and advertise recipient-inbox-v1). Update humanish on the catch host and restart it with \`humanish comms catch\` on that host, or drop comms.email to run without the inbox funnel.`,
         };
     }
     return { ok: true, wiring: { external: externalComms, email: externalCommsEmail, inboxUrl } };
 }
 /**
- * Off-app comms evidence (#297): drain everything the in-sandbox catch captured, route it into a
+ * Off-app comms evidence: drain everything the in-sandbox catch captured, route it into a
  * host fake inbox addressed to the declared recipients, and write the run-level digest-only thread
  * artifact while the subject is still alive, before it is killed. Wrapped so a drain error
  * never blocks teardown (invariant: all sandboxes torn down by id in the plane's finally). Returns
@@ -91,11 +91,11 @@ export async function drainSubjectComms(ctx, commsEmail, subjectShell, deployedC
             return "comms/thread.json";
         }
         else if (collected.captured > 0) {
-            warnings.push(`Comms catch captured ${collected.captured} email send(s) but none matched a declared recipient inbox — no comms evidence written. Declare comms.email.recipients[].address to match the address the app sends to.`);
+            warnings.push(`The email catch captured ${collected.captured} email send(s), but none matched a declared recipient inbox, so no email evidence was written. Set comms.email.recipients[].address to the address the app sends to.`);
         }
         else {
-            // Zero captures is the silent-broken shape (#351): the app never posted to the catch.
-            warnings.push(`Comms catch captured ZERO email sends — the app never delivered mail through the catch. Verify the app reads ${commsEmail.injectEnv} for its email API base URL (an SDK that ignores it sends real mail or throws) and that the flow reached an email step.`);
+            // Zero captures is the silent-broken shape: the app never posted to the catch.
+            warnings.push(`The email catch captured no email sends: the app never delivered mail through it. Verify the app reads ${commsEmail.injectEnv} for its email API base URL (an SDK that ignores it sends real mail or throws) and that the flow reached an email step.`);
         }
     }
     catch (error) {
@@ -104,8 +104,8 @@ export async function drainSubjectComms(ctx, commsEmail, subjectShell, deployedC
     return undefined;
 }
 /**
- * Adopter-hosted drain (#328/#387): same routing and digest-only artifact as the in-sandbox
- * catch — only the transport differs (HTTP GET /deliveries against the catch the operator
+ * Adopter-hosted drain: same routing and digest-only artifact as the in-sandbox
+ * catch. Only the transport differs (HTTP GET /deliveries against the catch the operator
  * runs). Called in the plane's finally so the evidence survives a failed run; a drain error never
  * masks the run's own outcome. Returns the thread's path when one was written.
  */