humanish 0.19.1 → 0.20.0

package/dist/index.d.ts

@@ -49,13 +49,13 @@ export { TERMINAL_PRODUCT_LAB_SCHEMA, buildTerminalProductBundle, runTerminalPro
 export type { CommandLogRecord, CostCategory, CostLine, InterventionRecord, LifecycleRecord, NoSpendProof, RunTerminalProductLabOptions, TerminalCostLedger, TerminalLedgers, TerminalProductLabHooks, TerminalProductLabResult, TerminalProductScoringContext } from "./e2b-terminal-lab.js";
 export { SHARED_WORLD_LAB_PROVIDER_METADATA, SHARED_WORLD_LAB_SCHEMA, buildSharedWorldBundle, runSharedWorldLab } from "./shared-world-lab.js";
 export type { RunSharedWorldLabOptions, SharedWorldLabErrorCode, SharedWorldLabHooks, SharedWorldLabResult, SharedWorldRoleResult } from "./shared-world-lab.js";
-export { CONCURRENT_ATTRIBUTION_LIMITS, CONCURRENT_SHARED_WORLD_LAB_SCHEMA, CONCURRENT_SHARED_WORLD_PROVIDER_METADATA, buildConcurrentSharedWorldBundle, runConcurrentSharedWorld } from "./concurrent-shared-world-lab.js";
-export type { ConcurrentSharedWorldLabErrorCode, ConcurrentSharedWorldLabResult, ConcurrentSharedWorldRoleResult, RunConcurrentSharedWorldLabOptions } from "./concurrent-shared-world-lab.js";
+export { CONCURRENT_ATTRIBUTION_LIMITS, CONCURRENT_SHARED_WORLD_LAB_SCHEMA, CONCURRENT_SHARED_WORLD_PROVIDER_METADATA, EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS, LOBBY_CODE_PATTERN, buildConcurrentSharedWorldBundle, extractLobbyCode, runConcurrentSharedWorld } from "./concurrent-shared-world-lab.js";
+export type { ConcurrentSharedWorldLabErrorCode, ConcurrentSharedWorldLabResult, ConcurrentSharedWorldPlaneClass, ConcurrentSharedWorldRoleResult, RunConcurrentSharedWorldLabOptions } from "./concurrent-shared-world-lab.js";
 export { probeUrl, readDetachedLog, runDetachedStep, startDetachedProcess } from "./e2b-detached.js";
 export type { DetachedStepOptions, DetachedStepResult, DetachedTimers } from "./e2b-detached.js";
 export { DEFAULT_DEVICE_PRESET, DEVICE_PRESETS, DEVICE_PRESET_NAMES, isDevicePresetName, resolveDevicePreset } from "./device-presets.js";
 export type { DevicePreset, DevicePresetName } from "./device-presets.js";
-export { actorResolvesToTerminal, cuaLaneCount, cuaLaneValidationReason, isHttpUrl, isLoopbackUrl, LAB_CONFIG_SCHEMA, MAX_CUA_LANES, concurrentSharedWorldValidationReason, parseLabConfig, resolveSeatUrl, routesToComputerUse, routesToConcurrentSharedWorld, routesToScriptedBrowser, routesToSharedWorld, routesToTerminalProduct, sharedWorldValidationReason, subjectStateInvalidReason } from "./lab-config.js";
+export { actorResolvesToTerminal, cuaLaneCount, cuaLaneValidationReason, isHttpUrl, isLoopbackUrl, LAB_CONFIG_SCHEMA, MAX_CUA_LANES, concurrentSharedWorldValidationReason, externalPublicSharedWorldValidationReason, parseLabConfig, resolveSeatUrl, routesToComputerUse, routesToConcurrentSharedWorld, routesToExternalPublicSharedWorld, routesToProvisionedSharedWorld, routesToScriptedBrowser, routesToSharedWorld, routesToTerminalProduct, sharedWorldValidationReason, subjectStateInvalidReason } from "./lab-config.js";
 export type { LabActor, LabActorLane, LabConfig, LabConfigParseResult, LabExecutionTerminal, LabRuntimeAuth, LabScenarioCaps, LabStateStepWhen, LabSubject, LabSubjectProduct, LabSubjectServe, LabSubjectSource, LabSubjectState, LabSubjectStateCheckpoint, LabSubjectStateStep, LabSubjectTopology, LabTerminalStdin, LabTerminalTransport } from "./lab-config.js";
 export { resolveLabDryRun, runLab, selectLabBackend } from "./lab-engine.js";
 export type { LabBackend, LabOutcome, RunLabOptions } from "./lab-engine.js";

package/dist/index.js

@@ -24,10 +24,10 @@ export { SCRIPTED_BROWSER_PROVIDER, runScriptedBrowserSession } from "./scripted
 export { SCRIPTED_BROWSER_LAB_SCHEMA, buildScriptedLabBundle, runScriptedBrowserLab } from "./scripted-browser-lab.js";
 export { TERMINAL_PRODUCT_LAB_SCHEMA, buildTerminalProductBundle, runTerminalProductLab } from "./e2b-terminal-lab.js";
 export { SHARED_WORLD_LAB_PROVIDER_METADATA, SHARED_WORLD_LAB_SCHEMA, buildSharedWorldBundle, runSharedWorldLab } from "./shared-world-lab.js";
-export { CONCURRENT_ATTRIBUTION_LIMITS, CONCURRENT_SHARED_WORLD_LAB_SCHEMA, CONCURRENT_SHARED_WORLD_PROVIDER_METADATA, buildConcurrentSharedWorldBundle, runConcurrentSharedWorld } from "./concurrent-shared-world-lab.js";
+export { CONCURRENT_ATTRIBUTION_LIMITS, CONCURRENT_SHARED_WORLD_LAB_SCHEMA, CONCURRENT_SHARED_WORLD_PROVIDER_METADATA, EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS, LOBBY_CODE_PATTERN, buildConcurrentSharedWorldBundle, extractLobbyCode, runConcurrentSharedWorld } from "./concurrent-shared-world-lab.js";
 export { probeUrl, readDetachedLog, runDetachedStep, startDetachedProcess } from "./e2b-detached.js";
 export { DEFAULT_DEVICE_PRESET, DEVICE_PRESETS, DEVICE_PRESET_NAMES, isDevicePresetName, resolveDevicePreset } from "./device-presets.js";
-export { actorResolvesToTerminal, cuaLaneCount, cuaLaneValidationReason, isHttpUrl, isLoopbackUrl, LAB_CONFIG_SCHEMA, MAX_CUA_LANES, concurrentSharedWorldValidationReason, parseLabConfig, resolveSeatUrl, routesToComputerUse, routesToConcurrentSharedWorld, routesToScriptedBrowser, routesToSharedWorld, routesToTerminalProduct, sharedWorldValidationReason, subjectStateInvalidReason } from "./lab-config.js";
+export { actorResolvesToTerminal, cuaLaneCount, cuaLaneValidationReason, isHttpUrl, isLoopbackUrl, LAB_CONFIG_SCHEMA, MAX_CUA_LANES, concurrentSharedWorldValidationReason, externalPublicSharedWorldValidationReason, parseLabConfig, resolveSeatUrl, routesToComputerUse, routesToConcurrentSharedWorld, routesToExternalPublicSharedWorld, routesToProvisionedSharedWorld, routesToScriptedBrowser, routesToSharedWorld, routesToTerminalProduct, sharedWorldValidationReason, subjectStateInvalidReason } from "./lab-config.js";
 export { resolveLabDryRun, runLab, selectLabBackend } from "./lab-engine.js";
 export { LAB_PREFLIGHT_SCHEMA, runLabPreflight } from "./lab-preflight.js";
 export { CLI_RESPONSE_SCHEMA, createProgram } from "./program.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/init-templates.js

@@ -197,6 +197,58 @@ scenario:
 # policies:
 #   redactScreenshots: true       # blur persisted frames (default off — full fidelity for local use)
 #   allowPublicTargets: true      # required to drive a non-loopback app-url (a deployment you own)
+defaults:
+  open: true
+`
+    },
+    {
+        path: "humanish/labs/cineguessr-3player.yaml",
+        plane: "source",
+        contents: `schema: humanish.lab.v2
+id: cineguessr-3player
+title: External-public shared world (N mobile personas share ONE public app at once)
+description: >-
+  A worked example of the EXTERNAL-PUBLIC shared-world route (#164 phase 2): N mobile-LAYOUT
+  personas play the SAME multiplayer lobby on a REAL public deployment AT ONCE. The public site is
+  the shared plane DIRECTLY — NO clone, NO getHost, NO subject sandbox, NO seed. A host-first barrier
+  extracts the shared-session code from the host seat's CDP-observed URL and threads it into the
+  follower join missions (followers go through the real Join flow). Dry-run (the default) emits ONE
+  external-public evidence bundle at $0. A live run needs OPENAI_API_KEY + E2B_API_KEY and
+  scenario.mode: live. Point appUrl + publicTarget at a public deployment YOU own/operate.
+  MOBILE FIDELITY: on the E2B-desktop route only width/height render (real mobile LAYOUT); there is
+  no touch input and DPR/isMobile are prompt-signal + metadata. HONESTY: attribution stays
+  shared-world, but every strength claim degrades honestly — provenance external-public (not seeded),
+  NO synthetic attestation (you cannot claim synthetic on a real site), NO authoritative shared-state
+  proof, concurrency by temporal co-occupancy + observed lobby convergence.
+subject:
+  source: app-url # the real public deployment IS the shared plane (no clone, no getHost)
+  topology: shared-world # the declared override of the per-lane-worlds default
+  appUrl: https://your-public-app.example/ # a deployment YOU own/operate
+  publicTarget: # REQUIRED ownership attestation (the honest analog of exposure: synthetic)
+    owner: your-org/your-app
+    authorized: true
+policies:
+  allowPublicTargets: true # REQUIRED: the shared plane is a real non-loopback public deployment
+actors:
+  - type: openai-computer-use
+    mission: You are one of several users on the same shared session at once. Play your role, then stop.
+    lanes: # the roster (>=2) with EXACTLY ONE host: true seat
+      - id: host
+        host: true # the designated host seat that creates the shared session
+        device: mobile # 414x896 mobile LAYOUT (no touch; DPR is prompt-signal on this route)
+        instruction: Create a shared lobby, wait for the others to join, then start and play.
+      - id: player-2
+        device: mobile
+        instruction: Join the lobby you're told the code for, then play.
+      - id: player-3
+        device: small-mobile
+        instruction: Join the lobby you're told the code for, then play.
+execution:
+  target: e2b-desktop
+  timeoutMs: 120000 # PER-SEAT session budget; also caps the host-first handoff deadline
+  concurrency: 3 # > 1 selects the CONCURRENT substrate
+scenario:
+  mode: dry-run # default; the live path opens N real mobile-layout seats against the public app
 defaults:
   open: true
 `

package/dist/init-templates.js.map

@@ -1 +1 @@
-{"version":3,"file":"init-templates.js","sourceRoot":"","sources":["../src/init-templates.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"init-templates.js","sourceRoot":"","sources":["../src/init-templates.ts"],"names":[],"mappings":"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"}

package/dist/lab-config.d.ts

@@ -162,6 +162,22 @@ export interface LabSubject {
      * `topology: shared-world` + `execution.concurrency > 1`; inert/warned elsewhere.
      */
     exposure?: "synthetic";
+    /**
+     * EXTERNAL-PUBLIC shared-world route ONLY (#164 phase 2): the author's REQUIRED ownership
+     * attestation when a real PUBLIC deployment (`source: app-url` + `topology: shared-world` +
+     * `concurrency > 1` + `policies.allowPublicTargets: true`) is used directly as the shared plane.
+     * The harness neither provisions nor exposes this target (no getHost, no clone, no seed), so it
+     * cannot attest the data is synthetic; instead the operator MUST attest they own/operate it.
+     * `owner` is a public-safe operator/repo label; `authorized` must be true. This is author-trust —
+     * the harness cannot verify ownership — surfaced honestly in the evidence class. Required on the
+     * external-public branch. On a non-`app-url` subject it is REJECTED (parse error); on any OTHER
+     * `app-url` config that does not route to external-public shared-world it is IGNORED-WITH-A-WARNING
+     * (forwardDeclaredWarnings), never silently consumed — it is meaningless without that plane.
+     */
+    publicTarget?: {
+        owner: string;
+        authorized: boolean;
+    };
     /** `clone`: one or more owner/repo slugs (public or authorized-private). */
     repos?: string[];
     clone?: LabSubjectClone;
@@ -257,6 +273,14 @@ export interface LabActorLane {
      * non-shared-world route (the per-lane-worlds fan-out roster has no per-lane entry).
      */
     entry?: string;
+    /**
+     * EXTERNAL-PUBLIC shared-world ONLY (#164 phase 2): marks this lane the DESIGNATED HOST seat — it
+     * creates the shared session (e.g. a multiplayer lobby) that the follower seats then join. Exactly
+     * ONE lane in the roster may carry `host: true` (validated in externalPublicSharedWorldValidationReason).
+     * The orchestrator watches the host seat's observed URL for the shared-session code and threads it
+     * into the follower missions at a host-first barrier. Inert/warned on every other route.
+     */
+    host?: boolean;
 }
 /**
  * Compact authoring sugar for repeated lane groups. The parser expands each group into concrete
@@ -544,11 +568,26 @@ export declare function routesToComputerUse(config: LabConfig): boolean;
  * (the cua route) — the topology declaration is the override switch.
  */
 export declare function routesToSharedWorld(config: LabConfig): boolean;
+/** The getHost provisioned-subject shared-world shape (clone/local-tree served + exposed in-sandbox). */
+export declare function routesToProvisionedSharedWorld(config: LabConfig): boolean;
+/**
+ * The EXTERNAL-PUBLIC shared-world shape (#164 phase 2): a real PUBLIC deployment used DIRECTLY as
+ * the shared plane — `source: app-url` + `topology: shared-world` + a computer-use actor on
+ * e2b-desktop + `policies.allowPublicTargets: true`. NO getHost, NO clone, NO subject sandbox, NO
+ * seed. The operator-ownership attestation `subject.publicTarget` is required (validated in
+ * externalPublicSharedWorldValidationReason, not here — this predicate is the router only, so a
+ * half-declared external-public config still routes here to get its precise fail-closed reason
+ * rather than silently downgrading to the per-lane cua route). Always concurrent (concurrency > 1 is
+ * enforced by the validation reason).
+ */
+export declare function routesToExternalPublicSharedWorld(config: LabConfig): boolean;
 /**
  * True when this config routes to the CONCURRENT shared-world backend (#164 phase 2): a shared-world
- * config with `execution.concurrency > 1` (N actor seats driving ONE getHost-exposed plane AT ONCE).
- * `concurrency` absent or 1 stays the sequential PoC (`routesToSharedWorld` → the sequential
- * backend). selectLabBackend checks this BEFORE routesToSharedWorld.
+ * config with `execution.concurrency > 1` (N actor seats driving ONE plane AT ONCE). Two plane
+ * classes: the getHost provisioned-subject shape (clone/local-tree) AND the external-public shape (a
+ * real public deployment used directly as the plane — `source: app-url` + `allowPublicTargets`, no
+ * getHost/clone/seed). `concurrency` absent or 1 stays the sequential PoC (getHost only).
+ * selectLabBackend checks this BEFORE routesToSharedWorld.
  */
 export declare function routesToConcurrentSharedWorld(config: LabConfig): boolean;
 /**
@@ -560,6 +599,18 @@ export declare function routesToConcurrentSharedWorld(config: LabConfig): boolea
  * is exported npm surface).
  */
 export declare function concurrentSharedWorldValidationReason(config: LabConfig): string | null;
+/**
+ * Cross-validate the EXTERNAL-PUBLIC shared-world declaration (#164 phase 2): a real PUBLIC
+ * deployment used DIRECTLY as the shared plane (no getHost, no clone, no subject sandbox, no seed).
+ * The honest analog of concurrentSharedWorldValidationReason for a plane the harness does NOT own:
+ * it FORBIDS every provisioned-subject field (serve/state.seed/state.checkpoint/exposure/clone/repos
+ * are inert with no sandbox — fail closed, never silently ignored, per invariant 6), and REQUIRES a
+ * non-loopback appUrl + allowPublicTargets + the operator-ownership attestation subject.publicTarget +
+ * concurrency > 1 + an actors[0].lanes roster of ≥2 with EXACTLY ONE host lane. The getHost synthetic
+ * gate is deliberately unreachable here (there is no internet-reachable harness-owned URL to attest).
+ * Enforced at parse AND re-enforced in the engine (runConcurrentSharedWorld is exported npm surface).
+ */
+export declare function externalPublicSharedWorldValidationReason(config: LabConfig): string | null;
 /**
  * Resolve a shared-world seat's entry URL from `serve.url` + a role's `entry` (relative path or
  * same-origin absolute URL). Returns null when the combination is not a same-origin loopback URL

package/dist/lab-config.js

@@ -284,9 +284,14 @@ export function parseLabConfig(raw) {
     // silently downgrading to a per-lane-worlds cua run. With `execution.concurrency > 1` the
     // concurrent extras (synthetic-subject attestation, 0.0.0.0 serve bind, no clone.keep) also apply.
     if (config.subject.topology === "shared-world") {
-        const reason = (config.execution?.concurrency ?? 1) > 1
-            ? concurrentSharedWorldValidationReason(config)
-            : sharedWorldValidationReason(config);
+        const reason = config.subject.source === "app-url"
+            // The external-public plane (a real public deployment as the shared plane): NEVER the getHost
+            // synthetic gate — that gate exists because getHost is internet-reachable AND harness-owned; a
+            // public site the harness neither provisioned nor exposed has neither property.
+            ? externalPublicSharedWorldValidationReason(config)
+            : (config.execution?.concurrency ?? 1) > 1
+                ? concurrentSharedWorldValidationReason(config)
+                : sharedWorldValidationReason(config);
         if (reason) {
             return invalid(reason);
         }
@@ -434,9 +439,13 @@ export function cuaLaneValidationReason(config) {
     }
     // Public targets fan out into N independent worlds driving the SAME public app — that is an
     // ambiguous shared-world-ish shape, not a per-lane target swarm. Permit N>1 public runs only when
-    // every roster lane declares its own target, making the adapter-owned topology explicit.
-    if (laneCount > 1 && config.policies?.allowPublicTargets === true && declaredLaneTargets(config).length === 0) {
-        return "policies.allowPublicTargets cannot be combined with multi-lane fan-out (N>1) — N lanes against one declared public target is the SHARED-WORLD topology (layer 7, #164), not per-lane worlds. Fan out against a loopback/provisioned subject, or run a single public-target lane.";
+    // every roster lane declares its own target, making the adapter-owned topology explicit. But when
+    // `subject.topology: shared-world` is ALSO declared, N lanes against one public target is the
+    // EXTERNAL-PUBLIC shared-world topology (#164 phase 2) — ROUTE it there (a real public deployment
+    // as the shared plane) instead of refusing; externalPublicSharedWorldValidationReason then applies.
+    if (laneCount > 1 && config.policies?.allowPublicTargets === true && declaredLaneTargets(config).length === 0
+        && config.subject.topology !== "shared-world") {
+        return "policies.allowPublicTargets cannot be combined with multi-lane fan-out (N>1) — N lanes against one declared public target is the SHARED-WORLD topology (layer 7, #164), not per-lane worlds. Declare `subject.topology: shared-world` to run the external-public shared-world route, fan out against a loopback/provisioned subject, or run a single public-target lane.";
     }
     return null;
 }
@@ -537,16 +546,39 @@ export function routesToComputerUse(config) {
  * (the cua route) — the topology declaration is the override switch.
  */
 export function routesToSharedWorld(config) {
+    return routesToProvisionedSharedWorld(config) || routesToExternalPublicSharedWorld(config);
+}
+/** The getHost provisioned-subject shared-world shape (clone/local-tree served + exposed in-sandbox). */
+export function routesToProvisionedSharedWorld(config) {
     return (config.subject.source === "clone" || config.subject.source === "local-tree")
         && config.subject.topology === "shared-world"
         && config.execution?.target === "e2b-desktop"
         && actorResolvesToComputerUse(config.actors[0]?.type);
 }
+/**
+ * The EXTERNAL-PUBLIC shared-world shape (#164 phase 2): a real PUBLIC deployment used DIRECTLY as
+ * the shared plane — `source: app-url` + `topology: shared-world` + a computer-use actor on
+ * e2b-desktop + `policies.allowPublicTargets: true`. NO getHost, NO clone, NO subject sandbox, NO
+ * seed. The operator-ownership attestation `subject.publicTarget` is required (validated in
+ * externalPublicSharedWorldValidationReason, not here — this predicate is the router only, so a
+ * half-declared external-public config still routes here to get its precise fail-closed reason
+ * rather than silently downgrading to the per-lane cua route). Always concurrent (concurrency > 1 is
+ * enforced by the validation reason).
+ */
+export function routesToExternalPublicSharedWorld(config) {
+    return config.subject.source === "app-url"
+        && config.subject.topology === "shared-world"
+        && config.execution?.target === "e2b-desktop"
+        && actorResolvesToComputerUse(config.actors[0]?.type)
+        && config.policies?.allowPublicTargets === true;
+}
 /**
  * True when this config routes to the CONCURRENT shared-world backend (#164 phase 2): a shared-world
- * config with `execution.concurrency > 1` (N actor seats driving ONE getHost-exposed plane AT ONCE).
- * `concurrency` absent or 1 stays the sequential PoC (`routesToSharedWorld` → the sequential
- * backend). selectLabBackend checks this BEFORE routesToSharedWorld.
+ * config with `execution.concurrency > 1` (N actor seats driving ONE plane AT ONCE). Two plane
+ * classes: the getHost provisioned-subject shape (clone/local-tree) AND the external-public shape (a
+ * real public deployment used directly as the plane — `source: app-url` + `allowPublicTargets`, no
+ * getHost/clone/seed). `concurrency` absent or 1 stays the sequential PoC (getHost only).
+ * selectLabBackend checks this BEFORE routesToSharedWorld.
  */
 export function routesToConcurrentSharedWorld(config) {
     return routesToSharedWorld(config) && (config.execution?.concurrency ?? 1) > 1;
@@ -580,6 +612,74 @@ export function concurrentSharedWorldValidationReason(config) {
     }
     return null;
 }
+/**
+ * Cross-validate the EXTERNAL-PUBLIC shared-world declaration (#164 phase 2): a real PUBLIC
+ * deployment used DIRECTLY as the shared plane (no getHost, no clone, no subject sandbox, no seed).
+ * The honest analog of concurrentSharedWorldValidationReason for a plane the harness does NOT own:
+ * it FORBIDS every provisioned-subject field (serve/state.seed/state.checkpoint/exposure/clone/repos
+ * are inert with no sandbox — fail closed, never silently ignored, per invariant 6), and REQUIRES a
+ * non-loopback appUrl + allowPublicTargets + the operator-ownership attestation subject.publicTarget +
+ * concurrency > 1 + an actors[0].lanes roster of ≥2 with EXACTLY ONE host lane. The getHost synthetic
+ * gate is deliberately unreachable here (there is no internet-reachable harness-owned URL to attest).
+ * Enforced at parse AND re-enforced in the engine (runConcurrentSharedWorld is exported npm surface).
+ */
+export function externalPublicSharedWorldValidationReason(config) {
+    const structuralReason = laneRosterStructuralValidationReason(config);
+    if (structuralReason) {
+        return structuralReason;
+    }
+    if (config.subject.source !== "app-url") {
+        return "the external-public shared-world route requires `subject.source: app-url` — a real public deployment is used directly as the shared plane (no clone, no provisioned subject).";
+    }
+    if (config.execution?.target !== "e2b-desktop") {
+        return "the external-public shared-world route requires `execution.target: e2b-desktop` — the role seats drive hosted desktop browsers against the one public deployment.";
+    }
+    if (!actorResolvesToComputerUse(config.actors[0]?.type)) {
+        return `the external-public shared-world route requires a registered computer-use actor (one of: ${registeredComputerUseActors().join(", ")}) — each role seat runs a computer-use session.`;
+    }
+    if ((config.execution?.concurrency ?? 1) <= 1) {
+        return "the external-public shared-world route requires `execution.concurrency > 1` (N concurrent seats sharing ONE public plane); concurrency 1 proves no shared world.";
+    }
+    if (config.policies?.allowPublicTargets !== true) {
+        return "the external-public shared-world route requires `policies.allowPublicTargets: true` — the shared plane is a real non-loopback public deployment.";
+    }
+    const appUrl = config.subject.appUrl ?? "";
+    if (!isHttpUrl(appUrl) || isLoopbackUrl(appUrl)) {
+        return "the external-public shared-world route requires a non-loopback http(s) `subject.appUrl` — a loopback URL is not a shared public plane (use the getHost provisioned route for a local subject).";
+    }
+    // The operator-ownership attestation (the honest analog of exposure: synthetic — you cannot claim
+    // synthetic on a real site, but you MUST attest you own/operate it). Author-trust; unverifiable.
+    if (config.subject.publicTarget?.authorized !== true) {
+        return "the external-public shared-world route requires `subject.publicTarget: { owner, authorized: true }` — you must attest you own/operate the public deployment used as the shared plane (author-trust; the harness cannot verify ownership).";
+    }
+    // FORBID every provisioned-subject field: with no sandbox they cannot act, so they are rejected
+    // with a precise reason, never silently ignored (invariant 6). exposure: synthetic in particular
+    // would be a LIE on a real site (the harness neither provisioned nor exposed it).
+    if (config.subject.exposure !== undefined) {
+        return "`subject.exposure: synthetic` is forbidden on the external-public shared-world route — you cannot attest a real public deployment is synthetic seeded data; use `subject.publicTarget` to attest ownership instead.";
+    }
+    if (config.subject.serve !== undefined) {
+        return "`subject.serve` is forbidden on the external-public shared-world route — the harness does not serve the plane (it is an already-deployed public app); there is no in-sandbox serve to run.";
+    }
+    if (config.subject.state?.seed !== undefined || config.subject.state?.checkpoint !== undefined || config.subject.state !== undefined) {
+        return "`subject.state` (seed/checkpoint/external) is forbidden on the external-public shared-world route — the harness neither seeds nor snapshots the plane (no in-sandbox filesystem to digest); no authoritative shared-state proof is possible on this class.";
+    }
+    if (config.subject.clone !== undefined || config.subject.repos !== undefined) {
+        return "`subject.clone`/`subject.repos` are forbidden on the external-public shared-world route — nothing is cloned; the public deployment IS the plane.";
+    }
+    const lanes = config.actors[0]?.lanes;
+    if (!lanes || lanes.length < 2) {
+        return "the external-public shared-world route requires an `actors[0].lanes` roster of at least 2 roles (a single-seat shared world proves no shared session).";
+    }
+    if (lanes.some((lane) => lane.entry !== undefined)) {
+        return "`actors[0].lanes[].entry` (the loopback same-origin seat path) is forbidden on the external-public shared-world route — there is no harness-served serve.url to resolve it against; seats open the public appUrl and reach the shared session through the real UI.";
+    }
+    const hostLanes = lanes.filter((lane) => lane.host === true);
+    if (hostLanes.length !== 1) {
+        return `the external-public shared-world route requires EXACTLY ONE \`host: true\` lane (the designated host seat that creates the shared session; got ${hostLanes.length}). The other ≥1 lanes are followers that join it.`;
+    }
+    return null;
+}
 /**
  * Resolve a shared-world seat's entry URL from `serve.url` + a role's `entry` (relative path or
  * same-origin absolute URL). Returns null when the combination is not a same-origin loopback URL
@@ -646,6 +746,9 @@ function forwardDeclaredWarnings(config) {
     const routesToTerminal = routesToTerminalProduct(config);
     const routesToShared = routesToSharedWorld(config);
     const routesToConcurrent = routesToConcurrentSharedWorld(config);
+    // The external-public plane (a real public deployment as the shared plane) consumes host lanes +
+    // subject.publicTarget; it is only ever the concurrent app-url shape.
+    const routesToExternalPublic = routesToConcurrent && config.subject.source === "app-url";
     const routesToHostedCuaBrowser = config.execution?.target === "e2b-desktop"
         && routesToCua;
     for (const [index, actor] of config.actors.entries()) {
@@ -653,6 +756,10 @@ function forwardDeclaredWarnings(config) {
         if (actor.lanes?.some((lane) => lane.entry !== undefined) && !routesToShared) {
             inert.push(`actors[${index}].lanes[].entry (the per-role loopback entry is a shared-world capability; needs subject.topology: shared-world)`);
         }
+        // The host-seat marker acts ONLY on the external-public shared-world route; inert elsewhere.
+        if (actor.lanes?.some((lane) => lane.host === true) && !routesToExternalPublic) {
+            inert.push(`actors[${index}].lanes[].host (the designated host-seat marker; needs the external-public shared-world route: app-url × topology shared-world × allowPublicTargets × concurrency > 1)`);
+        }
         if (routesToCua || routesToTerminal) {
             // The cua + terminal routes consume mission/persona/model + laneFocus.instruction (they
             // compose the agent prompt + bundle provenance); laneFocus.id/label remain inert. On the
@@ -705,6 +812,11 @@ function forwardDeclaredWarnings(config) {
     if (config.subject.state?.checkpoint !== undefined && !routesToShared) {
         inert.push("subject.state.checkpoint (the shared-world state-checkpoint probe; needs subject.topology: shared-world)");
     }
+    // publicTarget (the external-public ownership attestation) acts ONLY on the external-public
+    // shared-world route; inert elsewhere. (It is already parse-rejected on non-app-url sources.)
+    if (config.subject.publicTarget !== undefined && !routesToExternalPublic) {
+        inert.push("subject.publicTarget (the external-public ownership attestation; needs the external-public shared-world route: app-url × topology shared-world × allowPublicTargets × concurrency > 1)");
+    }
     // exposure (the synthetic-subject attestation) acts ONLY on the CONCURRENT shared-world route
     // (the getHost-exposed plane); inert on the sequential shared-world route (loopback) and elsewhere.
     if (config.subject.exposure !== undefined && !routesToConcurrent && !(routesToScripted && config.subject.source === "clone")) {
@@ -848,6 +960,11 @@ function parseSubject(raw) {
     if (source !== "local-tree" && raw.localTree !== undefined) {
         return invalid("`subject.localTree` applies only to local-tree subjects (keep/exclude/maxArchiveBytes for packing the working tree).");
     }
+    // publicTarget is app-url-ONLY (the external-public shared-world ownership attestation). It is
+    // meaningless without a real public deployment as the plane — reject it elsewhere (invariant 6).
+    if (source !== "app-url" && raw.publicTarget !== undefined) {
+        return invalid("`subject.publicTarget` applies only to app-url subjects on the external-public shared-world route (the operator's ownership attestation for a real public deployment used directly as the shared plane).");
+    }
     if (source === "clone") {
         const repos = strList(raw.repos);
         if (!repos || repos.length === 0) {
@@ -950,6 +1067,15 @@ function parseSubject(raw) {
             return invalid("`subject.appUrl` must be an http(s) URL.");
         }
         subject.appUrl = appUrl;
+        // publicTarget (external-public shared-world ownership attestation) is app-url-only. Shape it
+        // here; its REQUIRED-on-that-route semantics live in externalPublicSharedWorldValidationReason.
+        if (source === "app-url" && raw.publicTarget !== undefined) {
+            const publicTargetResult = parsePublicTarget(raw.publicTarget);
+            if (!publicTargetResult.ok) {
+                return publicTargetResult;
+            }
+            subject.publicTarget = publicTargetResult.value;
+        }
     }
     if (source === "terminal-product") {
         const productResult = parseProduct(raw.product);
@@ -960,6 +1086,24 @@ function parseSubject(raw) {
     }
     return { ok: true, value: subject };
 }
+// The publicTarget.owner is a public-safe operator/repo label surfaced in evidence (e.g.
+// "danielgwilson/cineguessr" or a bare org name). Slash allowed for the owner/repo convention.
+const PUBLIC_TARGET_OWNER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_./-]*$/;
+/** Parse the external-public shared-world ownership attestation ({ owner, authorized: true }). The
+ *  harness cannot verify ownership — this is author-trust, surfaced honestly in the evidence class. */
+function parsePublicTarget(raw) {
+    if (!isRecord(raw)) {
+        return invalid("`subject.publicTarget` must be an object ({ owner, authorized: true }) — the operator's ownership attestation for the external-public shared plane.");
+    }
+    const owner = str(raw.owner);
+    if (!owner || !PUBLIC_TARGET_OWNER_PATTERN.test(owner)) {
+        return invalid("`subject.publicTarget.owner` must be a public-safe operator/repo label (e.g. owner/repo); it is recorded in evidence, so it must carry no secret.");
+    }
+    if (raw.authorized !== true) {
+        return invalid("`subject.publicTarget.authorized` must be true — you must attest you own/operate the public deployment used as the shared plane (author-trust; the harness cannot verify ownership).");
+    }
+    return { ok: true, value: { owner, authorized: true } };
+}
 // The product name interpolates into evidence labels and the composed prompt; the public-safe
 // token shape is the same load-bearing constraint as a lab id.
 const PRODUCT_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
@@ -1438,6 +1582,15 @@ function parseLanes(raw, actorIndex) {
         const laneEntry = str(entry.entry);
         if (laneEntry !== undefined)
             lane.entry = laneEntry;
+        // `host` marks the designated host seat on the external-public shared-world route; the
+        // exactly-one-host check runs in externalPublicSharedWorldValidationReason (route context).
+        if (entry.host !== undefined) {
+            if (typeof entry.host !== "boolean") {
+                return invalid(`actors[${actorIndex}].lanes[${laneIndex}].host must be a boolean (marks the designated host seat on the external-public shared-world route).`);
+            }
+            if (entry.host)
+                lane.host = true;
+        }
         lanes.push(lane);
     }
     return { ok: true, value: lanes };