explorbot 0.2.3 → 0.2.4

package/README.md

@@ -138,7 +138,7 @@ EXPLORBOT_KNOWLEDGE="Log in as admin@example.com / secret123" \
   npx explorbot explore /admin/users --max-tests 3
 ```
 
-Output lands in a per-host state directory, `~/.explorbot/state/<host>/`, so runs against the same app collect in one place and nothing is written to your project. Set `EXPLORBOT_EPHEMERAL=1` to keep nothing between runs. See [Agentic Usage](docs/workflow/agentic-usage.md).
+Output lands in a per-host site directory, `~/.explorbot/sites/<host>/`, so runs against the same app collect in one place and nothing is written to your project. Set `EXPLORBOT_EPHEMERAL=1` to keep nothing between runs. See [Agentic Usage](docs/workflow/agentic-usage.md).
 
 ## Teaching Explorbot
 

package/bin/explorbot-cli.ts

@@ -11,6 +11,7 @@ import { App } from '../src/components/App.js';
 import { StatusPane } from '../src/components/StatusPane.js';
 import { ConfigParser, EXPLORBOT_ENV_VARS, PROVIDERS } from '../src/config.js';
 import { ExplorBot, type ExplorBotOptions } from '../src/explorbot.js';
+import { remote } from '../src/remote.js';
 import { Stats } from '../src/stats.js';
 import { Plan } from '../src/test-plan.js';
 import { getCliName } from '../src/utils/cli-name.ts';
@@ -26,8 +27,9 @@ const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../p
 const pkgVersion = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version as string;
 
 program.name(cli).description('AI-powered web exploration tool').version(pkgVersion, '-V, --version');
+remote.registerOption(program);
 
-if (!process.env.EXPLORBOT_NO_BANNER) {
+if (!process.env.EXPLORBOT_NO_BANNER && !process.argv.includes('prima')) {
   console.log(`⛵ ${chalk.yellow.bold(`Explorbot v${pkgVersion}`)} ${chalk.dim('Autonomous Testing Agent')}`);
 }
 
@@ -99,6 +101,10 @@ async function startTUI(explorBot: ExplorBot): Promise<void> {
 }
 
 async function showStatsAndExit(code: number): Promise<never> {
+  if (remote.isAttached()) {
+    await remote.close(code);
+    process.exit(code);
+  }
   if (Stats.hasActivity()) {
     await new Promise<void>((resolve) => {
       const { unmount } = render(

package/boat/api-tester/src/config.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import path, { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { parseEnv } from 'node:util';
 import { type AIConfig, type ApiHookFn, type ApiConfig as BaseApiConfig, ConfigMissingError, EXPLORBOT_CONFIG_PATHS, createModel, envConfigRequested, materializeKnowledge, missingConfigMessage, resolveConfigModels, resolveModel, resolveOutputRoot } from '../../../src/config.ts';
 import { type SiteRecord, findGlobalConfig, globalEnvPath, isGlobalConfigPath, registerSite, resolveSiteTarget } from '../../../src/global-config.ts';
@@ -213,10 +214,11 @@ export class ApibotConfigParser {
 
   private async loadConfigModule(configPath: string): Promise<any> {
     const ext = configPath.split('.').pop();
+    const moduleUrl = pathToFileURL(resolve(configPath)).href;
 
     if (ext === 'ts') {
       try {
-        return await import(configPath);
+        return await import(moduleUrl);
       } catch {
         const require = (await import('node:module')).createRequire(import.meta.url);
         return require(configPath);
@@ -224,7 +226,7 @@ export class ApibotConfigParser {
     }
 
     if (ext === 'js' || ext === 'mjs') {
-      return await import(configPath);
+      return await import(moduleUrl);
     }
 
     const content = readFileSync(configPath, 'utf8');

package/boat/doc-collector/bin/doc-collector-cli.ts

@@ -1,5 +1,7 @@
 #!/usr/bin/env bun
+import { remote } from '../../../src/remote.ts';
 import { createDocsCommands } from '../src/cli.ts';
 
 const program = createDocsCommands('doc-collector');
+remote.registerOption(program);
 program.parse();

package/boat/doc-collector/src/ai/documentarian.ts

@@ -67,17 +67,32 @@ class Documentarian {
       const message = error instanceof Error ? error.message : String(error);
       tag('warning').log(`Interactive documentation failed: ${message}.`);
       if (meaningfulInteractions.length > 0) {
-        tag('info').log(`Preserving ${meaningfulInteractions.length} observed interaction(s) without AI summary.`);
-        return this.normalizeDocumentation(
-          {
-            summary: `Observed ${meaningfulInteractions.length} interaction(s); AI-generated summary was unavailable.`,
-            can: [],
-            might: [],
-            interactions: meaningfulInteractions,
-          },
-          state,
-          research
-        );
+        tag('info').log(`Retrying static documentation while preserving ${meaningfulInteractions.length} observed interaction(s).`);
+        return this.documentStatic(state, research)
+          .then((documentation) =>
+            this.normalizeDocumentation(
+              {
+                ...documentation,
+                interactions: meaningfulInteractions,
+              },
+              state,
+              research
+            )
+          )
+          .catch((fallbackError) => {
+            const fallbackMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+            tag('warning').log(`Static documentation fallback failed: ${fallbackMessage}. Preserving observed interactions without AI summary.`);
+            return this.normalizeDocumentation(
+              {
+                summary: `Observed ${meaningfulInteractions.length} interaction(s); AI-generated summary was unavailable.`,
+                can: [],
+                might: [],
+                interactions: meaningfulInteractions,
+              },
+              state,
+              research
+            );
+          });
       }
       return this.documentStatic(state, research);
     }
@@ -113,13 +128,13 @@ class Documentarian {
       },
     ];
 
-    const response = await this.provider.generateObject(messages, pageDocumentationSchema, undefined, {
+    const response = await this.provider.generateObject(messages, generatedPageDocumentationSchema, undefined, {
       agentName: 'documentarian',
     });
 
     return this.normalizeDocumentation(
       {
-        ...(response.object as PageDocumentation),
+        ...(response.object as GeneratedPageDocumentation),
         interactions,
       },
       state,
@@ -139,11 +154,11 @@ class Documentarian {
       },
     ];
 
-    const response = await this.provider.generateObject(messages, pageDocumentationSchema, undefined, {
+    const response = await this.provider.generateObject(messages, generatedPageDocumentationSchema, undefined, {
       agentName: 'documentarian',
     });
 
-    return this.normalizeDocumentation(response.object as PageDocumentation, state, research);
+    return this.normalizeDocumentation(response.object as GeneratedPageDocumentation, state, research);
   }
 
   private getSystemPrompt(): string {
@@ -259,7 +274,7 @@ class Documentarian {
     return message.includes('Failed to generate JSON') || message.includes('Failed to validate JSON') || message.includes('failed_generation') || message.includes('No object generated') || message.includes('response did not match schema');
   }
 
-  private normalizeDocumentation(documentation: PageDocumentation, _state: WebPageState, _research: string): PageDocumentation {
+  private normalizeDocumentation(documentation: GeneratedPageDocumentation & Partial<Pick<PageDocumentation, 'interactions'>>, _state: WebPageState, _research: string): PageDocumentation {
     const normalized = { ...documentation };
     if (!normalized.interactions) {
       normalized.interactions = undefined;
@@ -267,10 +282,10 @@ class Documentarian {
 
     const qualityNotes = this.evaluateDocumentationQuality(normalized);
 
-    return {
+    return pageDocumentationSchema.parse({
       ...normalized,
       qualityNotes,
-    };
+    });
   }
 
   private evaluateDocumentationQuality(documentation: PageDocumentation): string[] {
@@ -346,39 +361,54 @@ const stateTransitionSchema = z.object({
   action: z.string(),
   before: z.string(),
   after: z.string(),
-  targetUrl: z.string().nullable(),
-  discoveredUrls: z.array(z.string()).nullable(),
-  newCapabilities: z.array(z.string()).nullable(),
+  targetUrl: z.string().optional(),
+  discoveredUrls: z.array(z.string()).optional(),
+  newCapabilities: z.array(z.string()).optional(),
   element: z
     .object({
       role: z.string(),
       name: z.string(),
       section: z.string(),
-      container: z.string().nullable(),
-      locator: z.string().nullable(),
+      container: z.string().optional(),
+      locator: z.string().optional(),
     })
-    .nullable(),
+    .optional(),
   changes: z
     .object({
       urlChanged: z.boolean(),
       newElements: z.number(),
       removedElements: z.number(),
     })
-    .nullable(),
+    .optional(),
+  targetState: z
+    .object({
+      kind: z.enum(['page', 'dialog', 'modal', 'section']),
+      label: z.string(),
+      url: z.string(),
+    })
+    .optional(),
+  screenshot: z
+    .object({
+      title: z.string(),
+      relativePath: z.string(),
+    })
+    .optional(),
 });
 
-const pageDocumentationSchema = z.object({
+const generatedPageDocumentationSchema = z.object({
   summary: z.string(),
   can: z.array(capabilitySchema),
   might: z.array(capabilitySchema),
-  interactions: z.array(stateTransitionSchema).nullable(),
+});
+
+const pageDocumentationSchema = generatedPageDocumentationSchema.extend({
+  interactions: z.array(stateTransitionSchema).optional(),
+  qualityNotes: z.array(z.string()).optional(),
 });
 
 type StateTransition = DocStateTransition;
-type PageDocumentation = Omit<z.infer<typeof pageDocumentationSchema>, 'interactions'> & {
-  interactions?: StateTransition[];
-  qualityNotes?: string[];
-};
+type GeneratedPageDocumentation = z.infer<typeof generatedPageDocumentationSchema>;
+type PageDocumentation = z.infer<typeof pageDocumentationSchema>;
 
 export { Documentarian };
 export type { PageDocumentation, StateTransition };

package/boat/doc-collector/src/config.ts

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import path, { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { parseEnv } from 'node:util';
 import { ConfigParser } from '../../../src/config.ts';
 
@@ -90,10 +91,11 @@ class DocbotConfigParser {
 
   private async loadConfigModule(configPath: string): Promise<any> {
     const ext = configPath.split('.').pop();
+    const moduleUrl = pathToFileURL(resolve(configPath)).href;
 
     if (ext === 'ts') {
       try {
-        return await import(configPath);
+        return await import(moduleUrl);
       } catch {
         const require = (await import('node:module')).createRequire(import.meta.url);
         return require(configPath);
@@ -101,7 +103,7 @@ class DocbotConfigParser {
     }
 
     if (ext === 'js' || ext === 'mjs') {
-      return await import(configPath);
+      return await import(moduleUrl);
     }
 
     return JSON.parse(readFileSync(configPath, 'utf8'));

package/boat/prima/src/activity-line.ts

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { type ActivityEntry, addActivityListener, removeActivityListener } from '../../../src/activity.ts';
+import { isVerboseMode } from '../../../src/utils/logger.ts';
+
+const RESET_LINE = '\r\u001b[2K';
+
+const stream = process.stderr;
+let tracking = false;
+
+export function trackActivityLine(): void {
+  if (tracking) return;
+  if (!stream.isTTY) return;
+  if (isVerboseMode()) return;
+
+  tracking = true;
+  addActivityListener(writeActivityLine);
+}
+
+export function clearActivityLine(): void {
+  if (!tracking) return;
+
+  tracking = false;
+  removeActivityListener(writeActivityLine);
+  stream.write(RESET_LINE);
+}
+
+function writeActivityLine(activity: ActivityEntry | null): void {
+  if (!activity) return;
+
+  const width = (stream.columns || 80) - 2;
+  const message = Array.from(activity.message.replace(/\s+/g, ' ').trim()).slice(0, width).join('');
+  stream.write(`${RESET_LINE}${chalk.gray(message)}`);
+}

package/boat/prima/src/cli.ts

@@ -2,83 +2,71 @@ import { Command } from 'commander';
 import dedent from 'dedent';
 import { keepServerRunning } from '../../../src/browser-server.ts';
 import { browserErrorMessage } from '../../../src/utils/browser-errors.ts';
-import { setPreserveConsoleLogs } from '../../../src/utils/logger.ts';
+import { isVerboseMode, setQuietMode } from '../../../src/utils/logger.ts';
+import { clearActivityLine, trackActivityLine } from './activity-line.ts';
 import { type EnvelopeData, renderEnvelope } from './envelope.ts';
 import { Prima, type PrimaOptions } from './prima.ts';
 
 const helpContract = dedent`
