humanish 0.110.3 → 0.111.0

package/dist/study/warnings.js

@@ -1,72 +1,54 @@
 import { isComputerUseComposition, isScriptedBrowserComposition, isSharedWorldComposition, isTerminalProductComposition, } from "./routing.js";
 import { declaredParticipantIds } from "./plan-participants.js";
 import { addressedRecipients } from "./parse/comms.js";
-import { focusOf, rosterOf } from "./parse/actors.js";
-// The computer-use and terminal routes consume mission/persona/model and laneFocus.instruction (they
-// compose the agent prompt and bundle provenance); laneFocus.id/label stay inert. On the computer-use
-// E2B route actors[0].lanes is consumed (the fan-out roster).
+import { actorOf, participantList, declaredParticipantCount, scenarioRefOf, } from "./study-fields.js";
+// The computer-use and terminal routes consume mission/persona/model (they compose the agent prompt
+// and bundle provenance).
 const promptRoute = (routes) => routes.cua || routes.terminal;
-// The scripted-browser route consumes persona and count (trace/bundle provenance; surface roster).
-// The prompt fields can never act there: the scripted actor runs no model.
+// The scripted-browser route consumes persona and surfaces (trace/bundle provenance). The prompt
+// fields can never act there: the scripted actor runs no model.
 const scriptedRoute = (routes) => !promptRoute(routes) && routes.scripted;
 const otherRoute = (routes) => !promptRoute(routes) && !routes.scripted;
-/** Rows for each actor, reported as `actors[<index>].<field>`, in this order per actor. */
+/** Rows for the actor and its participants, reported first, in this order. */
 const ACTOR_ROWS = [
     // Shared-world-only fields on the roster: a participant's `entry` is inert anywhere else
     // (claims match mechanism).
     {
-        field: "lanes[].entry",
-        reason: "the per-participant loopback entry is a shared-world capability; needs subject.topology: shared-world",
-        applies: (actor, routes) => Boolean(rosterOf(actor)?.some((entry) => entry.entry !== undefined)) && !routes.shared,
+        field: "participants[].entry",
+        reason: "the per-participant loopback entry is a shared-world capability; needs route: shared-world",
+        applies: (config, routes) => Boolean(participantList(config)?.some((entry) => entry.entry !== undefined)) &&
+            !routes.shared,
     },
     // The host marker acts only on the external-public shared-world route; inert elsewhere.
     {
-        field: "lanes[].host",
+        field: "participants[].host",
         reason: "the designated host-participant marker; needs the external-public shared-world route: app-url × topology shared-world × allowPublicTargets",
-        applies: (actor, routes) => Boolean(rosterOf(actor)?.some((entry) => entry.host === true)) && !routes.externalPublic,
+        applies: (config, routes) => Boolean(participantList(config)?.some((entry) => entry.host === true)) &&
+            !routes.externalPublic,
     },
     {
-        field: "laneFocus.id",
-        applies: (actor, routes) => promptRoute(routes) && Boolean(focusOf(actor)?.id),
-    },
-    {
-        field: "laneFocus.label",
-        applies: (actor, routes) => promptRoute(routes) && Boolean(focusOf(actor)?.label),
-    },
-    {
-        field: "lanes",
-        reason: "only the computer-use route runs more than one participant",
-        applies: (actor, routes) => routes.terminal && Boolean(rosterOf(actor)),
-    },
-    {
-        field: "mission",
+        field: "actor.mission",
         reason: "the scripted-browser actor runs no model",
-        applies: (actor, routes) => scriptedRoute(routes) && Boolean(actor.mission),
+        applies: (config, routes) => scriptedRoute(routes) && Boolean(actorOf(config)?.mission),
     },
     {
-        field: "laneFocus",
+        field: "actor.model",
         reason: "the scripted-browser actor runs no model",
-        applies: (actor, routes) => scriptedRoute(routes) && Boolean(focusOf(actor)),
+        applies: (config, routes) => scriptedRoute(routes) && Boolean(actorOf(config)?.model),
     },
+    // On every other route the prompt fields and persona are inert.
     {
-        field: "model",
-        reason: "the scripted-browser actor runs no model",
-        applies: (actor, routes) => scriptedRoute(routes) && Boolean(actor.model),
+        field: "actor.mission",
+        applies: (config, routes) => otherRoute(routes) && Boolean(actorOf(config)?.mission),
     },
     {
-        field: "lanes",
-        reason: "the scripted-browser route fans out via actors[0].count, not an actors[0].lanes roster",
-        applies: (actor, routes) => scriptedRoute(routes) && Boolean(rosterOf(actor)),
+        field: "actor.persona",
+        applies: (config, routes) => otherRoute(routes) && Boolean(actorOf(config)?.persona),
     },
-    // On every other route the prompt fields, persona and the `lanes[]` roster are inert.
-    { field: "mission", applies: (actor, routes) => otherRoute(routes) && Boolean(actor.mission) },
     {
-        field: "laneFocus",
-        applies: (actor, routes) => otherRoute(routes) && Boolean(focusOf(actor)),
+        field: "actor.model",
+        applies: (config, routes) => otherRoute(routes) && Boolean(actorOf(config)?.model),
     },
-    { field: "persona", applies: (actor, routes) => otherRoute(routes) && Boolean(actor.persona) },
-    { field: "model", applies: (actor, routes) => otherRoute(routes) && Boolean(actor.model) },
-    { field: "lanes", applies: (actor, routes) => otherRoute(routes) && Boolean(rosterOf(actor)) },
 ];
 const TERMINAL_ONLY = "needs subject.source: terminal-product + a registered terminal actor";
 const RESERVED = "reserved; no route reads it yet";
