@iamu-dev/iamu 0.0.0-stage → 0.2.0-beta.10

package/dist/templates/skills/iamu-setup.md

@@ -0,0 +1,270 @@
+---
+name: iamu-setup
+description: Set up a project for iamu — scaffold the iamu/ tree, capture domain context, seed primary persona, and draft inaugural scenario. Ready to run immediately via iamu-run.
+generatedBy: __IAMU_VERSION__
+---
+
+Set up a project for scenario-driven walkthroughs — all local, no cloud required. Scaffolds an `iamu/` tree under your project root, analyzes the repo to compose a project-context summary, persists context to `iamu/context.yml`, seeds 1 primary persona into `iamu/personas/`, and drafts 1 inaugural scenario into `iamu/scenarios/`. Ready to run immediately with `iamu-run`.
+
+Model reminder (internal — users never type these): `capability → scenario → run → finding`. A scenario is the runnable thing — a situation narrative bound to a persona. Capabilities are optional labels that group scenarios. `iamu-new` creates scenarios; `iamu-run` executes them; `iamu-findings` reviews results.
+
+What this skill does, end to end:
+
+- **Scaffold** — `iamu/` tree on disk via `iamu init`. No login, no cloud.
+- **Understand** — read the repo to identify domain, primary user archetypes, reachable routes, and testability.
+- **Propose & Scaffold Baseline** — present a single unified briefing: domain narrative, primary persona, and inaugural scenario. On confirmation ("yes"), scaffold `context.yml`, `testability.md`, persona, outline, and scenario to disk.
+- **Next Action** — point directly to `iamu-run <scenario>` with copy-pasteable execution command.
+- **Cloud (optional)** — offer to link to Iamu cloud for sharing / teams / managed runs via `iamu auth login`. User can accept, skip, or defer.
+
+$ARGUMENTS
+
+## Steps
+
+### 1. Scaffold the iamu/ tree
+
+Check whether `iamu/config.json` already exists:
+
+- **If already scaffolded (`iamu/config.json` exists):** Do not re-run `iamu init`. Introduce the step concisely and proceed directly to Step 2:
+  > Analyzing your codebase now to map the domain, primary persona, and first test scenario.
+- **If not yet scaffolded:** Run `iamu init [project-name]` in the terminal (pass a project name if the user named one explicitly; otherwise omit). The command scaffolds `iamu/config.json`, entity subdirs, `.runs/`, `.cache/`, `.gitignore`.
+  Introduce iamu first:
+  > **iamu** tests your product as realistic personas and reports what works, what doesn't, and how to fix it. I'll analyze your codebase now to map the domain and prepare your first test scenario.
+- **Error containing "legacy `.iamu/` layout"** → tell the user to remove the legacy directory, then re-run.
+
+### 2. Understand the project
+
+Explore the codebase automatically — do NOT ask the user what files to read. Extract domain and environment facts strictly from code:
+
+1. **Framework & Dev Server Port Detection:**
+   - Inspect package manifests: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`.
+   - Read framework configs to reliably extract default dev ports:
+     - `vite.config.*` / `svelte.config.*` → default port 5173
+     - `astro.config.*` → default port 4321
+     - `next.config.*` / Rails / Remix → default port 3000
+     - `wrangler.toml` / `wrangler.json` (Cloudflare Workers/Pages)
+     - `docker-compose.yml`
+   - Read `.env`, `.env.development`, `.env.local` for `PORT`, `VITE_PORT`, `NEXT_PUBLIC_APP_URL`.
+   - If unsure, check port reachability on common ports (3000, 5173, 8080, 4321).
+2. **Reachable Entry Route:**
+   - Scan page directories: `app/**/page.tsx`, `pages/**/*.tsx`, `src/routes/**/*.svelte`, React Router `routes.ts`/`App.tsx`.
+   - Pick a concrete static route (e.g. `/incidents/new`, `/cart`, `/checkout`), NOT an unresolved parameterized path (`/projects/:id`) unless seed fixture IDs are known.
+3. **Auth & Persona Access:**
+   - Inspect auth route guards (`middleware.ts`, ProtectedRoute, session hooks).
+   - Identify dev bypass (`MOCK_AUTH`), test accounts/fixtures, persona switcher, or public access.
+4. **Domain Narrative & Cast:**
+   - Read `README.md`, `CLAUDE.md`, docs, OpenAPI / JSON schemas, user models.
+   - Extract 1 primary protagonist and 2 secondary actors from real user roles.
+   - **STRICT REGULATION RULE:** Never infer regulations from industry keywords. Only include `governed_by` if the codebase explicitly references specific legislation or statutory standards. Non-regulated software is the default — omit `governed_by` entirely if absent.
+5. **Primary Persona Rigor:**
+   - Follow `iamu/.prompts/persona.md`: no generic marketing adjectives ("tech-savvy", "coffee lover"). Ground in working physical reality, time pressure, and concrete diagnostic friction / bounce conditions. True whether the product exists or not.
+
+Synthesize the project into a cohesive, substantive narrative (1–2 paragraphs):
+- What the product fundamentally is, its primary domain, and who uses it.
+- Key user journeys and operational characteristics (e.g. mobile floor use, audit deadlines).
+- Market and geography (only if evident).
+
+Audit testability and target environment:
+Inspect `package.json` dev scripts, existing mock harnesses (MSW, seed scripts), auth route guards (`middleware.ts`, ProtectedRoute, session hooks), and page/route directories (`app/`, `src/routes/`). Use these findings to populate `iamu/testability.md`.
+
+**If there is no code (greenfield, design phase, or test sandbox):** do NOT interrogate the user with a multi-part survey or ask for dev auth plumbing. Ask for a single entry point:
+> No local codebase detected. To seed context, provide one of:
+> - A target URL (staging, production, or docs — e.g., `https://app.example.com`)
+> - A one-sentence description of what this product does
+> - Or type `"sandbox"` to seed a pre-configured B2B SaaS demo
+
+**Autonomous Enrichment:**
+- **URL provided:** Fetch or search public marketing/docs for that site. Automatically extract the substantive narrative, core user journeys, and key actors.
+- **One-sentence summary provided:** Immediately expand into a full substantive narrative using domain knowledge.
+- **"sandbox" provided:** Seed a standard B2B SaaS narrative with Admin and End-User roles.
+
+### 3. Present Unified Baseline Proposal (Single Confirmation Gate)
+
+Present the discovered domain context, 1 primary persona, and 1 inaugural scenario in a single scannable briefing.
+
+Do NOT wrap the briefing in a markdown code fence (` ``` `). Output normal markdown so the user's terminal formats bolding and layout cleanly.
+Do NOT split this into multiple sequential permission questions. Present the complete baseline package at once:
+
+Discovered Project Context:
+  Domain:       <domain name, e.g. workplace safety management>
+  Scope:        <Jurisdiction or "Standard Web App / Unregulated">
+  Cast:         <Primary Protagonist> (protagonist), <Secondary Actor 1>, <Secondary Actor 2>
+  Target:       <target_url, e.g. http://localhost:5173> (Dev Command: `<dev_command, e.g. pnpm dev>`)
+  Auth Access:  <How walker assumes role, e.g. "Dev persona switcher" or "Public">
+
+<1 cohesive paragraph: what the product fundamentally is, who actually uses it, and its core operational reality. No marketing fluff, no hedging, and no tech stack trivia.>
+
+Baseline Test Proposal (WYSIWGW Spec-Sheet):
+  Persona:      <Name> (<Role / Title>)
+                • Reality: <Working context, physical habits, tenure>
+                • Friction: <Diagnostic friction, skepticism, bounce trigger>
+  Situation:    <Outline Title>
+                • Tension: <Core problem-space tension in X vs Y format — no UI button names>
+                • Evaluation Checkpoint: <Concrete binary yes/partial/no question for evaluator>
+  Walk Surface: Entry: `<entry_path>` | Target: `<target_url>`
+  Walker Brief: "<2–3 sentence first-person test brief that will be written verbatim to disk. States immediate intent and constraints before opening tool. Zero UI terminology.>"
+
+---
+
+**Interactive Decision:**
+Prompt the user to confirm or adjust the baseline:
+- If your environment provides an interactive user-prompt tool (e.g. `ask_question`, `ask_followup_question`), invoke it:
+  - Question: "Scaffold this iamu test baseline?"
+  - Options:
+    1. "[Recommended] Scaffold baseline and prepare first walkthrough"
+    2. "Switch perspective: Walk as <Secondary Actor 1 Name> (<Role>)"
+    3. "Adjust domain context, target URL, or persona details"
+- Otherwise (in CLI or text-only environments), present them as an enumerated list:
+
+Scaffold this iamu test baseline?
+  1. [Recommended] Scaffold baseline and prepare first walkthrough
+  2. Switch perspective: Walk as <Secondary Actor 1 Name> (<Role>)
+  3. Adjust domain, target URL, or persona details
+
+Press Enter to accept [1], select 2, or tell me what to adjust:
+(Treat empty Enter or return as Option 1)
+
+### 4. Scaffold the Test Suite Atomically
+
+When the user selects Option 1 (or confirms):
+
+1. **Write `iamu/context.yml`**:
+   Derive the structured frontmatter fields (`domain`, `actors`, `jurisdiction`, `governed_by`) from the confirmed text, and write `iamu/context.yml` with your file-editing tool. Put structured fields in frontmatter and the substantive narrative in the markdown body below the `---`:
+
+   ```yaml
+   ---
+   schema_version: 1
+   domain: workplace safety management
+   # jurisdiction: Sweden / EU          # optional
+   # governed_by:                       # strictly optional - omit if not regulated
+   #   - name: AFS 2023:2
+   #     authority_level: regulation
+   actors:
+     - name: Store Admin
+       role: Manages catalog, inventory, and order fulfillment
+     - name: First-Time Buyer
+       role: Explores products, adds to cart, and checks out
+     - name: Customer Support Agent
+       role: Handles order discrepancies, refunds, and customer inquiries
+   access: >-
+     No login in dev. In the page, set localStorage "dev_persona" to the
+     persona's access value and reload.
+   ---
+
+   <The substantive 1–2 paragraph project description and core user journeys>
+   ```
+
+   Rules:
+   - `domain` — one line. Mandatory.
+   - Body markdown (below `---`) — substantive description and user journeys. Downstream skills read this as extended grounding.
+   - `jurisdiction` — optional. Only if evident or relevant.
+   - `governed_by[]` — strictly optional. Order by authority. Omit entirely if no regulations apply.
+   - `actors[]` — all identified roles and their responsibilities. Keep secondary roles here so context has cast depth.
+   - `access` — optional. Only what the docs actually say; leave it out rather than guess.
+   - Do NOT add `industry` or `architecture` — these don't affect walkthroughs.
+
+2. **Write `iamu/testability.md`**:
+   Scaffold the target environment, dev command, auth strategy, reachable surfaces, mock harnesses, and untestable boundaries discovered from the code:
+
+   ```markdown
+   ---
+   target_url: http://localhost:3000
+   dev_command: <detected dev script, e.g. pnpm dev or pnpm dev:mock>
+   auth_strategy: <dev_switcher | interactive | test_accounts | public>
+   harnesses:
+     - <detected harnesses, e.g. msw, seed>
+   ---
+
+   # Project Testability & Environment
+
+   ## Target & Run Instructions
+   - Command: <dev command>
+   - Base URL: <target_url>
+
+   ## Auth & Access Boundary
+   - <How a walker becomes this persona in dev or test mode>
+
+   ## Reachable Surfaces
+   - <List discovered routes/entry points, e.g. /login, /dashboard, /incidents>
+
+   ## Mocks & Data Fixtures
+   - <List existing MSW mock files, DB seed scripts, or fixture directories>
+
+   ## Untestable Boundaries (Do Not Walk)
+   - <List un-mocked external dependencies, e.g. live Stripe charges, SMS 2FA, external SSO>
+   ```
+
+   Keep `context.yml` strictly about domain reality (which the Walker subagent reads), and `testability.md` strictly about developer testability and execution boundaries (which orchestrator skills read).
+
+3. **Scaffold Primary Persona**:
+   Scaffold 1 primary protagonist into `iamu/personas/<persona-slug>.md` using the CLI:
+   ```bash
+   iamu new persona --name "<Name>" --role "<Role>" --disposition "<Disposition>" --body "<2-4 sentence narrative detailing technical habits, patience level, and specific friction triggers>" [--access "<account-or-role>"] --json
+   ```
+
+4. **Scaffold Situation Outline**:
+   Scaffold the inaugural outline into `iamu/outlines/<outline-slug>.md` using the CLI:
+   ```bash
+   iamu new outline --name "<Outline Title>" --tension "<Core Tension>" --human-test "<Concrete yes/partial/no evaluation question>" --narrative "<2-3 sentence problem-space narrative without UI terms>" --json
+   ```
+
+5. **Scaffold Bound Scenario**:
+   Bind the persona and outline into `iamu/scenarios/<persona-slug>--<outline-slug>.md` using the CLI:
+   ```bash
+   iamu new scenario --name "<persona-slug>--<outline-slug>" --outline "<outline-slug>" --persona "<persona-slug>" --entry "<entry_path>" --body "<Persona's first-person test brief describing what they intend to achieve>" --json
+   ```
+
+6. **Validate all entities**:
+   ```bash
+   iamu validate --all
+   ```
+
+7. **Present Completion & Immediate Next Action**:
+   Render the visual scaffolding tree and provide the direct command to run the walkthrough:
+
+   ```text
+   ✓ Scaffolding complete:
+
+     iamu/
+     ├── context.yml          [domain: <domain>]
+     ├── testability.md       [target: <target_url>]
+     ├── personas/
+     │   └── <persona-slug>.md
+     ├── outlines/
+     │   └── <outline-slug>.md
+     └── scenarios/
+         └── <persona-slug>--<outline-slug>.md
+
+   Next step:
+     Ensure your dev server is running on <target_url>, then run:
+
+       $ iamu-run <persona-slug>--<outline-slug>
+
+   Other commands when you're ready:
+   • iamu-new      Draft a scenario for a different product flow
+   • iamu-propose  Brainstorm high-risk workflows and blind spots
+   • iamu doctor   Diagnose test environment and target health
+   • iamu auth login  Link to Iamu Cloud to share run reports with your team (optional)
+   ```
+
+### 5. Cloud link (optional)
+
+Cloud linking is optional and non-blocking. It is recommended after executing your first walkthrough so you have run reports and findings to share.
+
+If the user explicitly asks to link during setup:
+1. Tell the user: "Opening browser for Iamu Cloud login..." then run `iamu auth login`. Allow the command at least 150 seconds for the user to complete sign-in in their browser. If your shell cannot wait that long, or runs where no browser can open (remote or container session), ask the user to run `iamu auth login` in their own terminal and tell you when it is done.
+2. In a non-interactive shell with existing cloud projects, login stops after sign-in and lists them as `iamu auth login --project <id>` lines plus `--project new`. Show that list, ask which project this repository belongs to, then re-run with their choice.
+3. On success the output ends with `Dashboard: <url>` and registered MCP server.
+
+If login times out or fails:
+- "Your local project setup is 100% complete and fully functional. Personas, scenarios, outlines, and walkthroughs run locally without cloud."
+- Point to: `iamu-run <persona-slug>--<outline-slug>`.
+
+## Guidelines
+
+- **Baseline is runnable immediately.** Setup scaffolds configuration, 1 primary persona, 1 outline, and 1 bound scenario. The project graduates from setup in a 100% runnable state.
+- **Clean terminal formatting.** Do not wrap agent briefings in markdown code fences (` ``` `). Use fixed column alignment for attributes and clean tree diagrams for generated files.
+- **Non-regulated software is the default.** Do not invent or force regulations (`governed_by`) on apps, developer tools, or consumer software. If the codebase has no compliance documentation, omit `governed_by` entirely.
+- **Explore automatically.** Read the codebase before asking the user anything. The user should only need to confirm or correct, not describe their own project from scratch.
+- **Context on disk is load-bearing.** Once step 4 writes `iamu/context.yml`, every downstream skill (`iamu-new`, `iamu-run`) auto-loads it.
+- **Handle re-runs gracefully.** An already-scaffolded project is a no-op on scaffold, a refresh on context/personas/scenarios (if the user opts in), and a re-prompt on cloud link.
+- **Handle errors gracefully.** Unreachable file → note it, move on. Unreachable cloud → report and let the user retry or defer.

