@jevitate/cli 0.1.0

package/dist/ux-api.js

@@ -0,0 +1,231 @@
+// ux-api.ts — the CLI layer over @jevitate/ux. Two surfaces:
+//   - runUxReview(): offline analysis over a saved Recording (`jevitate ux`).
+//   - runUsabilityMission(): live analysis during an exploration
+//     (`explore --strategy usability`) — reuses explore()'s loop via the
+//     additive onSnapshot hook, collects evidence per screen, and analyzes
+//     ONCE post-run (proper batching/budget; no model calls slow the browser).
+//
+// This is the ONLY place @jevitate/ux meets @jevitate/explore — the dep
+// direction stays ux ⟂ explore (both are consumed here, neither imports the
+// other). Findings are advisory; a UX finding never gates a run.
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PlaywrightBrowserPort } from "@jevitate/playwright";
+import { CastActor, BrowseTheWeb } from "@jevitate/screenplay";
+import { explore, assertAuthorizedExploreTarget, } from "@jevitate/explore";
+import { UxAnalyzer, a11yChecks, buildReport, loadV1Rubric, } from "@jevitate/ux";
+import { resolveDataDir } from "./data-dir.js";
+const DEFAULT_JUDGMENT_BUDGET = 40;
+function emptyBehavior() {
+    return { noProgress: false, backtracks: 0, formReentry: 0, dwellMs: 0, errors: 0 };
+}
+/** explore's live `Control` → ux `Control` (same shape by design; drop `stability`). */
+function toUxControl(c) {
+    return {
+        index: c.index,
+        role: c.role,
+        name: c.name,
+        tag: c.tag,
+        inputType: c.inputType,
+        enabled: c.enabled,
+        summary: c.summary,
+        descriptor: c.descriptor,
+    };
+}
+/** a11y facts computable from a live snapshot's controls (honest subset). */
+function a11yFactsFromControls(controls) {
+    return {
+        controls: controls.map((c) => ({
+            controlRef: `control:${c.index}`,
+            accessibleName: c.name.trim().length > 0 ? c.name : null,
+            focusOrder: c.index,
+            targetSize: null,
+            contrastRatio: null,
+        })),
+    };
+}
+/** A live Snapshot (+ extracted page text) → one screen's UxEvidence. */
+export function snapshotToEvidence(snap, visibleText, appContext, job, history) {
+    const controls = snap.controls.map(toUxControl);
+    return {
+        screenId: snap.signature,
+        url: snap.url,
+        controls,
+        visibleText,
+        appContext,
+        ...(job !== undefined ? { job } : {}),
+        history,
+        behavior: emptyBehavior(),
+        a11yFacts: a11yFactsFromControls(controls),
+    };
+}
+function descriptorSummary(d) {
+    const parts = [d.role, d.name ?? d.testId ?? d.text].filter((s) => !!s);
+    return parts.join(" ") || "control";
+}
+function stepTarget(step) {
+    if ("target" in step && step.target)
+        return step.target;
+    return undefined;
+}
+/**
+ * A saved Recording → per-page UxEvidence. A Recording is deterministic and
+ * thin: it carries the CONTROLS the user touched (via each step's descriptor)
+ * and the page url, but NOT the full visible text or a11y geometry. So offline
+ * analysis is honestly partial — items needing `visibleText`/`a11yFacts` Skip,
+ * and coverage reports it. (The live mode carries the rich per-screen snapshot.)
+ */
+export function recordingToEvidence(recording, appContext, job) {
+    const screens = [];
+    const history = [];
+    for (let i = 0; i < recording.pages.length; i++) {
+        const page = recording.pages[i];
+        const controls = [];
+        let idx = 0;
+        const seen = new Set();
+        for (const rs of page.steps) {
+            const d = stepTarget(rs.step);
+            if (!d)
+                continue;
+            const key = JSON.stringify(d);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            controls.push({
+                index: idx++,
+                role: d.role ?? "",
+                name: d.name ?? d.testId ?? d.text ?? "",
+                tag: "",
+                inputType: null,
+                enabled: true,
+                summary: descriptorSummary(d),
+                descriptor: d,
+            });
+        }
+        const screenId = `${page.url}#${i}`;
+        screens.push({
+            screenId,
+            url: page.url,
+            controls,
+            visibleText: "",
+            appContext,
+            ...(job !== undefined ? { job } : {}),
+            history: [...history],
+            behavior: emptyBehavior(),
+            a11yFacts: { controls: [] },
+        });
+        history.push({ screenId, url: page.url });
+    }
+    return screens;
+}
+/**
+ * Offline UX review. FAIL-FAST: an analyzer `failed` outcome throws
+ * `UxAnalysisFailedError` (the CLI maps it to a non-zero fail envelope) — never
+ * a fabricated "clean" report.
+ */
+export async function runUxReview(opts) {
+    const analyzer = new UxAnalyzer({ judge: opts.judge, a11yChecker: a11yChecks });
+    const screens = recordingToEvidence(opts.recording, opts.appContext, opts.appContext.job);
+    const outcome = await analyzer.analyze({
+        screens,
+        rubric: loadV1Rubric(),
+        appContext: opts.appContext,
+        secrets: opts.secrets,
+        judgmentBudget: opts.judgmentBudget ?? DEFAULT_JUDGMENT_BUDGET,
+    });
+    if (outcome.kind === "failed") {
+        throw new UxAnalysisFailedError(outcome.reason, outcome.screenId, outcome.rubricItemId);
+    }
+    const report = buildReport(outcome);
+    const outDir = opts.outDir ?? resolveDataDir(["ux-reports"]);
+    await mkdir(outDir, { recursive: true });
+    const iso = (opts.nowIso ?? (() => new Date().toISOString()))();
+    const reportPath = join(outDir, `ux-${iso.replace(/[:.]/g, "-")}.json`);
+    await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    return { report, reportPath };
+}
+export class UxAnalysisFailedError extends Error {
+    screenId;
+    rubricItemId;
+    code = "E_UX_ANALYSIS";
+    constructor(reason, screenId, rubricItemId) {
+        super(`UX analysis failed: ${reason}${screenId ? ` (screen ${screenId})` : ""}`);
+        this.screenId = screenId;
+        this.rubricItemId = rubricItemId;
+        this.name = "UxAnalysisFailedError";
+    }
+}
+/**
+ * Live usability mission. Guardrail #1 authorizes BEFORE opening a browser.
+ * Reuses explore()'s loop (goal = the job) and, via the additive onSnapshot
+ * hook, collects one screen's evidence per observation — then analyzes ONCE
+ * after the run. A UX finding NEVER gates the loop (the hook's result is
+ * ignored by explore). The temp profile dir is always removed.
+ */
+export async function runUsabilityMission(opts) {
+    const origin = assertAuthorizedExploreTarget(opts.url, opts.allowlist);
+    const portFactory = opts.browserPortFactory ?? (() => new PlaywrightBrowserPort());
+    const port = portFactory();
+    const profileDir = await mkdtemp(join(tmpdir(), "jevitate-usability-"));
+    const session = await port.open({
+        profileDir,
+        headless: true,
+        allowedOrigins: [...opts.allowlist],
+        baseUrl: origin,
+    });
+    const collected = [];
+    const history = [];
+    const extract = opts.extractText ??
+        (async (s) => s.page.evaluate(() => (typeof document !== "undefined" && document.body ? document.body.innerText : "")));
+    try {
+        const actor = CastActor.named("usability-mission").whoCan(new BrowseTheWeb(session, [...opts.allowlist]));
+        const run = await explore({
+            actor,
+            judge: opts.judge,
+            gen: opts.gen,
+            goal: opts.job,
+            allowlist: opts.allowlist,
+            startUrl: opts.url,
+            bounds: opts.bounds,
+            secrets: opts.secrets,
+            site: origin,
+            missionContext: "usability review: pursue the stated job as a plausible first-time user, using only what is on screen",
+            onSnapshot: async (snap) => {
+                let visibleText = "";
+                try {
+                    visibleText = await extract(session);
+                }
+                catch {
+                    visibleText = ""; // best-effort; the analyzer Skips visibleText items honestly
+                }
+                const ev = snapshotToEvidence(snap, visibleText, opts.appContext, opts.job, [...history]);
+                collected.push(ev);
+                history.push({ screenId: ev.screenId, url: ev.url });
+            },
+        });
+        const analyzer = new UxAnalyzer({ judge: opts.judge, a11yChecker: a11yChecks });
+        const outcome = await analyzer.analyze({
+            screens: collected,
+            rubric: loadV1Rubric(),
+            appContext: opts.appContext,
+            secrets: opts.secrets,
+            judgmentBudget: opts.judgmentBudget ?? DEFAULT_JUDGMENT_BUDGET,
+        });
+        if (outcome.kind === "failed") {
+            throw new UxAnalysisFailedError(outcome.reason, outcome.screenId, outcome.rubricItemId);
+        }
+        const report = buildReport(outcome);
+        const outDir = opts.outDir ?? resolveDataDir(["ux-reports"]);
+        await mkdir(outDir, { recursive: true });
+        const iso = (opts.nowIso ?? (() => new Date().toISOString()))();
+        const reportPath = join(outDir, `usability-${iso.replace(/[:.]/g, "-")}.json`);
+        await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+        return { report, reportPath, stop: run.stop, screensObserved: collected.length };
+    }
+    finally {
+        await session.close();
+        await rm(profileDir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=ux-api.js.map

package/dist/ux-api.js.map

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

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare function readCliVersion(): string;

package/dist/version.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+/**
+ * The CLI's real published version, resolved at RUNTIME from @jevitate/cli's
+ * own package.json — never a hardcoded literal that silently drifts from what
+ * npm actually shipped (ticket #27).
+ *
+ * The CLI ships BUNDLED (a single `dist/bin.js` built by build.mjs/esbuild),
+ * and npm always includes package.json alongside `dist/`. This module is
+ * inlined INTO that bundle, so at runtime `import.meta.url` points at
+ * `dist/bin.js` and `../package.json` resolves to the shipped
+ * `packages/cli/package.json`. The SAME `../package.json` also resolves
+ * correctly from the un-bundled `tsc` output (`dist/version.js`) and from the
+ * TypeScript source under `src/` during tests — every layout keeps this module
+ * exactly one directory below the package root.
+ *
+ * If the file is somehow unreadable (an exotic pack, a broken install) we fall
+ * back to a safe constant rather than crashing `--version`. This is a display
+ * value, not a safety decision, so a fallback here is benign.
+ */
+const FALLBACK_VERSION = "0.0.0";
+export function readCliVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(here, "..", "package.json");
+        const parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (typeof parsed.version === "string" && parsed.version.length > 0) {
+            return parsed.version;
+        }
+    }
+    catch {
+        // fall through to the safe display fallback below
+    }
+    return FALLBACK_VERSION;
+}
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,gBAAgB,GAAG,OAAO,CAAC;AAEjC,MAAM,UAAU,cAAc;IAC5B,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACrD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;QACjD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAA0B,CAAC;QAClF,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpE,OAAO,MAAM,CAAC,OAAO,CAAC;QACxB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,kDAAkD;IACpD,CAAC;IACD,OAAO,gBAAgB,CAAC;AAC1B,CAAC"}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@jevitate/cli",
+  "version": "0.1.0",
+  "description": "Jevitate CLI — author, run, and orchestrate browser-automation Journeys from the command line.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matt-cochran/jevitate.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://jevitate.com",
+  "bugs": "https://github.com/matt-cochran/jevitate/issues",
+  "author": "Matt Cochran",
+  "keywords": [
+    "browser-automation",
+    "testing",
+    "e2e",
+    "playwright",
+    "screenplay",
+    "journeys",
+    "exploration",
+    "usability",
+    "mcp",
+    "cli",
+    "jevitate"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "jevitate": "dist/bin.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "ui"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@openrouter/ai-sdk-provider": "^3.1.0",
+    "@typesafe-ai/sdk": "^0.6.0",
+    "ai": "^7.0.107",
+    "better-sqlite3": "^11.0.0",
+    "commander": "^12.0.0",
+    "playwright": "^1.49.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.2",
+    "@jevitate/ai-core": "0.1.0",
+    "@jevitate/daemon": "0.1.0",
+    "@jevitate/interpreter": "0.1.0",
+    "@jevitate/explore": "0.1.0",
+    "@jevitate/domain": "0.1.0",
+    "@jevitate/missions": "0.1.0",
+    "@jevitate/load": "0.1.0",
+    "@jevitate/inbox": "0.1.0",
+    "@jevitate/example-site": "0.1.0",
+    "@jevitate/mcp-facade": "0.1.0",
+    "@jevitate/recording": "0.1.0",
+    "@jevitate/playwright": "0.1.0",
+    "@jevitate/journey": "0.1.0",
+    "@jevitate/runtime": "0.1.0",
+    "@jevitate/regression": "0.1.0",
+    "@jevitate/recorder": "0.1.0",
+    "@jevitate/skills": "0.1.0",
+    "@jevitate/ux": "0.1.0",
+    "@jevitate/sources": "0.1.0",
+    "@jevitate/storage-sqlite": "0.1.0",
+    "@jevitate/screenplay": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "bundle": "node ./build.mjs"
+  }
+}

