humanish 0.110.1 → 0.110.2

package/dist/substrates/local/firecracker-desktop.js

@@ -9,6 +9,7 @@ import { ownDesktopAllocation, } from "../desktop-session.js";
 import { runtimeDocker, runtimeExec, usesLima } from "./runtime-host.js";
 import { openLimaTunnel } from "./runtime-ssh.js";
 import { guestMediaConfigSchema } from "../../guest/media-config.js";
+import { cli } from "../../cli/invocation.js";
 const docker = async (args) => (await runtimeDocker(args, {}, 60_000)).stdout.trim();
 const readLogs = async (id) => {
     const result = await runtimeDocker(["logs", "--tail", "100", id], {}, 10_000);
@@ -18,12 +19,12 @@ function checkDesktopOptions(options) {
     if (options.media !== undefined) {
         guestMediaConfigSchema.parse(options.media);
         if (options.assets.media !== true)
-            throw new Error("This local runtime does not include media. Run humanish runtime setup --media.");
+            throw new Error(`This local runtime does not include media. Run ${cli("runtime setup --media")}.`);
     }
     if (options.recording !== undefined) {
         desktopRecordingConfigSchema.parse(options.recording);
         if (options.assets.media !== true)
-            throw new Error("This runtime does not include the recorder. Run humanish runtime setup --media.");
+            throw new Error(`This runtime does not include the recorder. Run ${cli("runtime setup --media")}.`);
     }
     let url;
     try {

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

@@ -3,6 +3,7 @@ import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
+import { cli } from "../../cli/invocation.js";
 const exec = promisify(execFile);
 export const LIMA_INSTANCE = "humanish-runtime";
 export const usesLima = (options = {}) => (options.platform ?? process.platform) === "darwin";
@@ -86,11 +87,11 @@ export async function limaStatus(options = {}) {
         version = (await hostExec("limactl", ["--version"], options)).stdout;
     }
     catch {
-        throw new Error("Install Lima 2.2 or newer (brew install lima), then run humanish runtime setup. Docker Desktop is not required.");
+        throw new Error(`Install Lima 2.2 or newer (brew install lima), then run ${cli("runtime setup")}. Docker Desktop is not required.`);
     }
     const match = /\b(\d+)\.(\d+)\.\d+/.exec(version);
     if (!match || Number(match[1]) < 2 || (Number(match[1]) === 2 && Number(match[2]) < 2))
-        throw new Error("Update Lima to 2.2 or newer (brew upgrade lima), then run humanish runtime setup.");
+        throw new Error(`Update Lima to 2.2 or newer (brew upgrade lima), then run ${cli("runtime setup")}.`);
     const output = (await hostExec("limactl", ["list", "--json"], options)).stdout.trim();
     const instance = output
         .split("\n")
@@ -104,8 +105,8 @@ export async function limaStatus(options = {}) {
         ready: instance?.status === "Running",
         exists: !!instance,
         message: instance
-            ? "The humanish Lima host is stopped. Run humanish runtime setup to start it."
-            : "Run humanish runtime setup to create the humanish Lima host and install the browser runtime.",
+            ? `The humanish Lima host is stopped. Run ${cli("runtime setup")} to start it.`
+            : `Run ${cli("runtime setup")} to create the humanish Lima host and install the browser runtime.`,
     };
 }
 export async function prepareLima(options = {}, progress) {

package/dist/substrates/local/runtime.js

@@ -7,6 +7,7 @@ import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { LOCAL_MEDIA_RUNTIME_RELEASES, LOCAL_RUNTIME_RELEASES } from "./runtime-release.js";
 import { limaStatus, loadRuntimeArchive, prepareLima, runtimeArchitecture, runtimeDocker, runtimeExec, usesLima, } from "./runtime-host.js";
+import { cli } from "../../cli/invocation.js";
 const docker = async (args, options) => (await runtimeDocker(args, options)).stdout.trim();
 const runtimeRelease = (options) => options.release ??
     (options.media ? LOCAL_MEDIA_RUNTIME_RELEASES : LOCAL_RUNTIME_RELEASES)[runtimeArchitecture(options) ?? "amd64"];
@@ -80,7 +81,7 @@ export async function localRuntimeStatus(options = {}) {
             installed: false,
             message: lima
                 ? "Docker is unavailable inside the humanish Lima host. Check limactl shell humanish-runtime -- sudo systemctl status docker; Docker Desktop is not used."
-                : "Docker is unavailable. Install/start Docker Engine and give your account access, then run humanish runtime setup.",
+                : `Docker is unavailable. Install/start Docker Engine and give your account access, then run ${cli("runtime setup")}.`,
         };
     }
     const release = runtimeRelease(options);
@@ -108,7 +109,7 @@ export async function localRuntimeStatus(options = {}) {
             : {
                 ok: true,
                 installed: false,
-                message: "Local runtime will download before the first live run. Run humanish runtime setup to prepare it now.",
+                message: `Local runtime will download before the first live run. Run ${cli("runtime setup")} to prepare it now.`,
             };
     }
     const image = images[0];
@@ -161,7 +162,7 @@ export async function prepareLocalRuntime(options = {}) {
     try {
         const response = await fetch(release.url, { signal });
         if (!response.ok || !response.body)
-            throw new Error(`Runtime download failed (HTTP ${response.status}). Run humanish runtime setup to retry.`);
+            throw new Error(`Runtime download failed (HTTP ${response.status}). Run ${cli("runtime setup")} to retry.`);
         let bytes = 0;
         const hash = createHash("sha256");
         await pipeline(Readable.fromWeb(response.body), new Transform({
@@ -181,7 +182,7 @@ export async function prepareLocalRuntime(options = {}) {
         await loadRuntimeArchive(archive, { ...options, signal });
         const after = await localRuntimeStatus(options);
         if (!after.assets)
-            throw new Error("Downloaded runtime did not provide the expected image. Run humanish runtime setup to retry.");
+            throw new Error(`Downloaded runtime did not provide the expected image. Run ${cli("runtime setup")} to retry.`);
         return after.assets;
     }
     finally {

package/dist/tui/contract.js

@@ -12,6 +12,7 @@
 //
 // It also makes the UI testable without a terminal: a test hands `startTui` a fake index and reads
 // the frames back.
+import { cli } from "../cli/invocation.js";
 /** Node version the Ink runtime requires (ink@7 declares `engines.node >= 22`). */
 export const TUI_MIN_NODE_MAJOR = 22;
 /**
@@ -41,12 +42,12 @@ export const TUI_BUNDLE_URL = new URL("../tui-app.js", import.meta.url);
  */
 export function terminalSurfaceMessage(state) {
     if (!state.supported) {
-        return `\`humanish tui\` needs Node ${TUI_MIN_NODE_MAJOR}+ (this is ${state.nodeVersion}); every other command works here`;
+        return `\`${cli("tui")}\` needs Node ${TUI_MIN_NODE_MAJOR}+ (this is ${state.nodeVersion}); every other command works here`;
     }
     if (!state.bundlePresent) {
-        return "`humanish tui` is not built in this checkout; run `pnpm build` (installed packages ship it prebuilt)";
+        return `\`${cli("tui")}\` is not built in this checkout; run \`pnpm build\` (installed packages ship it prebuilt)`;
     }
     return state.interactive
-        ? "`humanish tui` opens the interactive surface for browsing studies and runs"
-        : "`humanish tui` is the interactive screen a person uses to watch and start runs here. This shell is not a terminal, so pass it on to a person at one";
+        ? `\`${cli("tui")}\` opens the interactive surface for browsing studies and runs`
+        : `\`${cli("tui")}\` is the interactive screen a person uses to watch and start runs here. This shell is not a terminal, so pass it on to a person at one`;
 }

package/dist/verify/liveness.js

@@ -11,6 +11,7 @@ import { runLiveness } from "../run/run-index.js";
 import { parseSandboxReceipts, SANDBOX_RECEIPTS_ARTIFACT } from "../run/sandbox-receipts.js";
 import { RUN_STATUS_FILE } from "../run/status.js";
 import { plural } from "../run/text.js";
+import { cli } from "../cli/invocation.js";
 /** The stable code every RUN_NOT_FINISHED warning starts with. */
 const RUN_NOT_FINISHED = "RUN_NOT_FINISHED";
 const GONE_STATES = new Set(["killed", "already-gone"]);
@@ -55,7 +56,7 @@ async function reclaimState(runPaths, runId) {
     // Matched by digest: a reclaim receipt names each sandbox by digest, and one written before it
     // did holds the raw id, which is digested here.
     const journaled = new Set((journal === null ? [] : parseSandboxReceipts(journal)).map((receipt) => sandboxIdDigest(receipt.sandboxId)));
-    const command = `\`humanish reclaim --run ${runId}\``;
+    const command = `\`${cli(`reclaim --run ${runId}`)}\``;
     const receipt = reclaimReceipt(await readRunJsonIfExists(runPaths, RECLAIM_RECEIPT_ARTIFACT), runId);
     if (receipt === undefined)
         return {

package/dist/verify/verify.js

@@ -19,6 +19,7 @@ import { rerunLineageFindings } from "./rerun.js";
 import { sharedWorldEvidenceFindings } from "./shared-world.js";
 import { subjectStateFindings, undeclaredSubjectStateWarnings } from "./subject.js";
 import { plural } from "../run/text.js";
+import { cli } from "../cli/invocation.js";
 export const VERIFY_SCHEMA = "humanish.verify-result.v1";
 // The UNSCANNED_ARTIFACT reason names this many paths and counts the rest.
 const MAX_LISTED_UNSCANNED = 10;
@@ -387,7 +388,7 @@ function buildShareSafety(args) {
         ];
         reasons.push({
             code: "RAW_SANDBOX_ID",
-            message: `Raw sandbox ids appear in ${files.sort().join(", ")}. Runs from 0.110 keep them only in sandbox-receipts.ndjson; \`humanish export --format bundle --redact-screenshots\` writes a copy without them.`,
+            message: `Raw sandbox ids appear in ${files.sort().join(", ")}. Runs from 0.110 keep them only in sandbox-receipts.ndjson; \`${cli("export --format bundle --redact-screenshots")}\` writes a copy without them.`,
         });
     }
     const rawStreamIds = rawScreenshotStreamIds(args.bundle, args.redactedShapeFrames);

package/docs/architecture/terminal-product-route.md

@@ -1,7 +1,7 @@
 # Terminal-product route
 
 The live terminal-product route has shipped since `0.8.0`, with the in-sandbox runtime,
-command-scoped credential placement, exact-id cleanup proof, an interventions ledger, a cost and
+explicit credential placement (an E2B egress proxy by default, or command-scoped), exact-id cleanup proof, an interventions ledger, a cost and
 no-spend ledger, caps, and product scoring and feedback hooks. The
 [original plan](https://github.com/danielgwilson/humanish/blob/main/docs/history/goals/terminal-product-lane/goal.md)
 holds the build order and the safety contract.
@@ -30,7 +30,7 @@ fail-closed cross-validation, and forward-declared warnings.
 | `subject.product`                 | `{ name, publicSurfaces[], install?, workdir?, upload? }`: the only world the agent sees                                                                    |
 | `execution.target`                | `e2b-terminal` (or absent → implied)                                                                                                                        |
 | `execution.terminal`              | `{ transport: exec-stream, stdin: disabled }`                                                                                                               |
-| `execution.runtimeAuth`           | `openai-env` (default) or opt-in `openai-egress`; names-only durable evidence                                                                               |
+| `execution.runtimeAuth`           | `openai-egress` (default) or opt-in `openai-env`; names-only durable evidence                                                                               |
 | `execution.runtime.version`       | Optional exact `@openai/codex` version; observed before keyed execution                                                                                     |
 | `actor.model` / `reasoningEffort` | Passed to Codex as `--model` (default `gpt-5.6-sol`) and `-c model_reasoning_effort`; declarations, not observed provider identity                          |
 | `caps`                            | `{ maxUsd, maxJobs, maxMinutes }`: the blast-radius budget; `maxUsd > 0` is refused: no adopter cost source exists until issue 347 lands                    |
@@ -86,11 +86,8 @@ product's no-spend boundary still needs separate interpretation.
 
 ## Runtime auth: raw-key placement and remaining provider access
 
-`execution.runtimeAuth: openai-env` remains the compatible default. It supplies
-`CODEX_API_KEY` command-scoped to Codex, with `OPENAI_API_KEY` also supplied when
-that was the host source. Child processes can read and use the raw key.
-
-Opt in to keeping the raw key outside the sandbox:
+`execution.runtimeAuth: openai-egress` is the default: a study that declares no
+`runtimeAuth` keeps the raw key outside the sandbox, as if it declared:
 
 ```yaml
 execution:
@@ -115,7 +112,7 @@ output and errors, including errors during sandbox creation.
 This mode supports the default OpenAI endpoint only. humanish explicitly sets Codex's
 built-in `openai` provider and `openai_base_url` to `https://api.openai.com/v1` for
 that invocation. It does not support a custom provider, proxy base URL, or regional
-endpoint under this mode. `openai-env` retains its existing command behavior. E2B
+endpoint under this mode; a study that needs one declares `openai-env`. E2B
 header rules are a public-beta capability;
 `tests/routes/terminal/runtime-auth.test.ts` checks the local contract against the
 installed Desktop SDK (the lockfile has `@e2b/desktop` 2.4.0, resolving `e2b` 2.49.0).
@@ -136,6 +133,11 @@ requests can fail. E2B domain allowlists are routing controls rather than strict
 destination isolation on shared infrastructure. An existing exact OpenAI host
 rule is rejected instead of silently overwritten.
 
+`execution.runtimeAuth: openai-env` is the opt-in alternative. It supplies
+`CODEX_API_KEY` command-scoped to Codex, with `OPENAI_API_KEY` also supplied when
+that was the host source. Child processes can read and use the raw key, and so can
+anything the agent runs or a page it reads asks it to run.
+
 Evidence records the selected auth mode and the residual proxy capability.
 Resolved live actor traces use `keyPlacement: external` in `openai-egress`; the
 actor registry continues to describe the default `in-sandbox-command-scoped`
@@ -197,10 +199,10 @@ deadline.
 
 ## The original command-scoped safety contract
 
-The default mode **inverts** the credential-placement default of every other E2B route.
-On the computer-use route the model's key stays _outside_ the sandbox; here the
-agent-under-test runs _inside_ with a real `OPENAI_API_KEY`/`CODEX_API_KEY` and
-is **presumed exfiltratable**. The placement rule in invariants-and-defaults.md
+The `openai-env` mode **inverts** the credential-placement default of every other E2B route.
+On the computer-use route the model's key stays _outside_ the sandbox; under `openai-env` the
+agent-under-test runs _inside_ with a real `OPENAI_API_KEY`/`CODEX_API_KEY` and is **presumed
+exfiltratable**. The placement rule in invariants-and-defaults.md
 applies: _keys live where the keyed process runs, and nowhere else;
 blast radius is bounded by key scoping and budgets, not by hoping._
 

package/docs/contracts/run-bundle.md

@@ -585,7 +585,9 @@ shareSafety:
 bundle is safe to promote into a public issue. Public promotion should branch on
 `shareSafety.status`:
 
-- `share_ready`: feedback draft commands may render public issue payloads;
+- `share_ready`: feedback draft commands may render public issue payloads, and `observe --all --safe`
+  serves the run. The folder still holds `sandbox-receipts.ndjson` (raw sandbox ids) and `status.json`
+  (the recording pid); no Observer server serves them and bundle export omits them;
 - `local_only`: keep the run local; only supported redaction-only cases can produce a shareable derivative;
   `RAW_SANDBOX_ID` is one: a file other than `sandbox-receipts.ndjson` names one of the run's raw
   sandbox ids, which verify reads from the receipts and from any raw `providerResources[].id` in
@@ -658,6 +660,16 @@ trace references outside `screenshots/`. An unregistered
 `.mp4`, and a file or directory whose name contains `\`, are public-safety
 findings and block the run.
 
+The patterns live in `src/evidence/redaction.ts`: provider key formats (OpenAI,
+Anthropic, E2B, GitHub, GitLab, npm, Vercel, AWS, Google, Stripe, Slack,
+SendGrid, Hugging Face), JWTs, bearer and basic `Authorization` values, private
+key headers, database URLs with a password, the password in any URL's user info,
+credential query and fragment parameters with a value of 16 characters or more,
+credential-named upper-case variables set to a value of 16 characters or more
+with a digit and a letter, an AWS secret access key next to its name, E2B URLs, and Linux,
+macOS and Windows local paths. `tests/verify/secret-formats.test.ts` lists the
+formats and the ordinary values that must not match.
+
 Before matching, the scan undoes JSON and JS escapes, percent-encoding and HTML
 character references, the decoding bundle export applies (`decodeEscapes`), and
 then JSON whitespace escapes and quoted-printable. It reads inside base64 runs of
@@ -673,9 +685,13 @@ wrapped across lines, and inside hex runs of 32 characters or more:
 
 `observer/index.html` is exempt from that base64 rule: serve renders it from
 `run.json`, export regenerates it, and it embeds the Observer's own base64 fonts.
-Its text is still scanned. Known limits: base64 split across separate strings,
-nesting deeper than three levels, and encodings a pattern scan cannot undo (such
-as encryption) still grade `share_ready`. `tests/verify/encoding-coverage.test.ts`
+Its text is still scanned. A base64 run of up to 4096 characters is also read one
+slash-separated piece at a time, and from just after each slash in its first 64
+characters, so a URL path before an encoded key cannot shift its decoding. Known
+limits: base64 split across separate strings, nesting deeper than three levels,
+base64 that holds a slash itself and starts more than 64 characters into a longer
+run, and encodings a pattern scan cannot undo (such as encryption) still grade
+`share_ready`. `tests/verify/encoding-coverage.test.ts`
 records each case.
 
 Real email receiving adds `publication.restrictions: [real-communications]` and

package/docs/contracts/schemas.md

@@ -279,7 +279,7 @@ instruction?, target?, entry?, host?, reasoningEffort?, stopWhen?, dwell? }` bec
   an interactive PTY would overstate the mechanism (a duplex PTY
   transport does not ship). `terminal.stdin` defaults to `disabled`
   (`sent`/assisted input is rejected until the interventions ledger + a
-  non-comparable marker exist). `runtimeAuth` (`openai-env`, the default, or `openai-egress`)
+  non-comparable marker exist). `runtimeAuth` (`openai-egress`, the default, or `openai-env`)
   declares the agent's runtime-auth channel, recorded as names only. On a live run, the engine
   resolves the registered terminal descriptor and requires
   `keyPlacement: in-sandbox-command-scoped` before creating a sandbox. With `openai-env`
@@ -1068,9 +1068,9 @@ contract.
 ## Terminal Cost Ledger And No-Spend Proof
 
 The terminal-product route (`src/routes/terminal/route.ts`), under the default
-`runtimeAuth: openai-env`, passes a real provider key only to the in-sandbox agent
-command; `openai-egress` gives the command a placeholder and keeps the key in an
-external E2B header transform. Neither mode puts it in sandbox-global env or
+`runtimeAuth: openai-egress`, gives the in-sandbox agent command a placeholder and
+keeps the key in an external E2B header transform; `openai-env` passes a real
+provider key only to that command. Neither mode puts it in sandbox-global env or
 metadata, so the no-spend claim must be derived from a ledger, never asserted. The
 live run writes both to `terminal-ledgers.json` (a `cost` block + a
 `noSpendProof` block, additive to `humanish.terminal-ledgers.v1`).
@@ -1186,7 +1186,8 @@ the CLI's run command when that signal stops a live run outside post-run
 analysis. It first prints one line saying it is stopping and refuses any further sandbox
 create. It then kills the E2B sandboxes the run's `sandbox-receipts.ndjson` names, each sandbox
 a create in flight reports as its id arrives, and each one E2B lists with the run's owner tags,
-writes `reclaim-receipt.json` as `humanish reclaim` does, and exits
+writes `reclaim-receipt.json` as `humanish reclaim` does, rewrites each run file that names one of
+the run's raw sandbox ids with the marker and digest, as a finished run's publish does, and exits
 128+n. The bundle is not finished: run.json keeps its last live flush, with
 `outcome: { state: interrupted, ok: false, signal, at }` when the run had
 flushed one, and status.json gets no `outcome`. A `running` record that stopped refreshing still reads as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.110.1",
+  "version": "0.110.2",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",
@@ -56,11 +56,12 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && pnpm --filter humanish-observer build && pnpm --filter humanish-tui build && node scripts/finish-build.mjs",
-    "check": "pnpm format:check && pnpm lint && pnpm knip && pnpm prose:check && pnpm vocabulary:check && pnpm docs:check && pnpm site-css:check && pnpm typecheck && pnpm test && pnpm tui:test && pnpm build && pnpm guest-media:startup:proof && pnpm cli:startup:test && pnpm cli:preflight:test && pnpm cli:dotenv:test && pnpm cli:peer:test && pnpm tui:smoke",
+    "check": "pnpm format:check && pnpm lint && pnpm knip && pnpm prose:check && pnpm vocabulary:check && pnpm docs:check && pnpm site-css:check && pnpm typecheck && pnpm test && pnpm tui:test && pnpm build && pnpm guest-media:startup:proof && pnpm cli:startup:test && pnpm cli:preflight:test && pnpm cli:dotenv:test && pnpm cli:peer:test && pnpm cli:skill:test && pnpm tui:smoke",
     "cli:startup:test": "node scripts/terminal-startup-exit-proof.mjs",
     "cli:preflight:test": "node scripts/task-route-preflight-proof.mjs",
     "cli:dotenv:test": "node scripts/dotenv-proof.mjs",
     "cli:peer:test": "node scripts/peer-install-proof.mjs",
+    "cli:skill:test": "node scripts/skill-first-run-proof.mjs",
     "humanish": "tsx src/cli.ts",
     "pack:dry-run": "npm pack --dry-run",
     "prepack": "pnpm build",
@@ -74,6 +75,7 @@
     "tui:smoke": "node scripts/tui-smoke.mjs",
     "tui:test": "pnpm --filter humanish-tui test",
     "release:dogfood": "node scripts/release-dogfood.mjs",
+    "bench": "tsx bench/run.ts",
     "browser-control:proof": "node scripts/browser-control-proof.mjs",
     "docs:generate": "tsx scripts/generate-cli-docs.ts",
     "docs:check": "tsx scripts/generate-cli-docs.ts --check && tsx scripts/check-doc-paths.ts && tsx scripts/check-doc-symbols.ts && tsx scripts/check-doc-comments.ts && tsx scripts/check-doc-study-fields.ts",

package/skills/humanish/SKILL.md

@@ -289,7 +289,6 @@ Useful commands:
 ```bash
 npx humanish study list
 npx humanish study show first-run
-npx humanish watch first-run
 npx humanish run first-run --json --no-open
 ```
 
@@ -377,25 +376,30 @@ inbox page. See `docs/contracts/schemas.md` for the full `comms:` shape and
 ## First Proof Run
 
 Run the no-credentials path first. It is a dry run: humanish writes a synthetic
-run bundle and tests no target app behavior:
+run bundle and tests no target app behavior. Every command in this block
+finishes and exits, needs no key and spends nothing; lines marked
+`# live only` need keys and spend money, so run them only when the user has
+approved a live run. `run` prints the run id; use it in place of `<id>`.
 
 ```bash
-npx humanish doctor
-npx humanish watch
-npx humanish verify --run latest --json
-npx humanish feedback issue --run latest --repo example/app --format markdown
-```
-
-For CI or non-interactive proof:
-
-```bash
-npx humanish watch --json --no-open
+npx humanish doctor --json
 npx humanish run first-run --json --no-open
+npx humanish verify --run <id> --json
+npx humanish review --run <id> --json
+npx humanish observe --run <id>
+npx humanish run try-live --json --no-open  # live only
+npx humanish feedback issue --run <id> --repo example/app --format markdown  # live only
 ```
 
-The feedback command prints a public-safe Markdown draft. It must not call the
-GitHub API, require a token, update Projects, use provider credits, or claim
-product behavior proof from a dry run.
+`observe` prints the path of the run's Observer page for the person you are
+working for. Without an interactive terminal, `observe` and `watch` print the
+result and exit; at a person's terminal they serve the Observer until Ctrl-C.
+
+`feedback issue` drafts from a live run only and refuses a dry run with
+`HUMANISH_FEEDBACK_REQUIRES_LIVE_RUN`. Its Markdown draft is checked for
+secret, key, token and local-path shapes; it is not checked for personal data. It
+must not call the GitHub API, require a token, update Projects, use provider
+credits, or claim product behavior proof from a dry run.
 
 When the target app can run locally, prove a known browser path with a
 scripted-browser study after starting the app on loopback. The study replays a
@@ -414,8 +418,8 @@ no browser.
 # in another terminal, start the target app on 127.0.0.1 or localhost
 npx humanish study show <study> --json
 npx humanish run <study> --json --no-open
-npx humanish verify --run latest --json
-npx humanish observe --run latest --open   # for a person; it serves until Ctrl-C
+npx humanish verify --run <id> --json
+npx humanish observe --run <id> --open   # for a person; at their terminal it serves until Ctrl-C
 ```
 
 Do not use `humanish watch --count ...` as a substitute for a scripted-browser
@@ -442,7 +446,7 @@ Do not paste values into files, prompts, run bundles, issue drafts, or logs.
 Load local values only at invocation time:
 
 ```bash
-npx humanish watch .humanish/studies/local-live.yaml --dotenv .humanish/local/provider.env
+npx humanish run .humanish/studies/local-live.yaml --dotenv .humanish/local/provider.env --json --no-open
 ```
 
 When choosing dogfood targets, prefer apps, CLIs, or agent-facing tools with a