package/dist/templates/skills/iamu-status.md

@@ -0,0 +1,71 @@
+---
+name: iamu-status
+description: Check project testing status, list installed personas, scenarios, outlines, capabilities, or review walkthrough coverage and findings. Use when asked "what personas do we have?", "what scenarios exist?", "what is the test status?", "list personas", "what should we test next?", or to inspect iamu assets.
+generatedBy: __IAMU_VERSION__
+---
+
+You are the project's scenario-testing librarian. Your job is to give concise, structured overviews of iamu assets and testing status without dumping raw file bodies.
+
+$ARGUMENTS
+
+## Instructions
+
+### 1. Always use CLI commands for inspection
+
+- **List personas:** `iamu list personas` (or `--json`)
+- **List scenarios:** `iamu list scenarios` (or `--json`)
+- **List capabilities:** `iamu list capabilities`
+- **List outlines:** `iamu list outlines`
+- **List findings:** `iamu findings`
+- **Project state & run status:** `iamu status`
+
+Do NOT use `find`, `grep`, or `cat` to dump raw `.md` files in `iamu/`. The CLI outputs clean, validated data.
+
+### 2. Format entity responses with an executive tally and clickable links
+
+When the user asks for project status, lead with an executive tally banner, followed by scannable tables with clickable markdown file links:
+
+```
+Project Status: <P> Personas · <S> Scenarios (<R> Tested, <U> Untested) · <F> Open Findings · <C> Capabilities
+```
+
+**Personas:**
+| Slug | Name | Role | Status |
+|---|---|---|---|
+| [`elin-dahl`](iamu/personas/elin-dahl.md) | Elin Dahl | Architect & first-time house owner in Falun | active |
+
+**Scenarios:**
+| Slug | Persona | Outline | Status / Target |
+|---|---|---|---|
+| [`replacing-windows`](iamu/scenarios/replacing-windows.md) | [`elin-dahl`](iamu/personas/elin-dahl.md) | [`measure-and-order`](iamu/outlines/measure-and-order.md) | ready |
+
+**Findings:**
+| # | Severity | Type | Finding | File |
+|---|---|---|---|---|
+| 1 | CRITICAL | hinders | Submit fails opaquely on empty field | [`view`](iamu/findings/<slug>.md) |
+
+### 3. Ignore internal templates
+
+The directory `iamu/.prompts/` contains internal prompt templates (`persona.md`, `outline.md`, etc.). These are NOT project entities. Never list them or explain them to the user.
+
+### 4. Cloud line
+
+For a project-status question, add one line on the cloud from `iamu status --json` (`mode`, `sync`, `requests`) and `iamu auth status --json` (`authenticated`):
+
+- **Linked** → `Cloud: linked — <url from iamu open --print>`, then only what needs action: unpushed changes (`sync.pending_new` + `sync.pending_updates` + `walkthroughs.pending`, and `sync.local_deletions.count`) → `iamu sync`; `requests.open` above zero → `<N> team requests — iamu-findings`.
+- **Linked, no credentials** → `Cloud: linked, but this machine has no credentials — iamu auth login.`
+- **Local-only** → `Cloud: local-only.` Nothing more; no upgrade pitch.
+
+### 5. Provide copy-pasteable next actions
+
+Conclude with exact copy-pasteable commands:
+
+```
+Next actions:
+  iamu-run <scenario-slug>              # Run a walkthrough for this scenario
+  iamu-propose                          # Propose missing personas or scenarios
+  iamu-new                              # Draft a new scenario or persona
+  iamu-findings                         # Triage open findings
+  iamu open                             # Open project in cloud dashboard
+```
+