package/skills/jevitate-explore/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: jevitate-explore
+description: Scopes and runs a bounded exploration mission via `jevitate explore` (goal, coverage, exploratory, adversarial, or capability-scoped feature strategies) or the MCP `queue_exploration` tool — drives Jev (not you) on an authorized target and emits a replayable Recording. Use when there is no existing Journey for what needs testing and a human wants autonomous, bounded exploration.
+---
+
+You scope an exploration mission; you never drive the browser yourself. Jev
+(the judgment gateway) makes every click/type/select decision inside the
+exploration engine; a generative model writes only form text; an independent,
+user-supplied assertion — not the model's own "done" signal — decides whether
+a goal-based mission actually succeeded. Your entire job is composing a good
+mission and reading the result honestly.
+
+## Before you start
+
+- The target must already be authorized. This tool refuses an unknown or
+  unauthorized target by design (`E_UNAUTHORIZED_EXPLORE_TARGET` — authoring/test
+  plane only, never production writes). The allowlist defaults to the `--url`'s
+  own origin; widen it only with explicit `--allow <origin>` values the human
+  gave you. If you don't know whether a target is authorized, ask.
+- Pick a strategy deliberately (default is `goal`):
+  - `--strategy goal` (default): needs `--goal` and `--success`. Reaches a
+    stated end state.
+  - `--strategy coverage` / `--strategy exploratory`: state-coverage by
+    induction; the frontier itself is the objective, so it takes no
+    goal/success.
+  - `--strategy adversarial`: bounded misuse ("try to break it") whose stop
+    decision comes from a trusted hard-signal defect oracle, never Jev's own
+    signal. Needs only `--url`.
+  - `--feature <name> --route <glob>`: capability-scoped feature testing
+    (model-free; no goal/success, no gateway selection needed).
+
+## Writing a goal-based mission
+
+- Write a `--goal` in plain language describing the end state, not a sequence of
+  clicks ("place an order for one widget and reach the confirmation page," not
+  "click .add-to-cart then click #checkout").
+- Write a `--success` assertion independent of what you expect Jev to report —
+  checkable from page state alone, e.g. `urlIncludes:/confirmation`. Jev's own
+  "goal met?" judgment is advisory; the assertion is what decides success. If
+  you cannot state a concrete, checkable assertion, the goal is too vague —
+  narrow it first.
+
+## Running it
+
+- Goal: `jevitate explore --url <authorized-url> --goal "<goal>" --success
+  urlIncludes:/inbox [--allow <origin>] [--secret <value>] [--max-actions <n>]
+  [--max-decisions <n>] --real --json`. Model-driving strategies (`goal`,
+  `coverage`, `exploratory`, `adversarial`) need a gateway: `--real` (live
+  Jev + OpenRouter, after `jevitate ai setup`) or `--fake-ai` (a deterministic
+  pipeline smoke — it will NOT drive to a real goal). No selection fails closed.
+- Adversarial: `jevitate explore --strategy adversarial --url <authorized-url>
+  --real --json`.
+- Coverage: `jevitate explore --strategy coverage --url <authorized-url> --real
+  --json`.
+- Feature: `jevitate explore --feature checkout --route "/cart/**" --url
+  <authorized-url> --json` (model-free).
+- Authoring a promotable Journey: `jevitate explore-author-journey --url
+  <authorized-url> --goal "<goal>" --success <assertion> --id <journey-id>
+  --name "<name>" --real --json` — drives the goal-based mission and writes an
+  UNPROMOTED, parameterized Journey to the store. It is never auto-promoted.
+- MCP: the `queue_exploration` tool — `queue_exploration({ target, goal, ... })`
+  — enqueues a bounded mission and returns a `missionId` immediately (it does
+  not run inline). `target` must be a pre-registered mission target id, not a
+  raw URL.
+
+## Reading the result
+
+- The output is a deterministic `Recording`. Report the actual `outcome`, not an
+  optimistic gloss — a `blocked` or `exhausted` (budget) outcome with a partial
+  Recording is a precise repro of how far Jev got, but it is not success. A
+  goal-based run is success only when `outcome` is `succeeded`; adversarial CI
+  gates on `outcome === "defect"`; a coverage run gates on discovered defects.
+- A successful goal-based Recording is a candidate to hand to `jevitate-record`
+  for postdoc review, or to author directly via `explore-author-journey` —
+  say so when it succeeds.
+
+## What you must never do
+
+- Never widen `--allow`/the target beyond what the human explicitly authorized.
+- Never treat Jev's in-loop "done" signal as the final word — only the
+  `--success` assertion result is, for goal-based runs.
+- Never ask the exploration engine to do anything on a production target — this
+  is authoring/test-plane only, always.
+- Never fall back to a generic browser-automation tool if `jevitate explore`
+  is unavailable — that bypasses every guardrail this skill enforces.
+
+## Running it through MCP (shipped)
+
+- `jevitate mcp` starts the stdio MCP server; `queue_exploration` is one of its
+  allowlisted, wired tools. Register it in your harness with `jevitate mcp
+  --print-config <claude|cursor|codex|json>`, or let `jevitate init` register it
+  for each detected runtime.
+- `queue_exploration` needs a PROMOTED mission target, not a raw URL. Register
+  and promote one first with `jevitate mission target add <id> ...` then
+  `jevitate mission target promote <id>` (see `jevitate-mission-scope`). It
+  enqueues and returns a `missionId` immediately — it never runs inline.
+
+## Known gaps
+
+- Offline only: `queue_exploration` enqueues but does not itself run the
+  mission; a separate runner drains the queue. Treat the returned `missionId`
+  as "accepted," not "finished."
+- The MCP server also registers 8 inbox/command-queue tools
+  (`queue_retrieval`, `queue_action`, `get_command`, `list_incoming`,
+  `get_thread`, `approve_action`, `cancel_command`, `get_site_health`) that
+  currently return a typed `not_implemented` error — they are reserved surface,
+  not usable yet. The four wired tools are `find_capabilities`, `run_journey`,
+  `queue_exploration`, and `ai_generate_text`.

