@iamu-dev/iamu 0.8.0-beta.0 → 0.8.0-beta.2

package/dist/commands/advise.d.ts

@@ -3,6 +3,7 @@ export declare const ADVISOR_VERSION = "1.5.0";
 /** The installed `iamu/.prompts/advise.md`, or the bundled template. */
 export declare function readAdvisePrompt(projectRoot: string): string;
 export interface AdviseOptions {
+    run?: string;
     project?: boolean;
     json?: boolean;
     promptFile?: string;
@@ -11,15 +12,16 @@ export interface AdviseOptions {
  * Print the advisor's input: for a run (after the judge, before publish)
  * or, with --project, across every open finding in the project.
  */
-export declare function advise(runId: string | undefined, opts?: AdviseOptions): Promise<void>;
+export declare function advise(runIdArg: string | undefined, opts?: AdviseOptions): Promise<void>;
 export interface AdviseRecordOptions {
+    run?: string;
     project?: boolean;
     file?: string;
     data?: string;
     json?: boolean;
 }
 /** Record the advisor's answer for a run, or a project synthesis. */
-export declare function adviseRecord(runId: string | undefined, opts: AdviseRecordOptions): Promise<void>;
+export declare function adviseRecord(runIdArg: string | undefined, opts: AdviseRecordOptions): Promise<void>;
 export interface DirectionsOptions {
     json?: boolean;
 }

package/dist/commands/agent-commands.d.ts

@@ -0,0 +1,22 @@
+/** Skills the CLI points the agent at. */
+export type AgentSkill = "run" | "findings" | "design";
+/**
+ * How to invoke an iamu skill from the agent, in the form this project's
+ * host accepts (`/iamu:<skill>` with the plugin or Claude Code commands,
+ * else `/iamu-<skill>`). One name per skill: see `skillCommand`.
+ *
+ * @param projectRoot - Absolute path to the project root.
+ * @param skill - The skill to invoke.
+ * @param args - Arguments appended after the command, if any.
+ * @returns The slash command, e.g. `/iamu:run checkout`.
+ *
+ * @example
+ * ```ts
+ * agentCommand("/project", "run", "maya--video"); // "/iamu:run maya--video"
+ * ```
+ */
+export declare function agentCommand(projectRoot: string, skill: AgentSkill, args?: string): string;
+/** The re-run that turns a persona finding's fix into `verified`. */
+export declare function rerunCommand(projectRoot: string, scenario: string): string;
+/** The designer's review that turns a designer finding's fix into `verified`. */
+export declare function designReviewCommand(screen: string): string;

package/dist/commands/browse-actions.d.ts

@@ -28,6 +28,7 @@ export interface IndexedElement {
     name: string;
     type?: string;
     disabled?: boolean;
+    checked?: boolean;
 }
 export declare const INDEXED_SELECTOR: string;
 export declare function markAndQueryIndexedElements(page: Page): Promise<IndexedElement[]>;

package/dist/commands/browse-driver.d.ts

@@ -43,7 +43,9 @@ export interface BrowserDriver {
     /** The full command line of `pid`, or null when it is gone or cannot be read. */
     commandLine(pid: number): Promise<string | null>;
     /** Send SIGTERM to `pid`. Never throws. */
-    kill(pid: number): void;
+    kill(pid: number, signal?: NodeJS.Signals | number): void;
+    /** Is `pid` still alive in the OS process table? */
+    alive?(pid: number): boolean;
 }
 /** How long a CDP liveness probe may take before the port counts as dead. */
 export declare const CDP_PROBE_TIMEOUT_MS = 1000;
@@ -65,10 +67,9 @@ export declare const CDP_PROBE_TIMEOUT_MS = 1000;
  */
 export declare function probeCdp(port: number, timeoutMs?: number): Promise<boolean>;
 /**
- * The command line of a running process, read without a shell:
- * `/proc/<pid>/cmdline` on Linux, else `ps -ww -o args= -p <pid>`.
- * Windows has no equivalent we trust, so it answers null there — and
- * callers then leave the process alone.
+ * The command line of a running process:
+ * `/proc/<pid>/cmdline` on Linux, PowerShell CIM query on Windows,
+ * else `ps -ww -o args= -p <pid>`.
  *
  * @param pid - Process ID to inspect.
  * @param platform - Defaults to `process.platform`.
@@ -82,6 +83,12 @@ export declare function probeCdp(port: number, timeoutMs?: number): Promise<bool
  * @public
  */
 export declare function readProcessCommandLine(pid: number, platform?: NodeJS.Platform): Promise<string | null>;
+/**
+ * Supported browser executable names in process command lines.
+ *
+ * @public
+ */
+export declare const BROWSER_NAME_RE: RegExp;
 /**
  * Was this command line launched with exactly this `--user-data-dir`?
  * The profile directory is ours alone, so a match means the PID is the
@@ -116,6 +123,23 @@ export declare function isOurBrowser(commandLine: string | null, profileDir: str
  *
  * @public
  */
-export declare function reapBrowser(pid: number, profileDir: string, driver: Pick<BrowserDriver, "commandLine" | "kill">): Promise<boolean>;
+export declare function reapBrowser(pid: number, profileDir: string, driver: Pick<BrowserDriver, "commandLine" | "kill"> & {
+    alive?: (pid: number) => boolean;
+}): Promise<boolean>;
+/**
+ * Select the target page to act on from all open pages in the context.
+ * Filters out devtools and browser internal/extension pages unless only internal pages exist.
+ * Respects pageIndex when valid; otherwise prefers the last active non-blank page.
+ *
+ * @param rawPages - All pages returned by the browser context.
+ * @param pageIndex - Optional explicit zero-based index into the filtered pages array.
+ * @returns The selected Page and the list of user/available pages.
+ *
+ * @public
+ */
+export declare function selectTargetPage(rawPages: Page[], pageIndex?: number): {
+    page: Page | undefined;
+    pages: Page[];
+};
 /** The real driver: spawns Chrome and speaks CDP through playwright-core. */
 export declare const cdpDriver: BrowserDriver;

package/dist/commands/browse.d.ts

@@ -3,6 +3,8 @@ import { type BrowserDriver, type Size } from "./browse-driver.js";
 export type { BrowserDriver } from "./browse-driver.js";
 /** Parsed options for `iamu browse <command>`. */
 export interface BrowseOptions {
+    /** step: record into a run that is already completed. */
+    force?: boolean;
     shot?: string;
     nth?: string;
     submit?: boolean;
@@ -19,6 +21,10 @@ export interface BrowseOptions {
     surface?: string;
     maxSteps?: string | number;
     stepFile?: string;
+    /** Chained page actions executed sequentially in a single browse step before screenshot. */
+    then?: string[];
+    /** Include post-action indexed snapshot in browse step output (default: true). */
+    snapshot?: boolean;
     json?: boolean;
     /** Annotate snapshot with 1-based index numbers [#N] for click-index / fill-index */
     indexed?: boolean;
@@ -72,6 +78,25 @@ export declare function parseViewport(value: string | undefined): Size | null;
  * @public
  */
 export declare function findChrome(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, exists?: (p: string) => boolean): string | null;
+/**
+ * The OS window `start` opens: large enough for the viewport plus the
+ * browser's chrome, never smaller than 1280×900. `--width` / `--height`
+ * (deprecated) still win.
+ *
+ * @param viewport - The page size `start` emulates, or null for none.
+ * @param width - `--width`, when given.
+ * @param height - `--height`, when given.
+ * @returns The window size in pixels.
+ *
+ * @example
+ * ```ts
+ * windowSize({ width: 1920, height: 1080 }); // { width: 1936, height: 1200 }
+ * windowSize({ width: 390, height: 844 }); // { width: 1280, height: 964 }
+ * ```
+ *
+ * @public
+ */
+export declare function windowSize(viewport: Size | null, width?: string, height?: string): Size;
 /**
  * Should `start` launch without a window? `--headless` wins, then
  * `IAMU_HEADLESS`, then CI or a Linux box with no `DISPLAY`.
@@ -114,7 +139,8 @@ export declare function shouldDisableSandbox(env?: NodeJS.ProcessEnv, uid?: numb
  * terminated only when its command line shows our `--user-data-dir`;
  * a PID the OS has since handed to another process is left alone.
  *
- * @param opts - `viewport`, `run`, `port`, `width`, `height`, `headless`, `json`.
+ * @param opts - `viewport`, `run`, `port`, `headless`, `json` (and the
+ *   deprecated `width` / `height`, which override the derived window).
  * @param driver - Machine/browser seam; tests pass a fake.
  *
  * @example
@@ -177,7 +203,16 @@ export declare function detectAntiBotChallenge(page: Page, allowEvaluate?: boole
  */
 export declare function withPage(opts: BrowseOptions, driver: BrowserDriver, fn: (page: Page) => Promise<void>, 
 /** What the action looks for, named for the error message. */
-target?: string): Promise<PageResult | null>;
+target?: string, 
+/** Optional post-screenshot hook executed before detaching from CDP. */
+onPostShot?: (page: Page) => Promise<void>): Promise<PageResult | null>;
+/**
+ * Obtain an ARIA accessibility snapshot with fallback from body to :root,
+ * handling empty or about:blank pages gracefully.
+ *
+ * @public
+ */
+export declare function resilientAriaSnapshot(page: Page): Promise<string>;
 /** What {@link clearOriginStorage} removed. */
 export interface ClearedStorage {
     origin: string;
@@ -194,6 +229,27 @@ export declare function clearOriginStorage(origin: string, driver?: BrowserDrive
 returnTo?: string): Promise<ClearedStorage | {
     error: string;
 }>;
+/**
+ * Split a chained action string (e.g. `fill-index 22 "2026-11-20"`) into tokens,
+ * respecting single and double quotes.
+ *
+ * @public
+ */
+export declare function parseActionCommand(raw: string): string[];
+export interface ActionOptsOverride {
+    submit?: boolean;
+    nth?: string;
+}
+/**
+ * Extract `--submit` and `--nth <n>` flags from tokenized action arguments
+ * so inline flags are not treated as literal text arguments.
+ *
+ * @public
+ */
+export declare function extractActionFlags(tokens: string[]): {
+    args: string[];
+    optsOverride: ActionOptsOverride;
+};
 /**
  * `iamu browse <command> [args…]` — dispatch one browse subcommand.
  * Failures print to stderr and set exit code 1.

package/dist/commands/cloud-push.d.ts

@@ -10,9 +10,9 @@ export interface CloudRunInfo {
  * Push one run to the cloud when the project is cloud-linked. Returns
  * `undefined` for a local-only project, so callers print nothing.
  *
- * Called by every command that changes what the run's cloud copy shows
- * (`complete`, `evaluate-record`): offering "Open in Iamu Cloud" after a
- * local-only write would open a stale report.
+ * Called by `complete`, which offers "Open in Iamu Cloud" afterwards: a
+ * local-only write there would open a stale report. The record stages
+ * after it stay local; `iamu sync` publishes their result.
  */
 export declare function pushRunToCloud(projectRoot: string, runId: string): Promise<CloudRunInfo | undefined>;
 /** Project dashboard URL, or `null` for a local-only project. */

package/dist/commands/complete.d.ts

@@ -13,6 +13,8 @@ export interface CompleteOptions {
 }
 /** Non-fatal observations made while completing, reported after assembly. */
 export interface CompletionExtras {
+    /** What the walk left out: no steps, no closing summary. Never fatal. */
+    walkWarnings: string[];
     revisit: RevisitReport | null;
     viewportWarning: string | null;
     codeWarning: string | null;
@@ -34,6 +36,17 @@ export declare function pickCompletedAt(manifest: Pick<WalkthroughManifest, "com
 export declare function completedManifest(manifest: WalkthroughManifest, completedAt: string): WalkthroughManifest;
 /** Persist the completed manifest to disk atomically. */
 export declare function persistManifest(manifestPath: string, manifest: WalkthroughManifest, completedAt: string): Promise<WalkthroughManifest>;
+/**
+ * What a walk left out that `complete` assembles around anyway: no steps
+ * (an unblocked run then has no evidence) or no `summary.json` (no
+ * closing synthesis, no blocked or ended state). Warnings, not errors: a
+ * completion is still a completion.
+ */
+export declare function walkGapWarnings(run: {
+    runId: string;
+    runDirPath: string;
+    manifest: Pick<WalkthroughManifest, "blocked">;
+}, opts?: Pick<CompleteOptions, "force">): Promise<string[]>;
 /** `complete --json` output: the canonical plus whichever extras exist. */
 export declare function completeJsonPayload(canonical: CanonicalWalkthrough, extras: CompletionExtras): Record<string, unknown>;
 /** Non-fatal provenance warnings; prints nothing for a clean audit. */
@@ -99,6 +112,14 @@ type AssembledRunFiles = {
  * stages that re-derive them in parallel never interleave.
  */
 export declare function assembleRun(projectRoot: string, runId: string, manifest: WalkthroughManifest, completedAt: string): Promise<AssembledRunFiles>;
+/**
+ * {@link assembleRun} for a caller that already holds the run's record
+ * lock (`withRunLock` is not re-entrant). The record stages take the lock
+ * around their finding writes and this re-derivation together, so another
+ * stage never reads half-written findings or overwrites the report with
+ * an older canonical.
+ */
+export declare function assembleRunUnlocked(projectRoot: string, runId: string, manifest: WalkthroughManifest, completedAt: string): Promise<AssembledRunFiles>;
 /** One requested place, whether the run reached it, and what awaits there. */
 export type RevisitReportPlace = RevisitPlaceCoverage & {
     findings: Array<{

package/dist/commands/completion.d.ts

@@ -1,2 +1,4 @@
 import type { Command } from "commander";
+/** Shells `iamu completion [shell]` writes a script for. */
+export declare const SHELLS: readonly ["bash", "zsh", "fish"];
 export declare function completion(program: Command, shell?: string): void;

package/dist/commands/context.d.ts

@@ -52,6 +52,7 @@ export declare function resolveRunId(projectRoot: string, explicitRunId?: string
  */
 export declare function reportFatalError(err: unknown, argv?: readonly string[]): void;
 export declare function resolveProject(opts?: {
+    cwd?: string;
     json?: boolean | string;
 }): Promise<ProjectContext | null>;
 /**
@@ -72,3 +73,21 @@ export declare function resolveCloudProject(opts?: {
 export declare function safeReadEntity<T extends object = Record<string, unknown>>(projectRoot: string, type: EntityType, slug: string, opts?: {
     json?: boolean | string;
 }): Promise<Awaited<ReturnType<typeof readEntity<T>>> | null>;
+/**
+ * Refuse to record into a run that `iamu complete` already finished:
+ * canonical.json and report.md were derived from what was there, and a
+ * later step, finding or summary would leave them silently stale.
+ * `force` records anyway; the caller then re-derives with
+ * `iamu complete <run-id> --force`. A run without a readable manifest
+ * is not refused here (the writer reports what it needs).
+ *
+ * @returns true when the caller may write; false once the refusal has
+ *   been reported (exit code 1).
+ */
+export declare function refuseCompletedRun(runDirPath: string, runId: string, opts: {
+    json?: boolean;
+    force?: boolean;
+}, report?: (message: string, diag: {
+    code: string;
+    fix: string;
+}) => void): boolean;

package/dist/commands/dev-script.d.ts

@@ -0,0 +1,14 @@
+export type PackageManager = "pnpm" | "npm" | "yarn" | "bun";
+export interface DevScripts {
+    manager: PackageManager;
+    /** Scripts that look like they start the app, in preference order. */
+    scripts: string[];
+}
+/**
+ * The dev scripts `projectRoot`'s package.json declares. `null` without a
+ * readable package.json; an empty `scripts` list when it has none that
+ * start the app.
+ */
+export declare function detectDevScripts(projectRoot: string): DevScripts | null;
+/** The shell command that runs `script` with `manager`. */
+export declare function devCommand(manager: PackageManager, script: string): string;

package/dist/commands/doctor.d.ts

@@ -18,6 +18,12 @@ export interface DoctorResult {
 export declare function checkPortAvailable(port: number): Promise<boolean>;
 /** Check CDP responsiveness on a port */
 export declare function checkCdpResponsive(port: number): Promise<boolean>;
+/**
+ * The testability status a target URL earns when a person sets it:
+ * `verified` when it answers the probe (any response short of a server
+ * error, an external auth redirect included), else `configured`.
+ */
+export declare function probeTargetStatus(targetUrl: string): Promise<"verified" | "configured">;
 export declare function checkTargetHealth(targetUrl: string): Promise<DoctorCheck[]>;
 export declare function checkProjectHarnesses(projectRoot: string): Promise<DoctorCheck[]>;
 export declare function checkProjectTestabilityContract(projectRoot: string): Promise<{

package/dist/commands/edit-entity.d.ts

@@ -1,8 +1,10 @@
 export interface EditEntityOptions {
     json?: boolean;
 }
+/** Types `iamu edit <type>` opens: every entity plus project config. */
+export declare const EDITABLE_TYPES: readonly ["persona", "capability", "outline", "scenario", "finding", "source", "guidance", "testability", "context"];
 /**
- * Open an entity in the user's $EDITOR or $VISUAL, and validate its frontmatter
- * against the entity schema on exit.
+ * Open an entity or project configuration file in the user's $EDITOR or $VISUAL,
+ * and validate its frontmatter against the schema on exit.
  */
-export declare function editEntity(type: string, slug: string, opts?: EditEntityOptions): Promise<void>;
+export declare function editEntity(type: string, slug?: string, opts?: EditEntityOptions): Promise<void>;

package/dist/commands/evaluate.d.ts

@@ -23,17 +23,24 @@ export declare function applyVerdicts(canonical: CanonicalWalkthrough, recorded:
  * walkthrough for report markdown rendering.
  */
 export declare function applyRecordedVerdicts(canonical: CanonicalWalkthrough, runDirPath: string): Promise<CanonicalWalkthrough>;
-export declare function evaluate(runId: string, opts?: {
+export interface EvaluateOptions {
+    run?: string;
     json?: boolean;
     promptFile?: string;
-}): Promise<void>;
+}
+export declare function evaluate(runIdArg?: string, opts?: EvaluateOptions): Promise<void>;
 export interface EvaluateRecordOptions {
+    run?: string;
     file?: string;
     data?: string;
     json?: boolean;
+    /** @deprecated No-op since evaluate-record stopped prompting (removed in 0.9.0). */
     yes?: boolean;
+    /** @deprecated No-op since evaluate-record stopped prompting (removed in 0.9.0). */
     prompt?: boolean;
+    /** @deprecated No-op since evaluate-record stopped prompting (removed in 0.9.0). */
     view?: boolean;
+    /** @deprecated No-op since evaluate-record stopped pushing (removed in 0.9.0). */
     push?: boolean;
 }
-export declare function evaluateRecord(runId: string, opts: EvaluateRecordOptions): Promise<void>;
+export declare function evaluateRecord(runIdArg: string | undefined, opts: EvaluateRecordOptions): Promise<void>;

package/dist/commands/finding-stability.d.ts

@@ -46,6 +46,7 @@ interface HistoryFinding {
     scenario?: string;
     canonical_id?: string;
     triage_status?: string;
+    addressed_at?: string | null;
     updated_at?: string;
     created_at?: string;
     source?: string;

package/dist/commands/findings.d.ts

@@ -1,7 +1,16 @@
 export declare function findings(opts?: {
     open?: boolean;
+    /** Fix applied (`triage_status: addressed`), whatever its fix state. */
+    addressed?: boolean;
+    /** Hidden alias of `addressed`, kept for one release. */
     resolved?: boolean;
     dismissed?: boolean;
+    deferred?: boolean;
+    status?: string;
+    /** Only findings an active tester guidance rule flagged. */
+    flagged?: boolean;
+    /** Only addressed findings in this fix state. */
+    fixState?: string;
     scenario?: string;
     /** Only the persona's, or only the designer's. Default: both. */
     source?: string;

package/dist/commands/init.d.ts

@@ -1,25 +1,34 @@
+import { type TestabilityStatus } from "@iamu-dev/protocol";
 import type { HostAdapter } from "../adapters/types.js";
 /**
  * The setup skill as the user will see it. With the Iamu plugin enabled,
- * Claude Code has `/iamu:init` and no `iamu-setup`.
+ * Claude Code has `/iamu:init` and no `iamu-setup` (see `skillCommand`).
  */
 export declare function setupCommand(projectRoot: string, hosts: HostAdapter[]): string;
+/**
+ * The "start your dev server" line of the init summary: the project's own
+ * dev script under its package manager, the recorded `dev_command`, or
+ * an honest "none found" — never a guessed `pnpm dev`.
+ */
+export declare function devServerHint(projectRoot: string, devCommandRecorded?: string | null): string;
 /**
  * Detect the target port for local dev execution.
  * Checks, in order:
  * 1. process.env.PORT
- * 2. .env files (.env.local, .env.development, .env) for PORT, VITE_PORT, APP_URL, NEXT_PUBLIC_APP_URL
- * 3. package.json scripts for `-p <port>` or `--port <port>` flags
- * 4. package.json dependencies and framework config files (vite -> 5173, astro -> 4321)
+ * 2. Root .env files, vite/astro config `port:`, package.json scripts/deps
+ * 3. Monorepo workspace subdirectories (apps/*, packages/*, web, frontend, client)
  */
 export declare function detectTargetPort(projectRoot: string): number | undefined;
 export declare function detectTargetUrl(projectRoot: string): string;
-export declare function createDraftTestabilityContent(targetUrl?: string): string;
+/** The target line of the init summary, by testability status. */
+export declare function describeTargetStatus(status: TestabilityStatus): string;
+export declare function createDraftTestabilityContent(targetUrl?: string, status?: TestabilityStatus): string;
 export interface InitOptions {
     name?: string;
     yes?: boolean;
     json?: boolean;
     cloud?: boolean;
+    target?: string;
 }
 /**
  * Scaffold `iamu/` and install skills for the detected hosts.

package/dist/commands/instructions-walk.d.ts

@@ -1,5 +1,11 @@
 import { type GuidanceRule, type RevisitPlace } from "@iamu-dev/local-store";
 import { type RunViewport, type ScenarioState } from "@iamu-dev/protocol";
+/**
+ * How to invoke this very CLI from a subagent's shell. Aliases and
+ * shell functions do not exist there, so name the executable that is
+ * running now.
+ */
+export declare function selfCommand(execPath?: string, scriptPath?: string): string;
 /** "The browser is sized as a phone screen, 390×844." */
 export declare function viewportLine(v: RunViewport): string;
 interface WalkerPromptParts {
@@ -9,6 +15,8 @@ interface WalkerPromptParts {
         role: string;
         disposition: string | null;
         background: string | null;
+        /** The persona's `## Today` section: how they do the job today. */
+        today?: string | null;
     };
     outline: {
         title: string;

package/dist/commands/instructions.d.ts

@@ -12,18 +12,9 @@ export declare function instructionsStage(slug?: string, opts?: {
     json?: boolean;
 }): Promise<void>;
 /**
- * Generates dynamic setup instructions for the project.
+ * Phases `iamu instructions [phase]` serves (`run` is an alias of `walk`).
  */
-export declare function instructionsSetup(opts?: {
-    json?: boolean;
-}): Promise<void>;
-/**
- * Generates dynamic triage instructions for reviewing run findings.
- */
-export declare function instructionsTriage(slug?: string, opts?: {
-    run?: string;
-    json?: boolean;
-}): Promise<void>;
+export declare const INSTRUCTION_PHASES: string[];
 /**
  * Top-level dispatcher for `iamu instructions [phase] [slug]`.
  */

package/dist/commands/list.d.ts

@@ -1,3 +1,6 @@
+import { type EntityType } from "@iamu-dev/protocol";
+/** `iamu list <type>` accepts each type by name or by these plurals. */
+export declare const PLURAL_LABELS: Record<EntityType, string>;
 export declare function list(type: string | undefined, opts: {
     capability?: string;
     diff?: string | boolean;

package/dist/commands/match.d.ts

@@ -3,18 +3,21 @@ import { type WalkthroughManifest } from "@iamu-dev/local-store";
 export declare function completedManifest(runDirPath: string, runId: string, opts?: {
     json?: boolean;
 }): Promise<WalkthroughManifest | null>;
+export interface MatchOptions {
+    run?: string;
+    json?: boolean;
+    promptFile?: string;
+}
 /**
  * Print the matcher's input bundle: this run's findings, the scenario's
  * earlier canonical findings, this run's steps, and the prompt.
  */
-export declare function match(runId: string, opts?: {
-    json?: boolean;
-    promptFile?: string;
-}): Promise<void>;
+export declare function match(runIdArg?: string, opts?: MatchOptions): Promise<void>;
 export interface MatchRecordOptions {
+    run?: string;
     file?: string;
     data?: string;
     json?: boolean;
 }
 /** Record the matcher's answer and re-derive the run's delta and report. */
-export declare function matchRecord(runId: string, opts: MatchRecordOptions): Promise<void>;
+export declare function matchRecord(runIdArg: string | undefined, opts: MatchRecordOptions): Promise<void>;

package/dist/commands/new-entity.d.ts

@@ -31,4 +31,6 @@ export interface NewEntityOptions {
     stateApproximation?: string;
     json?: boolean;
 }
+/** Entity types `iamu new <type>` creates (findings: `iamu new-finding`). */
+export declare const SUPPORTED_TYPES: readonly ["persona", "outline", "capability", "source", "scenario"];
 export declare function newEntity(type: string, opts: NewEntityOptions): Promise<void>;

package/dist/commands/new-finding.d.ts

@@ -22,6 +22,8 @@ export interface NewFindingOptions {
     recommendation?: string;
     /** Complete markdown body (overrides description and recommendation). */
     body?: string;
+    /** Record into a run that is already completed. */
+    force?: boolean;
     json?: boolean;
 }
 export declare function newFinding(opts: NewFindingOptions): Promise<void>;

package/dist/commands/persona-today.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A persona's baseline: the `## Today` section of the persona body, how
+ * this person does the job today (a paper sheet, a spreadsheet, phone
+ * calls, another tool). The walker compares the product against it and
+ * the judge weighs voluntary use against it. A body heading, not a
+ * frontmatter field, so no schema changes.
+ */
+/**
+ * Split a persona body into its `## Today` section and the rest. The
+ * section runs to the next heading of level one or two, or the end.
+ * `today` is null when there is no such section or it is empty.
+ *
+ * @example
+ * splitPersonaToday("Fixes taps.\n\n## Today\nA paper job sheet.")
+ * // → { today: "A paper job sheet.", rest: "Fixes taps." }
+ */
+export declare function splitPersonaToday(body: string): {
+    today: string | null;
+    rest: string;
+};

package/dist/commands/preflight.d.ts

@@ -10,14 +10,16 @@ export interface PreflightCheckResult {
     reason?: string;
 }
 /**
- * Detect the fast compile/typecheck/lint command for a target project.
+ * Detect the fast compile/typecheck command for a target project.
+ * Deliberately excludes lint scripts (`check`, `eslint`, `biome check`) so
+ * lint rules never block walkthrough execution.
  */
 export declare function detectPreflightCommand(targetDir: string): Promise<{
     command: string;
     args: string[];
 } | null>;
 /**
- * Executes a fast preflight type/lint check.
+ * Executes a fast preflight typecheck.
  */
 export declare function runPreflightCheck(targetDir: string): Promise<PreflightCheckResult>;
 /**

package/dist/commands/pull.d.ts

@@ -1,4 +1,4 @@
-export declare function pull(opts?: {
+export declare function pull(refs?: string[], opts?: {
     force?: boolean;
     preview?: boolean;
     json?: boolean;