@iamu-dev/iamu 0.8.0-beta.1 → 0.8.0-beta.3

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-driver.d.ts

@@ -44,6 +44,8 @@ export interface BrowserDriver {
     commandLine(pid: number): Promise<string | null>;
     /** Send SIGTERM to `pid`. Never throws. */
     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;
@@ -121,7 +123,9 @@ 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.

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;
@@ -76,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`.
@@ -118,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
@@ -214,6 +236,20 @@ returnTo?: string): Promise<ClearedStorage | {
  * @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,6 +1,8 @@
 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 or project configuration file in the user's $EDITOR or $VISUAL,
  * and validate its frontmatter against the schema on exit.

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,9 +1,16 @@
+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:
@@ -13,7 +20,9 @@ export declare function setupCommand(projectRoot: string, hosts: HostAdapter[]):
  */
 export declare function detectTargetPort(projectRoot: string): number | undefined;
 export declare function detectTargetUrl(projectRoot: string): string;
-export declare function createDraftTestabilityContent(targetUrl?: string, status?: "draft" | "verified"): 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;

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

@@ -15,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/post-walk.d.ts

@@ -0,0 +1,18 @@
+export interface PostWalkOptions {
+    run?: string;
+    critic?: boolean;
+    ux?: boolean;
+    byOrchestrator?: boolean;
+    json?: boolean;
+}
+/**
+ * Single-command post-walk orchestrator helper (`iamu post-walk [run-id]`).
+ *
+ * 1. Completes the run locally (`iamu complete --no-prompt --no-push`) if still `in-progress`.
+ * 2. Records any subagent answer files already present in `<run-dir>/`
+ *    (`matches.json`, `judge_answer.json` / `verdicts.json`, `advise_answer.json`,
+ *    `designer_answer.json`) in canonical lock-safe order.
+ * 3. Generates all remaining post-walk subagent prompts (`match_prompt.md`,
+ *    `judge_prompt.md`, `advise_prompt.md`, `designer_prompt.md`) in one hop.
+ */
+export declare function postWalk(runIdArg?: string, opts?: PostWalkOptions): Promise<void>;

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;

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

@@ -19,8 +19,16 @@ export interface SetEntityOptions {
     stateApproximation?: string;
     /** `false` clears scenario `state` (Commander defaults it to `true`). */
     state?: boolean;
+    /** Scenario bound persona slug, or `false` to clear. */
+    persona?: string | false;
+    /** Scenario outline slug. */
+    outline?: string | false;
     /** Persona access key or testability switching mechanism, or `false` to clear. */
     access?: string | false;
+    /** Persona role description. */
+    role?: string | false;
+    /** Persona disposition / attitude, or `false` to clear. */
+    disposition?: string | false;
     /** Capability route prefixes, comma-separated; replaces `paths`, or `false` to clear. */
     paths?: string | false;
     /** Capability route prefix to add (repeatable). */
@@ -33,6 +41,8 @@ export interface SetEntityOptions {
     capability?: string | false;
     /** Outline additional capabilities (comma-separated), or `false` to clear. */
     additionalCapabilities?: string | false;
+    /** Outline structural tension, or `false` to clear. */
+    tension?: string | false;
     /** Dev startup command, or `false` to clear (testability). */
     devCommand?: string | false;
     /** Authentication strategy (dev_switcher, interactive, test_accounts, public), or `false` to clear (testability). */
@@ -49,9 +59,9 @@ export interface SetEntityOptions {
     jurisdiction?: string | false;
     /** Orientation notes (context). */
     notes?: string | false;
-    /** Project description (context, alias for body narrative). */
+    /** Description (capability, outline, or context alias for body narrative). */
     description?: string | false;
-    /** Project name (context). */
+    /** Name or title (scenario, persona, outline, capability, context). */
     name?: string | false;
     /** Governing documents/standards (context patch). */
     governedBy?: ContextFrontmatter["governed_by"] | false;
@@ -59,12 +69,14 @@ export interface SetEntityOptions {
     actors?: ContextFrontmatter["actors"] | false;
     /** Domain glossary (context patch). */
     glossary?: ContextFrontmatter["glossary"] | false;
-    /** Markdown body narrative (testability, context). */
+    /** Markdown body narrative. */
     body?: string;
     /** JSON patch file (or - for stdin) containing staging fields. */
     file?: string;
     json?: boolean;
 }
+/** Fields `iamu set <type>` may change, by type (the keys are the types). */
+export declare const SETTABLE: Record<string, readonly (keyof SetEntityOptions)[]>;
 /**
  * `iamu set <type> <slug>` — change the staging fields of an existing
  * entity: a scenario's start path, target and starting state, a

package/dist/commands/skill-command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The command that runs skill `name` (`setup`, `run`, `findings`, …) in
+ * `projectRoot`, with `args` appended when given.
+ *
+ * @example
+ * ```ts
+ * skillCommand(root, "setup"); // "/iamu:init" with the plugin enabled
+ * skillCommand(root, "run", "maria--handoff"); // "/iamu-run maria--handoff"
+ * ```
+ */
+export declare function skillCommand(projectRoot: string, name: string, args?: string): string;
+/** The setup skill for `projectRoot`: what "run setup" means here. */
+export declare function setupSkill(projectRoot: string): string;

package/dist/commands/step.d.ts

@@ -79,6 +79,8 @@ export interface StepOptions {
     surface?: string;
     grounding?: string;
     maxSteps?: string | number;
+    /** Record into a run that is already completed. */
+    force?: boolean;
     json?: boolean;
 }
 /**

package/dist/commands/summary.d.ts

@@ -12,6 +12,8 @@ export interface SummaryOptions {
     /** The walk stopped before that: why. */
     stopped?: string;
     file?: string;
+    /** Record into a run that is already completed. */
+    force?: boolean;
     json?: boolean;
 }
 export interface SummaryData {

package/dist/commands/triage.d.ts

@@ -1,9 +1,13 @@
+/** Where a guidance rule written by `iamu triage --scope` applies. */
+export declare const SCOPES: readonly ["project", "outline", "capability"];
 export interface TriageOptions {
     status: string;
-    /** Why — the triager's words. Required when dismissing. */
+    /** Optional triage note or reason. */
     note?: string;
-    /** Dismiss reason: not_relevant | walker_error | duplicate. */
+    /** Dismiss reason: not_relevant | walker_error | out_of_scope | duplicate. */
     reason?: string;
+    /** Finding slug or id this repeats when dismissing as duplicate. */
+    duplicateOf?: string;
     /** Guidance rule text; defaults to "Don't report: <title>". */
     rule?: string;
     /** Where the guidance rule applies. Default: project. */
@@ -18,6 +22,19 @@ export interface TriageOptions {
     sweep?: boolean | string;
     json?: boolean;
 }
+/**
+ * What an addressed finding's fix now waits for: a re-run of its
+ * scenario (the persona's), or a designer's review of its screen.
+ */
+export interface AwaitingStep {
+    kind: "rerun" | "design_review";
+    /** The scenario to re-run (`rerun`). */
+    scenario?: string;
+    /** The screen to review (`design_review`). */
+    screen?: string;
+    /** The command that produces the proof. */
+    command: string;
+}
 /**
  * Set the triage status of one or more findings. Dismissing as
  * `not_relevant` or `walker_error` also writes a tester guidance rule