humanish 0.107.0 → 0.109.0

package/CONTRIBUTING.md

@@ -1,148 +0,0 @@
-# Contributing
-
-Thanks for helping make humanish better.
-
-## Read these in order
-
-1. [README.md](README.md): what humanish does and how a user runs a study.
-2. This file: the ground rules, the commands and what a pull request needs.
-3. [ARCHITECTURE.md](ARCHITECTURE.md): `humanish run <lab>` traced through the code, the code map
-   and the invariants a change must keep.
-4. [CONTEXT.md](CONTEXT.md): the domain terms and the field spellings that map to them.
-5. [docs/ramp/README.md](docs/ramp/README.md), for depth: current state, how to pick work and the
-   quality bar.
-
-[docs/README.md](https://github.com/danielgwilson/humanish/blob/main/docs/README.md) sorts the rest of `docs/` into guides, reference, design records
-and history.
-
-## Ground Rules
-
-- Follow [engineering principles](docs/principles/engineering.md): prefer simple,
-  idiomatic implementations and reuse established components. Validate the changed
-  behavior and material risks; keep required CI and release gates.
-- Keep examples synthetic and public-safe.
-- Do not commit `.env*`, `.npmrc`, `.humanish/`, generated run bundles, provider
-  credentials, private screenshots, raw transcripts, or customer data.
-- Prefer small PRs with explicit proof commands.
-- Keep a target product's page names, milestones, and vocabulary in adapters.
-- For changes to credentials, provider spend, hosted execution or GitHub mutation,
-  state the relevant authority and failure boundaries. Use dry runs where useful;
-  they do not establish live behavior.
-
-## Local Setup
-
-Use Node.js 22.19 or newer and pnpm 12; `packageManager` in `package.json` pins the pnpm version.
-
-```bash
-pnpm install --frozen-lockfile # as CI installs
-pnpm vitest run tests/<file>   # while editing: one test file, a few seconds
-pnpm docs:check                # after editing a doc: paths, anchors, symbols, the CLI reference
-pnpm format                    # oxfmt; run before every commit
-pnpm release:check             # once before pushing: the gate CI's test job runs
-```
-
-`release:check` runs `pnpm check` (format, lint, knip, the prose and vocabulary caps, typecheck,
-the test suites, build and the startup proofs), then `api:proof`, `public-surface:scan`,
-`skill:check` and `npm pack --dry-run`. On a 16-core Linux machine it takes about 6 minutes, 4 of
-them in `pnpm check`. The test step prints nothing for a few minutes while it runs. `skill:check`
-calls `npx skills`, so it needs network access.
-
-CI (`.github/workflows/ci.yml`) runs six jobs on every pull request and every push to `main`:
-
-| Job                          | What it runs                                                                                                                       |
-| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| `test` (Node 22.19.0 and 24) | `pnpm release:check`                                                                                                               |
-| `site`                       | `pnpm docs:check`, then the site's typecheck, `registry:check` and build                                                           |
-| `observer`                   | `pnpm build`, the Observer's typecheck and tests, `pnpm browser-control:proof` and the four `observer:*:proof` scripts in Chromium |
-| `tui`                        | The TUI's typecheck and tests                                                                                                      |
-| `guest-desktop`              | Builds the guest image and runs `pnpm guest-desktop:proof`, only when guest files change                                           |
-| `secret-scan`                | gitleaks over the full git history                                                                                                 |
-
-Two kinds of change need one more step:
-
-- After changing a CLI option, run `pnpm docs:generate`. `pnpm docs:check` fails on a stale
-  `site/content/docs/cli.mdx`.
-- After changing what `src/index.ts` exports, run `pnpm build`, then `pnpm api:proof --update`, and
-  review the diff to `tests/golden/public-api.json`. `pnpm api:proof` also runs `examples/` against
-  the packed package.
-
-`pnpm format` rewrites files with oxfmt. `pnpm check` fails on unformatted files.
-It also holds three counts to caps in package.json: oxlint warnings (`lint`), prose in `src/`
-comments (`prose:check`: issue references, `FIX-N` tags, all-caps emphasis), and identifiers and
-file names in `src/` outside the exempt contract modules that still say lane, seat, role, sim or
-study (`vocabulary:check`). Each check fails when its count rises above the cap and also when it
-falls below it, so the PR that reduces a count lowers the cap in the same commit; the failure
-message names the flag and the new value. CI's `caps` workflow (`scripts/check-cap-direction.mjs`)
-also fails a PR that raises or removes a cap against the base branch, unless the PR has the
-`raise-cap` label and a `Cap raise:` line in its body that says why. `pnpm lint` prints the warnings
-that already exist, several hundred of them; that is expected. `pnpm knip` fails on unused files,
-dependencies and exports, and on any import cycle.
-
-## Useful Commands
-
-```bash
-pnpm humanish --help
-pnpm humanish watch --json --no-open
-pnpm humanish verify --run latest --json
-pnpm pack:dry-run
-```
-
-## Make your first change
-
-This walkthrough changes the persona id a computer-use participant gets when neither the
-participant nor its actor names one. It runs offline and spends nothing. Two tests pin the id, and
-the steps below update both.
-
-1. Change `FALLBACK_PERSONA_ID` (`src/routes/computer-use/participant-prompt.ts`) from
-   `"cua-operator"` to a new id.
-2. Run `pnpm vitest run tests/routes/computer-use/lane-persona-fallback.test.ts`. It fails because
-   it asserts the old id. Update the assertion once the new id is what you want.
-3. Run `pnpm vitest run tests/routes/computer-use/local-vm.golden.test.ts`. It fails because the
-   local VM golden, `tests/golden/routes/computer-use-local-vm-live.json`, records the persona id.
-   Rerun it with `-u` to rewrite the golden, then check with `git diff tests/golden/` that only
-   the persona id changed.
-4. Run `mkdir -p .humanish/local/labs`, then copy `humanish/labs/dwell-window-todomvc.yaml` to
-   `.humanish/local/labs/walkthrough.yaml`. Change its `id` to `walkthrough` and delete its
-   `persona:` line.
-5. Run `pnpm humanish run walkthrough --dry-run --no-open`. It prints the run id on its `run:`
-   line. Check `persona.id` in `.humanish/runs/<runId>/run.json`.
-6. Run `pnpm humanish verify --run latest`, then `pnpm format` and `pnpm release:check`.
-
-Common changes touch these tests and contracts:
-
-| Change                    | Tests                                                                                                                                                      | Contract or doc to update                                                      |
-| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
-| A lab manifest field      | `tests/lab/config.test.ts`, the route's tests. Its cases pin each lab's warnings, so a new warning fails cases that expect none                            | `docs/contracts/schemas.md`, `site/content/docs/lab-manifests.mdx`             |
-| A CLI option              | the command's tests under `tests/cli/`                                                                                                                     | Run `pnpm docs:generate` to update `site/content/docs/cli.mdx`                 |
-| A `run.json` field        | the route's tests; rerun them with `-u` to update `tests/golden/routes/` and `tests/golden/failures/<route>/`                                              | `docs/contracts/run-bundle.md`                                                 |
-| An actor trace field      | `tests/actors/`, `tests/actors/conformance.test.ts`, then the route goldens with `-u`                                                                      | `docs/contracts/schemas.md#actor-trace`, `docs/architecture/actor-contract.md` |
-| Observer data             | `tests/observer/data-contract.test.ts` with `UPDATE_OBSERVER_DATA_GOLDENS=1`                                                                               | `docs/architecture/observer.md`                                                |
-| Observer UI               | `observer/tests/` and the four `observer:*:proof` scripts                                                                                                  | `observer/AGENTS.md`                                                           |
-| A route's behavior        | the route's folder in `tests/routes/` (the scripted route's main suite is `tests/routes/scripted/route.test.ts`), `tests/lab/task-route-preflight.test.ts` | the support matrix in `docs/ramp/README.md`                                    |
-| An actor                  | `tests/actors/`, `tests/actors/conformance.test.ts`                                                                                                        | `docs/architecture/actor-contract.md`                                          |
-| Redaction or share safety | `tests/evidence/`, `tests/run/transient-comms-secrets.test.ts`                                                                                             | `docs/contracts/policy.md`                                                     |
-| Study analysis            | `tests/analysis/`                                                                                                                                          | `docs/contracts/study-analysis.md`                                             |
-| A public export           | `pnpm build` and `pnpm api:proof` (`--update` to accept)                                                                                                   | `tests/golden/public-api.json`                                                 |
-| An example                | `pnpm build` and `pnpm api:proof`, which runs every example                                                                                                | `examples/README.md`                                                           |
-
-Three folders hold fixtures. `tests/fixtures/` holds test inputs, `humanish/fixtures/` holds the
-synthetic apps this repo's own labs start, and the root `fixtures/` holds synthetic apps and cases
-that several tests and scripts copy, such as `fixtures/minimal-app/`.
-
-### Find the test folders outside the `src/` mirror
-
-Most of `tests/` mirrors `src/`. Six folders sit outside that mirror. `tests/admission/` pins what the CLI and the
-library do when they refuse a lab before a run starts, and `tests/scripts/` tests `scripts/`.
-`tests/surface/` checks the README, the site, `site/public/llms.txt`, the agent skill and the package
-against the shipped CLI. `tests/helpers/`, `tests/fixtures/` and `tests/golden/` hold shared test
-code, inputs and goldens.
-
-## Pull Requests
-
-PRs should include:
-
-- a concise summary;
-- why the design is the simplest adequate option, when adding architectural complexity;
-- proof commands and outcomes;
-- any remaining gaps;
-- confirmation that fixtures and examples are synthetic or redacted.

package/dist/actors/codex/qualified-versions.d.ts

@@ -1,72 +0,0 @@
-/**
- * Codex CLI releases the restricted launcher admits, per host, oldest first. Each qualified
- * release needs a receipt under docs/goals/computer-use-actor/receipts/ that meets
- * docs/architecture/restricted-codex-analysis.md ("Admitting a Codex CLI release"). Removing a
- * release stops new launches; saved bundles stay readable through the separate reader lists in
- * src/actors/contract.ts.
- *
- * A release string is a compatibility check, not binary attestation: the launcher compares what
- * `codex --version`, initialize and thread start report, and a modified binary can report any
- * of them.
- */
-export declare const QUALIFIED_CODEX_CLI_VERSIONS: {
-    readonly "linux-x64": readonly ["0.154.0", "0.157.1", "0.159.2", "0.159.3", "0.160.0"];
-    readonly "darwin-arm64": readonly ["0.154.0"];
-};
-/**
- * The pre-existing admission, not a qualification. Hosted participants on these hosts ran
- * 0.154.0 while it was the only admitted release, and they keep it; no qualification has run
- * on either host, and no later release is admitted there.
- */
-export declare const PREEXISTING_CODEX_CLI_ADMISSIONS: {
-    readonly "linux-arm64": readonly ["0.154.0"];
-    readonly "darwin-x64": readonly ["0.154.0"];
-};
-type QualifiedHost = keyof typeof QUALIFIED_CODEX_CLI_VERSIONS;
-type PreexistingHost = keyof typeof PREEXISTING_CODEX_CLI_ADMISSIONS;
-export type CodexHost = QualifiedHost | PreexistingHost;
-export type AdmittedCodexCliVersion = (typeof QUALIFIED_CODEX_CLI_VERSIONS)[QualifiedHost][number] | (typeof PREEXISTING_CODEX_CLI_ADMISSIONS)[PreexistingHost][number];
-export declare function codexHost(platform: NodeJS.Platform, arch: string): CodexHost | undefined;
-/** Releases that passed qualification on this host; the pre-existing admission is excluded. */
-export declare function qualifiedCodexCliVersions(platform: NodeJS.Platform, arch: string): readonly AdmittedCodexCliVersion[];
-/** Everything the launcher starts on this host: qualified releases or the pre-existing one. */
-export declare function admittedCodexCliVersions(platform: NodeJS.Platform, arch: string): readonly AdmittedCodexCliVersion[];
-/** What a declaration names before the installed CLI is detected: the host's newest release. */
-export declare function defaultCodexCliVersion(platform?: NodeJS.Platform, arch?: string): AdmittedCodexCliVersion;
-/** The version from `codex --version` output (`codex-cli 0.157.1`); any other shape is undefined. */
-export declare function parseCodexCliVersion(stdout: string): string | undefined;
-/**
- * doctor's recovery for an unadmitted CLI: the release it found and where, what this host admits,
- * and how to replace that binary with the newest admitted release.
- */
-export declare function codexVersionRecovery(detected: string | undefined, installation?: CodexInstallation, platform?: NodeJS.Platform, arch?: string): string;
-/**
- * Where the `codex` humanish found was installed, which decides the command that replaces it.
- * `path` is the file on `PATH`.
- */
-export type CodexInstallation = {
-    readonly kind: "project";
-    readonly path: string;
-    readonly project: string;
-} | {
-    readonly kind: "global";
-    readonly path: string;
-} | {
-    readonly kind: "other";
-    readonly path: string;
-};
-/**
- * Classifies the `codex` on `PATH` by the file it resolves to. A project's node_modules/.bin/codex
- * resolving into that project's @openai/codex is project-local, so `npx` runs it before any global
- * install. One inside npm's global prefix (`npm prefix -g`) is global. Anything else, such as
- * Homebrew or a standalone download, is other.
- */
-export declare function classifyCodexInstallation(found: {
-    path: string;
-    resolved: string;
-}, npmGlobalPrefix: string | undefined): CodexInstallation;
-/** One sentence: how to put the newest admitted Codex CLI in place of the one humanish found. */
-export declare function codexInstallAdvice(installation: CodexInstallation | undefined, platform?: NodeJS.Platform, arch?: string): string;
-/** For refusal messages: the admitted releases on this host, or every host when it has none. */
-export declare function describeQualifiedCodexCliVersions(platform?: NodeJS.Platform, arch?: string): string;
-export {};

package/dist/actors/codex/qualified-versions.js

@@ -1,132 +0,0 @@
-import path from "node:path";
-/**
- * Codex CLI releases the restricted launcher admits, per host, oldest first. Each qualified
- * release needs a receipt under docs/goals/computer-use-actor/receipts/ that meets
- * docs/architecture/restricted-codex-analysis.md ("Admitting a Codex CLI release"). Removing a
- * release stops new launches; saved bundles stay readable through the separate reader lists in
- * src/actors/contract.ts.
- *
- * A release string is a compatibility check, not binary attestation: the launcher compares what
- * `codex --version`, initialize and thread start report, and a modified binary can report any
- * of them.
- */
-export const QUALIFIED_CODEX_CLI_VERSIONS = {
-    "linux-x64": ["0.154.0", "0.157.1", "0.159.2", "0.159.3", "0.160.0"],
-    "darwin-arm64": ["0.154.0"],
-};
-/**
- * The pre-existing admission, not a qualification. Hosted participants on these hosts ran
- * 0.154.0 while it was the only admitted release, and they keep it; no qualification has run
- * on either host, and no later release is admitted there.
- */
-export const PREEXISTING_CODEX_CLI_ADMISSIONS = {
-    "linux-arm64": ["0.154.0"],
-    "darwin-x64": ["0.154.0"],
-};
-const HOST_LABELS = {
-    "linux-x64": "Linux x64",
-    "darwin-arm64": "macOS arm64",
-    "linux-arm64": "Linux arm64",
-    "darwin-x64": "macOS x64",
-};
-export function codexHost(platform, arch) {
-    const host = `${platform}-${arch}`;
-    return Object.hasOwn(QUALIFIED_CODEX_CLI_VERSIONS, host) ||
-        Object.hasOwn(PREEXISTING_CODEX_CLI_ADMISSIONS, host)
-        ? host
-        : undefined;
-}
-/** Releases that passed qualification on this host; the pre-existing admission is excluded. */
-export function qualifiedCodexCliVersions(platform, arch) {
-    const host = codexHost(platform, arch);
-    return host !== undefined && Object.hasOwn(QUALIFIED_CODEX_CLI_VERSIONS, host)
-        ? QUALIFIED_CODEX_CLI_VERSIONS[host]
-        : [];
-}
-/** Everything the launcher starts on this host: qualified releases or the pre-existing one. */
-export function admittedCodexCliVersions(platform, arch) {
-    const host = codexHost(platform, arch);
-    if (host === undefined)
-        return [];
-    return Object.hasOwn(QUALIFIED_CODEX_CLI_VERSIONS, host)
-        ? QUALIFIED_CODEX_CLI_VERSIONS[host]
-        : PREEXISTING_CODEX_CLI_ADMISSIONS[host];
-}
-/** What a declaration names before the installed CLI is detected: the host's newest release. */
-export function defaultCodexCliVersion(platform = process.platform, arch = process.arch) {
-    return (admittedCodexCliVersions(platform, arch).at(-1) ??
-        QUALIFIED_CODEX_CLI_VERSIONS["linux-x64"].at(-1));
-}
-/** The version from `codex --version` output (`codex-cli 0.157.1`); any other shape is undefined. */
-export function parseCodexCliVersion(stdout) {
-    return /^codex-cli ([0-9][0-9A-Za-z.+-]{0,63})$/.exec(stdout.trim())?.[1];
-}
-function describeHost(host) {
-    return Object.hasOwn(QUALIFIED_CODEX_CLI_VERSIONS, host)
-        ? QUALIFIED_CODEX_CLI_VERSIONS[host].join(", ")
-        : `${PREEXISTING_CODEX_CLI_ADMISSIONS[host].join(", ")} (pre-existing admission, not qualified)`;
-}
-/**
- * doctor's recovery for an unadmitted CLI: the release it found and where, what this host admits,
- * and how to replace that binary with the newest admitted release.
- */
-export function codexVersionRecovery(detected, installation, platform = process.platform, arch = process.arch) {
-    const found = detected === undefined
-        ? "The installed Codex CLI did not report a recognizable version"
-        : `Found Codex CLI ${detected}`;
-    const where = installation === undefined ? "" : ` at \`${installation.path}\``;
-    return `${found}${where}; ${describeQualifiedCodexCliVersions(platform, arch)}. ${codexInstallAdvice(installation, platform, arch)} Then sign in with a ChatGPT account (\`codex login\`).`;
-}
-const inside = (file, directory) => file.startsWith(`${directory}${path.sep}`);
-/**
- * Classifies the `codex` on `PATH` by the file it resolves to. A project's node_modules/.bin/codex
- * resolving into that project's @openai/codex is project-local, so `npx` runs it before any global
- * install. One inside npm's global prefix (`npm prefix -g`) is global. Anything else, such as
- * Homebrew or a standalone download, is other.
- */
-export function classifyCodexInstallation(found, npmGlobalPrefix) {
-    const bin = path.dirname(found.path);
-    const modules = path.dirname(bin);
-    if (path.basename(bin) === ".bin" &&
-        path.basename(modules) === "node_modules" &&
-        inside(found.resolved, path.join(modules, "@openai", "codex")))
-        return { kind: "project", path: found.path, project: path.dirname(modules) };
-    if (npmGlobalPrefix !== undefined &&
-        (found.path === path.join(npmGlobalPrefix, "bin", "codex") ||
-            inside(found.resolved, path.join(npmGlobalPrefix, "lib", "node_modules", "@openai", "codex"))))
-        return { kind: "global", path: found.path };
-    return { kind: "other", path: found.path };
-}
-/**
- * The command that installs the newest admitted Codex CLI where it replaces the one humanish
- * found: in its project for a project-local install, otherwise npm's global install.
- */
-function codexInstallCommand(installation, platform = process.platform, arch = process.arch) {
-    const version = defaultCodexCliVersion(platform, arch);
-    return installation?.kind === "project"
-        ? `npm install -D @openai/codex@${version}`
-        : `npm install -g @openai/codex@${version}`;
-}
-/** One sentence: how to put the newest admitted Codex CLI in place of the one humanish found. */
-export function codexInstallAdvice(installation, platform = process.platform, arch = process.arch) {
-    const command = codexInstallCommand(installation, platform, arch);
-    switch (installation?.kind) {
-        case undefined:
-            return `Install the newest with \`${command}\`.`;
-        case "global":
-            return `Replace it with \`${command}\`.`;
-        case "project":
-            return `It is installed in this project: run \`${command}\` in \`${installation.project}\`, or \`npm uninstall @openai/codex\` there to use the global Codex.`;
-        case "other":
-            return `Update it with the tool that installed it, or put Codex ${defaultCodexCliVersion(platform, arch)} first on PATH.`;
-    }
-}
-/** For refusal messages: the admitted releases on this host, or every host when it has none. */
-export function describeQualifiedCodexCliVersions(platform = process.platform, arch = process.arch) {
-    const host = codexHost(platform, arch);
-    if (host !== undefined)
-        return `${HOST_LABELS[host]} accepts Codex CLI ${describeHost(host)}`;
-    return Object.keys(HOST_LABELS)
-        .map((key) => `${HOST_LABELS[key]}: ${describeHost(key)}`)
-        .join("; ");
-}

package/dist/cli/commands/lab-format.d.ts

@@ -1,8 +0,0 @@
-import type { CuaActorLabResult } from "../../routes/computer-use/types.js";
-import type { ScriptedBrowserLabResult } from "../../routes/scripted/types.js";
-import type { TerminalProductLabResult } from "../../routes/terminal/types.js";
-import type { ConcurrentSharedWorldLabResult } from "../../routes/shared-world/types.js";
-export declare function formatConcurrentSharedWorldLabHuman(result: ConcurrentSharedWorldLabResult): string;
-export declare function formatTerminalLabHuman(result: TerminalProductLabResult): string;
-export declare function formatScriptedLabHuman(result: ScriptedBrowserLabResult): string;
-export declare function formatCuaLabHuman(result: CuaActorLabResult): string;

package/dist/cli/commands/lab-route-run.d.ts

@@ -1,19 +0,0 @@
-import { type InternalRunLabOptions, type LabOutcome } from "../../run-lab.js";
-import type { LabConfig } from "../../lab/types.js";
-import type { LoadedAdapterScorer } from "./lab-scorer.js";
-export interface RouteRun {
-    readonly options: InternalRunLabOptions;
-    present(outcome: LabOutcome): Promise<void>;
-    /** Handles an error runLab threw, and rethrows any it does not handle. */
-    onRunError?(error: unknown): Promise<void>;
-}
-/**
- * Plans the lab with a route's options, then presents the refusal or the run. `beforeRun` runs
- * only for a plan that will run: it loads the scorer, or writes its own refusal and returns
- * undefined, so a refused lab never imports the scorer's host code. `afterRun` runs once runLab
- * has returned or thrown, before presentation, which may hold its own signal handlers (watch's
- * Observer and tunnel).
- */
-export declare function runRoute(config: LabConfig, run: RouteRun, beforeRun?: () => Promise<{
-    scorer?: LoadedAdapterScorer;
-} | undefined>, afterRun?: () => void): Promise<void>;

package/dist/cli/commands/lab-route-scripted.d.ts

@@ -1,17 +0,0 @@
-import { Command } from "commander";
-import type { LabConfig } from "../../lab/types.js";
-import { type CliIo, type LabCommandOptions } from "../io.js";
-import type { RouteRun } from "./lab-route-run.js";
-interface ScriptedRouteArgs {
-    command: Command;
-    io: CliIo;
-    config: LabConfig;
-    mode: "run" | "watch";
-    options: LabCommandOptions;
-}
-/**
- * The scripted route's CLI setup: its open semantics and runLab options, and how it presents the
- * outcome. Undefined when watch-mode setup has already written its own result.
- */
-export declare function scriptedRouteRun(args: ScriptedRouteArgs): RouteRun | undefined;
-export {};

package/dist/cli/commands/lab-route-terminal.d.ts

@@ -1,17 +0,0 @@
-import { Command } from "commander";
-import type { LabConfig } from "../../lab/types.js";
-import { type CliIo, type LabCommandOptions } from "../io.js";
-import type { RouteRun } from "./lab-route-run.js";
-interface TerminalRouteArgs {
-    command: Command;
-    io: CliIo;
-    config: LabConfig;
-    mode: "run" | "watch";
-    options: LabCommandOptions;
-}
-/**
- * The terminal route's CLI setup: its open semantics and runLab options, and how it presents the
- * outcome. Undefined when watch-mode setup has already written its own result.
- */
-export declare function terminalRouteRun(args: TerminalRouteArgs): RouteRun | undefined;
-export {};

package/dist/cli/commands/lab-run.d.ts

@@ -1,9 +0,0 @@
-import { Command } from "commander";
-import { type CliIo, type LabCommandOptions } from "../io.js";
-export declare function runLabCommand(args: {
-    command: Command;
-    io: CliIo;
-    lab: string;
-    mode: "run" | "watch";
-    options: LabCommandOptions;
-}): Promise<void>;

package/dist/cli/commands/lab.d.ts

@@ -1,3 +0,0 @@
-import { Command } from "commander";
-import { type CliIo } from "../io.js";
-export declare function registerLabCommands(parent: Command, io: CliIo): void;

package/dist/cli/commands/lab.js

@@ -1,199 +0,0 @@
-import { formatAutomaticAnalysisBudget } from "../../analysis/automatic-config.js";
-import { resolve } from "node:path";
-import { Command, Option } from "commander";
-import { inspectLabManifest, listLabManifests } from "../../lab/discover.js";
-import { runLabPreflight, } from "../../lab/preflight.js";
-import { runLabCommand } from "./lab-run.js";
-import { countOption, participantsOption } from "../renamed-options.js";
-import { applyEnvFileOption, JSON_OPTION_DESCRIPTION, parsePositiveInteger, writeResult, } from "../io.js";
-export function registerLabCommands(parent, io) {
-    const lab = parent
-        .command("lab")
-        .description("List, inspect, and run humanish lab manifests.")
-        .summary("List, inspect, and run humanish lab manifests.");
-    lab
-        .command("list")
-        .description("List committed and ignored humanish lab manifests.")
-        .option("--cwd <path>", "Target project directory.", ".")
-        .option("--json", JSON_OPTION_DESCRIPTION)
-        .action((options, command) => handleLabList(io, options, command));
-    lab
-        .command("inspect")
-        .argument("<lab>", "Lab id or .yaml path.")
-        .description("Inspect a humanish lab manifest without running it.")
-        .option("--cwd <path>", "Target project directory.", ".")
-        .option("--json", JSON_OPTION_DESCRIPTION)
-        .action((labName, options, command) => handleLabInspect(io, labName, options, command));
-    lab
-        .command("preflight")
-        .argument("<lab>", "Lab id or .yaml path.")
-        .description("Check lab metadata or explicitly probe reachability. Metadata mode does not verify setup; use doctor --lab <lab> first.")
-        .option("--cwd <path>", "Target project directory.", ".")
-        .addOption(new Option("--reachability <mode>", "Reachability mode.")
-        .choices(["metadata", "public-preview", "sandbox-loopback", "prepared-host"])
-        .default("metadata"))
-        .option("--timeout-ms <ms>", "Target reachability timeout.", String(30_000))
-        .option("--env-file <path>", "Load a local env file for this preflight without persisting values.")
-        .option("--json", JSON_OPTION_DESCRIPTION)
-        .action((labName, options, command) => handleLabPreflight(io, labName, options, command));
-    lab
-        .command("run")
-        .argument("<lab>", "Lab id or .yaml path.")
-        .description("Run a humanish lab manifest. Same as `humanish run <lab>`, grouped under `lab`.")
-        .option("--env-file <path>", "Load a local env file for this lab without persisting values.")
-        .option("--dry-run", "Render contract evidence without live provider spend.")
-        .option("--open", "Open the observer in the default browser.")
-        .option("--no-open", "Render without opening a browser.")
-        .option("--detach", "Render/open once and exit without attached watch server.")
-        .option("--port <port>", "Local observer server port when following.", "0")
-        .option("--count <count>", "Override the participant count of a preview or computer-use lab.")
-        // The older spelling of --count, hidden and noted on stderr (renamed-options.ts).
-        .addOption(new Option("--sims <count>").hideHelp())
-        .option("--rerun-failed-from <run>", "CUA fan-out only: create a new run for failed participants from a prior run.")
-        .option("--participants <ids>", "CUA rerun only: comma-separated participant ids from the source run. Ids are the lab's declared actors[0].lanes[].id, or lane-01, lane-02, … by position.")
-        // The older spelling of --participants, hidden and noted on stderr (renamed-options.ts).
-        .addOption(new Option("--lanes <participant-ids>").hideHelp())
-        .option("--run-id <id>", "Explicit lab run id; refused when that run already exists.")
-        .option("--cwd <path>", "Target project directory.", ".")
-        .option("--scorer <path>", "Terminal/computer-use/shared-world labs only: repo-relative adopter scorer module (.mjs). Overrides review.scorer.ref. Executable code: review it as code.")
-        .option("--json", JSON_OPTION_DESCRIPTION)
-        .addHelpText("after", [
-        "",
-        "Examples:",
-        "  humanish lab run first-run",
-        "  humanish lab run fanout-demo --rerun-failed-from latest --participants lane-02,lane-04",
-        "  humanish lab run my-terminal-lab --scorer scorers/product.mjs",
-        "  humanish lab run .humanish/labs/private-dogfood.yaml --env-file .humanish/local/provider.env",
-        "",
-        "Human watch path:",
-        "  humanish watch first-run",
-        "  humanish watch --lab .humanish/labs/local.yaml",
-    ].join("\n"))
-        .action((labName, options, command) => handleLabRun(io, labName, options, command));
-}
-async function handleLabList(io, options, command) {
-    const result = await listLabManifests(options.cwd);
-    writeResult(command, io, result, formatLabListHuman);
-    io.setExitCode(0);
-}
-async function handleLabInspect(io, labName, options, command) {
-    const result = await inspectLabManifest(options.cwd, labName);
-    writeResult(command, io, result, formatLabInspectHuman);
-    io.setExitCode(result.ok ? 0 : 2);
-}
-async function handleLabPreflight(io, labName, options, command) {
-    if (!(await applyEnvFileOption({
-        command,
-        cwd: options.cwd,
-        envFile: options.envFile,
-        io,
-    }))) {
-        return;
-    }
-    const timeoutMs = parsePositiveInteger(options.timeoutMs);
-    if (timeoutMs === null) {
-        const result = {
-            schema: "humanish.lab-preflight-result.v1",
-            ok: false,
-            cwd: resolve(options.cwd),
-            lab: labName,
-            reachability: options.reachability,
-            checks: [{ name: "timeout", ok: false, message: "--timeout-ms must be a positive integer." }],
-            targets: [],
-            sandbox: { created: false },
-            spend: { e2bDesktop: false, model: false },
-            warnings: [],
-            error: {
-                code: "HUMANISH_LAB_PREFLIGHT_INVALID_OPTION",
-                message: "--timeout-ms must be a positive integer.",
-            },
-        };
-        writeResult(command, io, result, formatLabPreflightHuman);
-        io.setExitCode(2);
-        return;
-    }
-    const result = await runLabPreflight({
-        cwd: options.cwd,
-        lab: labName,
-        reachability: options.reachability,
-        timeoutMs,
-    });
-    writeResult(command, io, result, formatLabPreflightHuman);
-    io.setExitCode(result.ok ? 0 : 2);
-}
-async function handleLabRun(io, labName, options, command) {
-    const count = countOption(io, options);
-    const participants = participantsOption(io, options);
-    if (!(await applyEnvFileOption({
-        command,
-        cwd: options.cwd,
-        envFile: options.envFile,
-        io,
-        // runLabCommand discovers keys once the lab resolves to a live run.
-        discoverKeys: false,
-    }))) {
-        return;
-    }
-    await runLabCommand({
-        command,
-        io,
-        lab: labName,
-        mode: "run",
-        options: { ...options, count, participants },
-    });
-}
-function formatLabListHuman(result) {
-    if (result.labs.length === 0) {
-        return ([
-            `No humanish labs found in ${result.cwd}`,
-            "Create one under humanish/labs/*.yaml, .humanish/labs/*.yaml, or pass a .yaml path.",
-            ...result.warnings.map((warning) => `warning: ${warning}`),
-        ].join("\n") + "\n");
-    }
-    return ([
-        "humanish labs",
-        ...result.labs.map((lab) => `- ${lab.id} ${lab.source} ${lab.origin} ${lab.path}${lab.title ? ` (${lab.title})` : ""}`),
-        ...result.warnings.map((warning) => `warning: ${warning}`),
-    ].join("\n") + "\n");
-}
-function formatLabInspectHuman(result) {
-    if (!result.ok || !result.config) {
-        return `${result.error?.code}: ${result.error?.message}\n`;
-    }
-    const config = result.config;
-    return ([
-        "humanish lab",
-        `id: ${config.id}`,
-        `subject: ${config.subject.source}`,
-        ...(config.execution?.target ? [`execution: ${config.execution.target}`] : []),
-        `actors: ${config.actors.map((actor) => actor.type).join(", ")}`,
-        ...(config.title ? [`title: ${config.title}`] : []),
-        ...(config.description ? [`description: ${config.description}`] : []),
-        ...(result.path ? [`path: ${result.path}`] : []),
-        ...(result.origin ? [`origin: ${result.origin}`] : []),
-        ...(config.subject.repos?.length ? [`repos: ${config.subject.repos.join(", ")}`] : []),
-        ...(result.personas ?? []).map((persona) => `persona ${persona.id}: ${persona.brief ? `authored context (before runtime additions)\n${persona.brief.text}` : "unresolved; id only"}`),
-        ...result.warnings.map((warning) => `warning: ${warning}`),
-    ].join("\n") + "\n");
-}
-function formatLabPreflightHuman(result) {
-    const checkedTargets = result.targets.filter((target) => target.checked);
-    const reachableTargets = checkedTargets.filter((target) => target.reachable === true);
-    const blockedTargets = result.targets.filter((target) => target.status === "blocked");
-    return ([
-        `humanish lab preflight ${result.ok ? "passed" : "failed"}`,
-        `lab: ${result.labId ?? result.lab}`,
-        ...(result.route ? [`route: ${result.route}`] : []),
-        `reachability: ${result.reachability}`,
-        `targets: ${checkedTargets.length ? `${reachableTargets.length}/${checkedTargets.length} reachable` : `${result.targets.length} declared, not checked`}`,
-        ...(blockedTargets.length ? [`blocked-targets: ${blockedTargets.length}`] : []),
-        `spend: ${result.spend.e2bDesktop ? "one e2b desktop, no model calls" : "none"}`,
-        ...(result.analysis ? [formatAutomaticAnalysisBudget(result.analysis)] : []),
-        ...(result.sandbox.created
-            ? [`sandbox: created=yes killed=${result.sandbox.killed === true ? "yes" : "no"}`]
-            : []),
-        ...result.checks.map((check) => `- ${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`),
-        ...(result.error ? [`error: ${result.error.code}: ${result.error.message}`] : []),
-        ...result.warnings.map((warning) => `warning: ${warning}`),
-    ].join("\n") + "\n");
-}

package/dist/cli/renamed-options.d.ts

@@ -1,11 +0,0 @@
-import type { CliIo } from "./io.js";
-/** `--participants`, or `--lanes` when only the older spelling is set. */
-export declare function participantsOption(io: CliIo, options: {
-    participants?: string | undefined;
-    lanes?: string | undefined;
-}): string | undefined;
-/** `--count`, or `--sims` when only the older spelling is set. */
-export declare function countOption(io: CliIo, options: {
-    count?: string | undefined;
-    sims?: string | undefined;
-}): string | undefined;