humanish 0.107.0 → 0.109.0

package/dist/cli/renamed-options.js

@@ -1,18 +0,0 @@
-// Options renamed in this minor keep their older name for one more minor, so a skill installed
-// before the rename still runs. The older name is hidden from --help, sets the same value and
-// prints one stderr line naming the new name. Each command reads its options through these
-// functions once, at the top of its action, so one invocation prints the line once.
-function renamedOption(io, name, value, olderName, olderValue) {
-    if (olderValue !== undefined) {
-        io.writeErr(`warning: --${olderName} is deprecated and is removed in the next minor. Use --${name}.\n`);
-    }
-    return value ?? olderValue;
-}
-/** `--participants`, or `--lanes` when only the older spelling is set. */
-export function participantsOption(io, options) {
-    return renamedOption(io, "participants", options.participants, "lanes", options.lanes);
-}
-/** `--count`, or `--sims` when only the older spelling is set. */
-export function countOption(io, options) {
-    return renamedOption(io, "count", options.count, "sims", options.sims);
-}

package/dist/lab/composition-rules.d.ts

@@ -1,7 +0,0 @@
-import type { LabConfig } from "./types.js";
-/** The first composition rule a config breaks, in the parser's order, or null. */
-export declare function compositionReason(config: LabConfig): string | null;
-/** Why a this-repo lab cannot run live. The parser and the preview planner both refuse with it. */
-export declare const THIS_REPO_DRY_RUN_ONLY = "this-repo labs are dry-run only; use a clone or app-url subject for a live run.";
-/** A desktop-cli subject with no product to study. The computer-use planner checks this too. */
-export declare function desktopCliProductReason(config: LabConfig): string | null;

package/dist/lab/config.d.ts

@@ -1,7 +0,0 @@
-import { type LabConfigParseResult } from "./types.js";
-/**
- * Validate a parsed YAML object into a LabConfig. Pure: the caller owns file IO. Structural
- * validation only. Fields the engine does not yet consume are accepted but reported in
- * `warnings` so `lab inspect` never silently swallows a setting that does nothing.
- */
-export declare function parseLabConfig(raw: unknown): LabConfigParseResult;

package/dist/lab/discover.d.ts

@@ -1,65 +0,0 @@
-import type { ActorPersonaRef } from "../actors/contract.js";
-import { type LabConfig } from "./types.js";
-declare const LAB_LIST_SCHEMA = "humanish.lab-list.v1";
-declare const LAB_INSPECT_SCHEMA = "humanish.lab-inspect.v1";
-type LabOrigin = "committed" | "ignored" | "explicit";
-interface ResolvedLabConfig {
-    config: LabConfig;
-    origin: LabOrigin;
-    path: string;
-    warnings: string[];
-}
-export interface LabResolveFailure {
-    ok: false;
-    cwd: string;
-    lab: string;
-    error: {
-        code: "HUMANISH_LAB_NOT_FOUND" | "HUMANISH_LAB_INVALID";
-        message: string;
-    };
-    warnings: string[];
-}
-export type LabResolveResult = ({
-    ok: true;
-} & ResolvedLabConfig) | LabResolveFailure;
-export interface LabListEntry {
-    id: string;
-    source: LabConfig["subject"]["source"];
-    origin: LabOrigin;
-    path: string;
-    title?: string;
-    /**
-     * The manifest's own first sentence. The list is where someone decides which study to open, and a
-     * list of names cannot answer "what is this one" for a project with twenty labs in it — the
-     * stakeholder feedback that added this was, verbatim, "so i know wtf they are".
-     */
-    description?: string;
-}
-export interface LabListResult {
-    schema: typeof LAB_LIST_SCHEMA;
-    ok: true;
-    cwd: string;
-    labs: LabListEntry[];
-    warnings: string[];
-}
-export interface LabInspectResult {
-    /** Persona context only, before route instructions and runtime grants. */
-    personas?: Array<{
-        id: string;
-        resolved: boolean;
-        brief?: ActorPersonaRef["brief"];
-    }>;
-    schema: typeof LAB_INSPECT_SCHEMA;
-    ok: boolean;
-    cwd: string;
-    lab: string;
-    config?: LabConfig;
-    origin?: LabOrigin;
-    path?: string;
-    error?: LabResolveFailure["error"];
-    warnings: string[];
-}
-export declare function resolveLabManifest(cwd: string, lab: string): Promise<LabResolveResult>;
-export declare function listLabManifests(cwd: string): Promise<LabListResult>;
-export declare function inspectLabManifest(cwd: string, lab: string): Promise<LabInspectResult>;
-export {};