@@ -90,17 +72,10 @@ const CONFIG_ROWS = [
         field: "subject.state",
         applies: (config, routes) => Boolean(config.subject.state) && !routes.cua && !routes.scripted,
     },
-    // topology + checkpoint act only on the shared-world route; a set-but-unconsumed value
-    // (incl. an explicit per-lane-worlds, which the computer-use route already is by mechanism) warns
-    // inert.
-    {
-        field: "subject.topology",
-        reason: "drives behavior only on the shared-world route; needs subject.topology: shared-world + clone × e2b-desktop × a computer-use actor + a roster of ≥2 participants",
-        applies: (config, routes) => config.subject.topology !== undefined && !routes.shared,
-    },
+    // The checkpoint acts only on the shared-world route.
     {
         field: "subject.state.checkpoint",
-        reason: "the shared-world state-checkpoint probe; needs subject.topology: shared-world",
+        reason: "the shared-world state-checkpoint probe; needs route: shared-world",
         applies: (config, routes) => config.subject.state?.checkpoint !== undefined && !routes.shared,
     },
     // publicTarget (the external-public ownership attestation) acts only on the external-public
@@ -160,18 +135,10 @@ const CONFIG_ROWS = [
         field: "execution.concurrency",
         applies: (config, routes) => config.execution?.concurrency !== undefined && !routes.cua,
     },
