humanish 0.106.1 → 0.108.0

package/dist/routes/shared-world/{seat-records.js → bundle-records.js}

@@ -5,7 +5,7 @@ import { participantAssignment } from "../../lab/participant-assignment.js";
 import { participantEvent, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { declaredScreenForRender } from "../../substrates/e2b/desktop-geometry.js";
 import { publicSafeRouteLabel } from "./provenance.js";
-import { participantTaxonomyLabel } from "./seats.js";
+import { participantTaxonomyLabel } from "./participant-specs.js";
 function participantView(ctx, spec, index) {
     const { args, external, inProgress } = ctx;
     const taxonomy = participantTaxonomyLabel(spec.planned.labels);
@@ -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,10 +30,10 @@ 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 lane): otherwise an
-    // ABSENT declared means either "the preset rendered faithfully" or "there was no live
+    // 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
     // outcome", and a dry-run bundle keeps the self-confirming shape this field exists to kill.
     const fallbackDeclared = declaredScreenForRender(spec.planned.device.preset, spec.planned.device.name, spec.planned.device.resolution);
     const desktopGeometry = outcome?.desktopGeometry ?? {
@@ -79,9 +80,9 @@ 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}.`,
-        startedAt: args.createdAt,
-        updatedAt: args.createdAt,
+                    : `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,
     });
 }
 function sharedWorldStream(ctx, spec, index, view) {
@@ -92,10 +93,10 @@ 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.createdAt,
+        updatedAt: args.run.createdAt,
         embed: lastScreenshot
             ? {
                 kind: "screenshot",
@@ -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 } : {}),
@@ -135,9 +136,9 @@ function sharedWorldStream(ctx, spec, index, view) {
                     },
                 ]
                 : []),
-            // Run-level comms evidence belongs to the ONE shared app, not a persona — register it once, on
+            // 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" }]
                 : []),
@@ -151,7 +152,7 @@ function sharedWorldStream(ctx, spec, index, view) {
 }
 function sharedWorldEvents(ctx, spec, view) {
     const { args, inProgress, nextEventId } = ctx;
-    const createdAt = args.createdAt;
+    const createdAt = args.run.createdAt;
     const { outcome, session } = view;
     const events = [];
     const record = (event) => events.push(participantEvent(spec, event));
@@ -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,20 +1,20 @@
 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
- *  count: lane COUNT says how many seats existed; this says how many ever ran at once. */
+/** 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;
-/** Project the concurrent run into a humanish.run-bundle.v1 with the CONCURRENT shared-world block. */
+/** Project the concurrent run into a humanish.run-bundle.v1 with the concurrent shared-world block. */
 export declare function buildConcurrentSharedWorldBundle(args: ConcurrentBundleArgs): RunBundle;
 export declare function renderConcurrentReviewMarkdown(bundle: RunBundle): string;

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,14 +8,14 @@ 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 "./seat-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
- *  count: lane COUNT says how many seats existed; this says how many ever ran at once. */
+/** 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
         .filter((w) => w.endedAt > w.startedAt)
@@ -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;
@@ -90,14 +90,14 @@ function formatSharedWorldActorOutcomes(outcomes, expectedCount) {
 }
 /** The run's first two events: its creation and the shared plane's provenance. */
 function planeEvents(args, external) {
-    const { plan, descriptor, createdAt, dryRun, actorSpecs } = args;
+    const { plan, descriptor, run: { createdAt }, dryRun, actorSpecs, } = args;
     const events = [];
     events.push({
         id: "event-000-created",
         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
@@ -108,8 +108,8 @@ function planeEvents(args, external) {
             ? `packed working tree (archiveSha256 ${args.subject.archiveSha256}${args.subject.dirty === true ? ", dirty working tree" : args.subject.dirty === false ? ", clean working tree" : ""})`
             : "packed working tree (archive digest unresolved; provisioning failed before resolution)"
         : `clone of ${args.subject.repo}${args.subjectCommit ? `@${args.subjectCommit}` : ""}`;
-    // External-public plane provenance is HONESTLY different: an operator-declared, operator-OWNED
-    // public deployment humanish neither provisioned nor seeded — NO getHost, NO clone, NO synthetic
+    // External-public plane provenance differs: an operator-declared, operator-owned public
+    // deployment humanish neither provisioned nor seeded, with no getHost, no clone and no synthetic
     // attestation (claiming synthetic on a real site is a lie). The origin persists digest-only.
     // planSharedWorldLab refuses an external-public plane without a declared owner; the fallback
     // says so rather than naming one.
@@ -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).
+    // Build the concurrent shared-world evidence block. routeHostDigest is sha256-16 of the origin each
+    // 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]"));
@@ -156,7 +158,7 @@ function sharedWorldEvidence(args, external, inProgress, planeCommit) {
             seedDigest: args.seedDigest,
         };
     });
-    // Option A (external-public): NO authoritative shared-state proof — OMIT stateSeries entirely (there
+    // Option A (external-public): no authoritative shared-state proof, so stateSeries is omitted (there
     // is no in-sandbox filesystem to digest; concurrency is proven by temporal co-occupancy + lobby
     // convergence). The provisioned-getHost plane keeps its authoritative in-sandbox checkpoint series.
     const stateSeries = external
@@ -182,14 +184,14 @@ function sharedWorldEvidence(args, external, inProgress, planeCommit) {
         };
     });
     // The plane block is plane-class-specific. getHost: harness-minted hostDigest + synthetic