package/skills/jevitate-load-test/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: jevitate-load-test
+description: Runs a seeded, human-paced concurrent load test of a promoted Journey via `jevitate load run`, against an explicitly authorized target only. Use when a user wants a capacity/throughput measurement, not a single functional run.
+---
+
+You scope and run a throughput/capacity measurement, never a single functional
+check (use `jevitate-run-journey` for that instead).
+
+## Before you start — authorization is mandatory, not optional
+
+- `jevitate load run` refuses to start with zero `--authorized-origin` values
+  (`E_LOAD_RUN`, "at least one --authorized-origin is required"). This is not a
+  formality — running N concurrent actors against a target the operator hasn't
+  explicitly authorized for load is exactly the kind of irreversible,
+  high-blast-radius action this platform's guardrails exist to prevent. Never
+  add an `--authorized-origin` value the human did not explicitly state.
+
+## Running it
+
+- `jevitate load run <journeyId> --authorized-origin <origin> [--authorized-origin
+  <origin2> ...] --param k=v --concurrency <n> --iterations <n> --seed <n>
+  --json`.
+- `<journeyId>` must be a promoted Journey id (same discovery flow as
+  `jevitate-run-journey`: `jevitate journey find`/`find_capabilities` first).
+- `--seed` makes the run reproducible — if the human wants to compare two
+  configurations, keep the seed fixed and vary only `--concurrency`/
+  `--iterations`.
+
+## Reading the result
+
+- The report's metrics are always labeled `measured` or `modeled` — never
+  report a `modeled` number as if it were `measured`, and if the report says a
+  requested live run could not run, that is a failure to surface honestly, not
+  a number to approximate around.
+
+## What you must never do
+
+- Never run a load test against a target without an explicit, human-stated
+  `--authorized-origin`.
+- Never scale `--concurrency`/`--iterations` up beyond what the human asked for
+  "just to get a cleaner number" — a bigger run is a bigger real-world load on
+  someone's infrastructure.