-    // execution.caps is consumed on the computer-use route (maxUsd is the fail-closed spend abort);
-    // inert (warned) everywhere else so a misplaced budget field is never trusted to cap a route it
-    // cannot.
-    {
-        field: "execution.caps",
-        reason: "only the computer-use route enforces it, with a computer-use actor on e2b-desktop",
-        applies: (config, routes) => Boolean(config.execution?.caps) && !routes.cua,
-    },
-    // terminal-product consumes subject.product, scenario.caps, execution.{terminal,runtimeAuth}:
-    // dry-run records the contract; live execution enforces caps and command-scoped auth. On every
-    // other route they are inert and must warn so a
-    // misplaced safety/budget field is never trusted to do something it cannot.
+    // parse/front.ts refuses a `caps` key the declared route does not read, so no row lists `caps`.
+    // terminal-product consumes subject.product and execution.{terminal,runtimeAuth}: dry-run records
+    // the contract; live execution enforces command-scoped auth. On every other route they are inert
+    // and must warn so a misplaced safety field is never trusted to do something it cannot.
     {
         field: "subject.product",
         reason: "needs subject.source: terminal-product or desktop-cli with the matching actor",
@@ -179,18 +146,6 @@ const CONFIG_ROWS = [
             !routes.terminal &&
             config.subject.source !== "desktop-cli",
     },
-    {
-        field: "scenario.caps",
-        reason: TERMINAL_ONLY,
-        applies: (config, routes) => Boolean(config.scenario?.caps) && !routes.terminal,
-    },
-    // The study-level budget is a CUA-route capability; the terminal route is a single agent whose
-    // maxUsd already caps the whole run, so a maxTotalUsd there would be trusted and unenforced.
-    {
-        field: "scenario.caps.maxTotalUsd",
-        reason: "the study-level budget is a computer-use route capability; the terminal route's maxUsd already caps the whole run",
-        applies: (config, routes) => config.scenario?.caps?.maxTotalUsd !== undefined && routes.terminal,
-    },
     {
         field: "execution.terminal",
         reason: TERMINAL_ONLY,
@@ -246,13 +201,12 @@ const CONFIG_ROWS = [
         reason: "no current route reads it",
         applies: (config) => config.execution?.desktop?.codexAppServer !== undefined,
     },
-    // scenario.ref is consumed on the scripted-browser route (required there); forward-declared
+    // `scenario` is consumed on the scripted-browser route (required there); forward-declared
     // everywhere else.
     {
-        field: "scenario.ref",
-        applies: (config, routes) => Boolean(config.scenario?.ref) && !routes.scripted,
+        field: "scenario",
+        applies: (config, routes) => Boolean(scenarioRefOf(config)) && !routes.scripted,
     },
-    { field: "scenario.inline", applies: (config) => Boolean(config.scenario?.inline) },
     // review.{scoring,milestones,vocabulary} stay forward-declared on every route.
     // review.scorer is consumed (loaded + wired, or fail-closed at load) on every scorer-capable
     // route, so it does not warn there; on the scripted-browser route the actor carries no scorer seam,
@@ -277,7 +231,6 @@ const CONFIG_ROWS = [
         reason: "the scripted-browser actor has no adopter-scorer seam; declare it on a terminal / computer-use / shared-world route",
         applies: (config, routes) => Boolean(config.review?.scorer) && routes.scripted,
     },
-    { field: "personas", applies: (config) => Boolean(config.personas) },
 ];
 function routesOf(config) {
     const cua = isComputerUseComposition(config);
@@ -294,44 +247,23 @@ function routesOf(config) {
             config.execution?.target === "e2b-desktop",
     };
 }
-function rowLabel(row, prefix = "") {
-    return row.reason === undefined
-        ? `${prefix}${row.field}`
-        : `${prefix}${row.field} (${row.reason})`;
+function inertRows(config) {
+    const routes = routesOf(config);
+    return [...ACTOR_ROWS, ...CONFIG_ROWS].filter((row) => row.applies(config, routes));
 }
 /**
- * The fields a config sets that its route does not read, each as `field` or `field (reason)`. A v2
- * file gets them as one warning; a v3 study is refused for any of them.
+ * The fields a config sets that its route does not read, each as `field` or `field (reason)`.
+ * parseStudy refuses a study for any of them.
  */
 export function inertFieldLabels(config) {
-    const routes = routesOf(config);
-    const inert = [];
-    for (const [index, actor] of config.actors.entries()) {
-        for (const row of ACTOR_ROWS)
-            if (row.applies(actor, routes))
-                inert.push(rowLabel(row, `actors[${index}].`));
-    }
-    for (const row of CONFIG_ROWS)
-        if (row.applies(config, routes))
-            inert.push(rowLabel(row));
-    return inert;
+    return inertRows(config).map((row) => row.reason === undefined ? row.field : `${row.field} (${row.reason})`);
 }
 /**
  * The same fields as `inertFieldLabels`, as paths without their reasons, such as
- * `actors[0].lanes[].entry` or `execution.timeoutMs`. `humanish migrate` drops each one.
+ * `participants[].entry` or `execution.timeoutMs`. `humanish migrate` drops each one.
  */
 export function inertFieldPaths(config) {
-    const routes = routesOf(config);
-    const paths = [];
-    for (const [index, actor] of config.actors.entries()) {
-        for (const row of ACTOR_ROWS)
-            if (row.applies(actor, routes))
-                paths.push(`actors[${index}].${row.field}`);
-    }
-    for (const row of CONFIG_ROWS)
-        if (row.applies(config, routes))
-            paths.push(row.field);
-    return paths;
+    return inertRows(config).map((row) => row.field);
 }
 // Report fields that are present but not yet consumed by the engine, so a user never trusts a
 // setting that silently does nothing.
@@ -347,7 +279,7 @@ export function forwardDeclaredWarnings(config) {
     // and the cap delivers waves of M. Say so up front (inspect + dry-run + run): a green run in
     // waves is otherwise indistinguishable from the all-live run the author meant.
     {
-        const participantCount = rosterOf(config.actors[0])?.length ?? config.actors[0]?.count ?? 1;
+        const participantCount = participantList(config)?.length ?? declaredParticipantCount(config) ?? 1;
         const cap = config.execution?.concurrency;
         if (routes.cua && cap !== undefined && participantCount > 1 && cap < participantCount) {
             warnings.push(`execution.concurrency ${cap} caps a ${participantCount}-participant roster: participants run in waves of ${cap}, never all live at once. Remove execution.concurrency (the default runs all ${participantCount} participants simultaneously) or set it to ${participantCount}; declare a lower cap only to bound simultaneous paid desktops.`);

package/dist/substrates/local/runtime-config.js

@@ -1,23 +1,24 @@
-import { rosterOf } from "../../study/parse/actors.js";
+import { actorOf, capsOf, participantList } from "../../study/study-fields.js";
 // The runtime image enforces a 30-minute lifetime; reserve setup/teardown room.
 export const LOCAL_BROWSER_LIFETIME_MS = 30 * 60_000;
 const MAX_SESSION_MS = 20 * 60_000;
 export function isLocalBrowserStudy(config) {
     return (config.subject.source === "app-url" &&
         config.execution?.target === "local" &&
-        ["local-agent", "openai-computer-use"].includes(config.actors[0]?.type ?? ""));
+        ["local-agent", "openai-computer-use"].includes(actorOf(config)?.type ?? ""));
 }
 /** Defaults for the explicitly selected local substrate; hosted configurations are untouched. */
 export function localBrowserDefaults(config) {
-    if (!isLocalBrowserStudy(config))
+    const actor = actorOf(config);
+    if (!isLocalBrowserStudy(config) || actor === undefined)
         return config;
     return {
         ...config,
-        actors: config.actors.map((actor) => ({
+        actor: {
             ...actor,
             model: actor.model ?? "gpt-6-astra",
             reasoningEffort: actor.reasoningEffort ?? "low",
-        })),
+        },
         execution: {
             ...config.execution,
             timeoutMs: config.execution?.timeoutMs ?? MAX_SESSION_MS,
@@ -26,19 +27,18 @@ export function localBrowserDefaults(config) {
                 resolution: config.execution?.desktop?.resolution ?? [960, 720],
             },
         },
-        ...(config.review?.analysis === undefined && config.actors[0]?.type === "local-agent"
+        ...(config.review?.analysis === undefined && actor.type === "local-agent"
             ? { review: { ...config.review, analysis: { provider: "codex" } } }
             : {}),
     };
 }
 export function localBrowserUnsupportedReason(config) {
-    const actor = config.actors[0];
+    const actor = actorOf(config);
     const desktop = config.execution?.desktop;
     if ((config.execution?.timeoutMs ?? MAX_SESSION_MS) > MAX_SESSION_MS) {
         return "Local browser sessions currently support at most 20 minutes, within the runtime's 30-minute lifetime.";
     }
-    if (config.actors.length !== 1 ||
-        !actor ||
+    if (!actor ||
         (actor.type === "local-agent" && actor.localAgent !== undefined && actor.localAgent !== "codex")) {
         return "Local browser studies support only Codex local-agent or openai-computer-use participants.";
     }
@@ -46,7 +46,7 @@ export function localBrowserUnsupportedReason(config) {
         desktop.resolution[1] !== 720 ||
         desktop.device !== undefined ||
         (desktop.browser !== undefined && !["default", "chromium"].includes(desktop.browser)) ||
-        rosterOf(actor)?.some((entry) => entry.device !== undefined) ||
+        participantList(config)?.some((entry) => entry.device !== undefined) ||
         desktop.template !== undefined ||
         desktop.sandboxTimeoutMs !== undefined) {
         return "The local browser runtime currently uses a 960×720 Chromium desktop. Omit hosted templates, device presets and sandboxTimeoutMs.";
@@ -61,17 +61,15 @@ export function localBrowserUnsupportedReason(config) {
     if (actor.type === "local-agent" &&
         (actor.model !== "gpt-6-astra" ||
             actor.reasoningEffort !== "low" ||
-            rosterOf(actor)?.some((entry) => entry.reasoningEffort !== undefined && entry.reasoningEffort !== "low") ||
+            participantList(config)?.some((entry) => entry.reasoningEffort !== undefined && entry.reasoningEffort !== "low") ||
             actor.maxOutputTokens !== undefined ||
-            config.execution?.caps?.maxUsd !== undefined ||
-            config.execution?.caps?.maxTotalUsd !== undefined ||
-            config.scenario?.caps?.maxUsd !== undefined ||
-            config.scenario?.caps?.maxTotalUsd !== undefined)) {
+            capsOf(config)?.maxUsd !== undefined ||
+            capsOf(config)?.maxTotalUsd !== undefined)) {
         return "Local Codex participants currently use gpt-6-astra at low effort. Account dollar/output-token caps are unavailable; use API participants for those controls.";
     }
     for (const target of [
         config.subject.appUrl,
-        ...(rosterOf(actor) ?? []).map((entry) => entry.target),
+        ...(participantList(config) ?? []).map((entry) => entry.target),
     ].filter(Boolean)) {
         let url;
         try {