-    // attestation. external-public: operator-declared publicOriginDigest, NO hostDigest, NO exposure
-    // (claiming synthetic on a real site would be a lie — verify asserts both ABSENT there).
+    // attestation. external-public: operator-declared publicOriginDigest, no hostDigest, no exposure
+    // (claiming synthetic on a real site would be false; verify asserts both are absent there).
     const plane = external
         ? {
             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).
+            // publicOriginDigest is the observed convergence origin; declaredOriginDigest records the
+            // operator-declared origin for reference (a redirect that makes them differ is no failure).
             ...(args.publicOriginDigest === undefined
                 ? {}
                 : { publicOriginDigest: args.publicOriginDigest }),
@@ -216,7 +218,7 @@ function sharedWorldEvidence(args, external, inProgress, planeCommit) {
             ? [...EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS]
             : [...CONCURRENT_ATTRIBUTION_LIMITS],
         laneWindows: windows,
-        // Option A: external-public carries NO stateSeries.
+        // Option A: external-public carries no stateSeries.
         ...(stateSeries === undefined ? {} : { stateSeries }),
         outcomes,
         ...(args.lobbyConvergenceDigest === undefined
@@ -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
@@ -241,7 +243,7 @@ function finishedGaps(actorResults, shortfall) {
 }
 /** Records the concurrency event and returns the review. */
 function concurrencyReview(args, external, inProgress, evidence, events, nextEventId) {
-    const { plan, descriptor, createdAt, dryRun, actorSpecs, actorResults } = args;
+    const { plan, descriptor, run: { createdAt }, dryRun, actorSpecs, actorResults, } = args;
     const { sharedWorld, windows, stateSeries, outcomes } = evidence;
     const overlaps = args.judgment.world.overlap;
     const deltas = (stateSeries ?? []).filter((snapshot, i) => i > 0 && snapshot.digest !== (stateSeries ?? [])[i - 1].digest).length;
@@ -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 lanes were LIVE AT ONCE, not how many lanes exist — a
-    // 6-lane run capped at 3 must never read as 6-wide concurrency (#350, the field failure).
+    // 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.
     const capForReport = plan.concurrency;
     const maxLive = maxSimultaneousWindows(windows);
     events.push({
@@ -260,31 +262,31 @@ 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 = {
         schema: REVIEW_SCHEMA,
         verdict,
-        // Plane-class-aware: the external-public plane has NO getHost/clone/seed and carries NO
+        // 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
                 ? [
@@ -294,15 +296,15 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
     };
     return review;
 }
-/** Project the concurrent run into a humanish.run-bundle.v1 with the CONCURRENT shared-world block. */
+/** Project the concurrent run into a humanish.run-bundle.v1 with the concurrent shared-world block. */
 export function buildConcurrentSharedWorldBundle(args) {
-    const { plan, descriptor, createdAt, dryRun, actorSpecs, actorResults } = args;
+    const { plan, descriptor, run: { createdAt }, dryRun, actorSpecs, actorResults, } = args;
     const inProgress = args.inProgress === true;
     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
-    // (external-public) lands in the bundle. The plane identity is a DIGEST (plane.hostDigest on
+    // 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]";
     const planeCommit = external ? undefined : dryRun ? undefined : args.subjectCommit;
@@ -323,19 +325,15 @@ export function buildConcurrentSharedWorldBundle(args) {
     const ranLive = actorResults.some((result) => result.outcome.session !== undefined || result.outcome.sessionError !== undefined);
     const cost = concurrentCostSummary(args, inProgress);
     return {
-        ...bundleHead({
+        ...bundleHead(args.run, {
             ...receivingPublication(plan.residual, args.dryRun),
-            runId: args.runId,
-            mode: dryRun ? "dry-run" : "live",
             participants: actorSpecs.length,
-            createdAt,
-            ...(args.lab === undefined ? {} : { lab: args.lab }),
             source: args.source,
         }),
         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: {
@@ -344,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,
@@ -361,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,
@@ -381,7 +379,7 @@ export function buildConcurrentSharedWorldBundle(args) {
     };
 }
 /**
- * Priced like per-lane worlds: each seat's model tokens and desktop, plus the provisioned plane's
+ * Priced like `per-lane-worlds`: each participant's model tokens and desktop, plus the provisioned plane's
  * desktop. Absent when nothing ran, so dry runs and in-progress snapshots stay byte-stable.
  */
 function concurrentCostSummary(args, inProgress) {
@@ -416,7 +414,7 @@ function concurrentCostSummary(args, inProgress) {
         ],
     });
 }
-/** The declared (dry-run) state digest: the probe RECIPE (command digests), no run. */
+/** The declared (dry-run) state digest: the probe recipe (command digests), no run. */
 function declaredStateDigest(state) {
     const probes = state?.checkpoint ?? [];
     return combineCheckpointDigest(probes.map((probe) => `${probe.name}=${commandDigestOf(probe.command)}`));
@@ -433,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

@@ -2,13 +2,13 @@ import type { Shell } from "../../substrates/shell.js";
 import { type DetachedTimers } from "../../substrates/detached.js";
 import { type LabSubjectState, type LabSubjectStateCheckpoint } from "../../lab/types.js";
 import { type SharedWorldCheckpoint } from "../../run/shared-world-evidence.js";
-/** Combine a snapshot's per-probe digests into ONE sha256-16 (digest-only; no raw value). */
+/** Combine a snapshot's per-probe digests into one sha256-16 (digest-only; no raw value). */
 export declare function combineCheckpointDigest(parts: string[]): string;
 /**
- * Run ONE checkpoint snapshot LIVE: each declared probe runs read-only via the detached
+ * 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
+ * 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
  * stale-status reuse across snapshots.
  */
 export declare function runCheckpointSnapshot(args: {
@@ -21,5 +21,5 @@ export declare function runCheckpointSnapshot(args: {
     requestTimeoutMs: number;
     timers: DetachedTimers;
 }): Promise<SharedWorldCheckpoint>;
-/** sha256-16 over the ordered seed-step command digests — the seeded-state RECIPE identity. */
+/** sha256-16 over the ordered seed-step command digests: the seeded-state recipe identity. */
 export declare function seedRecipeDigest(state: LabSubjectState | undefined): string;

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

@@ -6,15 +6,15 @@ import { redactText } from "../../evidence/redaction.js";
 import {} from "../../run/shared-world-evidence.js";
 // Per-checkpoint probe budget (read-only aggregate probes are fast).
 const CHECKPOINT_TIMEOUT_MS = 60_000;
-/** Combine a snapshot's per-probe digests into ONE sha256-16 (digest-only; no raw value). */
+/** Combine a snapshot's per-probe digests into one sha256-16 (digest-only; no raw value). */
 export function combineCheckpointDigest(parts) {
     return commandDigestOf(parts.join("\n"));
 }
 /**
- * Run ONE checkpoint snapshot LIVE: each declared probe runs read-only via the detached
+ * 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
+ * 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
  * stale-status reuse across snapshots.
  */
 export async function runCheckpointSnapshot(args) {
@@ -39,7 +39,7 @@ export async function runCheckpointSnapshot(args) {
         deltaFromPrev: args.prevDigest !== undefined && digest !== args.prevDigest,
     };
 }
-/** sha256-16 over the ordered seed-step command digests — the seeded-state RECIPE identity. */
+/** sha256-16 over the ordered seed-step command digests: the seeded-state recipe identity. */
 export function seedRecipeDigest(state) {
     const seed = state?.seed ?? [];
     return commandDigestOf(seed.map((step) => `${step.name}:${commandDigestOf(step.command)}`).join("\n"));

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

@@ -14,31 +14,32 @@ 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
- * it cannot host a catch — but the OPERATOR can, and then humanish still does every other part of
+ * 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
  * the previously-inert block into a working one. Returns an error message when the declared catch
  * does not answer as a humanish catch.
  */
-export declare function prepareExternalComms(config: Pick<LabConfig, "comms">, planeClass: ConcurrentSharedWorldPlaneClass, dryRun: boolean, warnings: string[]): Promise<{
+export declare function prepareExternalComms(config: Pick<LabConfig, "comms">, planeClass: ConcurrentSharedWorldPlaneClass, dryRun: boolean, warnings: string[], env: Record<string, string | undefined>): Promise<{
     ok: true;
     wiring: ExternalCommsWiring | undefined;
 } | {
     ok: false;
+    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
+ * 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
  * the thread's path when one was written.
  */
 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.
  */