package/skills/jevitate-mission-scope/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: jevitate-mission-scope
+description: Reads a diff, pull request, changelog, or user story and scopes change-driven testing — identifies at-risk routes/features, maps them to existing promoted Journeys, runs the most relevant ones, and recommends which newly-discovered repros to promote. Use when a user wants to know "what should I test" after a code change, rather than testing everything or picking targets blindly.
+---
+
+You scope testing to what actually changed. You never drive a browser yourself —
+Jev (the judgment gateway) makes browser-driving decisions inside the
+exploration engine, and the deterministic Journey runner executes promoted
+Journeys; your job is entirely the "what and why," spending tokens once to
+target instead of on every click.
+
+## 1. Read the change
+
+Given a diff, PR description, changelog entry, or user story, identify:
+- Which routes/pages/features it plausibly touches (file paths → routes is a
+  judgment call — a change to `src/checkout/*` plausibly affects the checkout
+  flow even if no route string literally appears in the diff).
+- Whether it's additive (a new feature, lower regression risk to *existing*
+  Journeys but a candidate for a *new* exploration goal) or modifying existing
+  behavior (higher regression risk — prioritize existing promoted Journeys that
+  exercise the touched area).
+- Anything explicitly called out as risky (auth, payment, data deletion) —
+  weight these higher regardless of diff size.
+
+State your reasoning in one or two sentences before acting — "what changed" and
+"why this is (or isn't) at risk" — so the human reviewing your output can
+sanity-check the judgment, not just the commands you ran.
+
+## 2. Map to existing promoted Journeys first
+
+- `jevitate journey find "<term>" --json` (or MCP `find_capabilities`) once per
+  at-risk area you identified in step 1. Try more than one query term per area
+  if the first returns nothing plausible — a Journey's `name`/`description`
+  might not use the same words as the diff.
+- For each match, run it: `jevitate journey run <id> --param k=v ... --json` (or
+  MCP `run_journey`). Read the `outcome` field; treat only `"ok"`/`"healed"` as
+  a pass, never a non-success outcome.
+- If a promoted Journey exists for an at-risk area and it passes, that area has
+  regression coverage — say so plainly; you do not need to additionally explore
+  it from scratch.
+
+## 3. Where no promoted Journey covers an at-risk area
+
+This is exactly the gap the exploration engine and `queue_exploration` exist
+for. Prefer `jevitate-explore` (see that skill) or the `queue_exploration` MCP
+tool to scope a **bounded** mission at the specific at-risk area:
+- For a concrete end state, a goal-based mission: `jevitate explore --url <authorized-url>
+  --goal "<goal>" --success <assertion>` — the `--success` assertion written
+  from the diff/story's stated intent (e.g. `urlIncludes:/confirmation`), never
+  a vague "test everything" goal.
+- For a named capability with route scoping: `jevitate explore --feature <name>
+  --route <glob> --url <authorized-url>` (model-free capability coverage).
+- For "try to break the changed area": `jevitate explore --strategy adversarial
+  --url <authorized-url>` (bounded misuse + a trusted hard-signal defect oracle).
+- For state coverage of the changed area: `jevitate explore --strategy coverage
+  --url <authorized-url>`.
+- Only if you cannot reach an authorized target at all (or `jevitate explore`
+  is genuinely absent from your environment) do you stop and report the gap —
+  never fall back to a generic browser-automation tool; that would bypass every
+  guardrail (bounded budget, independent assertion, redaction, deterministic
+  Recording output) this platform exists to provide.
+
+## 4. Recommend promotion of new repros
+
+After a `jevitate explore` mission produces a new `Recording` (a "discovered
+repro"), you do not promote it yourself — promotion is a human-approval gate.
+Two additive paths help here: `jevitate explore-author-journey` writes an
+UNPROMOTED, parameterized Journey (still human-gated), and `jevitate regression
+capture --from <recording.json> --id <id>` turns a failing Recording into a
+committed regression artifact. Recommend, with reasoning: which discovered
+repros are worth promoting into the durable regression suite (does it cover a
+genuinely new, at-risk path? did it reveal a defect worth a permanent
+prove-broken/prove-fixed test?), and which are one-off exploratory noise not
+worth keeping. Narrow the regression set to what matters — quality over
+quantity.
+
+## What you must never do
+
+- Never test everything indiscriminately when a diff/story is available to
+  scope from — that defeats the entire purpose of this skill.
+- Never invent a Journey id, route, or param value — every id you run must have
+  come from a `find`/`find_capabilities` result you saw in this session.
+- Never promote anything yourself — recommend, and let a human decide.
+
+## Registering and promoting a mission target (for queue_exploration)
+
+`queue_exploration` runs against a PROMOTED mission target, never a raw URL.
+When you want to queue a scoped mission at an at-risk area via MCP:
+- `jevitate mission target add <id> --url <authorized-url> [--goal ...] [--route
+  <glob> ...] --json` registers the target (unpromoted).
+- `jevitate mission target list --json` shows registered targets and their
+  promoted/unpromoted state.
+- `jevitate mission target promote <id> --json` promotes it — a human-gated act,
+  same as Journey promotion. Only a promoted target is enqueueable.
+
+Then `queue_exploration({ target: "<id>", ... })` (via the `jevitate mcp`
+server, registered with `jevitate mcp --print-config ...` or `jevitate init`)
+enqueues a bounded mission and returns a `missionId`.
+
+## Known gaps
+
+- The MCP inbox/command-queue tools (`queue_retrieval`, `queue_action`,
+  `get_command`, `list_incoming`, `get_thread`, `approve_action`,
+  `cancel_command`, `get_site_health`) are registered on the `jevitate mcp`
+  server but return a typed `not_implemented` error today — the wired tools are
+  `find_capabilities`, `run_journey`, `queue_exploration`, and
+  `ai_generate_text`. Scoping and running work fully through those four.