package/dist/lab/init-templates.js

@@ -1,416 +0,0 @@
-export const DEFAULT_LOCAL_BROWSER_STARTER = {
-    appUrl: "http://127.0.0.1:3000",
-    mission: "Use the app's primary flow. Explain anything confusing and stop when the task is complete or you are stuck.",
-};
-function localBrowserLab(starter = DEFAULT_LOCAL_BROWSER_STARTER) {
-    return {
-        path: "humanish/labs/local-browser.yaml",
-        plane: "source",
-        contents: `schema: humanish.lab.v2
-id: local-browser
-title: Local browser · your app · Codex account
-description: >-
-  Run a Codex-account participant in an isolated local browser against your loopback app—no E2B
-  or OpenAI API key. Inference is remote and uses account quota. Before the first live run, use
-  humanish doctor --lab local-browser to check the supported Codex login and local runtime.
-subject:
-  source: app-url
-  appUrl: ${JSON.stringify(starter.appUrl)}
-actors:
-  - type: local-agent
-    localAgent: codex
-    persona: synthetic-new-user
-    mission: ${JSON.stringify(starter.mission)}
-execution:
-  target: local
-  concurrency: 1
-  timeoutMs: 120000
-scenario:
-  mode: live
-defaults:
-  open: true
-`,
-    };
-}
-/**
- * The flagship live lab. A ChatGPT-account Codex participant has no API-dollar price, so preflight
- * refuses a dollar cap on it (HUMANISH_CUA_LAB_UNPRICED_CAP); that variant is bounded by the
- * session timeout instead of a cap it could never enforce.
- */
-function tryLiveLab(actor, localAgent = "codex") {
-    const account = actor === "local-agent";
-    const cost = account
-        ? `  WHAT IT COSTS: one participant, one small task, a few E2B desktop minutes and your Codex
-  account's usage. Account usage has no dollar price humanish can enforce, so the ten-minute
-  session limit below bounds the run.`
-        : `  WHAT IT COSTS: one participant, one small task, and a $2 cap on estimated model spend. The
-  run stops before its next model request once the estimate passes $2, so the last request can take
-  it slightly over. Hosted desktop time is billed separately.`;
-    const participant = account
-        ? `  # Your machine has a coding agent signed in, so this lab uses it: no provider API key,
-  # only E2B. To use a provider key instead, swap to \`type: openai-computer-use\` and add
-  # execution.caps.maxUsd.
-  - type: local-agent
-    localAgent: ${localAgent}`
-        : `  - type: openai-computer-use
-    # Bounds each model reply. Under the cap below it also bounds what a stalled or lost request
-    # can cost, so the run can retry it instead of stopping.
-    maxOutputTokens: 8192`;
-    const bound = account
-        ? "  timeoutMs: 600000 # bounds the run; a dollar cap cannot be enforced on account usage"
-        : `  timeoutMs: 600000
-  caps:
-    maxUsd: 2 # estimated model spend; the run stops before its next request once it passes this`;
-    return {
-        path: "humanish/labs/try-live.yaml",
-        plane: "source",
-        contents: `schema: humanish.lab.v2
-id: try-live
-title: Your first REAL study — one participant, a real app, a hosted desktop
-description: >-
-  This lab runs live out of the box, on purpose. Every other starter file here is a template you
-  have to fill in first, and a first live run that cannot succeed is where most people stop.
-  THE SUBJECT IS A DEMO, NOT YOUR APP: it clones drawDB, a real public open-source diagram editor,
-  and serves it inside the sandbox. That is what makes this runnable with nothing to configure.
-  Once you have watched it work, point subject at your own app (see humanish/labs/cua-browser.yaml
-  for the shape) — that is the study you actually want.
-${cost}
-  WHAT A GOOD RESULT LOOKS LIKE: not necessarily a pass. A participant who gets stuck and says so
-  is the most useful thing this tool produces — humanish will refuse to call that a credible pass,
-  on purpose, and the friction they describe is the finding. A first run that ends in "I could not
-  do it, and here is where I got lost" worked exactly as intended.
-subject:
-  source: clone
-  repos:
-    - drawdb-io/drawdb
-  clone:
-    depth: 1
-  serve:
-    # Plain npm — humanish provides the Node runtime the stock desktop image does not ship.
-    install: npm install --no-audit --no-fund
-    build: npm run build
-    start: npx vite preview --host 127.0.0.1 --port 3000
-    url: http://127.0.0.1:3000/
-actors:
-${participant}
-    persona: synthetic-new-user
-    mission: >-
-      You have never seen this diagram tool before. Add two tables and give them meaningful names,
-      then stop and say what you did, what confused you, and where you hesitated.
-execution:
-  target: e2b-desktop
-${bound}
-scenario:
-  mode: live # the point of this lab — the others start as dry-run
-defaults:
-  open: true
-`,
-    };
-}
-export const starterFiles = [
-    {
-        path: "humanish/README.md",
-        plane: "source",
-        contents: `# humanish
-
-This directory is the committed source of persona simulation intent for this app.
-
-Keep this directory public-safe:
-
-- synthetic personas only;
-- synthetic fixtures only;
-- env var names only, never values;
-- no PII, PHI, secrets, raw private transcripts, private screenshots, customer data, or patient data.
-
-Generated run bundles, screenshots, traces, logs, and local overrides belong in ignored \`.humanish/\`.
-
-Labs:
-
-- committed reusable labs live in humanish/labs/*.yaml;
-- private or machine-local labs live in ignored .humanish/labs/*.yaml or .humanish/local/labs/*.yaml;
-- run a lab with \`humanish watch <lab>\` or \`humanish lab run <lab>\`.
-
-Format standard:
-
-- human-authored humanish source uses .yaml;
-- generated artifacts, synthetic fixtures, and event streams use .json or .ndjson;
-- .yml is reserved for outside ecosystem files such as GitHub Actions, not humanish source.
-`,
-    },
-    {
-        path: "humanish/personas/synthetic-new-user.yaml",
-        plane: "source",
-        contents: `schema: humanish.persona.v1
-id: synthetic-new-user
-name: Synthetic New User
-summary: A privacy-safe first-time user evaluating the app with realistic but synthetic needs.
-traits:
-  patience: medium
-  technical_confidence: medium
-constraints:
-  - Do not use real personal data.
-  - Do not use production accounts.
-  - Treat all credentials as env var names only.
-`,
-    },
-    {
-        path: "humanish/personas/skeptical-power-user.yaml",
-        plane: "source",
-        contents: `schema: humanish.persona.v1
-id: skeptical-power-user
-name: Skeptical Power User
-summary: A privacy-safe experienced user looking for speed, reversibility, and clear proof.
-traits:
-  patience: low
-  technical_confidence: high
-  accessibility_needs: keyboard_first
-constraints:
-  - Do not use real personal data.
-  - Prefer synthetic fixture inputs.
-  - Flag unclear recovery paths.
-`,
-    },
-    {
-        path: "humanish/scenarios/first-run-smoke.yaml",
-        plane: "source",
-        contents: `schema: humanish.scenario.v1
-id: first-run-smoke
-title: First-run smoke
-persona: synthetic-new-user
-goal: Reach the first meaningful product state without using private data.
-mode: dry-run
-steps:
-  - name: Open the app
-    expectation: The app shell is reachable.
-  - name: Complete the first synthetic action
-    expectation: The user sees a clear next state.
-  - name: Capture review notes
-    expectation: Notes are public-safe and evidence-backed.
-`,
-    },
-    {
-        path: "humanish/scenarios/onboarding-regression.yaml",
-        plane: "source",
-        contents: `schema: humanish.scenario.v1
-id: onboarding-regression
-title: Onboarding regression
-persona: skeptical-power-user
-goal: Exercise onboarding friction using synthetic inputs and explicit recovery checks.
-mode: dry-run
-steps:
-  - name: Start onboarding
-    expectation: Required information is clear.
-  - name: Use synthetic fixture data
-    expectation: No real user data is entered.
-  - name: Check recovery path
-    expectation: The user can back out or retry safely.
-`,
-    },
-    {
-        path: "humanish/labs/first-run.yaml",
-        plane: "source",
-        contents: `schema: humanish.lab.v2
-id: first-run
-title: First-run synthetic Observer
-description: Public-safe starter lab that generates a synthetic run bundle and Observer without provider spend.
-subject:
-  source: this-repo
-actors:
-  - type: synthetic-persona
-    count: 4
-scenario:
-  mode: dry-run
-defaults:
-  open: true
-`,
-    },
-    tryLiveLab("openai-computer-use"),
-    localBrowserLab(),
-    {
-        path: "humanish/labs/cua-browser.yaml",
-        plane: "source",
-        contents: `schema: humanish.lab.v2
-id: cua-browser
-title: Computer-use browser lab
-description: >-
-  A registered computer-use actor drives your app in a hosted desktop browser and emits an
-  evidence bundle into gitignored .humanish/. Screenshots are full-fidelity (raw) by default;
-  set policies.redactScreenshots: true to blur at capture for a share-as-is bundle. Typed
-  text is recorded as length only. Dry-run by default; switch scenario.mode to live (with
-  OPENAI_API_KEY + E2B_API_KEY via --env-file) for a real session. The clone subject below
-  serves your repo INSIDE the sandbox; declared subject env NAMES are provisioned from
-  --env-file (values are never persisted).
-subject:
-  source: clone
-  repos: [your-org/your-app]
-  serve:
-    install: pnpm install --frozen-lockfile
-    build: pnpm build
-    start: pnpm start
-    url: http://127.0.0.1:3000/
-    # installTimeoutMs: 1200000   # bump for monorepo-scale installs/builds (default 600000)
-    # buildTimeoutMs: 1800000
-  # env: [DATABASE_URL]
-  # state:                        # the subject's STATE story (recorded as provenance):
-  #   seed:                       # ordered, bounded seed/migration/fixture steps (commands are
-  #     - name: db-up             # author-trusted; evidence records sha256 digests, never text)
-  #       command: sudo service postgresql start && pg_isready -t 30
-  #       when: before-start      # before-build | before-start (default) | after-ready
-  #     - name: db-migrate
-  #       command: pnpm prisma migrate deploy
-  #       timeoutMs: 300000       # per-step budget (default 300000)
-  #     - name: admin-user        # after-ready steps run against the RUNNING app
-  #       command: curl -sf -X POST http://127.0.0.1:3000/api/test/bootstrap-admin
-  #       when: after-ready
-  #   # Or point at a shared DB you do NOT control — recorded as UNPINNED in provenance;
-  #   # each name must also be declared in subject.env:
-  #   # external: [DATABASE_URL]
-  # clone:
-  #   keep: true                  # leave the sandbox up on FAILURE so you can debug install/boot
-  # Alternative: drive a deployment you own (Vercel preview, staging) instead of a clone:
-  # source: app-url
-  # appUrl: https://your-preview.vercel.app/
-actors:
-  - type: openai-computer-use
-    persona: first-time-visitor
-    mission: >-
-      Explore the app as a brand-new user trying to complete its primary flow. Note anything
-      confusing. Stop when the flow completes or you are stuck.
-execution:
-  target: e2b-desktop
-  # 20 minutes: a session should end because the participant finished, not because a timer fired,
-  # so this is as long as the substrate allows rather than as long as seems reasonable. This route
-  # clones, installs, builds and serves the subject before the actor starts, so the sandbox deadline
-  # is this budget PLUS 40 minutes of provisioning and teardown headroom — and a sandbox may not
-  # live longer than 60. Raising this above 20 minutes fails the run closed before it starts; raise
-  # execution.desktop.sandboxTimeoutMs deliberately if you need more.
-  # Spend protection belongs to the dollar caps, not the clock.
-  timeoutMs: 1200000
-  desktop:
-    device: desktop             # mobile | small-mobile | narrow-mobile | tablet | desktop | wide
-    # browser: chrome            # default | chrome | chromium | firefox; concrete values fail closed
-    # Presets size the physical screen; Chrome's window width has a ~500px minimum.
-    # For mobile presets, opt into CSS viewport, touch, DPR and mobile user-agent emulation:
-    # fidelity: { mobileEmulation: true } # Chrome/Chromium only; desktop/tablet lanes unchanged
-    # The bundle records measured screen, page viewport and emulation fidelity separately.
-scenario:
-  mode: dry-run
-# 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/lobby-trivia-3player.yaml",
-        plane: "source",
-        contents: `schema: humanish.lab.v2
-id: lobby-trivia-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: by default Chrome's physical window has a 500px minimum width, no touch
-  emulation and desktop DPR/user-agent behavior. Set execution.desktop.fidelity.mobileEmulation to true
-  to request the mobile preset's CSS viewport, touch, DPR and mobile user agent on Chrome/Chromium.
-  The bundle records measured geometry and emulation fidelity. 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 preset; physical window width floors to 500 (see emulation above)
-        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
-  # PER-SEAT session budget; also caps the host-first handoff deadline. Budget for the WHOLE arc:
-  # seat provisioning + shared-session assembly + actual play. A first live run of the worked
-  # example died at 120000 with every seat expiring mid game and zero mission actions taken.
-  timeoutMs: 420000
-  concurrency: 3 # all 3 seats live at once (the default when omitted); lower only to cap paid desktops
-  # desktop:
-  #   fidelity: { mobileEmulation: true } # opt into mobile CSS viewport, touch, DPR and user agent
-scenario:
-  mode: dry-run # default; the live path opens N real mobile-layout seats against the public app
-defaults:
-  open: true
-`,
-    },
-    {
-        path: "humanish/coverage-map.md",
-        plane: "source",
-        contents: `# Coverage Map
-
-This file should enumerate screens, roles, states, and paths before scenarios are treated as complete.
-
-Current starter coverage is intentionally minimal and synthetic.
-`,
-    },
-    {
-        path: "humanish/coverage-matrix.md",
-        plane: "source",
-        contents: `# Coverage Matrix
-
-| Area | Persona | Happy Path | Sad Path | Status |
-| --- | --- | --- | --- | --- |
-| First run | synthetic-new-user | planned | planned | starter |
-| Onboarding | skeptical-power-user | planned | planned | starter |
-`,
-    },
-];
-export const runtimeDirectories = [
-    { path: ".humanish/runs", plane: "runtime" },
-    { path: ".humanish/cache", plane: "runtime" },
-    { path: ".humanish/tmp", plane: "runtime" },
-    { path: ".humanish/logs", plane: "runtime" },
-    { path: ".humanish/labs", plane: "runtime" },
-    { path: ".humanish/local/labs", plane: "runtime" },
-    { path: ".humanish/local/personas", plane: "runtime" },
-];
-export const humanishScripts = {
-    humanish: "humanish",
-    "humanish:doctor": "humanish doctor",
-    "humanish:run": "humanish run --dry-run",
-    "humanish:watch": "humanish watch",
-    "humanish:watch:ci": "humanish watch --json --no-open",
-    "humanish:verify": "humanish verify",
-};
-/**
- * The starter files, with the live lab written for the brain this machine can use.
- *
- * `local-agent` is not a variant of the lab so much as a different participant: on a machine with
- * a signed-in Codex and no provider key, the study runs with the operator's own agent and needs
- * only E2B. Writing the other one there would hand someone homework instead of a first run.
- */
-export function starterFilesFor(actor, localBrowser = DEFAULT_LOCAL_BROWSER_STARTER, localAgent) {
-    return starterFiles.map((file) => file.path === "humanish/labs/local-browser.yaml"
-        ? localBrowserLab(localBrowser)
-        : file.path === "humanish/labs/try-live.yaml"
-            ? tryLiveLab(actor, localAgent)
-            : file);
-}

package/dist/lab/keys.d.ts

@@ -1,2 +0,0 @@
-/** The first key in `raw` that LAB_KEYS does not list, as an error message; undefined if none. */
-export declare function findUnknownLabKey(raw: unknown): string | undefined;

package/dist/lab/parse/comms.d.ts

@@ -1,12 +0,0 @@
-import type { LabComms, LabCommsEmail, LabCommsRecipient, LabConfigParseFailure } from "../types.js";
-export declare function parseComms(raw: unknown): {
-    ok: true;
-    value: LabComms | undefined;
-} | LabConfigParseFailure;
-/** The participant a declared inbox recipient belongs to. The manifest spells it `lane`. */
-export declare function recipientParticipantId(recipient: LabCommsRecipient): string;
-/** The declared recipients that name an address, in declaration order, by participant id. */
-export declare function addressedRecipients(email: Pick<LabCommsEmail, "recipients">): {
-    participantId: string;
-    address: string;
-}[];

package/dist/lab/parse/execution.d.ts

@@ -1,19 +0,0 @@
-import type { LabConfigParseFailure, LabDefaults, LabExecution, LabPolicies, LabReview, LabScenario } from "../types.js";
-export declare function parseExecution(raw: unknown): {
-    ok: true;
-    value: LabExecution | undefined;
-} | LabConfigParseFailure;
-export declare function parsePersonas(raw: unknown): Record<string, unknown>[] | undefined;
-export declare function parseScenario(raw: unknown): {
-    ok: true;
-    value: LabScenario | undefined;
-} | LabConfigParseFailure;
-export declare function parsePolicies(raw: unknown): {
-    ok: true;
-    value: LabPolicies | undefined;
-} | LabConfigParseFailure;
-export declare function parseReview(raw: unknown): {
-    ok: true;
-    value: LabReview | undefined;
-} | LabConfigParseFailure;
-export declare function parseDefaults(raw: unknown): LabDefaults | undefined;

package/dist/lab/parse/subject-state.d.ts

@@ -1,30 +0,0 @@
-import type { LabConfigParseFailure, LabSubjectState } from "../types.js";
-/**
- * LITERAL non-secret subject env. Real apps need configuration before they will boot — a public base
- * URL, a transport selector, a feature flag — and none of that is secret. Routing it through
- * `subject.env` would force an adopter to carry a private env file just to reproduce a public study.
- *
- * These values ARE recorded in evidence (they are part of how the subject was configured), so a
- * value that looks like a credential is refused here rather than committed to a public repo.
- */
-export declare function parseEnvValues(raw: unknown): {
-    ok: true;
-    value?: Record<string, string>;
-} | LabConfigParseFailure;
-/**
- * Structural parse of `subject.state` into a candidate LabSubjectState. Deliberately keeps
- * unrecognized `when`/`timeoutMs` values in the candidate (instead of silently dropping
- * them) so subjectStateInvalidReason rejects them — a state declaration that silently does
- * less than it says would violate invariant 6.
- */
-export declare function parseState(raw: unknown): {
-    ok: true;
-    value: LabSubjectState | undefined;
-} | LabConfigParseFailure;
-/**
- * Semantic validation for `subject.state`, shared by parseLabConfig and the engine
- * (runCuaActorLab re-enforces it on configs that arrive through the library API). Returns
- * the failure message, or null when the declaration is valid. Reads the candidate
- * defensively — library callers can hand the engine arbitrarily-shaped objects.
- */
-export declare function subjectStateInvalidReason(state: LabSubjectState, env: readonly string[] | undefined): string | null;

package/dist/lab/plan.d.ts

@@ -1,19 +0,0 @@
-import type { InternalRunLabOptions } from "../run-lab.js";
-import type { LabDeps } from "./lab-deps.js";
-import type { PlanResult } from "./plan-types.js";
-import type { LabConfig } from "./types.js";
-/** The five execution paths a lab can take. */
-export type LabRoute = "preview" | "computer-use" | "shared-world" | "terminal" | "scripted";
-/**
- * The route a config takes. It never refuses: a config no route can run still gets the route
- * whose own checks refuse it with the most precise reason.
- */
-export declare function routeOf(config: LabConfig): LabRoute;
-/** Resolve dry-run: explicit override wins, else the scenario mode, else the given fallback. */
-export declare function resolveLabDryRun(config: LabConfig, override: boolean | undefined, fallback: boolean | undefined): boolean | undefined;
-/**
- * The plan a lab runs under, built without reading files, env or the network. Each route's planner
- * makes every refusal that route makes, in the route's order and with its codes and messages; the
- * route's exported runner calls the same planner.
- */
-export declare function planLab(config: LabConfig, options: InternalRunLabOptions, deps?: LabDeps): PlanResult;