package/dist/templates.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolves the root directory containing `templates/`.
+ * In development (source/vitest): import.meta.url is in `src/` or `src/commands/`,
+ * so templates are located at `src/templates`.
+ * In production bundle (tsup): import.meta.url is in `dist/`,
+ * and copy-assets.mjs copies templates to `dist/templates`.
+ */
+export declare function getTemplatesRoot(): string;
+export declare function getTemplateDir(subdir: "skills" | "prompts"): string;
+export declare function getTemplateFile(subdir: "skills" | "prompts", filename: string): string;

package/dist/ui/journey-diff.d.ts

@@ -0,0 +1,3 @@
+import type { JourneyDiff } from "@iamu-dev/local-store";
+export declare function formatJourneyDiffTerminal(diff: JourneyDiff): string;
+export declare function printJourneyDiff(diff: JourneyDiff): void;

package/dist/ui/json.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pick specified keys from an array of records or a single record.
+ * Supports comma-separated field list: e.g. "slug,name,role".
+ * If fields is boolean true or undefined/empty, returns target as-is.
+ */
+export declare function filterJsonFields<T extends Record<string, unknown>>(target: T[] | T, fields?: string | boolean): unknown;

package/dist/ui/logger.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Standard verbosity and quiet mode helpers driven by IAMU_QUIET and IAMU_VERBOSE environment variables.
+ */
+export declare function isQuiet(): boolean;
+export declare function isVerbose(): boolean;

