@iamu-dev/iamu 0.2.0-beta.1 → 0.2.0-beta.10

package/dist/bin.js

@@ -200,17 +200,24 @@ function defaultConfig(params) {
     cloud_api_url: null
   };
 }
-var baseProjectFields, localOnlyConfig, cloudLinkedConfig, projectConfigSchema;
+var modelTierSchema, projectModelsConfigSchema, baseProjectFields, localOnlyConfig, cloudLinkedConfig, projectConfigSchema;
 var init_config = __esm({
   "../../packages/protocol/dist/schemas/frontmatter/config.js"() {
     "use strict";
     init_common();
     init_version();
+    modelTierSchema = z4.string().min(1).max(128).describe("Model role tier ('fast', 'thorough', 'inherit') or a specific model identifier.");
+    projectModelsConfigSchema = z4.object({
+      walker: modelTierSchema.optional(),
+      matcher: modelTierSchema.optional(),
+      judge: modelTierSchema.optional()
+    }).strict();
     baseProjectFields = {
       schema_version: z4.literal(SCHEMA_VERSION),
       id: uuidSchema,
       project_slug: slugSchema,
-      project_name: z4.string().min(1)
+      project_name: z4.string().min(1),
+      models: projectModelsConfigSchema.optional()
     };
     localOnlyConfig = z4.object({
       ...baseProjectFields,
@@ -817,7 +824,14 @@ var init_scenario = __esm({
       reviews: z15.array(z15.string().min(1).max(64)).max(16).default([]),
       baseline_score: z15.number().min(0).max(100).nullish(),
       current_score: z15.number().min(0).max(100).nullish(),
-      target_score: z15.number().min(0).max(100).default(95)
+      target_score: z15.number().min(0).max(100).default(95),
+      /** Environment state preconditions and approximation guidance. */
+      state: z15.object({
+        /** Description of data/records expected to exist in the environment. */
+        description: z15.string().max(2048).nullish(),
+        /** Guidance on how to squint or approximate if exact records are absent. */
+        approximation: z15.string().max(2048).nullish()
+      }).nullish()
     });
   }
 });
@@ -1154,7 +1168,21 @@ var init_walkthrough_bundle = __esm({
           judge_prompt: z19.string().optional(),
           judge_model: z19.string().optional()
         }).optional()
-      }).optional()
+      }).optional(),
+      models: z19.object({
+        walker: z19.string().optional(),
+        matcher: z19.string().optional(),
+        judge: z19.string().optional(),
+        walker_reported: z19.string().optional(),
+        matcher_reported: z19.string().optional(),
+        judge_reported: z19.string().optional(),
+        walker_tier: z19.string().optional(),
+        matcher_tier: z19.string().optional(),
+        judge_tier: z19.string().optional(),
+        execution_mode: z19.enum(["multi_agent", "single_agent"]).optional(),
+        velocity_sec_per_step: z19.number().optional(),
+        total_duration_sec: z19.number().optional()
+      }).optional().describe("AI model configuration and reported runtime provenance for this walkthrough.")
     });
     walkthroughBundleSchema = z19.object({
       manifest: bundleManifestSchema,
@@ -1377,6 +1405,7 @@ var init_walkthrough_canonical = __esm({
       build: buildMetadataSchema.optional(),
       viewport: runViewportSchema.optional(),
       environment: z20.string().optional(),
+      models: z20.record(z20.unknown()).optional(),
       findings: z20.array(canonicalFindingSchema),
       steps: z20.array(canonicalStepSchema),
       human_tests: z20.array(canonicalHumanTestSchema),
@@ -7248,6 +7277,7 @@ async function buildCanonical(projectRoot, manifest, completedAt, inputs) {
     ...manifest.build ? { build: manifest.build } : {},
     ...manifest.viewport ? { viewport: manifest.viewport } : {},
     ...manifest.environment ? { environment: manifest.environment } : {},
+    ...manifest.models ? { models: manifest.models } : {},
     findings: canonicalFindings,
     steps: canonicalSteps,
     human_tests: humanTests,
@@ -7408,6 +7438,20 @@ function renderCanonicalMarkdown(canonical) {
     lines.push(`- Viewport: ${canonical.viewport.device} (${canonical.viewport.width}\xD7${canonical.viewport.height})`);
   }
   lines.push(`- Started: ${canonical.provenance.started_at}`, `- Completed: ${canonical.provenance.completed_at}`, `- Walker prompt: ${canonical.provenance.walker_prompt.id}@${canonical.provenance.walker_prompt.version}`, `- Findings: ${canonical.findings.length}`, `- Steps: ${canonical.steps.length}`);
+  const models = canonical.models;
+  if (models) {
+    const parts = [
+      models.walker ? `Walker: ${models.walker}${models.walker_reported ? ` (${models.walker_reported})` : ""}` : "",
+      models.judge ? `Judge: ${models.judge}${models.judge_reported ? ` (${models.judge_reported})` : ""}` : "",
+      models.matcher ? `Matcher: ${models.matcher}` : ""
+    ].filter(Boolean);
+    if (parts.length > 0) {
+      lines.push(`- Models: ${parts.join(" \xB7 ")}`);
+    }
+    if (typeof models.velocity_sec_per_step === "number") {
+      lines.push(`- Velocity: ~${models.velocity_sec_per_step}s/step (${models.total_duration_sec}s total)`);
+    }
+  }
   const what = canonical.what_worked;
   if (what && what.length > 0) {
     lines.push("", "## What worked");
@@ -7777,6 +7821,7 @@ async function assembleWalkthroughBundle(projectRoot, runId) {
       report_markdown: report3,
       verdict: verdictArray,
       judge_meta: judgeMeta,
+      ...manifest.models ? { models: manifest.models } : {},
       ...buildFields(manifest),
       ...await readCanonicalExtras(projectRoot, runId)
     },
@@ -10443,9 +10488,275 @@ var init_prune = __esm({
   }
 });
 
-// ../../packages/local-store/dist/human-test-link.js
+// ../../packages/local-store/dist/explore-map.js
+import { randomBytes as randomBytes2 } from "crypto";
 import { promises as fs19 } from "fs";
 import path15 from "path";
+function templateToken(token) {
+  if (token === "")
+    return token;
+  if (/^\d+$/.test(token))
+    return ":id";
+  if (UUID.test(token))
+    return ":id";
+  if (DATE.test(token))
+    return ":date";
+  if (/^[0-9a-f]{8,}$/i.test(token) && /\d/.test(token))
+    return ":id";
+  if (token.length >= 16 && /\d/.test(token) && /[a-z]/i.test(token)) {
+    return ":id";
+  }
+  return token;
+}
+function templatePath(pathname) {
+  const trimmed = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname || "/";
+  return trimmed.split("/").map((seg) => templateToken(decodeSegment(seg))).join("/");
+}
+function encodeQueryValue(v) {
+  return v.startsWith(":") ? v : encodeURIComponent(v);
+}
+function decodeSegment(seg) {
+  try {
+    return decodeURIComponent(seg);
+  } catch {
+    return seg;
+  }
+}
+function explorePlaceKey(raw) {
+  if (!raw)
+    return null;
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    return null;
+  }
+  if (u.protocol !== "http:" && u.protocol !== "https:")
+    return null;
+  const params = [...u.searchParams.entries()].filter(([k]) => !k.toLowerCase().startsWith("utm_")).map(([k, v]) => [k, templateToken(v)]).sort(([a, av], [b, bv]) => a.localeCompare(b) || av.localeCompare(bv));
+  const query = params.map(([k, v]) => `${encodeURIComponent(k)}=${encodeQueryValue(v)}`).join("&");
+  let key = templatePath(u.pathname);
+  if (query)
+    key += `?${query}`;
+  const route = /^#!?(\/.*)$/.exec(u.hash);
+  if (route) {
+    const [hashPath] = route[1].split("?");
+    key += `#${templatePath(hashPath)}`;
+  }
+  return key;
+}
+function exploreViewSignature(headings) {
+  return headings.map((h) => h.trim().replace(/\s+/g, " ").replace(/\d+/g, "#").toLowerCase()).filter(Boolean).join(" | ");
+}
+function exploreSignature(headings, title) {
+  return exploreViewSignature(headings) || title.trim().toLowerCase();
+}
+function matchExploreSurface(map2, url, signature) {
+  const place = explorePlaceKey(url);
+  if (!place)
+    return null;
+  const atPlace = map2.surfaces.filter((s) => s.place === place);
+  return atPlace.find((s) => s.signature === signature) ?? (atPlace.length === 1 ? atPlace[0] : null);
+}
+function exploreSurfaceKey(place, view) {
+  return view === null ? place : `${place}~${fnv1a(view)}`;
+}
+function fnv1a(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function exploreDir(projectRoot) {
+  return path15.join(cacheDir(projectRoot), "explore");
+}
+function composeExploreId(now, randomHex) {
+  const ts = now.toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
+  return `${ts}-${randomHex ?? randomBytes2(3).toString("hex")}`;
+}
+function isValidExploreId(id) {
+  return MAP_ID.test(id);
+}
+function mapPath(projectRoot, id) {
+  if (!isValidExploreId(id))
+    throw new Error(`Not an explore map id: ${id}`);
+  return path15.join(exploreDir(projectRoot), id, "map.json");
+}
+async function writeExploreMap(projectRoot, map2) {
+  const file = mapPath(projectRoot, map2.id);
+  await fs19.mkdir(path15.dirname(file), { recursive: true });
+  await atomicWriteFile(file, `${JSON.stringify(map2, null, 2)}
+`);
+  return file;
+}
+async function readExploreMap(projectRoot, id) {
+  const raw = await fs19.readFile(mapPath(projectRoot, id), "utf8");
+  const map2 = JSON.parse(raw);
+  if (map2?.schema !== EXPLORE_MAP_SCHEMA || !Array.isArray(map2.surfaces)) {
+    throw new Error(`Unreadable explore map: ${id}`);
+  }
+  return map2;
+}
+async function listExploreMaps(projectRoot) {
+  try {
+    const entries = await fs19.readdir(exploreDir(projectRoot), {
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isDirectory() && isValidExploreId(e.name)).map((e) => e.name).sort();
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    throw err;
+  }
+}
+function exploreCoverage(map2, steps) {
+  const byPlace = /* @__PURE__ */ new Map();
+  for (const s of map2.surfaces) {
+    byPlace.set(s.place, [...byPlace.get(s.place) ?? [], s]);
+  }
+  const reachedBy = /* @__PURE__ */ new Map();
+  const unresolvedBy = /* @__PURE__ */ new Map();
+  const runOnlyBy = /* @__PURE__ */ new Map();
+  const add = (m, k, s) => m.set(k, [...m.get(k) ?? [], s]);
+  for (const step of steps) {
+    const place = explorePlaceKey(step.url);
+    if (!place)
+      continue;
+    const atPlace = byPlace.get(place);
+    if (!atPlace) {
+      add(runOnlyBy, place, step);
+      continue;
+    }
+    const hit = tieStep(map2, atPlace, step);
+    if (hit.length === 0)
+      add(unresolvedBy, place, step);
+    for (const s of hit)
+      add(reachedBy, s.key, step);
+  }
+  const surfaces = map2.surfaces.map((s) => {
+    const base = {
+      key: s.key,
+      label: s.label,
+      place: s.place,
+      url: s.url,
+      depth: s.depth
+    };
+    const reached = reachedBy.get(s.key);
+    if (reached)
+      return { ...base, status: "reached", runs: distinctRuns(reached) };
+    const unresolved = unresolvedBy.get(s.place);
+    if (unresolved) {
+      return { ...base, status: "place_only", runs: distinctRuns(unresolved) };
+    }
+    return { ...base, status: "unreached", runs: [] };
+  });
+  const runOnly = [...runOnlyBy].map(([place, list2]) => ({
+    place,
+    steps: list2.length,
+    runs: distinctRuns(list2)
+  }));
+  runOnly.sort((a, b) => b.steps - a.steps || a.place.localeCompare(b.place));
+  return {
+    map_id: map2.id,
+    runs: new Set(steps.map((s) => s.run_id)).size,
+    steps: steps.length,
+    reached: surfaces.filter((s) => s.status === "reached").length,
+    place_only: surfaces.filter((s) => s.status === "place_only").length,
+    unreached: surfaces.filter((s) => s.status === "unreached").length,
+    surfaces,
+    run_only_places: runOnly
+  };
+}
+function tieStep(map2, atPlace, step) {
+  if (typeof step.signature === "string") {
+    const m = matchExploreSurface(map2, step.url, step.signature);
+    return m ? [m] : [];
+  }
+  if (atPlace.length === 1)
+    return [atPlace[0]];
+  const name = step.surface?.trim();
+  if (!name)
+    return [];
+  return atPlace.filter((s) => [s.label, ...s.headings].filter(Boolean).some((n) => surfaceMatches(n, name) || surfaceMatches(name, n)));
+}
+function distinctRuns(steps) {
+  return [...new Set(steps.map((s) => s.run_id))].sort();
+}
+async function readAllRunSteps(projectRoot) {
+  const out = [];
+  for (const runId of await listRuns(projectRoot)) {
+    let steps;
+    try {
+      steps = await readStepsForRun(projectRoot, runId);
+    } catch {
+      continue;
+    }
+    for (const s of steps) {
+      out.push({ run_id: runId, url: s.url, surface: s.surface });
+    }
+  }
+  return out;
+}
+function actionSignature(a) {
+  const where = a.outcome.kind === "surface" ? a.outcome.surface : a.outcome.kind === "skipped" ? `skipped:${a.outcome.reason}` : a.outcome.kind === "external" ? `external:${a.outcome.url}` : a.outcome.kind;
+  return `${a.role} "${a.name}" \u2192 ${where}`;
+}
+function diffExploreMaps(a, b) {
+  const aByKey = new Map(a.surfaces.map((s) => [s.key, s]));
+  const bByKey = new Map(b.surfaces.map((s) => [s.key, s]));
+  const ref = (s) => ({
+    key: s.key,
+    label: s.label
+  });
+  const onlyA = a.surfaces.filter((s) => !bByKey.has(s.key)).map(ref);
+  const onlyB = b.surfaces.filter((s) => !aByKey.has(s.key)).map(ref);
+  const changed = [];
+  let common2 = 0;
+  for (const sa of a.surfaces) {
+    const sb = bByKey.get(sa.key);
+    if (!sb)
+      continue;
+    common2++;
+    const setA = new Set(sa.actions.map(actionSignature));
+    const setB = new Set(sb.actions.map(actionSignature));
+    const inA = [...setA].filter((x) => !setB.has(x)).sort();
+    const inB = [...setB].filter((x) => !setA.has(x)).sort();
+    if (inA.length > 0 || inB.length > 0) {
+      changed.push({ ...ref(sa), only_a: inA, only_b: inB });
+    }
+  }
+  const union = common2 + onlyA.length + onlyB.length;
+  return {
+    a: a.id,
+    b: b.id,
+    common: common2,
+    only_a: onlyA,
+    only_b: onlyB,
+    surface_overlap: union === 0 ? 1 : common2 / union,
+    changed_actions: changed
+  };
+}
+var EXPLORE_MAP_SCHEMA, UUID, DATE, MAP_ID;
+var init_explore_map = __esm({
+  "../../packages/local-store/dist/explore-map.js"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+    init_revisit();
+    init_runs();
+    init_walkthrough_canonical2();
+    EXPLORE_MAP_SCHEMA = 1;
+    UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    DATE = /^\d{4}-\d{2}-\d{2}$/;
+    MAP_ID = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}-[0-9a-f]{6}$/;
+  }
+});
+
+// ../../packages/local-store/dist/human-test-link.js
+import { promises as fs20 } from "fs";
+import path16 from "path";
 function humanTestLinks(verdicts) {
   const best = /* @__PURE__ */ new Map();
   for (const v of verdicts) {
@@ -10468,7 +10779,7 @@ async function linkFindingsToHumanTests(projectRoot, runId, verdicts) {
   const dir = entityDirPath(projectRoot, "finding");
   let names;
   try {
-    names = await fs19.readdir(dir);
+    names = await fs20.readdir(dir);
   } catch {
     return [];
   }
@@ -10476,11 +10787,11 @@ async function linkFindingsToHumanTests(projectRoot, runId, verdicts) {
   for (const name of names) {
     if (!name.endsWith(".md") || name.startsWith("."))
       continue;
-    const file = path15.join(dir, name);
+    const file = path16.join(dir, name);
     let raw;
     let fm;
     try {
-      raw = await fs19.readFile(file, "utf8");
+      raw = await fs20.readFile(file, "utf8");
       fm = parseFrontmatter(raw).frontmatter;
     } catch {
       continue;
@@ -10711,14 +11022,14 @@ var init_cloud_client = __esm({
 });
 
 // ../../packages/local-store/dist/last-pull.js
-import { promises as fs20 } from "fs";
-import path16 from "path";
+import { promises as fs21 } from "fs";
+import path17 from "path";
 function lastPullPath(projectRoot) {
-  return path16.join(cacheDir(projectRoot), "last-pull.json");
+  return path17.join(cacheDir(projectRoot), "last-pull.json");
 }
 async function readLastPull(projectRoot) {
   try {
-    const raw = await fs20.readFile(lastPullPath(projectRoot), "utf8");
+    const raw = await fs21.readFile(lastPullPath(projectRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -11004,7 +11315,7 @@ var init_frontmatter2 = __esm({
 });
 
 // ../../packages/local-store/dist/pull/write.js
-import { promises as fs21 } from "fs";
+import { promises as fs22 } from "fs";
 async function loadLocalIndex(projectRoot, type2) {
   const byId = /* @__PURE__ */ new Map();
   const bySlug = /* @__PURE__ */ new Map();
@@ -11033,7 +11344,7 @@ async function classifyExisting(projectRoot, type2, cloudId, localSlug, targetSl
   if (localSlug !== targetSlug)
     return "untracked";
   const lastSynced = localIndex.lastPushById[cloudId];
-  const bytes = await fs21.readFile(entityFilePath(projectRoot, type2, localSlug), "utf8");
+  const bytes = await fs22.readFile(entityFilePath(projectRoot, type2, localSlug), "utf8");
   return lastSynced && hashNormalizedContent(bytes) === lastSynced ? "fast_forward" : "diverged";
 }
 async function writeOrSkip(projectRoot, type2, cloudId, slug, frontmatter, body, localIndex, mode, cloudVersion) {
@@ -11094,13 +11405,13 @@ async function writeOrSkip(projectRoot, type2, cloudId, slug, frontmatter, body,
   }
   if (existingSlugForId && existingSlugForId !== slug) {
     try {
-      await fs21.unlink(entityFilePath(projectRoot, type2, existingSlugForId));
+      await fs22.unlink(entityFilePath(projectRoot, type2, existingSlugForId));
       localIndex.bySlug.delete(existingSlugForId);
     } catch {
     }
   }
   await writeEntity(projectRoot, type2, frontmatter, text);
-  const bytes = await fs21.readFile(entityFilePath(projectRoot, type2, slug), "utf8");
+  const bytes = await fs22.readFile(entityFilePath(projectRoot, type2, slug), "utf8");
   const hash = hashNormalizedContent(bytes);
   localIndex.byId.set(cloudId, slug);
   localIndex.bySlug.set(slug, cloudId);
@@ -11154,7 +11465,7 @@ var init_write = __esm({
 });
 
 // ../../packages/local-store/dist/pull/entities.js
-import { promises as fs22 } from "fs";
+import { promises as fs23 } from "fs";
 function buildContextFrontmatter(payload) {
   const cloudCtx = payload.context ?? {};
   const glossary = (payload.glossary ?? []).map((g) => ({
@@ -11209,7 +11520,7 @@ async function pullContext(projectRoot, cloud, projectId, mode, result) {
   const frontmatter = buildContextFrontmatter(payload);
   let hasLocal = false;
   try {
-    await fs22.access(contextPath(projectRoot));
+    await fs23.access(contextPath(projectRoot));
     hasLocal = true;
   } catch {
     hasLocal = false;
@@ -11239,7 +11550,7 @@ async function pullContext(projectRoot, cloud, projectId, mode, result) {
       frontmatter,
       notes_body: existingNotes
     });
-    const bytes = await fs22.readFile(contextPath(projectRoot), "utf8");
+    const bytes = await fs23.readFile(contextPath(projectRoot), "utf8");
     const hash = hashNormalizedContent(bytes);
     await recordLastPull(projectRoot, "context:root", hash);
     await recordLastPush(projectRoot, "context:root", hash);
@@ -11769,6 +12080,7 @@ var init_dist2 = __esm({
     init_prune();
     init_fix_state();
     init_revisit();
+    init_explore_map();
     init_walkthrough_canonical2();
     init_journey_diff();
     init_finding_match();
@@ -11800,15 +12112,15 @@ function resolveApiUrl(configured) {
   assertSecureApiUrl(url, configured ? "API URL" : "IAMU_API_URL");
   return url;
 }
-function parseStore(raw, path28) {
+function parseStore(raw, path30) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new CredentialsFileError(path28, "not valid JSON", err);
+    throw new CredentialsFileError(path30, "not valid JSON", err);
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new CredentialsFileError(path28, "expected a JSON object");
+    throw new CredentialsFileError(path30, "expected a JSON object");
   }
   return parsed;
 }
@@ -11816,26 +12128,26 @@ function isNotFound(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
 async function readCredentialsStore() {
-  const path28 = getCredentialsPath();
+  const path30 = getCredentialsPath();
   let raw;
   try {
-    raw = await readFile(path28, "utf-8");
+    raw = await readFile(path30, "utf-8");
   } catch (err) {
     if (isNotFound(err)) return {};
     warnUnreadableStoreOnce(err);
     throw err;
   }
   try {
-    return parseStore(raw, path28);
+    return parseStore(raw, path30);
   } catch (err) {
     warnUnreadableStoreOnce(err);
     throw err;
   }
 }
 async function writeCredentialsStore(store) {
-  const path28 = getCredentialsPath();
-  await mkdir(dirname(path28), { recursive: true, mode: 448 });
-  await atomicWriteFile(path28, `${JSON.stringify(store, null, 2)}
+  const path30 = getCredentialsPath();
+  await mkdir(dirname(path30), { recursive: true, mode: 448 });
+  await atomicWriteFile(path30, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
@@ -11855,16 +12167,16 @@ function resolveApiKey(apiUrl) {
   } catch {
     return null;
   }
-  const path28 = getCredentialsPath();
+  const path30 = getCredentialsPath();
   let raw;
   try {
-    raw = readFileSync(path28, "utf-8");
+    raw = readFileSync(path30, "utf-8");
   } catch (err) {
     if (!isNotFound(err)) warnUnreadableStoreOnce(err);
     return null;
   }
   try {
-    const entry = parseStore(raw, path28)[url];
+    const entry = parseStore(raw, path30)[url];
     if (typeof entry !== "object" || entry === null) return null;
     const token = entry.token;
     return typeof token === "string" && token ? token : null;
@@ -11896,19 +12208,19 @@ var init_credentials = __esm({
     "use strict";
     init_dist2();
     init_dist();
-    DEFAULT_API_URL = "https://api.iamu.dev";
+    DEFAULT_API_URL = "https://app.iamu.dev";
     CredentialsFileError = class extends IamuConfigError {
       /**
        * @param path - The unreadable credentials file.
        * @param reason - What is wrong with it.
        * @param cause - Underlying parse error, if any.
        */
-      constructor(path28, reason, cause) {
+      constructor(path30, reason, cause) {
         super(
-          `Credentials file ${path28} is corrupt (${reason}). Fix it by hand, or delete it and run \`iamu auth login\` again.`,
+          `Credentials file ${path30} is corrupt (${reason}). Fix it by hand, or delete it and run \`iamu auth login\` again.`,
           {
             cause,
-            suggestedAction: `Delete ${path28} and run \`iamu auth login\`, or set IAMU_TOKEN.`
+            suggestedAction: `Delete ${path30} and run \`iamu auth login\`, or set IAMU_TOKEN.`
           }
         );
       }
@@ -11993,7 +12305,7 @@ async function resolveCloudProject(opts) {
     commandError("Not cloud-linked. Run `iamu auth login` to connect.", opts);
     return null;
   }
-  const apiUrl = ctx.config.cloud_api_url ?? "https://api.iamu.dev";
+  const apiUrl = ctx.config.cloud_api_url ?? DEFAULT_API_URL;
   try {
     assertSecureApiUrl(apiUrl, "cloud_api_url");
   } catch (err) {
@@ -12287,15 +12599,6 @@ function mcpJson(cmd) {
     2
   );
 }
-function vscodeMcpJson(cmd) {
-  return JSON.stringify(
-    {
-      servers: { iamu: { type: "stdio", command: cmd[0], args: cmd.slice(1) } }
-    },
-    null,
-    2
-  );
-}
 function detectHosts(projectRoot) {
   return HOST_ADAPTERS.filter(
     (host) => host.detectionPaths.some((p) => existsSync3(join3(projectRoot, p)))
@@ -12344,13 +12647,17 @@ var init_registry = __esm({
       {
         name: "GitHub Copilot",
         value: "github-copilot",
-        detectionPaths: [".vscode", ".github/copilot-instructions.md"],
-        supportsSkills: false,
-        getSkillsDir: () => "",
-        getCommandPath: (root, id) => join3(root, ".github", "prompts", `iamu-${id}.prompt.md`),
-        formatCommand: descOnlyFormat,
-        getMcpConfigPath: (root) => join3(root, ".vscode", "mcp.json"),
-        formatMcpConfig: vscodeMcpJson
+        detectionPaths: [
+          ".github/copilot-instructions.md",
+          ".github/skills",
+          ".copilot"
+        ],
+        supportsSkills: true,
+        getSkillsDir: (root) => join3(root, ".github", "skills"),
+        getCommandPath: (root, id) => join3(root, ".github", "skills", `iamu-${id}`, "SKILL.md"),
+        formatCommand: richFormat,
+        getMcpConfigPath: (root) => join3(root, ".mcp.json"),
+        formatMcpConfig: mcpJson
       },
       {
         name: "Cline",
@@ -12388,10 +12695,10 @@ var init_registry = __esm({
       {
         name: "Antigravity",
         value: "antigravity",
-        detectionPaths: [".gemini", ".agent", "GEMINI.md", "AGENTS.md"],
+        detectionPaths: [".agent", ".agents", "AGENTS.md", ".gemini", "GEMINI.md"],
         supportsSkills: true,
-        getSkillsDir: (root) => existsSync3(join3(root, ".agent")) && !existsSync3(join3(root, ".gemini")) ? join3(root, ".agent", "skills") : join3(root, ".gemini", "skills"),
-        getCommandPath: (root, id) => existsSync3(join3(root, ".agent")) && !existsSync3(join3(root, ".gemini")) ? join3(root, ".agent", "skills", `iamu-${id}`, "SKILL.md") : join3(root, ".gemini", "skills", `iamu-${id}`, "SKILL.md"),
+        getSkillsDir: (root) => existsSync3(join3(root, ".agents")) ? join3(root, ".agents", "skills") : join3(root, ".agent", "skills"),
+        getCommandPath: (root, id) => existsSync3(join3(root, ".agents")) ? join3(root, ".agents", "skills", `iamu-${id}`, "SKILL.md") : join3(root, ".agent", "skills", `iamu-${id}`, "SKILL.md"),
         formatCommand: richFormat,
         getMcpConfigPath: (root) => join3(root, ".mcp.json"),
         formatMcpConfig: mcpJson
@@ -12525,9 +12832,17 @@ async function needsWrite(filePath, content) {
     return true;
   }
 }
-function isCliWrittenSkill(path28) {
+function isCliWrittenSkill(path30) {
+  try {
+    return /^generatedBy:/m.test(readFileSync3(path30, "utf-8"));
+  } catch {
+    return false;
+  }
+}
+function isCliWrittenPrompt(path30) {
   try {
-    return /^generatedBy:/m.test(readFileSync3(path28, "utf-8"));
+    const content = readFileSync3(path30, "utf-8");
+    return content.includes("iamu") || /^generatedBy:/m.test(content);
   } catch {
     return false;
   }
@@ -12538,14 +12853,41 @@ function planSkillFiles(hosts, projectRoot, version2) {
   for (const host of hosts) {
     if (pluginProvidesSkills(host, projectRoot)) {
       for (const name of skillTemplates.keys()) {
-        const path28 = join4(host.getSkillsDir(projectRoot), name, "SKILL.md");
-        if (isCliWrittenSkill(path28)) files.push({ host, path: path28, content: null });
+        const path30 = join4(host.getSkillsDir(projectRoot), name, "SKILL.md");
+        if (isCliWrittenSkill(path30)) files.push({ host, path: path30, content: null });
       }
     } else if (host.supportsSkills) {
       const skillsDir = host.getSkillsDir(projectRoot);
       for (const [name, content] of skillTemplates) {
         files.push({ host, path: join4(skillsDir, name, "SKILL.md"), content });
       }
+      if (host.value === "antigravity") {
+        for (const name of skillTemplates.keys()) {
+          const legacyPath = join4(
+            projectRoot,
+            ".gemini",
+            "skills",
+            name,
+            "SKILL.md"
+          );
+          if (isCliWrittenSkill(legacyPath)) {
+            files.push({ host, path: legacyPath, content: null });
+          }
+        }
+      }
+      if (host.value === "github-copilot") {
+        for (const cmd of commandsFromSkills(skillTemplates)) {
+          const legacyPrompt = join4(
+            projectRoot,
+            ".github",
+            "prompts",
+            `iamu-${cmd.id}.prompt.md`
+          );
+          if (isCliWrittenPrompt(legacyPrompt)) {
+            files.push({ host, path: legacyPrompt, content: null });
+          }
+        }
+      }
     } else {
       for (const cmd of commandsFromSkills(skillTemplates)) {
         files.push({
@@ -12570,6 +12912,15 @@ function detectInstalledHosts(projectRoot) {
       const skillDir = join4(host.getSkillsDir(projectRoot), "iamu-setup");
       if (existsSync5(skillDir)) return true;
     }
+    if (host.value === "github-copilot") {
+      const legacyPrompt = join4(
+        projectRoot,
+        ".github",
+        "prompts",
+        "iamu-setup.prompt.md"
+      );
+      if (existsSync5(legacyPrompt)) return true;
+    }
     return false;
   });
 }
@@ -12636,7 +12987,13 @@ async function installSkillsForHosts(hosts, projectRoot, version2, opts) {
     let hostUpdated = 0;
     let hostTotal = 0;
     for (const f of planned) {
-      if (f.host !== host || f.content === null) continue;
+      if (f.host !== host) continue;
+      if (f.content === null) {
+        await rm(f.path, { force: true });
+        await rmdir(dirname3(f.path)).catch(() => {
+        });
+        continue;
+      }
       hostTotal++;
       if (host.supportsSkills) totalSkills++;
       else totalCommands++;
@@ -13482,12 +13839,24 @@ async function browserLogin(apiUrl, opts, t) {
       chalk8.red(`
   Auth session expired or failed (HTTP ${result.status}).`)
     );
+    console.error(
+      chalk8.dim("  Re-run `iamu auth login` to start a new login session.\n")
+    );
     process.exitCode = 1;
     return null;
   }
   if (result.kind === "timeout") {
     s.stop("Authentication timed out.");
-    console.error(chalk8.red("\n  Authentication timed out. Try again."));
+    console.error(
+      chalk8.red(
+        "\n  Authentication timed out (no approval received within 2 minutes)."
+      )
+    );
+    console.error(
+      chalk8.dim(
+        "  \u2022 Complete browser authorization faster, or authenticate non-interactively with --token <key>.\n  \u2022 Local setup is unaffected \u2014 re-run `iamu auth login` anytime.\n"
+      )
+    );
     process.exitCode = 1;
     return null;
   }
@@ -13513,7 +13882,12 @@ async function startAuthSession(apiUrl, timeoutMs) {
     if (!res.ok) {
       console.error(
         chalk8.red(
-          `  Failed to start auth session: ${res.text || `HTTP ${res.status}`}`
+          `  Failed to start auth session at ${apiUrl}: ${res.text || `HTTP ${res.status}`}`
+        )
+      );
+      console.error(
+        chalk8.dim(
+          "  \u2022 The cloud service may be experiencing downtime or maintenance.\n  \u2022 Local setup is unaffected; continue with local workflows or retry later with `iamu auth login`.\n"
         )
       );
       process.exitCode = 1;
@@ -13527,7 +13901,13 @@ async function startAuthSession(apiUrl, timeoutMs) {
     return { sessionId: data.sessionId, loginUrl: data.loginUrl };
   } catch (err) {
     console.error(
-      chalk8.red("  Cannot reach Iamu Cloud.") + chalk8.dim(` (${errorMessage(err)})`)
+      chalk8.red(`  Cannot reach Iamu Cloud (${apiUrl}).`) + chalk8.dim(`
+  Reason: ${errorMessage(err)}`)
+    );
+    console.error(
+      chalk8.dim(
+        "\n  \u2022 Check your internet connection or proxy settings.\n  \u2022 If using a custom instance, pass --url <api-url> or set IAMU_API_URL.\n  \u2022 Local setup is unaffected; continue with local workflows or retry later with `iamu auth login`.\n"
+      )
     );
     process.exitCode = 1;
     return null;
@@ -13994,7 +14374,7 @@ import {
   readlinkSync,
   realpathSync as realpathSync2
 } from "fs";
-import path17 from "path";
+import path18 from "path";
 function git(args, cwd) {
   return execFileSync("git", args, {
     cwd,
@@ -14047,8 +14427,8 @@ function detectWorktreeState(projectRoot, iamuDirName = IAMU_DIR) {
     const top = git(["rev-parse", "--show-toplevel"], projectRoot).toString("utf8").trim();
     if (!top) return void 0;
     const realTop = realpathSync2(top);
-    const realIamu = path17.join(realpathSync2(projectRoot), iamuDirName);
-    const iamuRel = path17.relative(realTop, realIamu).split(path17.sep).join("/");
+    const realIamu = path18.join(realpathSync2(projectRoot), iamuDirName);
+    const iamuRel = path18.relative(realTop, realIamu).split(path18.sep).join("/");
     const pathspec = iamuRel.startsWith("..") ? [":(top)"] : [":(top)", `:(top,exclude,literal)${iamuRel}`];
     const status2 = git(
       [
@@ -14078,7 +14458,7 @@ function detectWorktreeState(projectRoot, iamuDirName = IAMU_DIR) {
     );
     for (const file of sorted.slice(0, MAX_UNTRACKED_HASHED)) {
       const rel = file.replace(/\/$/, "");
-      hash.update(`${file}\0${hashFile(path17.join(realTop, rel))}
+      hash.update(`${file}\0${hashFile(path18.join(realTop, rel))}
 `);
     }
     if (sorted.length > MAX_UNTRACKED_HASHED) {
@@ -14249,15 +14629,29 @@ __export(start_run_exports, {
   formatBuild: () => formatBuild,
   formatViewport: () => formatViewport,
   resolveStartUrl: () => resolveStartUrl,
-  startRun: () => startRun
+  startRun: () => startRun,
+  testabilityTarget: () => testabilityTarget
 });
-import path18 from "path";
+import fs24 from "fs/promises";
+import path19 from "path";
 import chalk11 from "chalk";
-function resolveStartUrl(target, scenario) {
-  const base = target ?? scenario.target_url ?? null;
+async function testabilityTarget(projectRoot) {
+  try {
+    const raw = await fs24.readFile(
+      path19.join(projectRoot, "iamu", "testability.md"),
+      "utf8"
+    );
+    const { frontmatter } = parseFrontmatter(raw);
+    return typeof frontmatter.target_url === "string" && frontmatter.target_url.trim().length > 0 ? frontmatter.target_url.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function resolveStartUrl(target, scenario, fallbackTarget) {
+  const base = target ?? scenario.target_url ?? fallbackTarget ?? null;
   if (!base) {
     return {
-      error: "No target \u2014 pass --target <url>, or set target_url on the scenario."
+      error: "No target \u2014 pass --target <url>, set target_url on the scenario, or define target_url in iamu/testability.md."
     };
   }
   let parsed;
@@ -14357,7 +14751,8 @@ async function startRun(scenarioSlug, opts) {
     );
     return;
   }
-  const start2 = resolveStartUrl(opts.target, fm);
+  const fallbackTarget = await testabilityTarget(projectRoot);
+  const start2 = resolveStartUrl(opts.target, fm, fallbackTarget);
   if ("error" in start2) {
     commandError(start2.error, opts);
     return;
@@ -14391,6 +14786,18 @@ async function startRun(scenarioSlug, opts) {
   }
   const build = detectBuild({ cwd: projectRoot, label: opts.build });
   const environment = resolveEnvironment(opts.env, start2.url);
+  const cfg = await readConfig(projectRoot).catch(() => null);
+  const walker = opts.walker ?? process.env.IAMU_WALKER_MODEL ?? cfg?.models?.walker ?? "fast";
+  const judge = opts.judge ?? process.env.IAMU_JUDGE_MODEL ?? cfg?.models?.judge ?? "thorough";
+  const matcher = opts.matcher ?? process.env.IAMU_MATCHER_MODEL ?? cfg?.models?.matcher ?? "thorough";
+  const models = {
+    walker,
+    judge,
+    matcher,
+    walker_tier: ["fast", "thorough", "inherit"].includes(walker) ? walker : "custom",
+    judge_tier: ["fast", "thorough", "inherit"].includes(judge) ? judge : "custom",
+    matcher_tier: ["fast", "thorough", "inherit"].includes(matcher) ? matcher : "custom"
+  };
   let revisit = [];
   try {
     revisit = await computeRevisitPlaces(projectRoot, scenarioSlug, start2.url);
@@ -14408,13 +14815,14 @@ async function startRun(scenarioSlug, opts) {
     status: "running",
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     completed_at: null,
+    models,
     ...build ? { build } : {},
     ...environment ? { environment } : {},
     ...revisit.length > 0 ? { revisit } : {},
     ...viewport ? { viewport } : {}
   };
   await atomicWriteFile(
-    path18.join(run.absPath, "walkthrough.json"),
+    path19.join(run.absPath, "walkthrough.json"),
     JSON.stringify(manifest, null, 2) + "\n"
   );
   if (opts.json) {
@@ -14422,13 +14830,14 @@ async function startRun(scenarioSlug, opts) {
       JSON.stringify(
         {
           run_id: run.runId,
-          path: path18.relative(projectRoot, run.absPath),
+          path: path19.relative(projectRoot, run.absPath),
           scenario_slug: scenarioSlug,
           target_url: start2.url,
           target_reachable: targetReachable,
           ...targetWarning ? { target_warning: targetWarning } : {},
           persona_slug: fm.persona,
           outline_slug: fm.outline,
+          models,
           build: build ?? null,
           environment: environment ?? null,
           revisit,
@@ -14447,6 +14856,9 @@ async function startRun(scenarioSlug, opts) {
   console.log(`  ${chalk11.dim("persona:")}  ${fm.persona}`);
   console.log(`  ${chalk11.dim("outline:")}  ${fm.outline}`);
   console.log(`  ${chalk11.dim("target:")}   ${start2.url}`);
+  console.log(
+    `  ${chalk11.dim("models:")}   walker: ${chalk11.cyan(walker)} \xB7 judge: ${chalk11.cyan(judge)} \xB7 matcher: ${chalk11.cyan(matcher)}`
+  );
   if (targetWarning) {
     console.log(`  ${symbols.warning} ${chalk11.yellow(targetWarning)}`);
   }
@@ -14466,7 +14878,7 @@ async function startRun(scenarioSlug, opts) {
     );
   }
   console.log(
-    `  ${chalk11.dim("path:")}     ${path18.relative(projectRoot, run.absPath)}`
+    `  ${chalk11.dim("path:")}     ${path19.relative(projectRoot, run.absPath)}`
   );
   console.log();
   console.log(`  ${chalk11.bold("Next steps for blind execution:")}`);
@@ -14507,8 +14919,8 @@ var report_exports = {};
 __export(report_exports, {
   report: () => report
 });
-import { promises as fs23 } from "fs";
-import path19 from "path";
+import { promises as fs25 } from "fs";
+import path20 from "path";
 import chalk12 from "chalk";
 async function report(scenario, opts) {
   const ctx = await resolveProject(opts);
@@ -14527,8 +14939,8 @@ async function report(scenario, opts) {
   for (const rid of runs.reverse()) {
     try {
       const dir = runDir(projectRoot, rid);
-      const mRaw = await fs23.readFile(
-        path19.join(dir, "walkthrough.json"),
+      const mRaw = await fs25.readFile(
+        path20.join(dir, "walkthrough.json"),
         "utf8"
       );
       const manifest = JSON.parse(mRaw);
@@ -14536,8 +14948,8 @@ async function report(scenario, opts) {
       if (scenario && manifest.scenario_slug !== scenario) continue;
       let canonical = null;
       try {
-        const cRaw = await fs23.readFile(
-          path19.join(dir, "canonical.json"),
+        const cRaw = await fs25.readFile(
+          path20.join(dir, "canonical.json"),
           "utf8"
         );
         canonical = JSON.parse(cRaw);
@@ -15744,12 +16156,13 @@ var init_serve = __esm({
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
-  init: () => init
+  init: () => init,
+  setupCommand: () => setupCommand
 });
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
 import { basename as basename2, join as join5 } from "path";
-import { isCancel as isCancel3, multiselect } from "@clack/prompts";
+import { isCancel as isCancel3, multiselect, select as select3 } from "@clack/prompts";
 import chalk17 from "chalk";
 function loadPromptTemplates() {
   const templates = /* @__PURE__ */ new Map();
@@ -15771,9 +16184,9 @@ function loadPromptTemplates() {
   return templates;
 }
 function setupCommand(projectRoot, hosts) {
-  if (!iamuPluginEnabled(projectRoot)) return "iamu-setup";
+  if (!iamuPluginEnabled(projectRoot)) return "/iamu-setup";
   if (hosts.every((h) => h.value === "claude")) return "/iamu:init";
-  return "iamu-setup   (Claude Code: /iamu:init)";
+  return "/iamu-setup   (Claude Code: /iamu:init)";
 }
 async function init(opts) {
   const options = typeof opts === "string" ? { name: opts } : opts ?? {};
@@ -15793,10 +16206,10 @@ async function init(opts) {
   }
   let freshInit = false;
   if (existsSync7(join5(iamuDir2, "config.json"))) {
-    const config = await readConfig(projectRoot);
+    const config2 = await readConfig(projectRoot);
     if (!options.json) {
       console.log(
-        chalk17.yellow("  iamu/ already exists") + chalk17.dim(` (${config?.project_name ?? "unknown"})`)
+        chalk17.yellow("  iamu/ already exists") + chalk17.dim(` (${config2?.project_name ?? "unknown"})`)
       );
     }
   } else {
@@ -15813,6 +16226,35 @@ async function init(opts) {
         ""
       )
     );
+    const testabilityPath = join5(iamuDir2, "testability.md");
+    if (!existsSync7(testabilityPath)) {
+      await writeFile3(
+        testabilityPath,
+        serializeFrontmatter(
+          {
+            status: "draft",
+            target_url: "http://localhost:3000"
+          },
+          `# Project Testability & Environment
+
+Target URL and execution harness for walkthroughs.
+Audited and populated during /iamu:init.
+
+## Target & Run Instructions
+- Default URL: http://localhost:3000
+
+## Reachable Surfaces
+(Run /iamu:init to discover testable routes)
+
+## Mocks & Data Fixtures
+(Run /iamu:init to inspect existing harnesses)
+
+## Untestable Boundaries
+(None documented yet)
+`
+        )
+      );
+    }
   }
   const promptTemplates = loadPromptTemplates();
   const promptsDir = join5(iamuDir2, ".prompts");
@@ -15869,20 +16311,57 @@ async function init(opts) {
     version2,
     { quiet: options.json }
   );
-  try {
-    const config = await readConfig(projectRoot);
-    if (config.cloud_linked) {
-      for (const host of selectedHosts) {
-        const mcpPath = host.getMcpConfigPath(projectRoot);
-        await writeSyncMcpEntry(mcpPath);
+  let config = await readConfig(projectRoot);
+  const shouldPromptCloud = isInteractive && freshInit && !config.cloud_linked && options.cloud !== false;
+  if (options.cloud === true && !config.cloud_linked) {
+    try {
+      await authLogin({ yes: options.yes });
+      config = await readConfig(projectRoot);
+    } catch {
+    }
+  } else if (shouldPromptCloud) {
+    console.log();
+    const cloudChoice = await select3({
+      message: "Connect this project to Iamu Cloud? (Free)",
+      options: [
+        {
+          value: "connect",
+          label: "Connect to Iamu Cloud (opens browser)",
+          hint: "recommended \u2014 shareable run reports, step replays, team sync"
+        },
+        {
+          value: "local",
+          label: "Continue local-only",
+          hint: "skip for now (link anytime with `iamu auth login`)"
+        }
+      ],
+      initialValue: "connect"
+    });
+    if (!isCancel3(cloudChoice) && cloudChoice === "connect") {
+      const prevExitCode = process.exitCode;
+      try {
+        await authLogin({ yes: options.yes });
+        config = await readConfig(projectRoot);
+      } catch {
+        process.exitCode = prevExitCode;
         if (!options.json) {
           console.log(
-            `  ${symbols.success} ${host.name} \u2014 iamu-sync MCP server`
+            chalk17.dim(
+              "  Cloud linking skipped. Your local setup is complete and fully functional."
+            )
           );
         }
       }
     }
-  } catch {
+  }
+  if (config.cloud_linked) {
+    for (const host of selectedHosts) {
+      const mcpPath = host.getMcpConfigPath(projectRoot);
+      await writeSyncMcpEntry(mcpPath);
+      if (!options.json) {
+        console.log(`  ${symbols.success} ${host.name} \u2014 iamu-sync MCP server`);
+      }
+    }
   }
   if (options.json) {
     console.log(
@@ -15894,7 +16373,10 @@ async function init(opts) {
           fresh: freshInit,
           tools: selectedHosts.map((h) => h.name),
           skillsCount: totalSkills,
-          commandsCount: totalCommands
+          commandsCount: totalCommands,
+          cloudLinked: Boolean(config.cloud_linked),
+          cloudProjectId: config.cloud_project_id ?? null,
+          dashboardUrl: config.cloud_linked && config.cloud_project_id ? getCloudDashboardUrl(void 0, config.cloud_project_id) : null
         },
         null,
         2
@@ -15902,43 +16384,89 @@ async function init(opts) {
     );
     return;
   }
-  if (totalSkills > 0 || totalCommands > 0) {
+  if (!options.json) {
     console.log();
-    const summaryParts = [];
-    if (totalSkills > 0) summaryParts.push(`${totalSkills} skills`);
-    if (totalCommands > 0) summaryParts.push(`${totalCommands} commands`);
     console.log(
-      chalk17.dim(
-        `  Total: ${summaryParts.join(" + ")} across ${selectedHosts.length} tool(s)`
+      chalk17.bold(
+        `  ${symbols.success} Project configured: ${chalk17.cyan(projectName)}`
       )
     );
-  }
-  console.log();
-  if (freshInit) {
-    console.log(chalk17.bold("  Next step:"));
     console.log();
-    console.log(chalk17.dim("  Open your editor and run:"));
+    if (selectedHosts.length > 0) {
+      const toolNames = selectedHosts.map((h) => h.name).join(", ");
+      console.log(
+        `  ${chalk17.dim("Tools:")}     ${toolNames} ${chalk17.dim(`(${totalSkills} skills + ${totalCommands} commands installed)`)}`
+      );
+    }
+    if (config.cloud_linked && config.cloud_project_id) {
+      const dashboardUrl = getCloudDashboardUrl(
+        void 0,
+        config.cloud_project_id
+      );
+      console.log(
+        `  ${chalk17.dim("Cloud:")}     ${chalk17.green("Linked")} \xB7 ${chalk17.cyan(dashboardUrl)}`
+      );
+    } else {
+      console.log(
+        `  ${chalk17.dim("Cloud:")}     Local-only ${chalk17.dim("(link anytime with `iamu auth login`)")}`
+      );
+    }
     console.log();
-    console.log(`    ${chalk17.cyan(setupCommand(projectRoot, selectedHosts))}`);
+    if (freshInit) {
+      console.log(chalk17.bold("  Next steps:"));
+      console.log();
+      console.log(
+        `    ${chalk17.bold("1.")} Start your application's dev server:`
+      );
+      console.log(
+        `       ${chalk17.cyan("$ pnpm dev")} ${chalk17.dim("(or npm run dev)")}`
+      );
+      console.log();
+      console.log(`    ${chalk17.bold("2.")} In your AI agent chat, run:`);
+      console.log(
+        `       ${chalk17.cyan(setupCommand(projectRoot, selectedHosts))}`
+      );
+      console.log();
+      console.log(
+        chalk17.dim(
+          "       Your agent will analyze your codebase, map user roles, and generate your first walkthrough scenario."
+        )
+      );
+      console.log();
+      console.log(chalk17.bold("  Core workflow:"));
+      console.log(
+        chalk17.dim("    \u2022 ") + chalk17.cyan("/iamu:init") + chalk17.dim("        Map domain & scaffold inaugural scenario")
+      );
+      console.log(
+        chalk17.dim("    \u2022 ") + chalk17.cyan("iamu-run <slug>") + chalk17.dim("   Walk scenario in browser & record findings")
+      );
+      console.log(
+        chalk17.dim("    \u2022 ") + chalk17.cyan("iamu-findings") + chalk17.dim("     Triage persona feedback & apply code fixes")
+      );
+      console.log(
+        chalk17.dim("    \u2022 ") + chalk17.cyan("iamu-propose") + chalk17.dim("      Brainstorm high-risk workflows & new personas")
+      );
+    } else {
+      console.log(chalk17.bold("  Updated:"));
+      console.log();
+      console.log(
+        chalk17.dim("  Skills and commands regenerated to latest version.")
+      );
+    }
     console.log();
     console.log(
-      chalk17.dim("  Your agent will analyze your codebase, ask a few")
+      `  ${chalk17.dim("Docs:")}       ${chalk17.underline("https://iamu.dev/docs")}`
     );
     console.log(
-      chalk17.dim("  questions, then you're ready for your first walkthrough.")
+      `  ${chalk17.dim("Quickstart:")} ${chalk17.underline("https://iamu.dev/quickstart")}`
     );
-  } else {
-    console.log(chalk17.bold("  Updated:"));
+    if (config.cloud_linked && config.cloud_project_id) {
+      console.log(
+        `  ${chalk17.dim("Dashboard:")}  ${chalk17.underline(getCloudDashboardUrl(void 0, config.cloud_project_id))}`
+      );
+    }
     console.log();
-    console.log(
-      chalk17.dim("  Skills and commands regenerated to latest version.")
-    );
   }
-  console.log();
-  console.log(
-    chalk17.dim("  Docs: ") + chalk17.underline("https://iamu.dev/quickstart")
-  );
-  console.log();
 }
 var init_init = __esm({
   "src/commands/init.ts"() {
@@ -15946,7 +16474,9 @@ var init_init = __esm({
     init_dist2();
     init_claude_plugin();
     init_registry();
+    init_cloud_url();
     init_symbols();
+    init_auth();
     init_mcp_config();
     init_skills();
     init_templates();
@@ -16242,7 +16772,10 @@ var init_browse_actions = __esm({
         usage: "goto <url>",
         minArgs: 1,
         run: async (p, args) => {
-          await p.goto(args[0], { waitUntil: "domcontentloaded" });
+          await p.goto(args[0], {
+            waitUntil: "domcontentloaded",
+            timeout: 1e4
+          });
         }
       },
       click: {
@@ -16403,6 +16936,12 @@ var init_browse_driver = __esm({
       commandLine: (pid) => readProcessCommandLine(pid),
       kill(pid) {
         try {
+          if (process.platform !== "win32") {
+            try {
+              process.kill(-pid, "SIGTERM");
+            } catch {
+            }
+          }
           process.kill(pid, "SIGTERM");
         } catch {
         }
@@ -16413,7 +16952,7 @@ var init_browse_driver = __esm({
 
 // src/commands/step-numbering.ts
 import { open, readdir, unlink } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 function stepFileName(stepNumber2) {
   return `${String(stepNumber2).padStart(3, "0")}.json`;
 }
@@ -16435,7 +16974,7 @@ async function reserveStepFile(stepsDir, limit) {
     if (candidate > limit.maxSteps) {
       throw new Error(stepLimitMessage(limit.maxSteps, limit.runId));
     }
-    const stepPath = path20.join(stepsDir, stepFileName(candidate));
+    const stepPath = path21.join(stepsDir, stepFileName(candidate));
     try {
       const handle = await open(stepPath, "wx");
       await handle.close();
@@ -16467,7 +17006,7 @@ __export(step_exports, {
   stepCommand: () => stepCommand
 });
 import { copyFile, mkdir as mkdir5, stat } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 import chalk19 from "chalk";
 function parseMaxSteps(val) {
   if (typeof val === "number" && Number.isFinite(val) && val > 0) return val;
@@ -16486,8 +17025,8 @@ async function recordStep(input) {
   if (!runDirPath) {
     throw new Error(`Run directory not found for run "${input.runId}"`);
   }
-  const stepsDir = path21.join(runDirPath, "steps");
-  const screenshotsDir = path21.join(runDirPath, "screenshots");
+  const stepsDir = path22.join(runDirPath, "steps");
+  const screenshotsDir = path22.join(runDirPath, "screenshots");
   await mkdir5(stepsDir, { recursive: true });
   await mkdir5(screenshotsDir, { recursive: true });
   const shotSource = input.shot ? await existingShot(input.shot) : null;
@@ -16501,11 +17040,11 @@ async function recordStep(input) {
     let finalScreenshotPath = null;
     if (shotSource) {
       const destName = `step-${stepNumber2}.png`;
-      finalScreenshotPath = path21.join(screenshotsDir, destName);
-      if (path21.resolve(finalScreenshotPath) !== shotSource) {
+      finalScreenshotPath = path22.join(screenshotsDir, destName);
+      if (path22.resolve(finalScreenshotPath) !== shotSource) {
         await copyFile(shotSource, finalScreenshotPath);
       }
-      screenshotRef = path21.join("screenshots", destName);
+      screenshotRef = path22.join("screenshots", destName);
     }
     const parsedStep = runStepSchema.parse({
       step_number: stepNumber2,
@@ -16530,7 +17069,7 @@ async function recordStep(input) {
   }
 }
 async function existingShot(shot) {
-  const resolved = path21.resolve(shot);
+  const resolved = path22.resolve(shot);
   const isFile = await stat(resolved).then((s) => s.isFile()).catch(() => false);
   if (!isFile) {
     throw new Error(
@@ -16572,7 +17111,7 @@ async function stepCommand(runArg, opts) {
         JSON.stringify(
           {
             step_number: res.step.step_number,
-            path: path21.relative(projectRoot, res.stepPath),
+            path: path22.relative(projectRoot, res.stepPath),
             action: res.step.action,
             note: res.step.note,
             url: res.step.url,
@@ -16599,7 +17138,7 @@ async function stepCommand(runArg, opts) {
       console.log(`  ${chalk19.dim("shot:")}       ${res.step.screenshot}`);
     }
     console.log(
-      `  ${chalk19.dim("file:")}       ${path21.relative(projectRoot, res.stepPath)}`
+      `  ${chalk19.dim("file:")}       ${path22.relative(projectRoot, res.stepPath)}`
     );
     console.log();
   } catch (err) {
@@ -16629,6 +17168,7 @@ __export(browse_exports, {
   readBrowseState: () => readBrowseState,
   shouldDisableSandbox: () => shouldDisableSandbox,
   start: () => start,
+  waitForVisualStability: () => waitForVisualStability,
   withPage: () => withPage
 });
 import { randomUUID as randomUUID7 } from "crypto";
@@ -16641,21 +17181,21 @@ import {
 } from "fs";
 import { rm as rm2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import path22 from "path";
+import path23 from "path";
 import chalk20 from "chalk";
 function stateDir() {
-  return path22.join(
-    process.env.IAMU_HOME ?? path22.join(homedir3(), ".iamu"),
+  return path23.join(
+    process.env.IAMU_HOME ?? path23.join(homedir3(), ".iamu"),
     "browse"
   );
 }
 function profileDir() {
-  return path22.join(stateDir(), "profile");
+  return path23.join(stateDir(), "profile");
 }
 function readBrowseState() {
   try {
     return JSON.parse(
-      readFileSync6(path22.join(stateDir(), "state.json"), "utf8")
+      readFileSync6(path23.join(stateDir(), "state.json"), "utf8")
     );
   } catch {
     return null;
@@ -16663,7 +17203,7 @@ function readBrowseState() {
 }
 function writeState(state) {
   mkdirSync(stateDir(), { recursive: true });
-  writeFileSync(path22.join(stateDir(), "state.json"), JSON.stringify(state));
+  writeFileSync(path23.join(stateDir(), "state.json"), JSON.stringify(state));
 }
 function fail(message, opts) {
   if (opts?.json) {
@@ -16726,7 +17266,7 @@ async function requestedViewport(opts) {
   let manifest;
   try {
     manifest = JSON.parse(
-      readFileSync6(path22.join(dir, "walkthrough.json"), "utf8")
+      readFileSync6(path23.join(dir, "walkthrough.json"), "utf8")
     );
   } catch {
     fail(
@@ -16778,6 +17318,8 @@ function chromeArgs(opts, port, headless) {
     `--window-size=${opts.width ?? "1280"},${opts.height ?? "900"}`,
     "--no-first-run",
     "--no-default-browser-check",
+    "--password-store=basic",
+    "--use-mock-keychain",
     ...headless ? ["--headless=new", "--disable-dev-shm-usage", "--disable-gpu"] : [],
     ...shouldDisableSandbox() ? ["--no-sandbox"] : [],
     "about:blank"
@@ -16830,11 +17372,50 @@ async function stop(opts, driver) {
   await driver.closeBrowser(state.port);
   if (state.pid) await reapBrowser(state.pid, profileDir(), driver);
   try {
-    unlinkSync(path22.join(stateDir(), "state.json"));
+    unlinkSync(path23.join(stateDir(), "state.json"));
   } catch {
   }
   report2(opts, { stopped: true }, [`  ${chalk20.green("\u2713")} Browser stopped`]);
 }
+async function waitForVisualStability(page, maxWaitMs = 300) {
+  let timer;
+  try {
+    const nodeTimeout = new Promise((resolve4) => {
+      timer = setTimeout(resolve4, maxWaitMs + 100);
+    });
+    const browserWait = page.evaluate((maxWait) => {
+      return new Promise((resolve4) => {
+        const timeout = setTimeout(resolve4, maxWait);
+        const done = () => {
+          clearTimeout(timeout);
+          resolve4();
+        };
+        const g = globalThis;
+        if (typeof g.requestAnimationFrame !== "function") {
+          done();
+          return;
+        }
+        g.requestAnimationFrame(() => {
+          g.requestAnimationFrame?.(() => {
+            const animations = g.document?.getAnimations ? g.document.getAnimations().filter((a) => a.playState === "running" && a.finished) : [];
+            if (animations.length === 0) {
+              done();
+              return;
+            }
+            Promise.allSettled(
+              animations.map((a) => a.finished)
+            ).finally(done);
+          });
+        });
+      });
+    }, maxWaitMs).catch(() => {
+    });
+    await Promise.race([browserWait, nodeTimeout]);
+  } catch {
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 async function withPage(opts, driver, fn, target) {
   const state = readBrowseState();
   if (!state) {
@@ -16854,11 +17435,11 @@ async function withPage(opts, driver, fn, target) {
     await fn(page);
     await page.waitForLoadState("domcontentloaded").catch(() => {
     });
-    await page.waitForTimeout(400);
     let screenshot = null;
     if (opts.shot) {
-      screenshot = path22.resolve(opts.shot);
-      mkdirSync(path22.dirname(screenshot), { recursive: true });
+      await waitForVisualStability(page);
+      screenshot = path23.resolve(opts.shot);
+      mkdirSync(path23.dirname(screenshot), { recursive: true });
       await page.screenshot({ path: screenshot, fullPage: Boolean(opts.full) });
     }
     return { url: page.url(), title: await page.title(), screenshot };
@@ -16937,7 +17518,7 @@ function printStep(opts, record, projectRoot) {
   if (opts.json) {
     const doc = {
       step_number: step.step_number,
-      path: path22.relative(projectRoot, record.stepPath),
+      path: path23.relative(projectRoot, record.stepPath),
       action: step.action,
       note: step.note,
       url: step.url,
@@ -16957,6 +17538,35 @@ function printStep(opts, record, projectRoot) {
   }
 }
 async function browseStep(args, opts, driver) {
+  if (opts.stepFile) {
+    try {
+      let raw;
+      if (opts.stepFile === "-") {
+        raw = readFileSync6(0, "utf8");
+      } else {
+        raw = readFileSync6(opts.stepFile, "utf8");
+      }
+      const data = JSON.parse(raw);
+      if (data.run && typeof data.run === "string") opts.run = data.run;
+      if (data.action && typeof data.action === "string")
+        opts.action = data.action;
+      if (data.note && typeof data.note === "string") opts.note = data.note;
+      if (data.surface && typeof data.surface === "string")
+        opts.surface = data.surface;
+      if (args.length === 0 && data.cmd) {
+        if (Array.isArray(data.cmd)) {
+          args = data.cmd.map(String);
+        } else if (typeof data.cmd === "string") {
+          args = data.cmd.trim().split(/\s+/);
+        }
+      }
+    } catch (err) {
+      return fail(
+        `Failed to read step payload from ${opts.stepFile}: ${err.message}`,
+        opts
+      );
+    }
+  }
   if (!opts.run)
     return fail("--run <run-id> is required for browse step.", opts);
   if (!opts.action) {
@@ -16982,10 +17592,10 @@ async function browseStep(args, opts, driver) {
   const runDirPath = resolveRunDir(ctx.projectRoot, opts.run);
   if (!runDirPath) return;
   const maxSteps = parseMaxSteps(opts.maxSteps);
-  if (await peekNextStepNumber(path22.join(runDirPath, "steps")) > maxSteps) {
+  if (await peekNextStepNumber(path23.join(runDirPath, "steps")) > maxSteps) {
     return fail(stepLimitMessage(maxSteps, opts.run), opts);
   }
-  const pendingShot = path22.join(
+  const pendingShot = path23.join(
     runDirPath,
     "screenshots",
     `.pending-${randomUUID7()}.png`
@@ -17056,11 +17666,14 @@ var doctor_exports = {};
 __export(doctor_exports, {
   checkCdpResponsive: () => checkCdpResponsive,
   checkPortAvailable: () => checkPortAvailable,
+  checkProjectHarnesses: () => checkProjectHarnesses,
+  checkProjectTestabilityContract: () => checkProjectTestabilityContract,
+  checkTargetHealth: () => checkTargetHealth,
   doctor: () => doctor,
   runDoctorChecks: () => runDoctorChecks
 });
 import { createServer } from "net";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync10, promises as fs26 } from "fs";
 import { join as join7 } from "path";
 import chalk21 from "chalk";
 function checkPortAvailable(port) {
@@ -17338,11 +17951,186 @@ async function checkAgentIntegrations(projectRoot) {
   }
   return checks;
 }
-async function runDoctorChecks(projectRoot) {
+async function checkTargetHealth(targetUrl) {
+  const checks = [];
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(targetUrl);
+  } catch {
+    checks.push({
+      category: "target",
+      name: "Target URL Format",
+      status: "error",
+      message: `Invalid target URL: "${targetUrl}"`,
+      remedy: "Provide a valid URL with protocol (e.g. http://localhost:3000)."
+    });
+    return checks;
+  }
+  try {
+    const res = await fetch(targetUrl, {
+      method: "GET",
+      redirect: "manual",
+      signal: AbortSignal.timeout(3e3)
+    });
+    if ([301, 302, 303, 307, 308].includes(res.status)) {
+      const location = res.headers.get("location") || "";
+      const isExternalAuth = /auth0\.com|okta\.com|clerk\.com|accounts\.google\.com|cognito|login\.microsoftonline\.com/i.test(
+        location
+      ) || location.includes("/oauth");
+      if (isExternalAuth) {
+        let redirectHost = location;
+        try {
+          redirectHost = new URL(location, targetUrl).host;
+        } catch {
+        }
+        checks.push({
+          category: "target",
+          name: "Authentication Boundary",
+          status: "warn",
+          message: `Target immediately redirects to external auth (${redirectHost})`,
+          remedy: "Configure a dev auth bypass or prepare for interactive login handshake before walking."
+        });
+        return checks;
+      }
+      checks.push({
+        category: "target",
+        name: "Target Reachability",
+        status: "ok",
+        message: `HTTP ${res.status} redirect -> ${location}`
+      });
+      return checks;
+    }
+    if (res.status >= 500) {
+      checks.push({
+        category: "target",
+        name: "Target Health",
+        status: "error",
+        message: `Target returned HTTP ${res.status} ${res.statusText || "Server Error"}`,
+        remedy: "Check dev server logs for unhandled exceptions or missing environment variables."
+      });
+      return checks;
+    }
+    checks.push({
+      category: "target",
+      name: "Target Reachability",
+      status: "ok",
+      message: `HTTP ${res.status} OK (${parsedUrl.origin})`
+    });
+  } catch (err) {
+    const message = err.message;
+    checks.push({
+      category: "target",
+      name: "Target Reachability",
+      status: "warn",
+      message: `Cannot connect to ${targetUrl} (${message})`,
+      remedy: "Ensure your dev server is running and listening on the specified port."
+    });
+  }
+  return checks;
+}
+async function checkProjectHarnesses(projectRoot) {
+  const checks = [];
+  const pkgPath = join7(projectRoot, "package.json");
+  if (!existsSync10(pkgPath)) return checks;
+  try {
+    const raw = await fs26.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    const scripts = pkg.scripts || {};
+    const allDeps = {
+      ...pkg.dependencies || {},
+      ...pkg.devDependencies || {}
+    };
+    const devScripts = ["dev", "start", "dev:mock", "serve"].filter(
+      (s) => s in scripts
+    );
+    if (devScripts.length > 0) {
+      checks.push({
+        category: "target",
+        name: "Dev Server Script",
+        status: "ok",
+        message: `Available scripts: ${devScripts.map((s) => `pnpm ${s}`).join(", ")}`
+      });
+    } else {
+      checks.push({
+        category: "target",
+        name: "Dev Server Script",
+        status: "warn",
+        message: "No standard dev script (dev, start, dev:mock) found in package.json",
+        remedy: "Add a `dev` or `start` script to package.json to boot your app locally."
+      });
+    }
+    if (allDeps.msw || existsSync10(join7(projectRoot, "src/mocks")) || existsSync10(join7(projectRoot, "mocks"))) {
+      checks.push({
+        category: "target",
+        name: "Mock Harness (MSW)",
+        status: "ok",
+        message: "Mock Service Worker detected. API mocks can decouple walks from live backends."
+      });
+    }
+    const seedScript = Object.keys(scripts).find(
+      (s) => /seed|db:seed|fixtures/i.test(s)
+    );
+    if (seedScript) {
+      checks.push({
+        category: "target",
+        name: "Database Seed",
+        status: "ok",
+        message: `Seed script detected (${seedScript}). Preconditions can be reset between runs.`
+      });
+    }
+  } catch {
+  }
+  return checks;
+}
+async function checkProjectTestabilityContract(projectRoot) {
+  const checks = [];
+  const testabilityPath = join7(projectRoot, "iamu", "testability.md");
+  if (!existsSync10(testabilityPath)) {
+    checks.push({
+      category: "target",
+      name: "Testability Contract (testability.md)",
+      status: "warn",
+      message: "iamu/testability.md not found",
+      remedy: "Run `/iamu:init` to audit your codebase and record testable routes, auth strategies, and mock harnesses."
+    });
+    return { checks };
+  }
+  try {
+    const raw = await fs26.readFile(testabilityPath, "utf8");
+    const { frontmatter } = parseFrontmatter(raw);
+    const targetUrl = typeof frontmatter.target_url === "string" ? frontmatter.target_url : void 0;
+    const details = [];
+    if (targetUrl) details.push(`Target: ${targetUrl}`);
+    if (frontmatter.dev_command) {
+      details.push(`Command: ${frontmatter.dev_command}`);
+    }
+    if (frontmatter.auth_strategy) {
+      details.push(`Auth: ${frontmatter.auth_strategy}`);
+    }
+    checks.push({
+      category: "target",
+      name: "Testability Contract (testability.md)",
+      status: "ok",
+      message: `Configured (${details.join(" \xB7 ") || "present"})`
+    });
+    return { checks, targetUrl };
+  } catch (err) {
+    checks.push({
+      category: "target",
+      name: "Testability Contract (testability.md)",
+      status: "warn",
+      message: `Unreadable testability contract: ${err.message}`,
+      remedy: "Repair iamu/testability.md frontmatter."
+    });
+    return { checks };
+  }
+}
+async function runDoctorChecks(projectRoot, opts) {
   const checks = [
     ...checkRuntimeChecks(),
     ...await checkBrowserChecks()
   ];
+  let effectiveTarget = opts?.target;
   if (!projectRoot || !existsSync10(join7(projectRoot, "iamu"))) {
     checks.push({
       category: "project",
@@ -17362,6 +18150,15 @@ async function runDoctorChecks(projectRoot) {
     checks.push(...await checkProjectConfiguration(projectRoot));
     checks.push(...await checkProjectContextAndEntities(projectRoot));
     checks.push(...await checkAgentIntegrations(projectRoot));
+    checks.push(...await checkProjectHarnesses(projectRoot));
+    const testability = await checkProjectTestabilityContract(projectRoot);
+    checks.push(...testability.checks);
+    if (!effectiveTarget && testability.targetUrl) {
+      effectiveTarget = testability.targetUrl;
+    }
+  }
+  if (effectiveTarget) {
+    checks.push(...await checkTargetHealth(effectiveTarget));
   }
   const okCount = checks.filter((c) => c.status === "ok").length;
   const warnCount = checks.filter((c) => c.status === "warn").length;
@@ -17378,7 +18175,7 @@ async function runDoctorChecks(projectRoot) {
 }
 async function doctor(opts) {
   const projectRoot = findProjectRoot(process.cwd()) ?? void 0;
-  const result = await runDoctorChecks(projectRoot);
+  const result = await runDoctorChecks(projectRoot, { target: opts?.target });
   if (opts?.json) {
     console.log(JSON.stringify(result, null, 2));
     if (!result.ok) process.exitCode = 1;
@@ -17392,7 +18189,8 @@ async function doctor(opts) {
     { key: "browser", title: "Browser Automation" },
     { key: "project", title: "Project Configuration" },
     { key: "agent", title: "Agent Integrations" },
-    { key: "cloud", title: "Cloud & Authentication" }
+    { key: "cloud", title: "Cloud & Authentication" },
+    { key: "target", title: "Target & Testability" }
   ];
   for (const cat of categories) {
     const catChecks = result.checks.filter((c) => c.category === cat.key);
@@ -17870,13 +18668,13 @@ __export(validate_exports, {
   validate: () => validate
 });
 import { randomUUID as randomUUID8 } from "crypto";
-import { promises as fs24 } from "fs";
-import path23 from "path";
+import { promises as fs27 } from "fs";
+import path24 from "path";
 import chalk23 from "chalk";
 function inferTypeFromPath(filePath, projectRoot) {
-  const rel = path23.relative(path23.join(projectRoot, "iamu"), filePath);
-  if (rel.startsWith("..") || path23.isAbsolute(rel)) return null;
-  const segments = rel.split(path23.sep);
+  const rel = path24.relative(path24.join(projectRoot, "iamu"), filePath);
+  if (rel.startsWith("..") || path24.isAbsolute(rel)) return null;
+  const segments = rel.split(path24.sep);
   if (segments.length < 2) return null;
   return TYPE_BY_ALIAS.get(segments[0]) ?? null;
 }
@@ -17906,7 +18704,7 @@ function validateFile(filePath, raw, projectRoot) {
     );
     return result;
   }
-  if (path23.basename(filePath) === "context.yml") {
+  if (path24.basename(filePath) === "context.yml") {
     applyZodValidation(contextFrontmatterSchema, frontmatter, result);
     const warnings = [];
     const hasNotes = Boolean(
@@ -17966,17 +18764,17 @@ async function buildRepairLookups(projectRoot) {
     }
   }
   const runScenario = /* @__PURE__ */ new Map();
-  const runsDir2 = path23.join(projectRoot, "iamu", ".runs");
+  const runsDir2 = path24.join(projectRoot, "iamu", ".runs");
   let runIds = [];
   try {
-    runIds = await fs24.readdir(runsDir2);
+    runIds = await fs27.readdir(runsDir2);
   } catch {
   }
   for (const runId of runIds) {
     try {
       const manifest = JSON.parse(
-        await fs24.readFile(
-          path23.join(runsDir2, runId, "walkthrough.json"),
+        await fs27.readFile(
+          path24.join(runsDir2, runId, "walkthrough.json"),
           "utf8"
         )
       );
@@ -17998,7 +18796,7 @@ async function fixFindings(projectRoot, results, dryRun) {
     let raw;
     let parsed;
     try {
-      raw = await fs24.readFile(result.path, "utf8");
+      raw = await fs27.readFile(result.path, "utf8");
       parsed = parseFrontmatter(raw);
     } catch {
       continue;
@@ -18007,7 +18805,7 @@ async function fixFindings(projectRoot, results, dryRun) {
       parsed.frontmatter,
       {
         ...lookups,
-        fileSlug: path23.basename(result.path, ".md"),
+        fileSlug: path24.basename(result.path, ".md"),
         newId: randomUUID8,
         body: parsed.body
       }
@@ -18042,9 +18840,9 @@ async function validate(filePath, opts) {
   if (process.exitCode === 1) return;
   const results = [];
   if (filePath) {
-    const abs = path23.isAbsolute(filePath) ? filePath : path23.resolve(process.cwd(), filePath);
+    const abs = path24.isAbsolute(filePath) ? filePath : path24.resolve(process.cwd(), filePath);
     try {
-      const raw = await fs24.readFile(abs, "utf8");
+      const raw = await fs27.readFile(abs, "utf8");
       results.push(validateFile(abs, raw, projectRoot));
     } catch (err) {
       commandError(
@@ -18054,24 +18852,24 @@ async function validate(filePath, opts) {
       return;
     }
   } else if (opts.run) {
-    const findingsDir = path23.join(projectRoot, "iamu", ENTITY_DIRS.finding);
+    const findingsDir = path24.join(projectRoot, "iamu", ENTITY_DIRS.finding);
     let names = [];
     try {
-      names = await fs24.readdir(findingsDir);
+      names = await fs27.readdir(findingsDir);
     } catch {
     }
     for (const name of names) {
       if (!name.endsWith(".md")) continue;
-      const abs = path23.join(findingsDir, name);
+      const abs = path24.join(findingsDir, name);
       try {
-        const raw = await fs24.readFile(abs, "utf8");
+        const raw = await fs27.readFile(abs, "utf8");
         const { frontmatter } = parseFrontmatter(raw);
         if (frontmatter.run === opts.run) {
           results.push(validateFile(abs, raw, projectRoot));
         }
       } catch {
         results.push({
-          path: path23.relative(projectRoot, abs),
+          path: path24.relative(projectRoot, abs),
           valid: false,
           errors: ["Cannot read file or parse frontmatter"]
         });
@@ -18104,31 +18902,31 @@ async function validate(filePath, opts) {
   } else {
     const typesToCheck = typeFilter ? ENTITY_TYPES.filter((t) => typeFilter.has(t)) : ENTITY_TYPES;
     for (const type2 of typesToCheck) {
-      const iamuTypeDir = path23.join(projectRoot, "iamu", ENTITY_DIRS[type2]);
+      const iamuTypeDir = path24.join(projectRoot, "iamu", ENTITY_DIRS[type2]);
       let names;
       try {
-        names = await fs24.readdir(iamuTypeDir);
+        names = await fs27.readdir(iamuTypeDir);
       } catch {
         continue;
       }
       for (const name of names) {
         if (!name.endsWith(".md")) continue;
-        const abs = path23.join(iamuTypeDir, name);
+        const abs = path24.join(iamuTypeDir, name);
         try {
-          const raw = await fs24.readFile(abs, "utf8");
+          const raw = await fs27.readFile(abs, "utf8");
           results.push(validateFile(abs, raw, projectRoot));
         } catch {
           results.push({
-            path: path23.relative(projectRoot, abs),
+            path: path24.relative(projectRoot, abs),
             valid: false,
             errors: ["Cannot read file"]
           });
         }
       }
     }
-    const ctxPath = path23.join(projectRoot, "iamu", "context.yml");
+    const ctxPath = path24.join(projectRoot, "iamu", "context.yml");
     try {
-      const raw = await fs24.readFile(ctxPath, "utf8");
+      const raw = await fs27.readFile(ctxPath, "utf8");
       results.push(validateFile(ctxPath, raw, projectRoot));
     } catch {
     }
@@ -18147,19 +18945,19 @@ async function validate(filePath, opts) {
           valid,
           errors: results.filter((r) => !r.valid).flatMap(
             (r) => r.errors.map((e) => ({
-              path: path23.relative(projectRoot, r.path),
+              path: path24.relative(projectRoot, r.path),
               message: e
             }))
           ),
           warnings: results.filter((r) => r.warnings && r.warnings.length > 0).flatMap(
             (r) => (r.warnings ?? []).map((w) => ({
-              path: path23.relative(projectRoot, r.path),
+              path: path24.relative(projectRoot, r.path),
               message: w
             }))
           ),
           ...opts.fix ? {
             repaired: repaired.map((r) => ({
-              path: path23.relative(projectRoot, r.path),
+              path: path24.relative(projectRoot, r.path),
               changes: r.repairs,
               valid: r.valid
             }))
@@ -18181,7 +18979,7 @@ async function validate(filePath, opts) {
   }
   let hasErrors = false;
   for (const r of results) {
-    const relPath = path23.relative(projectRoot, r.path);
+    const relPath = path24.relative(projectRoot, r.path);
     if (r.valid) {
       if (r.warnings && r.warnings.length > 0) {
         console.log(`  ${symbols.warning} ` + chalk23.yellow(relPath));
@@ -18372,10 +19170,26 @@ function defaultFrontmatter(type2, id, slug, name, opts) {
         ...base,
         name,
         role: opts.role ?? "TODO",
-        ...opts.disposition ? { disposition: opts.disposition } : {}
+        ...opts.disposition ? { disposition: opts.disposition } : {},
+        ...opts.access ? { access: opts.access } : {}
       };
-    case "outline":
-      return { ...base, title: name, ...description };
+    case "outline": {
+      const tests = Array.isArray(opts.humanTest) ? opts.humanTest : opts.humanTest ? [opts.humanTest] : [];
+      return {
+        ...base,
+        title: name,
+        ...description,
+        ...opts.capability ? { primary_capability: opts.capability } : {},
+        ...opts.tension ? { tension: opts.tension } : {},
+        ...opts.narrative ? { narrative: opts.narrative } : {},
+        ...tests.length > 0 ? {
+          human_tests: tests.map((t, idx) => ({
+            id: `test-${idx + 1}`,
+            question: t
+          }))
+        } : {}
+      };
+    }
     case "capability":
       return { ...base, title: name, ...description };
     case "source":
@@ -18385,13 +19199,21 @@ function defaultFrontmatter(type2, id, slug, name, opts) {
         url: opts.url,
         authority_level: opts.authority ?? "informational"
       };
-    case "scenario":
+    case "scenario": {
+      const stateObj = opts.stateDescription || opts.stateApproximation ? {
+        state: {
+          ...opts.stateDescription ? { description: opts.stateDescription } : {},
+          ...opts.stateApproximation ? { approximation: opts.stateApproximation } : {}
+        }
+      } : {};
       return {
         ...base,
         outline: opts.outline ?? null,
         persona: opts.persona ?? null,
-        ...opts.entry ? { entry_path: opts.entry } : {}
+        ...opts.entry ? { entry_path: opts.entry } : {},
+        ...stateObj
       };
+    }
     default:
       return base;
   }
@@ -18431,7 +19253,14 @@ async function newEntity(type2, opts) {
       return;
     }
   }
-  const slug = opts.slug ? slugify(opts.slug) : slugify(opts.name);
+  let slug;
+  if (opts.slug) {
+    slug = slugSchema.safeParse(opts.slug).success ? opts.slug : slugify(opts.slug);
+  } else if (slugSchema.safeParse(opts.name).success) {
+    slug = opts.name;
+  } else {
+    slug = slugify(opts.name);
+  }
   if (await entityExists(projectRoot, entityType, slug)) {
     commandError(
       `Entity already exists: iamu/${ENTITY_DIRS[entityType]}/${slug}.md`,
@@ -18441,7 +19270,7 @@ async function newEntity(type2, opts) {
   }
   const id = randomUUID9();
   const frontmatter = defaultFrontmatter(entityType, id, slug, opts.name, opts);
-  const body = "";
+  const body = opts.body ?? (entityType === "outline" ? "" : opts.narrative) ?? "";
   try {
     const record = await writeEntity(
       projectRoot,
@@ -18486,6 +19315,797 @@ var init_new_entity = __esm({
   }
 });
 
+// src/commands/explore-crawl.ts
+function candidateSig(c) {
+  return `${c.role}
+${c.name}
+${c.occurrence}`;
+}
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function skipReason(c, origin, deny) {
+  if (deny.some((re) => re.test(c.name) || c.href && re.test(c.href))) {
+    return "denied";
+  }
+  if (c.submit) return "submit";
+  if (UNSAFE_NAME.test(c.name)) return "unsafe_name";
+  if (c.href) {
+    let u = null;
+    try {
+      u = new URL(c.href);
+    } catch {
+    }
+    if (u && u.protocol !== "javascript:") {
+      if (u.protocol !== "http:" && u.protocol !== "https:") return "external";
+      if (u.origin !== origin) return "external";
+      if (UNSAFE_PATH.test(u.pathname)) return "unsafe_name";
+    }
+    if (c.download) return "download";
+  }
+  return null;
+}
+async function settle(page, settleMs) {
+  await page.waitForLoadState("domcontentloaded", { timeout: NAV_TIMEOUT_MS }).catch(() => {
+  });
+  await page.waitForLoadState("networkidle", { timeout: settleMs }).catch(() => {
+  });
+}
+async function readPage(page) {
+  return page.evaluate(READ_PAGE);
+}
+async function markDocument(page) {
+  await page.evaluate("window.__iamuDoc = true").catch(() => {
+  });
+}
+async function isSameDocument(page) {
+  return page.evaluate("window.__iamuDoc === true").catch(() => false);
+}
+async function clickCandidate(page, want) {
+  const state = await readPage(page);
+  const c = state.candidates.find(
+    (x) => candidateSig(x) === candidateSig(want)
+  );
+  if (!c) return false;
+  await page.locator(`[data-iamu-x="${c.index}"]`).click({ timeout: CLICK_TIMEOUT_MS });
+  return true;
+}
+async function crawl(page, opts) {
+  const origin = originOf(opts.startUrl);
+  if (!origin) throw new Error(`Not a URL: ${opts.startUrl}`);
+  let blocked = [];
+  await page.route("**/*", (route) => {
+    const req = route.request();
+    if (SAFE_METHODS.has(req.method())) return route.continue();
+    let where = req.url();
+    try {
+      const u = new URL(where);
+      where = u.origin === origin ? u.pathname : `${u.origin}${u.pathname}`;
+    } catch {
+    }
+    blocked.push(`${req.method()} ${where}`);
+    return route.abort("blockedbyclient");
+  });
+  const onDialog = (d) => {
+    d.dismiss().catch(() => {
+    });
+  };
+  const onPopup = (p) => {
+    if (p !== page) p.close().catch(() => {
+    });
+  };
+  page.on("dialog", onDialog);
+  page.context().on("page", onPopup);
+  try {
+    return await crawlFrom(page, opts, origin, () => {
+      const out = blocked;
+      blocked = [];
+      return out;
+    });
+  } finally {
+    page.off("dialog", onDialog);
+    page.context().off("page", onPopup);
+    await page.unroute("**/*").catch(() => {
+    });
+  }
+}
+async function crawlFrom(page, opts, origin, takeBlocked) {
+  const deny = opts.deny ?? [];
+  const settleMs = opts.settleMs ?? 1500;
+  const { budget } = opts;
+  const stats = {
+    surfaces: 0,
+    actions_tried: 0,
+    skipped: 0,
+    blocked_requests: 0,
+    errors: 0,
+    truncated: false
+  };
+  const surfaces = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const byPlaceView = /* @__PURE__ */ new Map();
+  const signatureOf = (s) => exploreSignature(s.headings, s.title);
+  function addSurface(state, place, view, path30, depth) {
+    const key = exploreSurfaceKey(place, view);
+    const surface = {
+      key,
+      url: state.url,
+      place,
+      view,
+      signature: signatureOf(state),
+      label: state.headings[0] ?? (state.title || place),
+      headings: state.headings,
+      fields: state.fields,
+      depth,
+      path: path30,
+      actions: []
+    };
+    surfaces.push(surface);
+    byKey.set(key, surface);
+    byPlaceView.set(`${place}
+${surface.signature}`, key);
+    stats.surfaces++;
+    opts.log?.(`  ${"  ".repeat(depth)}${key}  ${surface.label}`);
+    return surface;
+  }
+  async function goto(url) {
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: NAV_TIMEOUT_MS
+    });
+    await settle(page, settleMs);
+  }
+  async function replay(path30) {
+    if (!("goto" in (path30[0] ?? {}))) await goto(opts.startUrl);
+    for (const step of path30) {
+      if ("goto" in step) {
+        await goto(step.goto);
+      } else {
+        if (!await clickCandidate(page, step.click)) return false;
+        await settle(page, settleMs);
+      }
+    }
+    return true;
+  }
+  await goto(opts.startUrl);
+  if (await page.evaluate("Boolean(navigator.serviceWorker?.controller)").catch(() => false)) {
+    throw new Error(
+      "A service worker controls this page, and the write guard cannot see its requests. Explore without --attach (service workers are blocked there)."
+    );
+  }
+  const first = await readPage(page);
+  const firstPlace = explorePlaceKey(first.url);
+  if (!firstPlace || originOf(first.url) !== origin) {
+    throw new Error(`The start URL led off the product, to ${first.url}`);
+  }
+  addSurface(first, firstPlace, null, [], 0);
+  for (let i = 0; i < surfaces.length; i++) {
+    const surface = surfaces[i];
+    if (!await replay(surface.path)) {
+      stats.errors++;
+      surface.actions.push({
+        role: "",
+        name: "",
+        occurrence: 0,
+        outcome: { kind: "error", message: LOST }
+      });
+      continue;
+    }
+    const home = await readPage(page);
+    const seen = new Set(home.candidates.map(candidateSig));
+    const work = home.candidates.map((c) => ({ c, via: [] }));
+    const homeList = home.candidates.map(candidateSig).join("\n");
+    let pristine = true;
+    for (let w = 0; w < work.length; w++) {
+      const { c, via } = work[w];
+      const action = {
+        role: c.role,
+        name: c.name,
+        occurrence: c.occurrence,
+        ...c.href ? { href: c.href } : {},
+        ...via.length > 0 ? { via } : {},
+        outcome: { kind: "same" }
+      };
+      surface.actions.push(action);
+      const reason = skipReason(c, origin, deny);
+      if (reason) {
+        action.outcome = { kind: "skipped", reason };
+        stats.skipped++;
+        continue;
+      }
+      if (surface.depth >= budget.max_depth || stats.actions_tried >= budget.max_actions) {
+        action.outcome = { kind: "skipped", reason: "budget" };
+        stats.skipped++;
+        stats.truncated = true;
+        continue;
+      }
+      stats.actions_tried++;
+      takeBlocked();
+      const click = {
+        click: { role: c.role, name: c.name, occurrence: c.occurrence }
+      };
+      let outcome;
+      let revealed = 0;
+      let left = false;
+      let lost = false;
+      try {
+        if (!pristine || via.length > 0) {
+          if (!await replay([...surface.path, ...via])) {
+            throw new Error(LOST);
+          }
+        }
+        pristine = false;
+        const before = await readPage(page);
+        await markDocument(page);
+        if (c.newTab && c.href) {
+          await goto(c.href);
+        } else {
+          if (!await clickCandidate(page, c)) {
+            throw new Error("control is gone");
+          }
+          await settle(page, settleMs);
+        }
+        const after = await readPage(page);
+        if (originOf(after.url) !== origin) {
+          outcome = { kind: "external", url: after.url };
+          left = true;
+        } else {
+          const place = explorePlaceKey(after.url) ?? before.url;
+          const sig = signatureOf(after);
+          const sameDoc = !(c.newTab && c.href) && await isSameDocument(page);
+          const beforePlace = explorePlaceKey(before.url);
+          let key = byPlaceView.get(`${place}
+${sig}`);
+          let view = null;
+          if (!key) {
+            const inPage = sameDoc && place === beforePlace;
+            view = inPage ? sig : null;
+            key = exploreSurfaceKey(place, view);
+            if (byKey.has(key)) byPlaceView.set(`${place}
+${sig}`, key);
+          }
+          if (key === surface.key) {
+            outcome = { kind: "same" };
+            const list2 = after.candidates.map(candidateSig).join("\n");
+            for (const n of after.candidates) {
+              const s = candidateSig(n);
+              if (seen.has(s)) continue;
+              seen.add(s);
+              work.push({ c: n, via: [...via, click] });
+              revealed++;
+            }
+            if (list2 === homeList) pristine = true;
+          } else {
+            outcome = { kind: "surface", surface: key };
+            if (!byKey.has(key)) {
+              if (stats.surfaces >= budget.max_surfaces) {
+                stats.truncated = true;
+              } else {
+                const path30 = !sameDoc && view === null ? [{ goto: after.url }] : [...surface.path, ...via, click];
+                addSurface(after, place, view, path30, surface.depth + 1);
+              }
+            }
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        outcome = { kind: "error", message: msg.split("\n")[0].slice(0, 200) };
+        stats.errors++;
+        lost = msg === LOST;
+      }
+      action.outcome = outcome;
+      if (revealed > 0) action.revealed = revealed;
+      const writes = takeBlocked();
+      if (writes.length > 0) {
+        action.blocked_requests = [...new Set(writes)];
+        stats.blocked_requests += writes.length;
+      }
+      if (left) pristine = false;
+      if (lost) break;
+    }
+  }
+  return { surfaces, stats };
+}
+var UNSAFE_NAME, UNSAFE_PATH, SAFE_METHODS, CLICK_TIMEOUT_MS, LOST, NAV_TIMEOUT_MS, READ_PAGE;
+var init_explore_crawl = __esm({
+  "src/commands/explore-crawl.ts"() {
+    "use strict";
+    init_dist2();
+    UNSAFE_NAME = new RegExp(
+      `(?<![\\p{L}\\p{N}])(${[
+        // English
+        "delete",
+        "remove",
+        "destroy",
+        "erase",
+        "pay",
+        "pay now",
+        "purchase",
+        "buy",
+        "checkout",
+        "place order",
+        "order now",
+        "send",
+        "submit",
+        "save",
+        "confirm",
+        "approve",
+        "reject",
+        "decline",
+        "publish",
+        "archive",
+        "unsubscribe",
+        "log ?out",
+        "sign ?out",
+        "reset",
+        "transfer",
+        "invite",
+        "upload",
+        "import",
+        "deactivate",
+        "close account",
+        // Swedish
+        "ta bort",
+        "radera",
+        "betala",
+        "k\xF6p",
+        "best\xE4ll",
+        "skicka",
+        "skicka in",
+        "spara",
+        "bekr\xE4fta",
+        "godk\xE4nn",
+        "avsl\xE5",
+        "publicera",
+        "arkivera",
+        "logga ut",
+        "\xE5terst\xE4ll",
+        "\xF6verf\xF6r",
+        "bjud in",
+        "ladda upp"
+      ].join("|")})(?![\\p{L}\\p{N}])`,
+      "iu"
+    );
+    UNSAFE_PATH = /(^|\/)(log-?out|sign-?out|logga-?ut|delete|remove|destroy|unsubscribe)(\/|$)/i;
+    SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+    CLICK_TIMEOUT_MS = 3e3;
+    LOST = "could not return to surface";
+    NAV_TIMEOUT_MS = 15e3;
+    READ_PAGE = String.raw`(() => {
+  const SELECTOR = [
+    "a[href]", "button", "summary",
+    'input[type="button"]', 'input[type="submit"]',
+    'input[type="reset"]', 'input[type="image"]',
+    '[role="button"]', '[role="link"]', '[role="tab"]',
+    '[role="menuitem"]', '[role="menuitemradio"]', '[role="menuitemcheckbox"]',
+  ].join(",");
+  const clean = (s) => (s ?? "").replace(/\s+/g, " ").trim();
+  const visible = (el) => {
+    if (typeof el.checkVisibility === "function" &&
+        !el.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })) {
+      return false;
+    }
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0;
+  };
+  const textOf = (id) => clean(document.getElementById(id)?.innerText);
+  const nameOf = (el) => {
+    const label = clean(el.getAttribute("aria-label"));
+    if (label) return label;
+    const by = el.getAttribute("aria-labelledby");
+    if (by) {
+      const t = clean(by.split(/\s+/).map(textOf).join(" "));
+      if (t) return t;
+    }
+    if (el instanceof HTMLInputElement) {
+      return clean(el.value) || clean(el.alt) || clean(el.title);
+    }
+    const text = clean(el.innerText);
+    if (text) return text.slice(0, 80);
+    const img = el.querySelector("img[alt]");
+    return clean(img?.getAttribute("alt")) || clean(el.title);
+  };
+  const roleOf = (el) =>
+    el.getAttribute("role") || (el.tagName === "A" ? "link" : "button");
+
+  for (const el of document.querySelectorAll("[data-iamu-x]")) {
+    el.removeAttribute("data-iamu-x");
+  }
+  const seen = new Map();
+  const candidates = [];
+  let index = 0;
+  for (const el of document.querySelectorAll(SELECTOR)) {
+    if (!visible(el)) continue;
+    if (el.disabled || el.getAttribute("aria-disabled") === "true") continue;
+    const role = roleOf(el);
+    const name = nameOf(el);
+    const sig = role + "\n" + name;
+    const occurrence = seen.get(sig) ?? 0;
+    seen.set(sig, occurrence + 1);
+    let submit = false;
+    if (el instanceof HTMLButtonElement) {
+      // A button in a form submits unless it says type="button".
+      submit = el.form
+        ? el.type === "submit" || el.type === "reset"
+        : el.getAttribute("type") === "submit";
+    } else if (el instanceof HTMLInputElement) {
+      submit = ["submit", "reset", "image"].includes(el.type);
+    }
+    const anchor = el instanceof HTMLAnchorElement ? el : null;
+    el.setAttribute("data-iamu-x", String(index));
+    candidates.push({
+      index, role, name, occurrence,
+      href: anchor ? anchor.href : null,
+      download: anchor ? anchor.hasAttribute("download") : false,
+      newTab: anchor ? anchor.target === "_blank" : false,
+      submit,
+    });
+    index++;
+  }
+
+  const headings = [];
+  for (const el of document.querySelectorAll(
+    'h1, h2, [role="heading"][aria-level="1"], [role="heading"][aria-level="2"]',
+  )) {
+    if (!visible(el)) continue;
+    const t = clean(el.innerText);
+    if (t) headings.push(t.slice(0, 120));
+  }
+
+  const fields = [];
+  for (const f of document.querySelectorAll("input, select, textarea")) {
+    if (["hidden", "submit", "button", "reset", "image"].includes(f.type)) continue;
+    if (!visible(f)) continue;
+    const forLabel = f.id
+      ? document.querySelector('label[for="' + CSS.escape(f.id) + '"]')
+      : null;
+    const name =
+      clean(f.getAttribute("aria-label")) ||
+      clean(forLabel?.innerText) ||
+      clean(f.closest("label")?.innerText) ||
+      clean(f.placeholder) ||
+      clean(f.name);
+    if (name && !fields.includes(name)) fields.push(name.slice(0, 80));
+    if (fields.length >= 40) break;
+  }
+
+  return { url: location.href, title: clean(document.title), headings, fields, candidates };
+})()`;
+  }
+});
+
+// src/commands/explore.ts
+var explore_exports = {};
+__export(explore_exports, {
+  exploreCoverageCommand: () => exploreCoverageCommand,
+  exploreDiffCommand: () => exploreDiffCommand,
+  exploreList: () => exploreList,
+  exploreRun: () => exploreRun
+});
+import { promises as fs28 } from "fs";
+import path25 from "path";
+import chalk26 from "chalk";
+function fail2(message, json2) {
+  if (json2) console.error(JSON.stringify({ error: message }));
+  else console.error(chalk26.red(`  ${message}`));
+  process.exitCode = 1;
+}
+function positiveInt(raw, fallback, flag) {
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(`${flag} must be a positive whole number, got "${raw}"`);
+  }
+  return n;
+}
+async function testabilityTarget2(projectRoot) {
+  try {
+    const raw = await fs28.readFile(
+      path25.join(projectRoot, "iamu", "testability.md"),
+      "utf8"
+    );
+    const { frontmatter } = parseFrontmatter(raw);
+    return typeof frontmatter.target_url === "string" ? frontmatter.target_url : null;
+  } catch {
+    return null;
+  }
+}
+async function openPage(opts) {
+  const { chromium } = await import("playwright-core");
+  const viewport = parseViewport(opts.viewport) ?? {
+    width: 1280,
+    height: 800
+  };
+  if (opts.attach) {
+    const state = readBrowseState();
+    if (!state) {
+      throw new Error(
+        "No browser to attach to \u2014 start one with `iamu browse start` and sign in first."
+      );
+    }
+    const browser2 = await chromium.connectOverCDP(
+      `http://127.0.0.1:${state.port}`
+    );
+    const context = browser2.contexts()[0] ?? await browser2.newContext();
+    const page2 = await context.newPage();
+    await page2.setViewportSize(viewport);
+    return {
+      page: page2,
+      close: async () => {
+        await page2.close().catch(() => {
+        });
+        await browser2.close().catch(() => {
+        });
+      }
+    };
+  }
+  const chrome = findChrome();
+  if (!chrome) {
+    throw new Error(
+      "No Chrome or Chromium found \u2014 install one or set IAMU_BROWSER."
+    );
+  }
+  const browser = await chromium.launch({
+    executablePath: chrome,
+    headless: true,
+    chromiumSandbox: !shouldDisableSandbox()
+  });
+  const page = await browser.newPage({ viewport, serviceWorkers: "block" });
+  return { page, close: () => browser.close().catch(() => {
+  }) };
+}
+async function exploreRun(url, opts) {
+  const ctx = await resolveProject(opts);
+  if (!ctx) return;
+  const target = url ?? await testabilityTarget2(ctx.projectRoot);
+  if (!target) {
+    fail2(
+      "No URL to explore \u2014 pass one (iamu explore http://localhost:3000) or set target_url in iamu/testability.md.",
+      opts.json
+    );
+    return;
+  }
+  let startUrl;
+  let budget;
+  let deny;
+  try {
+    startUrl = new URL(target).href;
+    budget = {
+      max_surfaces: positiveInt(
+        opts.maxSurfaces,
+        DEFAULTS.max_surfaces,
+        "--max-surfaces"
+      ),
+      max_actions: positiveInt(
+        opts.maxActions,
+        DEFAULTS.max_actions,
+        "--max-actions"
+      ),
+      max_depth: positiveInt(opts.maxDepth, DEFAULTS.max_depth, "--max-depth")
+    };
+    deny = (opts.deny ?? []).map((d) => new RegExp(d, "i"));
+  } catch (err) {
+    fail2(err.message, opts.json);
+    return;
+  }
+  const quiet = opts.json || process.env.IAMU_QUIET === "1";
+  if (!quiet) {
+    console.error(chalk26.dim(`  Exploring ${startUrl} (read-only)\u2026`));
+  }
+  const now = /* @__PURE__ */ new Date();
+  let opened = null;
+  let result;
+  try {
+    opened = await openPage(opts);
+    result = await crawl(opened.page, {
+      startUrl,
+      budget,
+      deny,
+      log: quiet ? void 0 : (line) => console.error(chalk26.dim(line))
+    });
+  } catch (err) {
+    fail2(err.message.split("\n")[0], opts.json);
+    return;
+  } finally {
+    await opened?.close();
+  }
+  const build = detectBuild({ cwd: ctx.projectRoot });
+  const map2 = {
+    schema: 1,
+    id: composeExploreId(now),
+    created_at: now.toISOString(),
+    target_url: startUrl,
+    ...build ? { build: { ...build } } : {},
+    budget,
+    stats: result.stats,
+    surfaces: result.surfaces
+  };
+  const file = await writeExploreMap(ctx.projectRoot, map2);
+  const rel = path25.relative(process.cwd(), file);
+  if (opts.json) {
+    console.log(JSON.stringify({ id: map2.id, path: rel, stats: map2.stats }));
+    return;
+  }
+  const s = map2.stats;
+  console.log(
+    `
+  ${chalk26.bold(`${s.surfaces} surfaces`)} \xB7 ${s.actions_tried} controls tried \xB7 ${s.skipped} skipped \xB7 ${s.blocked_requests} writes blocked${s.errors ? ` \xB7 ${s.errors} errors` : ""}`
+  );
+  if (s.truncated) {
+    console.log(
+      chalk26.yellow(
+        "  Stopped by the budget before the product ran out \u2014 raise --max-surfaces / --max-actions / --max-depth to go further."
+      )
+    );
+  }
+  console.log(`  Map: ${rel}`);
+  console.log(chalk26.dim("  Next: iamu explore coverage"));
+}
+async function resolveMapId(projectRoot, id, offsetFromEnd = 1) {
+  if (id && id !== "latest") return id;
+  const ids = await listExploreMaps(projectRoot);
+  return ids.at(-offsetFromEnd) ?? null;
+}
+async function exploreList(opts) {
+  const ctx = await resolveProject(opts);
+  if (!ctx) return;
+  const rows = [];
+  for (const id of await listExploreMaps(ctx.projectRoot)) {
+    try {
+      const m = await readExploreMap(ctx.projectRoot, id);
+      rows.push({ id, target_url: m.target_url, surfaces: m.surfaces.length });
+    } catch {
+    }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ maps: rows }));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log("  No maps yet. Run: iamu explore <url>");
+    return;
+  }
+  for (const r of rows) {
+    console.log(
+      `  ${r.id}  ${r.surfaces} surfaces  ${chalk26.dim(r.target_url)}`
+    );
+  }
+}
+async function exploreCoverageCommand(mapId, opts) {
+  const ctx = await resolveProject(opts);
+  if (!ctx) return;
+  const id = await resolveMapId(ctx.projectRoot, mapId);
+  if (!id) {
+    fail2("No map yet. Run: iamu explore <url>", opts.json);
+    return;
+  }
+  let map2;
+  try {
+    map2 = await readExploreMap(ctx.projectRoot, id);
+  } catch (err) {
+    fail2(err.message, opts.json);
+    return;
+  }
+  const cov = exploreCoverage(map2, await readAllRunSteps(ctx.projectRoot));
+  if (opts.json) {
+    console.log(JSON.stringify(cov));
+    return;
+  }
+  console.log(
+    `
+  Map ${id} (${map2.surfaces.length} surfaces) against ${cov.runs} runs, ${cov.steps} steps`
+  );
+  console.log(
+    `  ${chalk26.green(`${cov.reached} reached`)} \xB7 ${chalk26.yellow(`${cov.place_only} URL reached, view unclear`)} \xB7 ${chalk26.red(`${cov.unreached} never reached`)}`
+  );
+  const section = (title, rows, color) => {
+    if (rows.length === 0) return;
+    console.log(`
+  ${color(title)}`);
+    for (const r of rows) {
+      console.log(
+        `    ${r.key.padEnd(32)} ${r.label}${chalk26.dim(`  (depth ${r.depth})`)}`
+      );
+    }
+  };
+  section(
+    "Never reached by a run",
+    cov.surfaces.filter((s) => s.status === "unreached"),
+    chalk26.red
+  );
+  section(
+    "URL reached, but no step names this view",
+    cov.surfaces.filter((s) => s.status === "place_only"),
+    chalk26.yellow
+  );
+  if (cov.run_only_places.length > 0) {
+    console.log(`
+  ${chalk26.cyan("Walked by runs, not in the map")}`);
+    for (const p of cov.run_only_places) {
+      console.log(
+        `    ${p.place.padEnd(32)} ${p.steps} steps, ${p.runs.length} runs`
+      );
+    }
+  }
+  if (cov.runs === 0) {
+    console.log(
+      chalk26.dim(
+        "\n  No runs yet \u2014 every surface counts as never reached. Walk a scenario first (iamu-run)."
+      )
+    );
+  }
+}
+async function exploreDiffCommand(a, b, opts) {
+  const ctx = await resolveProject(opts);
+  if (!ctx) return;
+  const idA = a ?? await resolveMapId(ctx.projectRoot, void 0, 2);
+  const idB = b ?? await resolveMapId(ctx.projectRoot, void 0, 1);
+  if (!idA || !idB || idA === idB) {
+    fail2(
+      "Need two maps to compare \u2014 explore again (iamu explore <url>), or name both maps.",
+      opts.json
+    );
+    return;
+  }
+  let mapA;
+  let mapB;
+  try {
+    mapA = await readExploreMap(ctx.projectRoot, idA);
+    mapB = await readExploreMap(ctx.projectRoot, idB);
+  } catch (err) {
+    fail2(err.message, opts.json);
+    return;
+  }
+  const d = diffExploreMaps(mapA, mapB);
+  if (opts.json) {
+    console.log(JSON.stringify(d));
+    return;
+  }
+  const pct = Math.round(d.surface_overlap * 100);
+  console.log(`
+  ${idA} \u2192 ${idB}`);
+  console.log(
+    `  ${chalk26.bold(`${pct}% of surfaces match`)} (${d.common} shared, ${d.only_a.length} only in the first, ${d.only_b.length} only in the second)`
+  );
+  if (d.only_a.length > 0) {
+    console.log(`
+  ${chalk26.red("Only in the first")}`);
+    for (const s of d.only_a) console.log(`    ${s.key.padEnd(32)} ${s.label}`);
+  }
+  if (d.only_b.length > 0) {
+    console.log(`
+  ${chalk26.green("Only in the second")}`);
+    for (const s of d.only_b) console.log(`    ${s.key.padEnd(32)} ${s.label}`);
+  }
+  if (d.changed_actions.length > 0) {
+    console.log(
+      `
+  ${chalk26.yellow(`Controls differ on ${d.changed_actions.length} shared surfaces`)}`
+    );
+    for (const c of d.changed_actions) {
+      console.log(`    ${c.key}  ${c.label}`);
+      for (const x of c.only_a) console.log(chalk26.red(`      - ${x}`));
+      for (const x of c.only_b) console.log(chalk26.green(`      + ${x}`));
+    }
+  }
+}
+var DEFAULTS;
+var init_explore = __esm({
+  "src/commands/explore.ts"() {
+    "use strict";
+    init_dist2();
+    init_build_info();
+    init_browse();
+    init_context4();
+    init_explore_crawl();
+    DEFAULTS = { max_surfaces: 40, max_actions: 300, max_depth: 6 };
+  }
+});
+
 // src/commands/completion.ts
 var completion_exports = {};
 __export(completion_exports, {
@@ -18676,13 +20296,14 @@ var init_completion = __esm({
 var instructions_walk_exports = {};
 __export(instructions_walk_exports, {
   composeWalkerPrompt: () => composeWalkerPrompt,
+  extractUntestableBoundaries: () => extractUntestableBoundaries,
   instructionsWalk: () => instructionsWalk,
   revisitSection: () => revisitSection,
   viewportLine: () => viewportLine
 });
 import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 import { join as join9 } from "path";
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 function selfCommand() {
   const q = (p) => /[\s"'$]/.test(p) ? JSON.stringify(p) : p;
   return `${q(process.execPath)} ${q(process.argv[1] ?? "iamu")}`;
@@ -18713,6 +20334,24 @@ function browseSurface(iamu, viewport) {
     ...viewport ? [viewportLine(viewport)] : []
   ].join("\n");
 }
+function extractUntestableBoundaries(body) {
+  const match2 = body.match(
+    /##\s+Untestable\s+Boundaries[^\n]*\n([\s\S]*?)(?=\n##|\s*$)/i
+  );
+  if (!match2) return [];
+  const section = match2[1];
+  const items = [];
+  for (const line of section.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ") || trimmed.startsWith("\u2022 ") || trimmed.startsWith("* ")) {
+      const item = trimmed.slice(2).trim();
+      if (item && !item.toLowerCase().includes("none documented")) {
+        items.push(item);
+      }
+    }
+  }
+  return items;
+}
 function guidanceLine(r) {
   const rule = r.rule.replace(/\s+/g, " ");
   return r.reason ? `- ${rule} (${r.reason.replace(/\s+/g, " ")})` : `- ${rule}`;
@@ -18785,6 +20424,23 @@ function composeWalkerPrompt(p) {
     "",
     "## First-person brief",
     p.brief ?? "",
+    ...p.context ? ["", "## Product domain & regulatory context", p.context.trim()] : [],
+    ...p.state?.description || p.state?.approximation ? [
+      "",
+      "## Expected state & semantic squinting",
+      p.state.description ? `Expected state: ${p.state.description}` : "",
+      p.state.approximation ? `Approximation strategy: ${p.state.approximation}` : "",
+      "Squinting Guardrails:",
+      "\u2022 If the exact target record/option is not available, apply the approximation strategy above to pick the closest plausible entity within the domain flow.",
+      "\u2022 Squinting does NOT permit drifting to unrelated settings, account profiles, or off-target pages. Stay strictly within the scenario journey.",
+      "\u2022 If the system is completely empty or unseeded, and your persona role cannot create data, do NOT report false product bugs about the empty state. Note that preconditions are unseeded/blocked."
+    ].filter(Boolean) : [],
+    ...p.untestableBoundaries && p.untestableBoundaries.length > 0 ? [
+      "",
+      "## Untestable Boundaries (DO NOT WALK)",
+      "These areas are un-mocked or live external services. Do NOT attempt to navigate, submit, or interact with them:",
+      ...p.untestableBoundaries.map((b) => `\u2022 ${b}`)
+    ] : [],
     ...revisitSection(p.revisit ?? []),
     "",
     "## Access",
@@ -18813,7 +20469,7 @@ function composeWalkerPrompt(p) {
     `Screenshots to: ${rd}/screenshots/step-N.png \u2014 absolute paths.`,
     `Record findings with: ${iamu} new-finding --scenario ${p.scenarioSlug} --run ${p.runId} --step <N> --title "..." --type <helps|hinders|missing|irrelevant|incorrect> --severity <critical|major|minor|observation> --ui-fact "..." --consequence "..." --task-impact <blocks|impairs|slows|neutral|accelerates|enables> --confidence <high|medium|low> --json \u2014 then add the body (description + "## Recommendation") below the frontmatter of the file it returns.`,
     "`--step <N>` is the step whose screenshot shows the problem (or strength): it is the evidence people see next to the finding, so record that step and its screenshot first, and pick the screenshot where the thing is actually visible.",
-    `Before you finish, write ${rd}/summary.json: {"what_worked": [...], "open_questions": [...]} \u2014 one sentence each, in the persona's language.`,
+    `Before you finish, write ${rd}/summary.json: {"what_worked": [...], "open_questions": [...], "model": "<your model identifier if known, e.g. claude-3-5-haiku, gemini-3.8-flash, or unspecified>"} \u2014 one sentence each, in the persona's language.`,
     "",
     "Do not read the product's source code, other iamu/ entity files, or earlier runs: you know only what the persona knows.",
     "",
@@ -18923,6 +20579,25 @@ async function instructionsWalk(opts) {
   if (!targetUrl) {
     targetUrl = sfm.target_url ?? null;
   }
+  const untestableBoundaries = [];
+  try {
+    const testabilityPath = join9(projectRoot, "iamu", "testability.md");
+    if (existsSync12(testabilityPath)) {
+      const raw = readFileSync8(testabilityPath, "utf-8");
+      const { frontmatter, body } = parseFrontmatter(raw);
+      if (!targetUrl && typeof frontmatter.target_url === "string" && frontmatter.target_url.trim().length > 0) {
+        targetUrl = frontmatter.target_url.trim();
+      }
+      const fromFm = Array.isArray(
+        frontmatter.untestable_boundaries
+      ) ? frontmatter.untestable_boundaries.filter(Boolean) : [];
+      const fromBody = extractUntestableBoundaries(body);
+      untestableBoundaries.push(
+        ...Array.from(/* @__PURE__ */ new Set([...fromFm, ...fromBody]))
+      );
+    }
+  } catch {
+  }
   if (!revisit) {
     try {
       revisit = await computeRevisitPlaces(projectRoot, sfm.slug, targetUrl);
@@ -18933,7 +20608,8 @@ async function instructionsWalk(opts) {
   const result = {
     scenario: {
       slug: sfm.slug,
-      brief: scenario.body.trim() || null
+      brief: scenario.body.trim() || null,
+      state: sfm.state ?? null
     },
     persona: {
       slug: sfm.persona,
@@ -18954,6 +20630,7 @@ async function instructionsWalk(opts) {
     methodology,
     dismissed_findings: dismissedFacts,
     tester_guidance: guidance,
+    untestable_boundaries: untestableBoundaries,
     // Where fixes awaiting a re-run were seen (for you; the walker gets
     // the places only, never which findings they belong to).
     revisit,
@@ -18987,7 +20664,10 @@ async function instructionsWalk(opts) {
       runDirPath,
       projectRoot,
       surface: opts.surface ?? "browse",
-      viewport
+      viewport,
+      state: sfm.state ?? null,
+      context: contextYml,
+      untestableBoundaries
     }) : null
   };
   if (opts.json) {
@@ -18995,30 +20675,40 @@ async function instructionsWalk(opts) {
     return;
   }
   console.log();
-  console.log(chalk26.bold("  Walk instructions"));
-  console.log(`  ${chalk26.dim("scenario:")}  ${sfm.slug}`);
-  console.log(`  ${chalk26.dim("persona:")}   ${pfm.name} (${pfm.role})`);
-  console.log(`  ${chalk26.dim("outline:")}   ${ofm.title}`);
-  if (targetUrl) console.log(`  ${chalk26.dim("target:")}    ${targetUrl}`);
+  console.log(chalk27.bold("  Walk instructions"));
+  console.log(`  ${chalk27.dim("scenario:")}  ${sfm.slug}`);
+  console.log(`  ${chalk27.dim("persona:")}   ${pfm.name} (${pfm.role})`);
+  console.log(`  ${chalk27.dim("outline:")}   ${ofm.title}`);
+  if (sfm.state?.description || sfm.state?.approximation) {
+    console.log(
+      `  ${chalk27.dim("state:")}     ${sfm.state.description ? sfm.state.description : sfm.state.approximation ?? ""}`
+    );
+  }
+  if (targetUrl) console.log(`  ${chalk27.dim("target:")}    ${targetUrl}`);
   console.log(
-    `  ${chalk26.dim("access:")}    ${projectAccess || personaAccess ? `${projectAccess ? "project" : ""}${projectAccess && personaAccess ? " + " : ""}${personaAccess ? "persona" : ""}` : "not recorded (walker would run as whoever is signed in)"}`
+    `  ${chalk27.dim("access:")}    ${projectAccess || personaAccess ? `${projectAccess ? "project" : ""}${projectAccess && personaAccess ? " + " : ""}${personaAccess ? "persona" : ""}` : "not recorded (walker would run as whoever is signed in)"}`
   );
   console.log(
-    `  ${chalk26.dim("dismissed:")} ${dismissedFacts.length} findings to skip`
+    `  ${chalk27.dim("dismissed:")} ${dismissedFacts.length} findings to skip`
   );
   console.log(
-    `  ${chalk26.dim("guidance:")}  ${guidance.length} tester guidance rule${guidance.length === 1 ? "" : "s"}`
+    `  ${chalk27.dim("guidance:")}  ${guidance.length} tester guidance rule${guidance.length === 1 ? "" : "s"}`
   );
+  if (untestableBoundaries.length > 0) {
+    console.log(
+      `  ${chalk27.dim("boundaries:")} ${untestableBoundaries.length} untestable boundaries to avoid`
+    );
+  }
   if (revisit.length > 0) {
     console.log(
-      `  ${chalk26.dim("re-check:")}  ${revisit.length} place${revisit.length === 1 ? "" : "s"} where fixes await a re-run`
+      `  ${chalk27.dim("re-check:")}  ${revisit.length} place${revisit.length === 1 ? "" : "s"} where fixes await a re-run`
     );
   }
   console.log(
-    `  ${chalk26.dim("methodology:")} ${methodology ? "loaded" : "missing (run iamu update)"}`
+    `  ${chalk27.dim("methodology:")} ${methodology ? "loaded" : "missing (run iamu update)"}`
   );
   console.log();
-  console.log(chalk26.dim("  Use --json to get the full instruction bundle."));
+  console.log(chalk27.dim("  Use --json to get the full instruction bundle."));
   console.log();
 }
 var SCREEN;
@@ -19044,8 +20734,8 @@ __export(new_finding_exports, {
 });
 import { randomUUID as randomUUID10 } from "crypto";
 import { access, readFile as readFile6 } from "fs/promises";
-import path24 from "path";
-import chalk27 from "chalk";
+import path26 from "path";
+import chalk28 from "chalk";
 async function newFinding(opts) {
   const ctx = await resolveProject(opts);
   if (!ctx) return;
@@ -19111,7 +20801,7 @@ async function newFinding(opts) {
     }
     try {
       await access(
-        path24.join(runDirPath, "steps", `${String(n).padStart(3, "0")}.json`)
+        path26.join(runDirPath, "steps", `${String(n).padStart(3, "0")}.json`)
       );
     } catch {
       commandError(
@@ -19126,7 +20816,7 @@ async function newFinding(opts) {
   if (!scenarioSlug) {
     try {
       const manifestRaw = await readFile6(
-        path24.join(runDirPath, "walkthrough.json"),
+        path26.join(runDirPath, "walkthrough.json"),
         "utf8"
       );
       const manifest = JSON.parse(manifestRaw);
@@ -19215,10 +20905,10 @@ async function newFinding(opts) {
       return;
     }
     console.log();
-    console.log(`  ${symbols.success} Created finding: ${chalk27.cyan(slug)}`);
-    console.log(`  ${chalk27.dim("path:")} ${record.path}`);
-    console.log(`  ${chalk27.dim("id:")}   ${id}`);
-    for (const w of warnings) console.log(`  ${chalk27.yellow("!")} ${w}`);
+    console.log(`  ${symbols.success} Created finding: ${chalk28.cyan(slug)}`);
+    console.log(`  ${chalk28.dim("path:")} ${record.path}`);
+    console.log(`  ${chalk28.dim("id:")}   ${id}`);
+    for (const w of warnings) console.log(`  ${chalk28.yellow("!")} ${w}`);
     console.log();
   } catch (err) {
     commandError(
@@ -19243,8 +20933,8 @@ __export(view_results_exports, {
   openBrowserResults: () => openBrowserResults,
   promptViewResults: () => promptViewResults
 });
-import { isCancel as isCancel4, select as select3 } from "@clack/prompts";
-import chalk28 from "chalk";
+import { isCancel as isCancel4, select as select4 } from "@clack/prompts";
+import chalk29 from "chalk";
 function launchCloudDashboard(config, runId) {
   const cloudRunId = runId ? toCloudRunUuid(runId) : void 0;
   const url = getCloudDashboardUrl(
@@ -19253,7 +20943,7 @@ function launchCloudDashboard(config, runId) {
     cloudRunId
   );
   console.log();
-  console.log(`  ${symbols.success} Opening Iamu Cloud: ${chalk28.cyan(url)}
+  console.log(`  ${symbols.success} Opening Iamu Cloud: ${chalk29.cyan(url)}
 `);
   openBrowser(url);
 }
@@ -19289,7 +20979,7 @@ async function promptViewResults(projectRoot, opts) {
     },
     { label: "Skip", value: "skip" }
   ];
-  const choice = await select3({
+  const choice = await select4({
     message: "View results?",
     options
   });
@@ -19321,9 +21011,9 @@ __export(evaluate_exports, {
   evaluate: () => evaluate,
   evaluateRecord: () => evaluateRecord
 });
-import { promises as fs25 } from "fs";
-import path25 from "path";
-import chalk29 from "chalk";
+import { promises as fs29 } from "fs";
+import path27 from "path";
+import chalk30 from "chalk";
 import { z as z25 } from "zod";
 function formatIssues(error) {
   return error.issues.map(
@@ -19353,10 +21043,10 @@ async function evaluate(runId, opts) {
   const resolved = await resolveProjectAndRunDir(runId, opts);
   if (!resolved) return;
   const { projectRoot, runDirPath } = resolved;
-  const canonicalPath = path25.join(runDirPath, "canonical.json");
+  const canonicalPath = path27.join(runDirPath, "canonical.json");
   let canonical;
   try {
-    const raw = await fs25.readFile(canonicalPath, "utf8");
+    const raw = await fs29.readFile(canonicalPath, "utf8");
     canonical = JSON.parse(raw);
   } catch {
     commandError(
@@ -19412,8 +21102,21 @@ async function evaluate(runId, opts) {
     )
   };
   const prompt = composeJudgePrompt(input);
+  const promptFilePath = opts?.promptFile ?? path27.join(runDirPath, "judge_prompt.md");
+  await fs29.writeFile(promptFilePath, prompt, "utf8");
   if (opts?.json) {
-    console.log(JSON.stringify({ ...input, judge_prompt: prompt }, null, 2));
+    console.log(
+      JSON.stringify(
+        {
+          ...input,
+          prompt_file: path27.relative(projectRoot, promptFilePath),
+          prompt_file_abs: path27.resolve(promptFilePath),
+          judge_prompt: prompt
+        },
+        null,
+        2
+      )
+    );
     return;
   }
   console.log(prompt);
@@ -19422,10 +21125,10 @@ async function evaluateRecord(runId, opts) {
   const resolved = await resolveProjectAndRunDir(runId, opts);
   if (!resolved) return;
   const { projectRoot, runDirPath } = resolved;
-  const canonicalPath = path25.join(runDirPath, "canonical.json");
+  const canonicalPath = path27.join(runDirPath, "canonical.json");
   let canonical;
   try {
-    const raw = await fs25.readFile(canonicalPath, "utf8");
+    const raw = await fs29.readFile(canonicalPath, "utf8");
     canonical = JSON.parse(raw);
   } catch {
     commandError(`No canonical.json for run: ${runId}`, opts);
@@ -19433,7 +21136,7 @@ async function evaluateRecord(runId, opts) {
   }
   let parsedFile;
   try {
-    const raw = await fs25.readFile(opts.file, "utf8");
+    const raw = await fs29.readFile(opts.file, "utf8");
     parsedFile = JSON.parse(raw);
   } catch {
     commandError(`Cannot read verdicts file: ${opts.file}`, opts);
@@ -19490,8 +21193,8 @@ ${formatIssues(fileResult.error)}`,
     overall: inputVerdicts.overall
   });
   const reportContent = renderCanonicalMarkdown(canonicalForReport);
-  const verdictsPath = path25.join(runDirPath, "verdicts.json");
-  const reportPath = path25.join(runDirPath, "report.md");
+  const verdictsPath = path27.join(runDirPath, "verdicts.json");
+  const reportPath = path27.join(runDirPath, "report.md");
   await Promise.all([
     atomicWriteFile(
       verdictsPath,
@@ -19505,14 +21208,14 @@ ${formatIssues(fileResult.error)}`,
     runId,
     validatedVerdicts
   );
-  const cloudInfo = await pushRunToCloud(projectRoot, runId);
+  const cloudInfo = opts?.push === false ? void 0 : await pushRunToCloud(projectRoot, runId);
   if (opts?.json) {
     console.log(
       JSON.stringify(
         {
           runId,
-          verdictsPath: path25.relative(projectRoot, verdictsPath),
-          reportPath: path25.relative(projectRoot, reportPath),
+          verdictsPath: path27.relative(projectRoot, verdictsPath),
+          reportPath: path27.relative(projectRoot, reportPath),
           verdictsCount: validatedVerdicts.length,
           linkedCount: linked.length,
           ...cloudInfo ? { cloud: cloudInfo } : {}
@@ -19525,18 +21228,18 @@ ${formatIssues(fileResult.error)}`,
   }
   console.log();
   console.log(
-    `  ${symbols.success} Recorded ${validatedVerdicts.length} verdicts for run ${chalk29.cyan(runId)}`
+    `  ${symbols.success} Recorded ${validatedVerdicts.length} verdicts for run ${chalk30.cyan(runId)}`
   );
   if (linked.length > 0) {
     console.log(
-      `  ${chalk29.dim("linked:")}  ${linked.length} finding${linked.length === 1 ? "" : "s"} to the human test${linked.length === 1 ? "" : "s"} citing ${linked.length === 1 ? "it" : "them"}`
+      `  ${chalk30.dim("linked:")}  ${linked.length} finding${linked.length === 1 ? "" : "s"} to the human test${linked.length === 1 ? "" : "s"} citing ${linked.length === 1 ? "it" : "them"}`
     );
   }
   console.log(
-    `  ${chalk29.dim("verdicts:")} ${path25.relative(projectRoot, verdictsPath)}`
+    `  ${chalk30.dim("verdicts:")} ${path27.relative(projectRoot, verdictsPath)}`
   );
   console.log(
-    `  ${chalk29.dim("report:")}  ${path25.relative(projectRoot, reportPath)}`
+    `  ${chalk30.dim("report:")}  ${path27.relative(projectRoot, reportPath)}`
   );
   printCloudRunInfo(cloudInfo);
   await promptViewResults(projectRoot, { ...opts, runId });
@@ -19600,9 +21303,9 @@ __export(complete_exports, {
   screenshotSizeWarning: () => screenshotSizeWarning,
   validateCanonicalWalkthrough: () => validateCanonicalWalkthrough
 });
-import { promises as fs26 } from "fs";
-import path26 from "path";
-import chalk30 from "chalk";
+import { promises as fs30 } from "fs";
+import path28 from "path";
+import chalk31 from "chalk";
 async function complete(runId, opts) {
   const run = await loadRun(runId, opts);
   if (!run) return;
@@ -19612,7 +21315,7 @@ async function complete(runId, opts) {
   }
   if (!opts?.json) {
     console.log();
-    console.log(chalk30.bold("  Assembling canonical JSON\u2026"));
+    console.log(chalk31.bold("  Assembling canonical JSON\u2026"));
   }
   const provenanceAudit = auditStepProvenance(
     await readStepsForRun(run.projectRoot, runId)
@@ -19622,6 +21325,36 @@ async function complete(runId, opts) {
     return;
   }
   const completedAt = pickCompletedAt(run.manifest);
+  const walkerSummary = await readWalkerSummary(run.runDirPath);
+  let judgeReported;
+  try {
+    const verdictsRaw = await fs30.readFile(
+      path28.join(run.runDirPath, "verdicts.json"),
+      "utf8"
+    );
+    const parsed = JSON.parse(verdictsRaw);
+    if (parsed.provenance?.model) {
+      judgeReported = parsed.provenance.model;
+    }
+  } catch {
+  }
+  const stepCount = provenanceAudit.step_count;
+  const durationSec = provenanceAudit.duration_seconds ?? (run.manifest.created_at && Date.parse(completedAt) > Date.parse(run.manifest.created_at) ? Math.round(
+    (Date.parse(completedAt) - Date.parse(run.manifest.created_at)) / 1e3 * 10
+  ) / 10 : null);
+  const velocitySec = provenanceAudit.avg_step_interval_seconds ?? (durationSec != null && stepCount > 1 ? Math.round(durationSec / (stepCount - 1) * 10) / 10 : null);
+  const existingModels = run.manifest.models ?? {};
+  const updatedModels = {
+    ...existingModels,
+    ...walkerSummary.model ? { walker_reported: walkerSummary.model } : {},
+    ...judgeReported ? { judge_reported: judgeReported } : {},
+    ...durationSec != null ? { total_duration_sec: durationSec } : {},
+    ...velocitySec != null ? { velocity_sec_per_step: velocitySec } : {}
+  };
+  run.manifest = {
+    ...run.manifest,
+    models: updatedModels
+  };
   const assembled = await assembleRun(
     run.projectRoot,
     runId,
@@ -19648,16 +21381,16 @@ async function loadRun(runId, opts) {
   if (!resolved) return null;
   const { projectRoot, runDirPath } = resolved;
   try {
-    await fs26.access(runDirPath);
+    await fs30.access(runDirPath);
   } catch {
     commandError(`Run not found: ${runId}`, opts);
     return null;
   }
-  const manifestPath = path26.join(runDirPath, "walkthrough.json");
+  const manifestPath = path28.join(runDirPath, "walkthrough.json");
   let manifest;
   try {
     manifest = JSON.parse(
-      await fs26.readFile(manifestPath, "utf8")
+      await fs30.readFile(manifestPath, "utf8")
     );
   } catch {
     commandError(`No walkthrough.json found for run: ${runId}`, opts);
@@ -19669,8 +21402,8 @@ async function reportAlreadyCompleted(run, opts) {
   const { runId, manifest } = run;
   if (opts?.json) {
     try {
-      const raw = await fs26.readFile(
-        path26.join(run.runDirPath, "canonical.json"),
+      const raw = await fs30.readFile(
+        path28.join(run.runDirPath, "canonical.json"),
         "utf8"
       );
       console.log(raw.trim());
@@ -19690,18 +21423,18 @@ async function reportAlreadyCompleted(run, opts) {
     return;
   }
   console.log();
-  console.log(chalk30.bold("  Run: ") + chalk30.cyan(runId));
-  console.log(`  status     ${chalk30.green("completed")}`);
+  console.log(chalk31.bold("  Run: ") + chalk31.cyan(runId));
+  console.log(`  status     ${chalk31.green("completed")}`);
   if (manifest.completed_at) {
-    console.log(`  completed  ${chalk30.dim(manifest.completed_at)}`);
+    console.log(`  completed  ${chalk31.dim(manifest.completed_at)}`);
   }
   const viewUrl = await pushedRunUrl(run.projectRoot, runId);
   if (viewUrl) {
-    console.log(`  view       ${chalk30.underline(viewUrl)}`);
+    console.log(`  view       ${chalk31.underline(viewUrl)}`);
   }
   console.log();
   console.log(
-    chalk30.dim(
+    chalk31.dim(
       "  Already completed \u2014 nothing to do. Use --force to reassemble the report."
     )
   );
@@ -19717,13 +21450,13 @@ function reportStrictProvenanceFailure(audit, opts) {
   }
   console.error();
   console.error(
-    chalk30.red(`  ${symbols.error} Strict provenance audit failed:`)
+    chalk31.red(`  ${symbols.error} Strict provenance audit failed:`)
   );
   for (const w of audit.warnings) {
-    console.error(chalk30.red(`    \u2022 ${w}`));
+    console.error(chalk31.red(`    \u2022 ${w}`));
   }
   console.error(
-    chalk30.dim(
+    chalk31.dim(
       "  Run was flagged as synthetic / scripted. Remove --strict-provenance to complete anyway."
     )
   );
@@ -19749,7 +21482,7 @@ async function collectCompletionExtras(run, opts) {
     parseRunViewport(manifest.viewport)
   );
   const codeWarning = opts?.force ? null : codeChangedWarning(manifest.build, detectWorktreeState(projectRoot));
-  const cloudInfo = await pushRunToCloud(projectRoot, runId);
+  const cloudInfo = opts?.push === false ? void 0 : await pushRunToCloud(projectRoot, runId);
   return { revisit, viewportWarning, codeWarning, cloudInfo };
 }
 function completeJsonPayload(canonical, extras) {
@@ -19764,30 +21497,41 @@ function completeJsonPayload(canonical, extras) {
 function printCompletionSummary(run, completedAt, assembled, extras, provenanceAudit) {
   const { runId, projectRoot, manifest } = run;
   const { canonical } = assembled;
-  const count = (n) => n === 0 ? chalk30.dim("0") : chalk30.cyan(String(n));
-  console.log(chalk30.bold("  Run: ") + chalk30.cyan(runId));
-  console.log(`  scenario   ${chalk30.dim(manifest.scenario_slug)}`);
-  console.log(`  url        ${chalk30.dim(manifest.target_url)}`);
+  const count = (n) => n === 0 ? chalk31.dim("0") : chalk31.cyan(String(n));
+  console.log(chalk31.bold("  Run: ") + chalk31.cyan(runId));
+  console.log(`  scenario   ${chalk31.dim(manifest.scenario_slug)}`);
+  console.log(`  url        ${chalk31.dim(manifest.target_url)}`);
   if (manifest.environment) {
-    console.log(`  env        ${chalk30.dim(manifest.environment)}`);
+    console.log(`  env        ${chalk31.dim(manifest.environment)}`);
   }
   if (manifest.build) {
-    console.log(`  build      ${chalk30.dim(formatBuild(manifest.build))}`);
+    console.log(`  build      ${chalk31.dim(formatBuild(manifest.build))}`);
   }
   if (manifest.viewport) {
-    console.log(`  device     ${chalk30.dim(formatViewport(manifest.viewport))}`);
+    console.log(`  device     ${chalk31.dim(formatViewport(manifest.viewport))}`);
   }
-  console.log(`  status     ${chalk30.green("completed")}`);
+  console.log(`  status     ${chalk31.green("completed")}`);
   console.log(`  findings   ${count(canonical.findings.length)}`);
   console.log(`  steps      ${count(canonical.steps.length)}`);
-  console.log(`  started    ${chalk30.dim(manifest.created_at)}`);
-  console.log(`  completed  ${chalk30.dim(completedAt)}`);
+  console.log(`  started    ${chalk31.dim(manifest.created_at)}`);
+  console.log(`  completed  ${chalk31.dim(completedAt)}`);
+  const models = manifest.models;
+  if (models?.velocity_sec_per_step != null) {
+    console.log(
+      `  velocity   ${chalk31.cyan(`~${models.velocity_sec_per_step}s/step`)} ${chalk31.dim(`(${models.total_duration_sec}s total)`)}`
+    );
+  }
+  if (models && (models.walker || models.judge || models.matcher)) {
+    const w = models.walker_reported ? `${models.walker} (${models.walker_reported})` : models.walker ?? "fast";
+    const j = models.judge_reported ? `${models.judge} (${models.judge_reported})` : models.judge ?? "thorough";
+    console.log(`  models     ${chalk31.dim(`walker: ${w} \xB7 judge: ${j}`)}`);
+  }
   console.log();
   console.log(
-    `  ${chalk30.dim("canonical:")} ${chalk30.dim(path26.relative(projectRoot, assembled.canonicalPath))}`
+    `  ${chalk31.dim("canonical:")} ${chalk31.dim(path28.relative(projectRoot, assembled.canonicalPath))}`
   );
   console.log(
-    `  ${chalk30.dim("report:")}    ${chalk30.dim(path26.relative(projectRoot, assembled.reportPath))}`
+    `  ${chalk31.dim("report:")}    ${chalk31.dim(path28.relative(projectRoot, assembled.reportPath))}`
   );
   if (extras.viewportWarning) {
     console.log();
@@ -19795,7 +21539,7 @@ function printCompletionSummary(run, completedAt, assembled, extras, provenanceA
   }
   if (extras.codeWarning) {
     console.log();
-    console.log(`  ${chalk30.yellow("!")} ${extras.codeWarning}`);
+    console.log(`  ${chalk31.yellow("!")} ${extras.codeWarning}`);
   }
   if (extras.revisit) printRevisit(extras.revisit);
   if (assembled.verification) printVerification(assembled.verification);
@@ -19807,13 +21551,13 @@ function printProvenanceWarnings(audit) {
   if (audit.warnings.length === 0) return;
   console.log();
   console.log(
-    `  ${symbols.warning} ${chalk30.yellow("Step provenance audit flagged suspicious timing:")}`
+    `  ${symbols.warning} ${chalk31.yellow("Step provenance audit flagged suspicious timing:")}`
   );
   for (const w of audit.warnings) {
-    console.log(`    ${chalk30.dim("\u2022")} ${w}`);
+    console.log(`    ${chalk31.dim("\u2022")} ${w}`);
   }
   console.log(
-    chalk30.dim(
+    chalk31.dim(
       "    Run appears to be programmatically batch-generated rather than an interactive walkthrough."
     )
   );
@@ -19845,17 +21589,17 @@ function screenshotFitsViewport(width, expected) {
 }
 async function screenshotSizeWarning(runDirPath, viewport) {
   if (!viewport) return null;
-  const dir = path26.join(runDirPath, "screenshots");
+  const dir = path28.join(runDirPath, "screenshots");
   let first;
   try {
-    first = (await fs26.readdir(dir)).filter((f) => f.toLowerCase().endsWith(".png")).sort((a, b) => a.localeCompare(b, void 0, { numeric: true }))[0];
+    first = (await fs30.readdir(dir)).filter((f) => f.toLowerCase().endsWith(".png")).sort((a, b) => a.localeCompare(b, void 0, { numeric: true }))[0];
   } catch {
     return null;
   }
   if (!first) return null;
   let size = null;
   try {
-    const handle = await fs26.open(path26.join(dir, first), "r");
+    const handle = await fs30.open(path28.join(dir, first), "r");
     try {
       const head = Buffer.alloc(24);
       const { bytesRead } = await handle.read(head, 0, 24, 0);
@@ -19872,12 +21616,14 @@ async function screenshotSizeWarning(runDirPath, viewport) {
 async function readWalkerSummary(runDirPath) {
   try {
     const data = JSON.parse(
-      await fs26.readFile(path26.join(runDirPath, "summary.json"), "utf8")
+      await fs30.readFile(path28.join(runDirPath, "summary.json"), "utf8")
     );
     const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.trim() !== "") : void 0;
+    const model = typeof data.model === "string" && data.model.trim() !== "" ? data.model.trim() : void 0;
     return {
       what_worked: strings(data.what_worked),
-      open_questions: strings(data.open_questions)
+      open_questions: strings(data.open_questions),
+      model
     };
   } catch {
     return {};
@@ -19979,7 +21725,7 @@ function validateCanonicalWalkthrough(canonical) {
 async function applyRecordedVerdicts(canonical, runDirPath) {
   try {
     const recorded = JSON.parse(
-      await fs26.readFile(path26.join(runDirPath, "verdicts.json"), "utf8")
+      await fs30.readFile(path28.join(runDirPath, "verdicts.json"), "utf8")
     );
     if (Array.isArray(recorded.verdicts)) {
       return applyVerdicts(canonical, recorded);
@@ -19989,7 +21735,7 @@ async function applyRecordedVerdicts(canonical, runDirPath) {
   return canonical;
 }
 async function persistCanonical(runDirPath, canonical) {
-  const canonicalPath = path26.join(runDirPath, "canonical.json");
+  const canonicalPath = path28.join(runDirPath, "canonical.json");
   await atomicWriteFile(
     canonicalPath,
     `${JSON.stringify(canonical, null, 2)}
@@ -19998,7 +21744,7 @@ async function persistCanonical(runDirPath, canonical) {
   return canonicalPath;
 }
 async function persistReport(runDirPath, canonical) {
-  const reportPath = path26.join(runDirPath, "report.md");
+  const reportPath = path28.join(runDirPath, "report.md");
   await atomicWriteFile(reportPath, renderCanonicalMarkdown(canonical));
   return reportPath;
 }
@@ -20098,17 +21844,17 @@ function placeLabel(p) {
 function printRevisit(r) {
   const missed = r.places.filter((p) => !p.reached);
   console.log();
-  const head = `  ${chalk30.bold("Re-check places:")} reached ${r.reached} of ${r.requested}`;
+  const head = `  ${chalk31.bold("Re-check places:")} reached ${r.reached} of ${r.requested}`;
   if (missed.length === 0) {
-    console.log(`${head} ${chalk30.green("\u2713")}`);
+    console.log(`${head} ${chalk31.green("\u2713")}`);
     return;
   }
   console.log(`${head} \u2014 not reached:`);
   for (const p of missed) {
-    console.log(`    ${chalk30.yellow("\u25CB")} ${placeLabel(p)}`);
+    console.log(`    ${chalk31.yellow("\u25CB")} ${placeLabel(p)}`);
   }
   console.log(
-    chalk30.dim(
+    chalk31.dim(
       "    Fixes there stay awaiting a re-run until a walk gets there."
     )
   );
@@ -20116,7 +21862,7 @@ function printRevisit(r) {
 function printVerification(verification) {
   console.log();
   console.log(
-    chalk30.bold("  Since this scenario's last run") + chalk30.dim(` (${verification.baseline_run_id.slice(0, 30)}\u2026)`) + chalk30.bold(":")
+    chalk31.bold("  Since this scenario's last run") + chalk31.dim(` (${verification.baseline_run_id.slice(0, 30)}\u2026)`) + chalk31.bold(":")
   );
   if (verification.resolved.length > 0) {
     console.log(
@@ -20125,7 +21871,7 @@ function printVerification(verification) {
   }
   if (verification.not_observed.length > 0) {
     console.log(
-      `    ${symbols.pending} ${verification.not_observed.length} not seen this run ${chalk30.dim("(not evidence of a fix)")}`
+      `    ${symbols.pending} ${verification.not_observed.length} not seen this run ${chalk31.dim("(not evidence of a fix)")}`
     );
   }
   if (verification.persists.length > 0) {
@@ -20166,14 +21912,14 @@ __export(match_exports, {
   match: () => match,
   matchRecord: () => matchRecord
 });
-import { promises as fs27 } from "fs";
-import path27 from "path";
-import chalk31 from "chalk";
+import { promises as fs31 } from "fs";
+import path29 from "path";
+import chalk32 from "chalk";
 async function completedManifest2(runDirPath, runId, opts) {
   let manifest;
   try {
     manifest = JSON.parse(
-      await fs27.readFile(path27.join(runDirPath, "walkthrough.json"), "utf8")
+      await fs31.readFile(path29.join(runDirPath, "walkthrough.json"), "utf8")
     );
   } catch {
     commandError(`Run not found: ${runId}`, opts);
@@ -20202,15 +21948,34 @@ async function match(runId, opts) {
   );
   const needed = input.current.length > 0 && (input.prior.length > 0 || (input.guidance ?? []).length > 0);
   const prompt = needed ? composeMatchPrompt(input) : null;
+  const promptFilePath = opts?.promptFile ?? path29.join(runDirPath, "match_prompt.md");
+  if (prompt) {
+    await fs31.writeFile(promptFilePath, prompt, "utf8");
+  } else {
+    try {
+      await fs31.unlink(promptFilePath);
+    } catch {
+    }
+  }
   if (opts?.json) {
     console.log(
-      JSON.stringify({ ...input, needed, match_prompt: prompt }, null, 2)
+      JSON.stringify(
+        {
+          ...input,
+          needed,
+          prompt_file: prompt ? path29.relative(ctx.projectRoot, promptFilePath) : null,
+          prompt_file_abs: prompt ? path29.resolve(promptFilePath) : null,
+          match_prompt: prompt
+        },
+        null,
+        2
+      )
     );
     return;
   }
   if (!prompt) {
     console.log(
-      chalk31.dim(
+      chalk32.dim(
         "  No earlier findings or tester guidance for this scenario to match against \u2014 nothing to do."
       )
     );
@@ -20226,7 +21991,7 @@ async function matchRecord(runId, opts) {
   if (!manifest) return;
   let answer;
   try {
-    answer = JSON.parse(await fs27.readFile(opts.file, "utf8"));
+    answer = JSON.parse(await fs31.readFile(opts.file, "utf8"));
   } catch {
     commandError(`Cannot read matches file: ${opts.file}`, opts);
     return;
@@ -20267,17 +22032,17 @@ async function matchRecord(runId, opts) {
   }
   console.log();
   console.log(
-    `  ${chalk31.green("\u2713")} Matched ${result.linked} finding${result.linked === 1 ? "" : "s"} to earlier ones, ${result.new} first seen, ${result.rechecked_fixed} earlier re-checked fixed`
+    `  ${chalk32.green("\u2713")} Matched ${result.linked} finding${result.linked === 1 ? "" : "s"} to earlier ones, ${result.new} first seen, ${result.rechecked_fixed} earlier re-checked fixed`
   );
   if (result.suppressed > 0) {
     console.log(
-      `  ${chalk31.yellow("!")} ${result.suppressed} finding${result.suppressed === 1 ? "" : "s"} match tester guidance (flagged with suppressed_by_guidance \u2014 dismiss them in triage if the rule holds)`
+      `  ${chalk32.yellow("!")} ${result.suppressed} finding${result.suppressed === 1 ? "" : "s"} match tester guidance (flagged with suppressed_by_guidance \u2014 dismiss them in triage if the rule holds)`
     );
   }
   if (verification) printVerification(verification);
   console.log();
   console.log(
-    chalk31.dim("  Run `iamu sync` to push the linked findings to the cloud.")
+    chalk32.dim("  Run `iamu sync` to push the linked findings to the cloud.")
   );
   console.log();
 }
@@ -20298,7 +22063,7 @@ __export(prune_exports, {
   prune: () => prune
 });
 import { confirm, isCancel as isCancel5 } from "@clack/prompts";
-import chalk32 from "chalk";
+import chalk33 from "chalk";
 function formatBytes(bytes) {
   if (bytes <= 0) return "0 B";
   if (bytes < 1024) return `${bytes} B`;
@@ -20344,7 +22109,7 @@ async function prune(opts = {}) {
     });
     if (preview.prunedRuns.length === 0) {
       console.log(
-        chalk32.dim("  No runs match the pruning criteria. Nothing to prune.")
+        chalk33.dim("  No runs match the pruning criteria. Nothing to prune.")
       );
       return preview;
     }
@@ -20353,7 +22118,7 @@ async function prune(opts = {}) {
       message: `Prune ${mode} ${preview.prunedRuns.length} run(s) and reclaim ${formatBytes(preview.totalBytesReclaimed)}?`
     });
     if (isCancel5(confirmed) || !confirmed) {
-      console.log(chalk32.yellow("  Pruning cancelled."));
+      console.log(chalk33.yellow("  Pruning cancelled."));
       return;
     }
   }
@@ -20364,14 +22129,14 @@ async function prune(opts = {}) {
   }
   if (result.dryRun) {
     console.log(
-      chalk32.cyan(
+      chalk33.cyan(
         `
   [DRY RUN] Would prune ${result.prunedRuns.length} of ${result.totalRunsScanned} run(s):`
       )
     );
   } else {
     console.log(
-      chalk32.bold(
+      chalk33.bold(
         `
   ${symbols.success} Pruned ${result.prunedRuns.length} of ${result.totalRunsScanned} run(s):`
       )
@@ -20379,18 +22144,18 @@ async function prune(opts = {}) {
   }
   if (result.prunedRuns.length === 0) {
     console.log(
-      chalk32.dim("    No runs matched the pruning criteria. Nothing pruned.")
+      chalk33.dim("    No runs matched the pruning criteria. Nothing pruned.")
     );
   } else {
     for (const run of result.prunedRuns) {
       const mode = run.fullyDeleted ? "removed" : "screenshots purged";
       const count = run.screenshotsDeleted > 0 ? `${run.screenshotsDeleted} screenshots, ` : "";
       console.log(
-        `    ${chalk32.dim("\u2022")} ${chalk32.bold(run.runId)} ${chalk32.dim(`(${run.scenarioSlug ?? "unknown scenario"})`)}: ${chalk32.yellow(formatBytes(run.bytesReclaimed))} (${count}${mode})`
+        `    ${chalk33.dim("\u2022")} ${chalk33.bold(run.runId)} ${chalk33.dim(`(${run.scenarioSlug ?? "unknown scenario"})`)}: ${chalk33.yellow(formatBytes(run.bytesReclaimed))} (${count}${mode})`
       );
     }
     console.log(
-      chalk32.dim(
+      chalk33.dim(
         `
   Total reclaimed: ${formatBytes(result.totalBytesReclaimed)} (${result.totalScreenshotsDeleted} screenshots deleted)
 `
@@ -20413,13 +22178,13 @@ init_context4();
 import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
 import { dirname as dirname5, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import chalk35 from "chalk";
+import chalk36 from "chalk";
 import { Command } from "commander";
 
 // src/commands/register-cloud.ts
 import { Option } from "commander";
 function registerCloudCommands(program2) {
-  program2.command("sync").helpGroup("Cloud:").description("Push pending local changes to cloud").option("--status", "Show pending sync count without pushing").option(
+  program2.command("sync").alias("push").helpGroup("Cloud:").description("Push pending local changes to cloud").option("--status", "Show pending sync count without pushing").option(
     "--keep-mine",
     "On conflict, overwrite the cloud version with the local one. CLI only \u2014 replacing a teammate's change is an explicit human action, so it is deliberately not exposed through the iamu_sync MCP tool."
   ).option(
@@ -20443,7 +22208,7 @@ function registerCloudCommands(program2) {
     "Connect to local cloud stack (default port: 3000)"
   ).addOption(
     new Option("-s, --staging", "Connect to staging cloud stack").hideHelp()
-  ).option("-t, --token <token>", "Authenticate directly with API token / key").option("--web-url <url>", "Custom web dashboard URL").option("--url <api-url>", "API URL (default: https://api.iamu.dev)").option("-y, --yes", "Accept default project without interactive selection").option(
+  ).option("-t, --token <token>", "Authenticate directly with API token / key").option("--token-stdin", "Read API token from standard input").option("--web-url <url>", "Custom web dashboard URL").option("--url <api-url>", "API URL (default: https://app.iamu.dev)").option("-y, --yes", "Accept default project without interactive selection").option(
     "--project <project-id>",
     "Cloud project ID to link to, or `new` to create one. Required in a non-interactive shell when cloud projects exist"
   ).option("--no-browser", "Do not launch browser automatically").addHelpText(
@@ -20532,13 +22297,13 @@ function registerFindingsCommands(program2) {
 
 // src/commands/register-project.ts
 function registerProjectCommands(program2) {
-  program2.command("init").helpGroup("Project:").description("Scaffold iamu/ + install skills").argument("[name]", "Project name (defaults to directory name)").option("-y, --yes", "Skip prompts and accept all detected defaults").option("--json", "Output initialization metadata as JSON").addHelpText(
+  program2.command("init").helpGroup("Project:").description("Scaffold iamu/ + install skills").argument("[name]", "Project name (defaults to directory name)").option("-y, --yes", "Skip prompts and accept all detected defaults").option("--cloud", "Connect to Iamu Cloud directly during init").option("--no-cloud", "Skip Iamu Cloud connection (local-only)").option("--json", "Output initialization metadata as JSON").addHelpText(
     "after",
-    "\nExamples:\n  $ iamu init\n  $ iamu init my-project -y\n  $ iamu init --json"
+    "\nExamples:\n  $ iamu init\n  $ iamu init my-project -y\n  $ iamu init --cloud\n  $ iamu init --json"
   ).action(
     async (name, opts) => {
       const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-      await init2({ name, yes: opts.yes, json: opts.json });
+      await init2({ name, yes: opts.yes, json: opts.json, cloud: opts.cloud });
     }
   );
   program2.command("status").helpGroup("Project:").description("Show project state: entities, runs, context, cloud link").option("--json", "Output as JSON").addHelpText(
@@ -20549,10 +22314,13 @@ function registerProjectCommands(program2) {
     await status2(opts);
   });
   program2.command("doctor").helpGroup("Project:").description(
-    "Diagnose environment: runtime, browser automation, skills, cloud"
+    "Diagnose environment: runtime, browser automation, skills, cloud, and target testability"
+  ).option(
+    "-t, --target <url>",
+    "Probe target URL health, reachability, and auth redirects"
   ).option("--json", "Output diagnostics as JSON").addHelpText(
     "after",
-    "\nExamples:\n  $ iamu doctor\n  $ iamu doctor --json"
+    "\nExamples:\n  $ iamu doctor\n  $ iamu doctor --target http://localhost:3000\n  $ iamu doctor --json"
   ).action(async (opts) => {
     const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
     await doctor2(opts);
@@ -20584,9 +22352,9 @@ function registerProjectCommands(program2) {
     "after",
     "\nExamples:\n  $ iamu validate --all\n  $ iamu validate --all --fix --dry-run\n  $ iamu validate iamu/personas/maria.md"
   ).action(
-    async (path28, opts) => {
+    async (path30, opts) => {
       const { validate: validate2 } = await Promise.resolve().then(() => (init_validate(), validate_exports));
-      await validate2(path28, opts);
+      await validate2(path30, opts);
     }
   );
   program2.command("update").helpGroup("Project:").description("Update and repair agent skills and prompts to latest version").option(
@@ -20599,11 +22367,27 @@ function registerProjectCommands(program2) {
   program2.command("new <type>").helpGroup("Project:").description(
     "Create a new entity (persona, outline, capability, source, scenario)"
   ).requiredOption("--name <name>", "Entity name").option("--slug <slug>", "Custom entity slug (defaults to slugified name)").option("--role <role>", "Role description (persona only)").option("--disposition <text>", "Disposition / attitude (persona only)").option(
+    "--access <role>",
+    "Access role or testing account key (persona only)"
+  ).option("--body <text>", "Markdown body / narrative content").option("--narrative <text>", "Alias for --body").option(
     "--description <text>",
     "One-line description (capability, outline)"
+  ).option("--capability <slug>", "Primary capability slug (outline only)").option(
+    "--tension <text>",
+    "Structural tension driving this situation (outline only)"
+  ).option(
+    "--human-test <question>",
+    "Human-test question evaluated at run completion (outline only, repeatable)",
+    (val, prev = []) => [...prev, val]
   ).option("--outline <slug>", "Outline slug (scenario only)").option("--persona <slug>", "Persona slug (scenario only)").option(
     "--entry <path>",
     "Where the situation starts, as a path on the product, e.g. /en/episodes/1 (scenario only)"
+  ).option(
+    "--state-description <text>",
+    "Assumed environment data/records state (scenario only)"
+  ).option(
+    "--state-approximation <text>",
+    "Guidance on how persona should approximate/squint if records are missing (scenario only)"
   ).option("--url <url>", "Document the source cites (source only, required)").option(
     "--authority <level>",
     "legislation | regulation | standard | company_policy | guideline | informational (source only, default informational)"
@@ -20616,6 +22400,54 @@ function registerProjectCommands(program2) {
       await newEntity2(type2, opts);
     }
   );
+  const explore = program2.command("explore").helpGroup("Project:").description(
+    "Map the running product with a read-only crawl; compare the map with runs (coverage) or with another map (diff)"
+  );
+  explore.command("run [url]", { isDefault: true }).description(
+    "Crawl from <url> (default: target_url in iamu/testability.md) and write iamu/.cache/explore/<id>/map.json"
+  ).option("--max-surfaces <n>", "Stop after this many surfaces (default 40)").option("--max-actions <n>", "Stop after this many clicks (default 300)").option(
+    "--max-depth <n>",
+    "Don't go more than this many clicks from the start (default 6)"
+  ).option(
+    "--deny <pattern...>",
+    "Never click a control whose name or link matches (regex, case-insensitive)"
+  ).option("--viewport <WxH>", "Page size, e.g. 390x844 (default 1280x800)").option(
+    "--attach",
+    "Crawl in a new tab of the `iamu browse` browser, keeping its sign-ins"
+  ).option("--json", "Output as JSON").addHelpText(
+    "after",
+    `
+Read-only: controls that read like writes (delete, pay, send, save, log out \u2026),
+form submits, downloads and other origins are never clicked, nothing is typed,
+and every request but GET/HEAD/OPTIONS is blocked before it leaves the browser.
+
+Examples:
+  $ iamu explore http://localhost:3000
+  $ iamu explore --attach --deny "^Admin"
+  $ iamu explore coverage
+  $ iamu explore diff`
+  ).action(
+    async (url, opts) => {
+      const { exploreRun: exploreRun2 } = await Promise.resolve().then(() => (init_explore(), explore_exports));
+      await exploreRun2(url, opts);
+    }
+  );
+  explore.command("coverage [map]").description(
+    "Surfaces of a map (default: latest) that no run reached, and places runs reached that the map lacks"
+  ).option("--json", "Output as JSON").action(async (map2, opts) => {
+    const { exploreCoverageCommand: exploreCoverageCommand2 } = await Promise.resolve().then(() => (init_explore(), explore_exports));
+    await exploreCoverageCommand2(map2, opts);
+  });
+  explore.command("diff [a] [b]").description("Compare two maps (default: the two latest)").option("--json", "Output as JSON").action(
+    async (a, b, opts) => {
+      const { exploreDiffCommand: exploreDiffCommand2 } = await Promise.resolve().then(() => (init_explore(), explore_exports));
+      await exploreDiffCommand2(a, b, opts);
+    }
+  );
+  explore.command("list").description("List maps").option("--json", "Output as JSON").action(async (opts) => {
+    const { exploreList: exploreList2 } = await Promise.resolve().then(() => (init_explore(), explore_exports));
+    await exploreList2(opts);
+  });
   program2.command("completion [shell]").helpGroup("Project:").description("Output shell completion script (bash, zsh, fish)").action(async (shell) => {
     const { completion: completion2 } = await Promise.resolve().then(() => (init_completion(), completion_exports));
     completion2(program2, shell);
@@ -20645,6 +22477,15 @@ function registerWalkthroughCommands(program2) {
   ).option(
     "--env <name>",
     "Environment the product runs in (default: the target URL's origin)"
+  ).option(
+    "--walker <tierOrModel>",
+    "Model tier ('fast', 'thorough', 'inherit') or model ID for driving browser navigation (default: fast)"
+  ).option(
+    "--judge <tierOrModel>",
+    "Model tier ('fast', 'thorough', 'inherit') or model ID for human test evaluation (default: thorough)"
+  ).option(
+    "--matcher <tierOrModel>",
+    "Model tier ('fast', 'thorough', 'inherit') or model ID for finding matching (default: thorough)"
   ).option(
     "--check",
     "Enforce target URL reachability (fail fast if server is offline)"
@@ -20675,7 +22516,10 @@ function registerWalkthroughCommands(program2) {
   ).option(
     "--run <run-id>",
     "Run ID to size browser (start) or record step into (step)"
-  ).option("--action <text>", "Action description (step only)").option("--note <text>", "Persona inner monologue / reasoning (step only)").option("--surface <name>", "Screen or surface name (step only)").option("--width <px>", "Window width (start)").option("--height <px>", "Window height (start)").option("--headless", "Run without a window (start)").option(
+  ).option("--action <text>", "Action description (step only)").option("--note <text>", "Persona inner monologue / reasoning (step only)").option("--surface <name>", "Screen or surface name (step only)").option(
+    "--step-file <path>",
+    "Read step payload (action, note, cmd) from a JSON file or '-' for stdin (step only)"
+  ).option("--width <px>", "Window width (start)").option("--height <px>", "Window height (start)").option("--headless", "Run without a window (start)").option(
     "--port <port>",
     "CDP port (start), default 9333",
     (value) => parsePortOption(value)
@@ -20751,9 +22595,9 @@ function registerWalkthroughCommands(program2) {
   ).option("-y, --yes", "Skip interactive prompts").option("--no-prompt", "Skip interactive prompt to view results").option("--view", "Open results in browser immediately without prompt").option(
     "--strict-provenance",
     "Fail if steps show synthetic or programmatic timing anomalies"
-  ).addHelpText(
+  ).option("--no-push", "Skip pushing the run to Iamu Cloud").addHelpText(
     "after",
-    "\nExamples:\n  $ iamu complete <run-id>\n  $ iamu complete <run-id> --view\n  $ iamu complete <run-id> --no-prompt\n  $ iamu complete <run-id> --json\n  $ iamu complete <run-id> --strict-provenance"
+    "\nExamples:\n  $ iamu complete <run-id>\n  $ iamu complete <run-id> --view\n  $ iamu complete <run-id> --no-prompt\n  $ iamu complete <run-id> --no-push\n  $ iamu complete <run-id> --json\n  $ iamu complete <run-id> --strict-provenance"
   ).action(
     async (runId, opts) => {
       const { complete: complete2 } = await Promise.resolve().then(() => (init_complete(), complete_exports));
@@ -20762,23 +22606,27 @@ function registerWalkthroughCommands(program2) {
   );
   program2.command("match <run-id>").helpGroup("Walkthrough:").description(
     "Compose the prompt that links this run's findings to earlier ones"
-  ).option("--json", "Output the match input bundle as JSON").action(async (runId, opts) => {
-    const { match: match2 } = await Promise.resolve().then(() => (init_match(), match_exports));
-    await match2(runId, opts);
-  });
+  ).option("--json", "Output the match input bundle as JSON").option("--prompt-file <path>", "Write the generated prompt to a file").action(
+    async (runId, opts) => {
+      const { match: match2 } = await Promise.resolve().then(() => (init_match(), match_exports));
+      await match2(runId, opts);
+    }
+  );
   program2.command("match-record <run-id>").helpGroup("Walkthrough:").description(
     "Record finding matches and re-derive the run's since-last-run delta"
   ).requiredOption("--file <path>", "Path to matches JSON file").option("--json", "Output match results as JSON").action(async (runId, opts) => {
     const { matchRecord: matchRecord2 } = await Promise.resolve().then(() => (init_match(), match_exports));
     await matchRecord2(runId, opts);
   });
-  program2.command("evaluate <run-id>").helpGroup("Walkthrough:").description("Compose evaluation prompt for human-test questions").option("--json", "Output evaluation input bundle as JSON").action(async (runId, opts) => {
-    const { evaluate: evaluate2 } = await Promise.resolve().then(() => (init_evaluate(), evaluate_exports));
-    await evaluate2(runId, opts);
-  });
-  program2.command("evaluate-record <run-id>").helpGroup("Walkthrough:").description("Record evaluation verdicts into the run's verdicts.json").requiredOption("--file <path>", "Path to verdicts JSON file").option("--json", "Output summary as JSON").option("-y, --yes", "Skip interactive prompts").option("--no-prompt", "Skip interactive prompt to view results").option("--view", "Open results in browser immediately without prompt").addHelpText(
+  program2.command("evaluate <run-id>").helpGroup("Walkthrough:").description("Compose evaluation prompt for human-test questions").option("--json", "Output evaluation input bundle as JSON").option("--prompt-file <path>", "Write the generated prompt to a file").action(
+    async (runId, opts) => {
+      const { evaluate: evaluate2 } = await Promise.resolve().then(() => (init_evaluate(), evaluate_exports));
+      await evaluate2(runId, opts);
+    }
+  );
+  program2.command("evaluate-record <run-id>").helpGroup("Walkthrough:").description("Record evaluation verdicts into the run's verdicts.json").requiredOption("--file <path>", "Path to verdicts JSON file").option("--json", "Output summary as JSON").option("-y, --yes", "Skip interactive prompts").option("--no-prompt", "Skip interactive prompt to view results").option("--no-push", "Skip pushing the updated run to Iamu Cloud").option("--view", "Open results in browser immediately without prompt").addHelpText(
     "after",
-    "\nExamples:\n  $ iamu evaluate-record <run-id> --file verdicts.json\n  $ iamu evaluate-record <run-id> --file verdicts.json --no-prompt\n  $ iamu evaluate-record <run-id> --file verdicts.json --json"
+    "\nExamples:\n  $ iamu evaluate-record <run-id> --file verdicts.json\n  $ iamu evaluate-record <run-id> --file verdicts.json --no-prompt\n  $ iamu evaluate-record <run-id> --file verdicts.json --no-push\n  $ iamu evaluate-record <run-id> --file verdicts.json --json"
   ).action(
     async (runId, opts) => {
       const { evaluateRecord: evaluateRecord2 } = await Promise.resolve().then(() => (init_evaluate(), evaluate_exports));
@@ -20807,23 +22655,23 @@ function registerAllCommands(program2) {
 
 // src/ui/panic.ts
 init_logger();
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 var handlersRegistered = false;
 var customSigintHandler = null;
 function logFatalAndExit(title, errOrReason) {
   process.stderr.write("\x1B[?25h");
   if (isVerbose()) {
-    console.error(chalk33.red(`
+    console.error(chalk34.red(`
   ${title}:`));
     console.error(
       errOrReason instanceof Error ? errOrReason.stack || errOrReason : errOrReason
     );
   } else {
     const msg = errOrReason instanceof Error ? errOrReason.message : String(errOrReason);
-    console.error(chalk33.red(`
+    console.error(chalk34.red(`
   Fatal Error: ${msg}`));
     console.error(
-      chalk33.dim(
+      chalk34.dim(
         "  Run with --verbose or DEBUG=1 to view the full stack trace.\n"
       )
     );
@@ -20842,7 +22690,7 @@ function setupProcessHandlers() {
       }
       process.exit(130);
     } else {
-      console.error(chalk33.dim("\n  Operation cancelled."));
+      console.error(chalk34.dim("\n  Operation cancelled."));
       process.exit(130);
     }
   });
@@ -20868,7 +22716,7 @@ function setupProcessHandlers() {
 import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join10 } from "path";
-import chalk34 from "chalk";
+import chalk35 from "chalk";
 var CACHE_FILE = join10(homedir4(), ".iamu", "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function isSemverGreater(latest, current) {
@@ -20921,7 +22769,7 @@ async function checkForUpdate(currentVersion) {
 function printUpdateNotice(currentVersion, latestVersion) {
   console.error();
   console.error(
-    `  ${chalk34.yellow("Update available:")} ${chalk34.dim(currentVersion)} \u2192 ${chalk34.green(latestVersion)}  ${chalk34.dim("(run: npm i -g @iamu-dev/iamu)")}`
+    `  ${chalk35.yellow("Update available:")} ${chalk35.dim(currentVersion)} \u2192 ${chalk35.green(latestVersion)}  ${chalk35.dim("(run: npm i -g @iamu-dev/iamu)")}`
   );
 }
 
@@ -20966,7 +22814,7 @@ var program = new Command().name("iamu").description(
     }
   }
   if (root.color === false || process.env.NO_COLOR) {
-    chalk35.level = 0;
+    chalk36.level = 0;
   }
   if (root.verbose) {
     process.env.IAMU_VERBOSE = "1";