-  Prima drives a browser that is already open. One command per process; every command
-  prints a plain-text envelope on stdout and exits 0 when ok, 1 when not.
-
-  TIERS - choose by what you hold, not by how hard the step looks
-    pw <fn>        Precise. A Playwright function expression built from a locator you
-                   already verified. No AI on the happy path.
-                     prima pw "({ page }) => page.click('[data-test=submit]')"
-    click / fill   One action described in words; AI resolves it on the current page.
-                     prima click "the primary action button in the header"
-                     prima fill "the search box" "a search term"
-    do <steps...>  Several described steps, run tester-style in one process.
-                     prima do "open the account menu" "choose the settings entry"
-    Never pass a locator or a function expression to click/fill/do - describe the target.
-    Never pass a description to pw - it takes executable code only.
-
-  LOOP
-    prima go <url|path|words>  reach the page you want to work on
-    prima research             once per new page; returns verified locators
-    prima pw "..."             drive the page with those locators
-    prima verify "..."         assert the outcome (prima ask "..." to inspect instead)
-    Fall back to click/fill/do whenever research left you no locator to hold.
-
-  ENVELOPE
-    ### Result     ok, command, healed, used
-    ### Page       url, title, state hash, visit count
-    ### Changes    what the accessibility tree gained or lost
-    ### Answer | ### Research | ### Verdict   output of ask, research, verify
-    ### Failure    error, reasoning, healing attempts, compact ARIA of the page
-    ### Instance   the browser you are on and the other instances running
-    ### Artifacts  paths to the full aria.yml, page.html and network.jsonl
-    used: is code that already executed - CodeceptJS steps to copy as they are, except
-          for pw, whose Playwright expression a test needs inside I.usePlaywrightTo(...).
-    Log lines can precede the envelope; start parsing at the first ### line.
-
-  HEALING AND FAILURE
-    A failed action is retried by AI along a different route; healed: true means the
-    outcome was reached another way and used: holds the code that worked.
-    --no-heal skips that and fails fast.
-    Failures print compact ARIA inline, so retarget from the envelope itself and open
-    the artifact files only when the inline snapshot is not enough.
-
-  SESSIONS
-    By default prima attaches to the playwright-cli browser of this workspace and works
-    on the tabs it already has open; driving the same session from both tools is the
-    intended usage.
-    playwright-cli open <url>  the session prima attaches to
-    --pw-session <title>       which playwright-cli session, when several are open
-    --endpoint <ep>            attach to a browser server endpoint directly
-    prima browser start        a prima-owned browser instead, when no session is open
-    --instance <name>          which prima-owned browser you talk to; parallel work
-                               needs one each
-    --session [file]           cookies and storage persisted across processes; ignored
-                               while attached, the attached session keeps its own
-    Prima never launches a browser implicitly and never closes an attached one - it
-    disconnects. browser list shows both kinds; ### Instance names the one you are on.
-    Every browser is reached over a Playwright browser-server endpoint, which needs the
-    Node build - run prima as "npx explorbot prima ..." or through the published prima
-    bin; from source under Bun the connection does not open.
-    When no AI model is usable pw still works; for everything else drive
-    playwright-cli directly.
-    Parsed but not active yet: --framework, so reported code is CodeceptJS whatever
-    you pass.
+  Prima is a high-level AI extension to playwright-cli, driving the browser it has open.
+
+    playwright-cli open <url>    starts the session
+    prima <command> ...          drives it
+    playwright-cli close         ends it
+
+  One call takes a whole job:
+
+    prima check "a workflow can be created and appears in the list" --expected "the new workflow is listed"
+    prima do "open the account menu" "choose the settings entry" "switch the theme to dark" "check it took effect"
+    prima pw "({ page }) => page.click('[data-test=submit]')"
+`;
+
+const checkHelp = dedent`
+  check takes an outcome rather than a click path, and works out how to reach it.
+  --expected  one outcome the run must reach, repeatable for several. Without it the
+              scenario text is the single expected outcome. Each comes back under
+              ### Expected outcomes as PASSED, FAILED or not verified - "not verified"
+              means the run never checked it, which is not the same as false.
+  Page problems seen on the way appear under ### Answer, not as step failures.
+`;
+
+const doHelp = dedent`
+  Each instruction is numbered and accounted for: ### Steps reports each as ok or FAIL
+  with what proved it. One that could not be carried out fails the command and says why.
+  Nothing runs past the last instruction given. A whole remaining sequence in one call is
+  what makes this tier cheap.
+`;
+
+const verifyHelp = dedent`
+  Reports each assertion it could express as PASSED or FAILED with its playwright form,
+  and gives no overall verdict - read the lines and decide. "none ran" means the claim
+  could not be expressed, which is not the same as false.
+`;
+
+const reportHelp = dedent`
+  Commands are logged as they run, so the report needs no browser and outlives the session.
+  The most recent session is reported unless --pw-session names another.
+`;
+
+const sessionHelp = dedent`
+  --endpoint <ep>    attach to a browser server endpoint directly, skipping discovery
+  --instance <name>  which prima-owned browser you talk to; parallel work needs one each
+  --session [file]   cookies and storage persisted across processes; ignored while
+                     attached, since the attached session keeps its own
+  --framework        parsed but not active yet; reported code is CodeceptJS either way
+  DEBUG='explorbot:*' in front of a command prints the log of everything it does.
+  When no AI model is usable pw still works; for everything else drive playwright-cli.
 `;
 
-function buildOptions(options: any): PrimaOptions {
+let rootOptions: () => any = () => ({});
+
+function buildOptions(subcommand: any): PrimaOptions {
+  const options = { ...rootOptions(), ...stripEmpty(subcommand) };
   return {
-    verbose: options.verbose || options.debug,
     config: options.config,
     path: options.path,
     instance: options.instance,
     session: options.session,
-    heal: options.heal,
     ephemeral: options.ephemeral,
     framework: options.framework,
     noVision: options.vision === false,
@@ -91,30 +79,39 @@ function buildOptions(options: any): PrimaOptions {
   };
 }
 
+function stripEmpty(options: any): any {
+  const present: any = {};
+  for (const [key, value] of Object.entries(options || {})) {
+    if (value === undefined) continue;
+    present[key] = value;
+  }
+  return present;
+}
+
 function addCommonOptions(cmd: Command): Command {
   return cmd
-    .option('-v, --verbose', 'Enable verbose logging')
-    .option('--debug', 'Enable debug logging (same as --verbose)')
     .option('-c, --config <path>', 'Path to explorbot configuration file')
     .option('-p, --path <path>', 'Working directory path')
     .option('-i, --instance <name>', 'Browser instance to drive')
     .option('--session [file]', 'Persist cookies and storage to a session file')
-    .option('--no-heal', 'Fail immediately instead of letting AI retry a failed action')
     .option('--ephemeral', 'Keep no state between runs; applies to config-free runs, where output goes to a temp directory')
     .option('--framework <name>', 'Not active yet: framework the reported code targets, codeceptjs or playwright')
     .option('--url <url>', 'Page to open when the session has no page yet')
     .option('--endpoint <ep>', 'Websocket endpoint of a browser server to attach to, skipping discovery')
-    .option('--pw-session <title>', 'Title of the playwright-cli session to attach to');
+    .option('--pw-session <title>', 'Title of the playwright-cli session to attach to')
+    .addHelpText('after', `\n${sessionHelp}`);
 }
 
 function primaFor(options: any): Prima {
-  setPreserveConsoleLogs(true);
   if (options.ephemeral) process.env.EXPLORBOT_EPHEMERAL = '1';
   return new Prima(buildOptions(options));
 }
 
-async function runPrima(options: any, command: string, run: (prima: Prima) => Promise<EnvelopeData>): Promise<void> {
+async function runPrima(options: any, command: string, run: (prima: Prima) => Promise<EnvelopeData>, record = true): Promise<void> {
+  setQuietMode(!isVerboseMode());
+  trackActivityLine();
   const prima = primaFor(options);
+  const startedAt = Date.now();
 
   let envelope: EnvelopeData;
   try {
@@ -124,6 +121,8 @@ async function runPrima(options: any, command: string, run: (prima: Prima) => Pr
     envelope = await prima.toolFailureEnvelope(command, error);
   }
 
+  if (record) prima.record(envelope, Date.now() - startedAt);
+  clearActivityLine();
   console.log(renderEnvelope(envelope));
   await prima.stop().catch(() => {});
   process.exit(envelope.ok ? 0 : 1);
@@ -143,32 +142,38 @@ async function runBrowser(options: any, run: (prima: Prima) => Promise<boolean>)
 
 export function createPrimaCommands(name = 'prima'): Command {
   const cmd = new Command(name);
-  cmd.description('Drive an already-open browser one command at a time and report back in a plain-text envelope');
+  cmd.description('Tests and drives a web app through described behaviour instead of locators: one command carries a whole scenario, verifies it, and reports the proof');
+  cmd.option('--pw-session <title>', 'Title of the playwright-cli session to attach to');
+  cmd.option('--url <url>', 'Page to open when the session has no page yet');
   cmd.addHelpText('after', `\n${helpContract}`);
+  rootOptions = () => cmd.opts();
 
   addCommonOptions(cmd.command('pw <fn>').description('Run a Playwright function expression against the open page')).action(async (fn, options) => {
     await runPrima(options, `pw ${fn}`, (prima) => prima.pw(fn));
   });
 
-  addCommonOptions(cmd.command('do <instructions...>').description('Run high-level instructions tester-style, one argument per instruction')).action(async (instructions, options) => {
-    await runPrima(options, `do ${instructions.join(' ')}`, (prima) => prima.do(instructions));
-  });
-
-  addCommonOptions(cmd.command('click <target>').description('Click an element described in plain words')).action(async (target, options) => {
-    await runPrima(options, `click ${target}`, (prima) => prima.click(target));
-  });
+  addCommonOptions(cmd.command('do <instructions...>').description('Run high-level instructions tester-style, one argument per instruction'))
+    .addHelpText('after', `\n${doHelp}`)
+    .action(async (instructions, options) => {
+      await runPrima(options, `do ${instructions.join(' ')}`, (prima) => prima.do(instructions));
+    });
 
-  addCommonOptions(cmd.command('fill <field> <value>').description('Fill a field described in plain words')).action(async (field, value, options) => {
-    await runPrima(options, `fill ${field} ${value}`, (prima) => prima.fill(field, value));
-  });
+  addCommonOptions(cmd.command('check <scenario>').description('Run a scenario end to end as a test, with its own verification, and report the steps it took'))
+    .option('--expected <outcome>', 'An outcome the run must reach; repeat the flag for several', (value: string, all: string[]) => [...all, value], [])
+    .addHelpText('after', `\n${checkHelp}`)
+    .action(async (scenario, options) => {
+      await runPrima(options, `check ${scenario}`, (prima) => prima.check(scenario, options.expected));
+    });
 
   addCommonOptions(cmd.command('ask <question>').description('Answer a question about the current page').option('--no-vision', 'Answer from page structure only, without a screenshot')).action(async (question, options) => {
     await runPrima(options, `ask ${question}`, (prima) => prima.ask(question));
   });
 
-  addCommonOptions(cmd.command('verify <assertion>').alias('assert').description('Assert a statement about the current page')).action(async (assertion, options) => {
-    await runPrima(options, `verify ${assertion}`, (prima) => prima.verify(assertion));
-  });
+  addCommonOptions(cmd.command('verify <assertion>').alias('assert').description('Assert a statement about the current page'))
+    .addHelpText('after', `\n${verifyHelp}`)
+    .action(async (assertion, options) => {
+      await runPrima(options, `verify ${assertion}`, (prima) => prima.verify(assertion));
+    });
 
   addCommonOptions(
     cmd.command('research').description('Map the current page and return verified locators').option('--data', 'Include data extraction in the map').option('--deep', 'Expand hidden elements for a deeper map').option('--fresh', 'Ignore the cached map and research the page again')
@@ -181,6 +186,30 @@ export function createPrimaCommands(name = 'prima'): Command {
     await runPrima(options, `go ${target}`, (prima) => prima.go(target));
   });
 
+  addCommonOptions(cmd.command('config').description('Show the AI models prima runs on and the config file they come from')).action(async (options) => {
+    setQuietMode(!isVerboseMode());
+    const prima = primaFor(options);
+    console.log(await prima.config().catch((error: unknown) => browserErrorMessage(error)));
+    await prima.stop().catch(() => {});
+    process.exit(0);
+  });
+
+  addCommonOptions(cmd.command('status <hash>').description('Show the artifacts and page detail recorded for an earlier command')).action(async (hash, options) => {
+    await runPrima(options, `status ${hash}`, (prima) => prima.status(hash), false);
+  });
+
+  addCommonOptions(cmd.command('report').description('Turn every command of a session into one html and markdown report'))
+    .addHelpText('after', `\n${reportHelp}`)
+    .action(async (options) => {
+      setQuietMode(!isVerboseMode());
+      console.log(
+        await primaFor(options)
+          .report()
+          .catch((error: unknown) => browserErrorMessage(error))
+      );
+      process.exit(0);
+    });
+
   const browser = cmd.command('browser').description('Manage the browsers prima drives');
 
   addCommonOptions(browser.command('start').description('Start a prima-owned browser and hold it open until Ctrl+C'))