package/dist/ui/panic.d.ts

@@ -0,0 +1,11 @@
+type SigintCleanup = () => Promise<void> | void;
+/**
+ * Registers an asynchronous cleanup handler to execute on SIGINT (e.g. closing an HTTP server).
+ * Returns an unregister function.
+ */
+export declare function registerSigintCleanup(handler: SigintCleanup): () => void;
+/**
+ * Registers global process handlers for graceful shutdown and top-level error boundaries.
+ */
+export declare function setupProcessHandlers(): void;
+export {};

package/dist/ui/symbols.d.ts

@@ -0,0 +1,11 @@
+export declare const symbols: {
+    success: string;
+    error: string;
+    pending: string;
+    warning: string;
+    modified: string;
+    add: string;
+    info: string;
+    dot: string;
+    question: string;
+};

package/dist/ui/table.d.ts

@@ -0,0 +1,20 @@
+export declare function stripAnsi(str: string): string;
+export declare function visualLength(str: string): number;
+export declare function padRight(str: string, targetWidth: number): string;
+export declare function truncate(str: string, maxWidth: number): string;
+export interface TableColumn<T> {
+    header: string;
+    value: (item: T) => string;
+    minWidth?: number;
+    maxWidth?: number;
+}
+export interface FormatTableOptions {
+    tty?: boolean;
+}
+/**
+ * Formats data into a cleanly aligned table with dynamically calculated column widths.
+ * Automatically accounts for ANSI color sequences in length calculations.
+ * When output is piped (!process.stdout.isTTY), automatically emits machine-readable
+ * Tab-Separated Values (TSV) without ANSI escapes, borders, or text truncation.
+ */
+export declare function formatTable<T>(items: T[], columns: TableColumn<T>[], options?: FormatTableOptions): string[];

package/dist/ui/update-check.d.ts

@@ -0,0 +1,6 @@
+export declare function isSemverGreater(latest: string, current: string): boolean;
+/**
+ * Non-blocking, cached check against npm registry for CLI updates.
+ */
+export declare function checkForUpdate(currentVersion: string): Promise<string | null>;
+export declare function printUpdateNotice(currentVersion: string, latestVersion: string): void;

package/dist/worktree-state.d.ts

@@ -0,0 +1,49 @@
+/** The build block's view of the working tree. */
+export interface WorktreeState {
+    git_dirty: boolean;
+    /** Only when dirty: 12 lowercase hex characters. */
+    worktree_hash?: string;
+}
+/** Answers the working-tree question for a project root. */
+export type WorktreeDetector = (projectRoot: string) => WorktreeState | undefined;
+/** Untracked files hashed at most; past this the count still counts. */
+export declare const MAX_UNTRACKED_HASHED = 2000;
+/**
+ * Whether the working tree has changes outside `iamu/`, and their
+ * fingerprint.
+ *
+ * Hash recipe (sha256, first 12 hex characters):
+ * 1. the bytes of `git diff HEAD --binary -- . ':(exclude)<iamu>'`, run
+ *    from the repository root with diff settings pinned;
+ * 2. then, for each untracked non-ignored file outside `iamu/` sorted by
+ *    path (bytewise, at most {@link MAX_UNTRACKED_HASHED}):
+ *    `<path>\0<sha256 of content>\n`, and past the cap `+<count>\n`.
+ *
+ * @example
+ * ```ts
+ * detectWorktreeState("/work/shop");
+ * // { git_dirty: true, worktree_hash: "3fa9c1d2e4b5" }
+ * ```
+ */
+export declare function detectWorktreeState(projectRoot: string, iamuDirName?: string): WorktreeState | undefined;
+/**
+ * Whether the product's code changed between `start-run` and `complete`.
+ * The build block's fingerprint is taken at start; an edit (or commit) made
+ * while the walker was out means the run's findings may mix two versions,
+ * and the build it lands in describes only the first.
+ *
+ * @param start - The run's recorded build block (`walkthrough.json`).
+ * @param now - The working tree as it is now.
+ * @returns A one-line warning, or null when nothing changed or either side
+ *   is unknown.
+ *
+ * @example
+ * ```ts
+ * codeChangedWarning({ git_dirty: false }, { git_dirty: true, worktree_hash: "a1b2c3d4e5f6" });
+ * // "the product's code changed during the walk …"
+ * ```
+ */
+export declare function codeChangedWarning(start: {
+    git_dirty?: boolean;
+    worktree_hash?: string;
+} | undefined, now: WorktreeState | undefined): string | null;

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@iamu-dev/iamu",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0-beta.10",
+  "type": "module",
+  "description": "Test your product as realistic personas — scenario-driven development CLI",
+  "license": "UNLICENSED",
+  "author": "Iamu <hello@iamu.dev>",
+  "homepage": "https://iamu.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iamu-dev/iamu.git",
+    "directory": "apps/cli"
+  },
+  "bugs": "https://github.com/iamu-dev/iamu/issues",
+  "keywords": [
+    "iamu",
+    "scenario-testing",
+    "persona-testing",
+    "walkthrough",
+    "ux-testing",
+    "devex",
+    "claude-code"
+  ],
+  "bin": {
+    "iamu": "./dist/bin.js"
+  },
+  "sideEffects": true,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "playwright-core": "^1.58.2",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.1.11",
+    "google-auth-library": "^11.1.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.11",
+    "@iamu-dev/local-store": "0.1.0",
+    "@iamu-dev/protocol": "0.1.0",
+    "@iamu/tsconfig": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup && tsc -b --force tsconfig.build.json --emitDeclarationOnly && node scripts/copy-assets.mjs",
+    "clean": "node -e \"fs.rmSync('dist', { recursive: true, force: true }); fs.rmSync('tsconfig.tsbuildinfo', { force: true }); fs.rmSync('tsconfig.build.tsbuildinfo', { force: true })\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "eval:walkthroughs": "vitest run --config vitest.benchmark.config.ts",
+    "eval:gemini": "node dist/eval/gemini-eval-cli.js",
+    "pack:dry-run": "npm pack --dry-run"
+  }
 }