@iamu-dev/iamu 0.2.0-beta.15 → 0.2.0-beta.17

package/dist/index.js

@@ -247,7 +247,14 @@ var init_capability = __esm({
     capabilityFrontmatterSchema = entityBaseSchema.extend({
       /** Human-readable title; corresponds to cloud `name`. */
       title: z5.string().min(1),
-      description: z5.string().nullish()
+      description: z5.string().nullish(),
+      /**
+       * Route patterns owned by this capability (e.g. `["/billing", "/invoices"]`).
+       * Evaluated with segment-boundary Longest Prefix Match against surface places.
+       */
+      paths: z5.array(z5.string()).default([]),
+      /** Optional visual grouping category (e.g. "Finance", "Administration"). */
+      area: z5.string().nullish()
     });
   }
 });
@@ -873,6 +880,58 @@ var init_source = __esm({
   }
 });
 
+// ../../packages/protocol/dist/schemas/frontmatter/testability.js
+import { z as z17 } from "zod";
+function emptyTestability(targetUrl = "http://localhost:3000") {
+  return {
+    frontmatter: {
+      schema_version: SCHEMA_VERSION,
+      status: "draft",
+      target_url: targetUrl
+    },
+    body: `# Project Testability & Environment
+
+Target URL and execution harness for walkthroughs.
+Audited and populated during /iamu:init.
+
+## Target & Run Instructions
+- Default URL: ${targetUrl}
+
+## Reachable Surfaces
+(Run /iamu:init to discover testable routes)
+
+## Mocks & Data Fixtures
+(Run /iamu:init to inspect existing harnesses)
+
+## Untestable Boundaries
+(None documented yet)
+`
+  };
+}
+var testabilityStatusEnum, authStrategyEnum, testabilityFrontmatterSchema;
+var init_testability = __esm({
+  "../../packages/protocol/dist/schemas/frontmatter/testability.js"() {
+    "use strict";
+    init_version();
+    testabilityStatusEnum = z17.enum(["draft", "verified"]);
+    authStrategyEnum = z17.enum([
+      "dev_switcher",
+      "interactive",
+      "test_accounts",
+      "public"
+    ]);
+    testabilityFrontmatterSchema = z17.object({
+      schema_version: z17.number().int().optional(),
+      status: testabilityStatusEnum.default("draft"),
+      target_url: z17.string().url().describe("Target URL where the product is hosted or served locally."),
+      dev_command: z17.string().max(1e3).optional().describe("Dev script or startup command to boot the app locally."),
+      auth_strategy: authStrategyEnum.or(z17.string().min(1).max(100)).optional().describe("How personas authenticate in test environments."),
+      harnesses: z17.array(z17.string().min(1).max(500)).max(64).optional().describe("Mocking frameworks, seed scripts, or test harnesses present."),
+      untestable_boundaries: z17.array(z17.string().min(1).max(1024)).max(128).optional().describe("External services, third-party APIs, or surfaces forbidden to autonomous walkers.")
+    });
+  }
+});
+
 // ../../packages/protocol/dist/schemas/frontmatter/index.js
 var ENTITY_TYPES, entityFrontmatterSchemas, ENTITY_DIRS;
 var init_frontmatter = __esm({
@@ -890,6 +949,7 @@ var init_frontmatter = __esm({
     init_run_artifacts();
     init_scenario();
     init_source();
+    init_testability();
     init_capability();
     init_finding();
     init_guidance();
@@ -928,7 +988,7 @@ var init_frontmatter = __esm({
 });
 
 // ../../packages/protocol/dist/device.js
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function deviceFromPersonaTags(tags) {
   const matches = [];
   for (const tag of tags ?? []) {
@@ -975,22 +1035,22 @@ var init_device = __esm({
       desktop: "desktop",
       laptop: "desktop"
     };
-    runViewportSchema = z17.object({
-      device: z17.enum(DEVICE_CLASSES),
-      width: z17.number().int().positive(),
-      height: z17.number().int().positive(),
-      source: z17.literal("persona-tags")
+    runViewportSchema = z18.object({
+      device: z18.enum(DEVICE_CLASSES),
+      width: z18.number().int().positive(),
+      height: z18.number().int().positive(),
+      source: z18.literal("persona-tags")
     });
   }
 });
 
 // ../../packages/protocol/dist/types/fingerprint.js
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var stepActionTypeEnum, stepActionAnchorSchema, stepActionSchema, networkFingerprintEntrySchema, hex, stepFingerprintSchema;
 var init_fingerprint = __esm({
   "../../packages/protocol/dist/types/fingerprint.js"() {
     "use strict";
-    stepActionTypeEnum = z18.enum([
+    stepActionTypeEnum = z19.enum([
       "click",
       "fill",
       "hover",
@@ -1000,46 +1060,46 @@ var init_fingerprint = __esm({
       "done",
       "note"
     ]);
-    stepActionAnchorSchema = z18.object({
+    stepActionAnchorSchema = z19.object({
       /** Max 512 chars to prevent bloating JSONB storage. */
-      role: z18.string().max(512).optional(),
+      role: z19.string().max(512).optional(),
       /** Max 512 chars to prevent bloating JSONB storage. */
-      accessibleName: z18.string().max(512).optional(),
+      accessibleName: z19.string().max(512).optional(),
       /** Max 512 chars to prevent bloating JSONB storage. */
-      text: z18.string().max(512).optional()
+      text: z19.string().max(512).optional()
     });
-    stepActionSchema = z18.object({
+    stepActionSchema = z19.object({
       type: stepActionTypeEnum,
       anchor: stepActionAnchorSchema.optional(),
       /** Max 10 fallback selectors, each capped at 1024 chars. */
-      selectorFallbacks: z18.array(z18.string().max(1024)).max(10).optional()
+      selectorFallbacks: z19.array(z19.string().max(1024)).max(10).optional()
     });
-    networkFingerprintEntrySchema = z18.object({
+    networkFingerprintEntrySchema = z19.object({
       /** HTTP method, max 16 chars (e.g. "GET", "POST", "OPTIONS"). */
-      method: z18.string().max(16),
+      method: z19.string().max(16),
       /** Templated URL pattern, max 2048 chars. */
-      urlPattern: z18.string().max(2048),
-      status: z18.number().int().nonnegative()
+      urlPattern: z19.string().max(2048),
+      status: z19.number().int().nonnegative()
     });
-    hex = (len) => z18.string().regex(new RegExp(`^([0-9a-f]{${len}})?$`), `expected hex string of length ${len} or ""`);
-    stepFingerprintSchema = z18.object({
+    hex = (len) => z19.string().regex(new RegExp(`^([0-9a-f]{${len}})?$`), `expected hex string of length ${len} or ""`);
+    stepFingerprintSchema = z19.object({
       /** Full page URL at time of step, max 4096 chars. */
-      url: z18.string().max(4096),
+      url: z19.string().max(4096),
       action: stepActionSchema,
       domHash: hex(64),
       axTreeHash: hex(64),
       screenshotPHash: hex(16),
       /** Max 500 network entries to prevent runner abuse bloating JSONB. */
-      networkFingerprint: z18.array(networkFingerprintEntrySchema).max(500),
-      consoleErrorCount: z18.number().int().nonnegative(),
-      jsExceptionCount: z18.number().int().nonnegative(),
-      settleDurationMs: z18.number().int().nonnegative()
+      networkFingerprint: z19.array(networkFingerprintEntrySchema).max(500),
+      consoleErrorCount: z19.number().int().nonnegative(),
+      jsExceptionCount: z19.number().int().nonnegative(),
+      settleDurationMs: z19.number().int().nonnegative()
     });
   }
 });
 
 // ../../packages/protocol/dist/schemas/walkthrough-bundle.js
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 function defaultEnvironment(targetUrl) {
   try {
     const origin = new URL(targetUrl).origin;
@@ -1058,147 +1118,147 @@ var init_walkthrough_bundle = __esm({
     init_finding();
     init_run_artifacts();
     init_fingerprint();
-    partNameSchema = z19.string().min(1).max(128).regex(/^[a-z][a-z0-9_-]*$/, {
+    partNameSchema = z20.string().min(1).max(128).regex(/^[a-z][a-z0-9_-]*$/, {
       message: "part_name must be kebab-or-snake-case ASCII starting with a letter"
     }).describe("Key of the matching multipart form field in the bundle body. Must match a binary part exactly.");
-    artifactRefSchema = z19.object({
-      kind: z19.enum(["screenshot", "report", "other"]).describe("Artifact family. 'screenshot' streams to files/walkthroughs/<run_id>/step-<seq>.<ext>; 'report' / 'other' reserved for future kinds."),
+    artifactRefSchema = z20.object({
+      kind: z20.enum(["screenshot", "report", "other"]).describe("Artifact family. 'screenshot' streams to files/walkthroughs/<run_id>/step-<seq>.<ext>; 'report' / 'other' reserved for future kinds."),
       part_name: partNameSchema,
-      filename: z19.string().min(1).max(256).describe("Original filename as the client saw it. Used for logging and as a fallback display label."),
-      content_type: z19.string().min(1).max(128).describe("MIME type. Screenshots MUST use one of image/png | image/jpeg | image/webp \u2014 the cloud handler enforces that subset separately."),
-      bytes_hash: z19.string().length(64).regex(/^[0-9a-f]+$/).optional().describe("Lowercase hex sha256 of the binary bytes. Optional in v1; client populates when available so cloud can detect transport corruption.")
+      filename: z20.string().min(1).max(256).describe("Original filename as the client saw it. Used for logging and as a fallback display label."),
+      content_type: z20.string().min(1).max(128).describe("MIME type. Screenshots MUST use one of image/png | image/jpeg | image/webp \u2014 the cloud handler enforces that subset separately."),
+      bytes_hash: z20.string().length(64).regex(/^[0-9a-f]+$/).optional().describe("Lowercase hex sha256 of the binary bytes. Optional in v1; client populates when available so cloud can detect transport corruption.")
     });
-    stepScreenshotRefSchema = z19.object({
+    stepScreenshotRefSchema = z20.object({
       part_name: partNameSchema,
-      filename: z19.string().min(1).max(256),
-      content_type: z19.string().min(1).max(128)
+      filename: z20.string().min(1).max(256),
+      content_type: z20.string().min(1).max(128)
     });
-    bundleStepSchema = z19.object({
-      seq: z19.number().int().min(1).describe("1-based step sequence. Persisted to `walkthrough_steps.bundle_order` so render order survives DB insert-order drift."),
-      title: z19.string().min(1).max(2048).describe("Short first-person heading for the step \u2014 shows in the rendered report."),
-      persona_reasoning: z19.string().max(65536).nullable().optional().describe("First-person inner voice capture. Nullable for terse / action-only steps."),
-      grounding: z19.string().max(65536).nullable().optional().describe("Optional citations, domain-knowledge grounding, or verification notes for this step."),
+    bundleStepSchema = z20.object({
+      seq: z20.number().int().min(1).describe("1-based step sequence. Persisted to `walkthrough_steps.bundle_order` so render order survives DB insert-order drift."),
+      title: z20.string().min(1).max(2048).describe("Short first-person heading for the step \u2014 shows in the rendered report."),
+      persona_reasoning: z20.string().max(65536).nullable().optional().describe("First-person inner voice capture. Nullable for terse / action-only steps."),
+      grounding: z20.string().max(65536).nullable().optional().describe("Optional citations, domain-knowledge grounding, or verification notes for this step."),
       created_at: isoTimestamp.describe("Client-side ISO timestamp. Trusted as-is by the cloud (runner writes cloud-side already trust the runner's clock \u2014 same invariant)."),
       fingerprint: stepFingerprintSchema.nullable().optional().describe("Full StepFingerprint object (dom/ax/screenshot hashes + network + console signals). Passed through verbatim to walkthrough_steps.fingerprint; runtime shape validated by the fingerprint package on write."),
       screenshot_ref: stepScreenshotRefSchema.nullable().optional().describe("When present, identifies the multipart binary part carrying this step's screenshot bytes."),
-      url: z19.string().min(1).max(STEP_URL_MAX_LENGTH).nullable().optional().describe("The page the persona was on when the step ended. Absent for runs recorded before steps carried a URL."),
-      surface: z19.string().min(1).max(STEP_SURFACE_MAX_LENGTH).nullable().optional().describe("The walker's short name for the screen (e.g. 'search results'). Optional.")
+      url: z20.string().min(1).max(STEP_URL_MAX_LENGTH).nullable().optional().describe("The page the persona was on when the step ended. Absent for runs recorded before steps carried a URL."),
+      surface: z20.string().min(1).max(STEP_SURFACE_MAX_LENGTH).nullable().optional().describe("The walker's short name for the screen (e.g. 'search results'). Optional.")
     });
-    bundleFindingSchema = z19.object({
+    bundleFindingSchema = z20.object({
       slug: slugSchema,
       frontmatter: findingFrontmatterSchema,
-      body: z19.string().max(1048576).describe("Full markdown body of the finding file. 1 MiB cap matches the entity import envelope."),
-      screenshot_refs: z19.array(stepScreenshotRefSchema).max(32).optional().describe("Optional per-finding screenshot parts (distinct from step screenshots \u2014 e.g. annotated evidence shots attached to the finding write-up).")
+      body: z20.string().max(1048576).describe("Full markdown body of the finding file. 1 MiB cap matches the entity import envelope."),
+      screenshot_refs: z20.array(stepScreenshotRefSchema).max(32).optional().describe("Optional per-finding screenshot parts (distinct from step screenshots \u2014 e.g. annotated evidence shots attached to the finding write-up).")
     });
-    verificationItemSchema = z19.object({
-      canonical_id: z19.string().max(64).optional(),
-      id: z19.string().max(64).optional(),
-      title: z19.string().max(1024),
-      type: z19.string().max(32).optional()
+    verificationItemSchema = z20.object({
+      canonical_id: z20.string().max(64).optional(),
+      id: z20.string().max(64).optional(),
+      title: z20.string().max(1024),
+      type: z20.string().max(32).optional()
     });
-    verificationGroup = z19.array(verificationItemSchema).max(500);
-    bundleVerificationSchema = z19.object({
-      baseline_run_id: z19.string().max(256),
+    verificationGroup = z20.array(verificationItemSchema).max(500);
+    bundleVerificationSchema = z20.object({
+      baseline_run_id: z20.string().max(256),
       resolved: verificationGroup.default([]),
       persists: verificationGroup.default([]),
       not_observed: verificationGroup.default([]),
       uncertain: verificationGroup.default([]),
       new_findings: verificationGroup.default([])
     });
-    buildMetadataSchema = z19.object({
-      label: z19.string().min(1).max(200).optional().describe("Human label for the build, from `iamu start-run --build`."),
-      git_sha: z19.string().regex(/^[0-9a-f]{7,64}$/i, { message: "git_sha must be a hex commit id" }).optional().describe("Commit of the product under test."),
-      git_branch: z19.string().min(1).max(255).optional(),
-      base_sha: z19.string().regex(/^[0-9a-f]{7,64}$/i, {
+    buildMetadataSchema = z20.object({
+      label: z20.string().min(1).max(200).optional().describe("Human label for the build, from `iamu start-run --build`."),
+      git_sha: z20.string().regex(/^[0-9a-f]{7,64}$/i, { message: "git_sha must be a hex commit id" }).optional().describe("Commit of the product under test."),
+      git_branch: z20.string().min(1).max(255).optional(),
+      base_sha: z20.string().regex(/^[0-9a-f]{7,64}$/i, {
         message: "base_sha must be a hex commit id"
       }).optional().describe("Commit the change is compared against (pull-request base)."),
-      git_dirty: z19.boolean().optional().describe("True when the working tree had changes outside `iamu/` (tracked edits vs HEAD, staged or not, or untracked non-ignored files). Absent outside git."),
-      worktree_hash: z19.string().regex(/^[0-9a-f]{12}$/, {
+      git_dirty: z20.boolean().optional().describe("True when the working tree had changes outside `iamu/` (tracked edits vs HEAD, staged or not, or untracked non-ignored files). Absent outside git."),
+      worktree_hash: z20.string().regex(/^[0-9a-f]{12}$/, {
         message: "worktree_hash must be 12 lowercase hex characters"
       }).optional().describe("Only when `git_dirty`: fingerprint of the uncommitted changes, so two runs on one commit with different edits are different builds."),
-      ci: z19.object({
-        provider: z19.string().min(1).max(64).describe("CI system that ran the walk, e.g. `github`, `azure`."),
-        run_url: z19.string().url().max(2048)
+      ci: z20.object({
+        provider: z20.string().min(1).max(64).describe("CI system that ran the walk, e.g. `github`, `azure`."),
+        run_url: z20.string().url().max(2048)
       }).optional()
     });
     ENVIRONMENT_MAX_LENGTH = 255;
-    bundleManifestSchema = z19.object({
-      run_id: z19.string().uuid().describe("Client-minted UUID. Becomes `walkthroughs.id` on cloud. Idempotent key for the push endpoint."),
-      scenario_id: z19.string().min(1).describe("Scenario reference \u2014 slug in local-only mode, UUID in cloud-linked mode. Cloud handler resolves to the tenant's scenarios.id."),
-      target_url: z19.string().url().max(2048),
-      lenses: z19.array(z19.string().min(1).max(64)).min(1).max(16).describe("Analysis lenses enabled for this run. Defaults to ['persona'] in most flows."),
-      status: z19.literal("completed").describe("v1 only accepts completed bundles (bundle-on-complete). In-progress runs are not pushable."),
-      client_origin: z19.literal("local").describe("Discriminator written to walkthroughs.client_origin. Reserved for `local` in this endpoint; runner-origin rows take a different code path."),
+    bundleManifestSchema = z20.object({
+      run_id: z20.string().uuid().describe("Client-minted UUID. Becomes `walkthroughs.id` on cloud. Idempotent key for the push endpoint."),
+      scenario_id: z20.string().min(1).describe("Scenario reference \u2014 slug in local-only mode, UUID in cloud-linked mode. Cloud handler resolves to the tenant's scenarios.id."),
+      target_url: z20.string().url().max(2048),
+      lenses: z20.array(z20.string().min(1).max(64)).min(1).max(16).describe("Analysis lenses enabled for this run. Defaults to ['persona'] in most flows."),
+      status: z20.literal("completed").describe("v1 only accepts completed bundles (bundle-on-complete). In-progress runs are not pushable."),
+      client_origin: z20.literal("local").describe("Discriminator written to walkthroughs.client_origin. Reserved for `local` in this endpoint; runner-origin rows take a different code path."),
       created_at: isoTimestamp,
       completed_at: isoTimestamp,
-      step_count: z19.number().int().min(0).max(1e4),
-      finding_count: z19.number().int().min(0).max(1e4),
-      report_markdown: z19.string().max(1048576).describe("report.md body verbatim. Persists to walkthroughs.report_markdown so dashboard can render without regenerating."),
-      what_worked: z19.array(z19.string().max(4096)).max(64).optional(),
-      open_questions: z19.array(z19.string().max(4096)).max(64).optional(),
+      step_count: z20.number().int().min(0).max(1e4),
+      finding_count: z20.number().int().min(0).max(1e4),
+      report_markdown: z20.string().max(1048576).describe("report.md body verbatim. Persists to walkthroughs.report_markdown so dashboard can render without regenerating."),
+      what_worked: z20.array(z20.string().max(4096)).max(64).optional(),
+      open_questions: z20.array(z20.string().max(4096)).max(64).optional(),
       verification: bundleVerificationSchema.optional().describe("Since-last-run delta from canonical.json \u2014 which earlier findings persist, were re-checked fixed, were not seen, and which are new. Persists to walkthroughs.verification."),
       build: buildMetadataSchema.optional().describe("Build of the product under test (git SHA, branch, CI run). Absent for runs started before `start-run` recorded it."),
-      environment: z19.string().min(1).max(ENVIRONMENT_MAX_LENGTH).optional().describe("Where the product ran: `--env <name>` or, by default, the target URL's origin (e.g. `http://localhost:3000`)."),
+      environment: z20.string().min(1).max(ENVIRONMENT_MAX_LENGTH).optional().describe("Where the product ran: `--env <name>` or, by default, the target URL's origin (e.g. `http://localhost:3000`)."),
       /** Holistic UX quality score from UX review pass. Present only when `lenses` includes "ux". */
-      ux_quality_score: z19.number().min(1).max(5).nullish(),
+      ux_quality_score: z20.number().min(1).max(5).nullish(),
       /** One-line rationale naming 1-2 structural factors that determined the score. */
-      ux_quality_rationale: z19.string().max(4096).nullish(),
-      verdict: z19.array(z19.object({
-        humanTestId: z19.string().optional(),
-        human_test_id: z19.string().optional(),
-        question: z19.string().default(""),
-        rating: z19.enum(["yes", "no", "partial", "not_applicable"]).optional(),
-        verdict: z19.enum(["yes", "no", "partial", "not_applicable"]).optional(),
-        reasoning: z19.string(),
-        groundingStepIds: z19.array(z19.string()).optional(),
-        grounding_step_ids: z19.array(z19.string()).optional(),
-        groundingFindingIds: z19.array(z19.string()).optional(),
-        grounding_finding_ids: z19.array(z19.string()).optional()
+      ux_quality_rationale: z20.string().max(4096).nullish(),
+      verdict: z20.array(z20.object({
+        humanTestId: z20.string().optional(),
+        human_test_id: z20.string().optional(),
+        question: z20.string().default(""),
+        rating: z20.enum(["yes", "no", "partial", "not_applicable"]).optional(),
+        verdict: z20.enum(["yes", "no", "partial", "not_applicable"]).optional(),
+        reasoning: z20.string(),
+        groundingStepIds: z20.array(z20.string()).optional(),
+        grounding_step_ids: z20.array(z20.string()).optional(),
+        groundingFindingIds: z20.array(z20.string()).optional(),
+        grounding_finding_ids: z20.array(z20.string()).optional()
       }).refine((v) => Boolean(v.humanTestId || v.human_test_id) && Boolean(v.rating || v.verdict), {
         message: "verdict item must include humanTestId or human_test_id, and rating or verdict"
       })).optional(),
-      judge_meta: z19.object({
-        overall: z19.object({
-          question: z19.string(),
-          answer: z19.string(),
-          reasoning: z19.string()
+      judge_meta: z20.object({
+        overall: z20.object({
+          question: z20.string(),
+          answer: z20.string(),
+          reasoning: z20.string()
         }),
-        provenance: z19.object({
-          judge_prompt: z19.string().optional(),
-          judge_model: z19.string().optional()
+        provenance: z20.object({
+          judge_prompt: z20.string().optional(),
+          judge_model: z20.string().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()
+      models: z20.object({
+        walker: z20.string().optional(),
+        matcher: z20.string().optional(),
+        judge: z20.string().optional(),
+        walker_reported: z20.string().optional(),
+        matcher_reported: z20.string().optional(),
+        judge_reported: z20.string().optional(),
+        walker_tier: z20.string().optional(),
+        matcher_tier: z20.string().optional(),
+        judge_tier: z20.string().optional(),
+        execution_mode: z20.enum(["multi_agent", "single_agent"]).optional(),
+        velocity_sec_per_step: z20.number().optional(),
+        total_duration_sec: z20.number().optional()
       }).optional().describe("AI model configuration and reported runtime provenance for this walkthrough.")
     });
-    walkthroughBundleSchema = z19.object({
+    walkthroughBundleSchema = z20.object({
       manifest: bundleManifestSchema,
-      steps: z19.array(bundleStepSchema).max(1e4),
-      findings: z19.array(bundleFindingSchema).max(1e4),
-      artifacts: z19.array(artifactRefSchema).max(1e4)
+      steps: z20.array(bundleStepSchema).max(1e4),
+      findings: z20.array(bundleFindingSchema).max(1e4),
+      artifacts: z20.array(artifactRefSchema).max(1e4)
     }).superRefine((bundle, ctx) => {
       if (bundle.manifest.step_count !== bundle.steps.length) {
         ctx.addIssue({
-          code: z19.ZodIssueCode.custom,
+          code: z20.ZodIssueCode.custom,
           path: ["manifest", "step_count"],
           message: `manifest.step_count (${bundle.manifest.step_count}) must equal steps.length (${bundle.steps.length})`
         });
       }
       if (bundle.manifest.finding_count !== bundle.findings.length) {
         ctx.addIssue({
-          code: z19.ZodIssueCode.custom,
+          code: z20.ZodIssueCode.custom,
           path: ["manifest", "finding_count"],
           message: `manifest.finding_count (${bundle.manifest.finding_count}) must equal findings.length (${bundle.findings.length})`
         });
@@ -1207,14 +1267,14 @@ var init_walkthrough_bundle = __esm({
       const expected = Array.from({ length: bundle.steps.length }, (_, i) => i + 1);
       if (seqs.join(",") !== expected.join(",")) {
         ctx.addIssue({
-          code: z19.ZodIssueCode.custom,
+          code: z20.ZodIssueCode.custom,
           path: ["steps"],
           message: `step seq values must be dense 1..${bundle.steps.length}; received [${seqs.join(",")}]`
         });
       }
       if (bundle.steps.length === 0 && bundle.artifacts.length > 0) {
         ctx.addIssue({
-          code: z19.ZodIssueCode.custom,
+          code: z20.ZodIssueCode.custom,
           path: ["steps"],
           message: `bundle declares ${bundle.artifacts.length} artifact(s) but no steps \u2014 step records were not read`
         });
@@ -1224,7 +1284,7 @@ var init_walkthrough_bundle = __esm({
       for (const name of partNames) {
         if (seen.has(name)) {
           ctx.addIssue({
-            code: z19.ZodIssueCode.custom,
+            code: z20.ZodIssueCode.custom,
             path: ["artifacts"],
             message: `duplicate artifact part_name: ${name}`
           });
@@ -1236,7 +1296,7 @@ var init_walkthrough_bundle = __esm({
       for (const [i, step] of bundle.steps.entries()) {
         if (step.screenshot_ref && !artifactPartNames.has(step.screenshot_ref.part_name)) {
           ctx.addIssue({
-            code: z19.ZodIssueCode.custom,
+            code: z20.ZodIssueCode.custom,
             path: ["steps", i, "screenshot_ref", "part_name"],
             message: `step[${step.seq}].screenshot_ref.part_name "${step.screenshot_ref.part_name}" is not declared in artifacts[]`
           });
@@ -1246,7 +1306,7 @@ var init_walkthrough_bundle = __esm({
         for (const [j, ref] of (finding.screenshot_refs ?? []).entries()) {
           if (!artifactPartNames.has(ref.part_name)) {
             ctx.addIssue({
-              code: z19.ZodIssueCode.custom,
+              code: z20.ZodIssueCode.custom,
               path: ["findings", i, "screenshot_refs", j, "part_name"],
               message: `finding[${finding.slug}].screenshot_refs[${j}].part_name "${ref.part_name}" is not declared in artifacts[]`
             });
@@ -1256,7 +1316,7 @@ var init_walkthrough_bundle = __esm({
       for (const [i, finding] of bundle.findings.entries()) {
         if (finding.frontmatter.scenario !== bundle.manifest.scenario_id) {
           ctx.addIssue({
-            code: z19.ZodIssueCode.custom,
+            code: z20.ZodIssueCode.custom,
             path: ["findings", i, "frontmatter", "scenario"],
             message: `finding.frontmatter.scenario "${finding.frontmatter.scenario}" must match manifest.scenario_id "${bundle.manifest.scenario_id}"`
           });
@@ -1265,7 +1325,7 @@ var init_walkthrough_bundle = __esm({
       for (const [i, finding] of bundle.findings.entries()) {
         if (finding.frontmatter.run !== bundle.manifest.run_id) {
           ctx.addIssue({
-            code: z19.ZodIssueCode.custom,
+            code: z20.ZodIssueCode.custom,
             path: ["findings", i, "frontmatter", "run"],
             message: `finding.frontmatter.run "${finding.frontmatter.run}" must match manifest.run_id "${bundle.manifest.run_id}"`
           });
@@ -1277,30 +1337,30 @@ var init_walkthrough_bundle = __esm({
       "updated",
       "unchanged"
     ];
-    walkthroughPushResponseSchema = z19.object({
-      run_id: z19.string().uuid(),
-      cloud_walkthrough_id: z19.string().uuid(),
-      status: z19.enum(WALKTHROUGH_PUSH_OUTCOMES),
-      step_count: z19.number().int().min(0),
-      finding_count: z19.number().int().min(0),
-      artifact_count: z19.number().int().min(0)
+    walkthroughPushResponseSchema = z20.object({
+      run_id: z20.string().uuid(),
+      cloud_walkthrough_id: z20.string().uuid(),
+      status: z20.enum(WALKTHROUGH_PUSH_OUTCOMES),
+      step_count: z20.number().int().min(0),
+      finding_count: z20.number().int().min(0),
+      artifact_count: z20.number().int().min(0)
     });
     WALKTHROUGH_CONFLICT_REASONS = [
       "project_mismatch",
       "scenario_mismatch",
       "step_count_mismatch"
     ];
-    walkthroughPushConflictSchema = z19.object({
-      code: z19.literal("walkthrough_conflict"),
-      reason: z19.enum(WALKTHROUGH_CONFLICT_REASONS),
-      run_id: z19.string().uuid(),
-      message: z19.string()
+    walkthroughPushConflictSchema = z20.object({
+      code: z20.literal("walkthrough_conflict"),
+      reason: z20.enum(WALKTHROUGH_CONFLICT_REASONS),
+      run_id: z20.string().uuid(),
+      message: z20.string()
     });
   }
 });
 
 // ../../packages/protocol/dist/types/walkthrough-canonical.js
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var CANONICAL_WALKTHROUGH_VERSION, canonicalScenarioRefSchema, canonicalTargetSchema, canonicalProvenanceSchema, canonicalStepSchema, canonicalFindingSchema, canonicalHumanTestSchema, canonicalHumanTestOverallSchema, canonicalErrorSchema, cloudMirrorStateSchema, canonicalWalkthroughSchema;
 var init_walkthrough_canonical = __esm({
   "../../packages/protocol/dist/types/walkthrough-canonical.js"() {
@@ -1310,106 +1370,106 @@ var init_walkthrough_canonical = __esm({
     init_walkthrough_bundle();
     init_enums();
     CANONICAL_WALKTHROUGH_VERSION = "1.0.0";
-    canonicalScenarioRefSchema = z20.object({
-      id: z20.string(),
-      slug: z20.string(),
-      persona_slug: z20.string(),
-      outline_slug: z20.string(),
-      brief: z20.string()
+    canonicalScenarioRefSchema = z21.object({
+      id: z21.string(),
+      slug: z21.string(),
+      persona_slug: z21.string(),
+      outline_slug: z21.string(),
+      brief: z21.string()
     }).passthrough();
-    canonicalTargetSchema = z20.object({
-      url: z20.string(),
+    canonicalTargetSchema = z21.object({
+      url: z21.string(),
       /** Where the product runs. "live" = real backend; "mock" = stubbed. */
-      backend_mode: z20.enum(["live", "mock", "unknown"]),
+      backend_mode: z21.enum(["live", "mock", "unknown"]),
       /** Browser / runner used for the walk. */
-      browser: z20.string()
+      browser: z21.string()
     }).passthrough();
-    canonicalProvenanceSchema = z20.object({
-      walker_prompt: z20.object({ id: z20.string(), version: z20.string() }).passthrough(),
-      judge_prompt: z20.object({ id: z20.string(), version: z20.string() }).passthrough().optional(),
-      judge_mode: z20.enum(["subagent", "same_agent_second_pass", "failed"]).optional(),
+    canonicalProvenanceSchema = z21.object({
+      walker_prompt: z21.object({ id: z21.string(), version: z21.string() }).passthrough(),
+      judge_prompt: z21.object({ id: z21.string(), version: z21.string() }).passthrough().optional(),
+      judge_mode: z21.enum(["subagent", "same_agent_second_pass", "failed"]).optional(),
       /** Model identifier used by the walker. Judge model (when it runs) is
        * stamped inside `judge_meta.provenance.model` on the DB row. */
-      model: z20.string(),
+      model: z21.string(),
       started_at: isoTimestamp,
       completed_at: isoTimestamp
     }).passthrough();
-    canonicalStepSchema = z20.object({
-      id: z20.string(),
-      step_number: z20.number().int(),
-      url: z20.string().optional(),
+    canonicalStepSchema = z21.object({
+      id: z21.string(),
+      step_number: z21.number().int(),
+      url: z21.string().optional(),
       /** The walker's short name for the screen. */
-      surface: z20.string().optional(),
-      screen_title: z20.string().optional(),
+      surface: z21.string().optional(),
+      screen_title: z21.string().optional(),
       /** Path reference to the screenshot file; never inline binary data. */
-      screenshot_ref: z20.string().nullable().optional(),
-      persona_reasoning: z20.string().nullable().optional(),
-      grounding: z20.string().nullable().optional(),
-      action: z20.string().optional()
+      screenshot_ref: z21.string().nullable().optional(),
+      persona_reasoning: z21.string().nullable().optional(),
+      grounding: z21.string().nullable().optional(),
+      action: z21.string().optional()
     }).passthrough();
-    canonicalFindingSchema = z20.object({
-      id: z20.string(),
+    canonicalFindingSchema = z21.object({
+      id: z21.string(),
       /** Stable across runs for pattern tracking — null until cross-run wiring lands. */
-      canonical_id: z20.string().nullable(),
+      canonical_id: z21.string().nullable(),
       type: findingTypeEnum,
-      severity: z20.enum(["critical", "major", "minor", "observation"]).nullable(),
+      severity: z21.enum(["critical", "major", "minor", "observation"]).nullable(),
       /** Depth-gate half 1: what the UI showed or did (observable without domain knowledge). */
-      ui_fact: z20.string().nullable(),
+      ui_fact: z21.string().nullable(),
       /** Depth-gate half 2: what it means for the persona. Null on legacy rows (pre-migration). */
-      consequence: z20.string().nullable(),
-      recommendation: z20.string().nullable(),
+      consequence: z21.string().nullable(),
+      recommendation: z21.string().nullable(),
       /** Step ids this finding cites as evidence (references `steps[].id`). */
-      linked_step_ids: z20.array(z20.string()),
+      linked_step_ids: z21.array(z21.string()),
       /** Parent scenario's human-test question id the finding bears on, if any. */
-      linked_human_test_id: z20.string().nullable(),
-      compliance_impact: z20.enum(["critical", "major", "minor", "informational"]).nullable().optional(),
-      task_impact: z20.enum(["blocks", "impairs", "slows", "neutral", "accelerates", "enables"]).nullable().optional(),
-      confidence: z20.enum(["high", "medium", "low"]).nullable().optional(),
-      regulatory_weight: z20.enum(["hard_requirement", "process_model", "best_practice"]).nullable().optional(),
-      citations: z20.array(z20.string()).optional()
+      linked_human_test_id: z21.string().nullable(),
+      compliance_impact: z21.enum(["critical", "major", "minor", "informational"]).nullable().optional(),
+      task_impact: z21.enum(["blocks", "impairs", "slows", "neutral", "accelerates", "enables"]).nullable().optional(),
+      confidence: z21.enum(["high", "medium", "low"]).nullable().optional(),
+      regulatory_weight: z21.enum(["hard_requirement", "process_model", "best_practice"]).nullable().optional(),
+      citations: z21.array(z21.string()).optional()
     }).passthrough();
-    canonicalHumanTestSchema = z20.object({
-      id: z20.string(),
-      question: z20.string(),
+    canonicalHumanTestSchema = z21.object({
+      id: z21.string(),
+      question: z21.string(),
       /** Null until judge stage writes via `record_judge_result`. */
-      verdict: z20.enum(["yes", "partial", "no", "not_applicable"]).nullable(),
-      reasoning: z20.string().nullable(),
-      grounding_step_ids: z20.array(z20.string()),
-      grounding_finding_ids: z20.array(z20.string())
+      verdict: z21.enum(["yes", "partial", "no", "not_applicable"]).nullable(),
+      reasoning: z21.string().nullable(),
+      grounding_step_ids: z21.array(z21.string()),
+      grounding_finding_ids: z21.array(z21.string())
     }).passthrough();
-    canonicalHumanTestOverallSchema = z20.object({
-      question: z20.string(),
+    canonicalHumanTestOverallSchema = z21.object({
+      question: z21.string(),
       /** Null until judge stage answers. */
-      answer: z20.string().nullable(),
-      reasoning: z20.string().nullable()
+      answer: z21.string().nullable(),
+      reasoning: z21.string().nullable()
     }).passthrough();
-    canonicalErrorSchema = z20.object({
-      stage: z20.string(),
-      message: z20.string(),
-      at: z20.string()
+    canonicalErrorSchema = z21.object({
+      stage: z21.string(),
+      message: z21.string(),
+      at: z21.string()
     }).passthrough();
-    cloudMirrorStateSchema = z20.enum([
+    cloudMirrorStateSchema = z21.enum([
       "pushed",
       "enqueued",
       "local-only",
       "already_pushed",
       "skipped"
     ]);
-    canonicalWalkthroughSchema = z20.object({
-      canonical_version: z20.literal(CANONICAL_WALKTHROUGH_VERSION),
-      run_id: z20.string(),
+    canonicalWalkthroughSchema = z21.object({
+      canonical_version: z21.literal(CANONICAL_WALKTHROUGH_VERSION),
+      run_id: z21.string(),
       scenario: canonicalScenarioRefSchema,
       target: canonicalTargetSchema,
       provenance: canonicalProvenanceSchema,
       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),
+      environment: z21.string().optional(),
+      models: z21.record(z21.unknown()).optional(),
+      findings: z21.array(canonicalFindingSchema),
+      steps: z21.array(canonicalStepSchema),
+      human_tests: z21.array(canonicalHumanTestSchema),
       human_test_overall: canonicalHumanTestOverallSchema,
-      errors: z20.array(canonicalErrorSchema),
+      errors: z21.array(canonicalErrorSchema),
       cloud_mirror_state: cloudMirrorStateSchema
     }).passthrough();
   }
@@ -1820,7 +1880,7 @@ var init_prompt_registry = __esm({
 });
 
 // ../../packages/protocol/dist/mcp-schemas.js
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var AuthorityLevelSchema, FindingTypeSchema, MirrorStatusSchema, FindingSummarySchema, ScenarioSummarySchema, RetrievalGapSchema, GetConstraintsDataSchema, GetConstraintsOutputSchema, QueryDataSchema, QueryOutputSchema, ListFindingsDataSchema, ListFindingsOutputSchema, ListScenariosDataSchema, ListScenariosOutputSchema, GetProjectDataSchema, GetProjectOutputSchema, CreateScenarioDataSchema, CreateScenarioOutputSchema, PrepareWalkthroughDataSchema, PrepareWalkthroughOutputSchema, PersonaSummarySchema, OutlineSummarySchema, CapabilitySummarySchema, ListPersonasDataSchema, ListPersonasOutputSchema, ListOutlinesDataSchema, ListOutlinesOutputSchema, ListCapabilitiesDataSchema, ListCapabilitiesOutputSchema, GetPersonaDataSchema, GetPersonaOutputSchema, GetOutlineDataSchema, GetOutlineOutputSchema, GetFindingDataSchema, GetFindingOutputSchema, CreatePersonaDataSchema, CreatePersonaOutputSchema, CreateOutlineDataSchema, CreateOutlineOutputSchema, CreateCapabilityDataSchema, CreateCapabilityOutputSchema, RecordStepDataSchema, RecordStepOutputSchema, RecordFindingDataSchema, RecordFindingOutputSchema, CompleteWalkthroughDataSchema, CompleteWalkthroughOutputSchema, GetJudgeInputDataSchema, GetJudgeInputOutputSchema, RecordJudgeResultDataSchema, RecordJudgeResultOutputSchema;
 var init_mcp_schemas = __esm({
   "../../packages/protocol/dist/mcp-schemas.js"() {
@@ -1832,352 +1892,352 @@ var init_mcp_schemas = __esm({
     init_fingerprint();
     AuthorityLevelSchema = authorityLevelEnum;
     FindingTypeSchema = findingTypeEnum;
-    MirrorStatusSchema = z21.enum([
+    MirrorStatusSchema = z22.enum([
       "synced",
       "pending_retry",
       "local_only",
       "not_applicable"
     ]);
-    FindingSummarySchema = z21.object({
-      id: z21.string(),
-      slug: z21.string().nullable(),
-      title: z21.string(),
+    FindingSummarySchema = z22.object({
+      id: z22.string(),
+      slug: z22.string().nullable(),
+      title: z22.string(),
       type: FindingTypeSchema,
       /** Discriminator: "canonical" for deduplicated cloud findings,
        *  "observation" for raw walkthrough findings (local or cloud). */
-      kind: z21.enum(["canonical", "observation"]),
-      severity: z21.enum(["critical", "major", "minor", "observation"]).nullable().describe("Effective severity. Null when not yet assigned."),
-      triage_status: z21.string().describe("open | addressed | dismissed"),
+      kind: z22.enum(["canonical", "observation"]),
+      severity: z22.enum(["critical", "major", "minor", "observation"]).nullable().describe("Effective severity. Null when not yet assigned."),
+      triage_status: z22.string().describe("open | addressed | dismissed"),
       /** First 200 chars of the finding description. Fetch get_finding for the full text. */
-      description: z21.string(),
-      walkthrough_id: z21.string().nullable(),
-      scenario_id: z21.string(),
+      description: z22.string(),
+      walkthrough_id: z22.string().nullable(),
+      scenario_id: z22.string(),
       created_at: isoTimestamp,
-      canonical_id: z21.string().nullable(),
-      cloud_mirrored: z21.boolean()
+      canonical_id: z22.string().nullable(),
+      cloud_mirrored: z22.boolean()
     });
-    ScenarioSummarySchema = z21.object({
-      id: z21.string(),
-      slug: z21.string().nullable(),
-      outline_id: z21.string(),
-      outline_slug: z21.string().nullable(),
-      persona_id: z21.string(),
-      persona_slug: z21.string().nullable(),
+    ScenarioSummarySchema = z22.object({
+      id: z22.string(),
+      slug: z22.string().nullable(),
+      outline_id: z22.string(),
+      outline_slug: z22.string().nullable(),
+      persona_id: z22.string(),
+      persona_slug: z22.string().nullable(),
       created_at: isoTimestamp,
-      baseline_score: z21.number().nullable(),
-      current_score: z21.number().nullable(),
-      target_score: z21.number().nullable(),
-      walkthrough_count: z21.number().int().nonnegative(),
-      latest_walkthrough_id: z21.string().nullable(),
-      cloud_mirrored: z21.boolean()
+      baseline_score: z22.number().nullable(),
+      current_score: z22.number().nullable(),
+      target_score: z22.number().nullable(),
+      walkthrough_count: z22.number().int().nonnegative(),
+      latest_walkthrough_id: z22.string().nullable(),
+      cloud_mirrored: z22.boolean()
     });
-    RetrievalGapSchema = z21.object({
-      type: z21.enum(["no_results", "low_relevance", "unverified_only"]),
-      query: z21.string(),
-      suggestion: z21.string()
+    RetrievalGapSchema = z22.object({
+      type: z22.enum(["no_results", "low_relevance", "unverified_only"]),
+      query: z22.string(),
+      suggestion: z22.string()
     });
-    GetConstraintsDataSchema = z21.object({
-      domain: z21.string(),
-      constraint_count: z21.number().int().nonnegative(),
-      constraints: z21.array(z21.object({
-        rule: z21.string(),
+    GetConstraintsDataSchema = z22.object({
+      domain: z22.string(),
+      constraint_count: z22.number().int().nonnegative(),
+      constraints: z22.array(z22.object({
+        rule: z22.string(),
         authority_level: AuthorityLevelSchema,
-        source_name: z21.string(),
-        source_section: z21.string(),
-        source_url: z21.string().nullable(),
-        source_version: z21.number(),
-        source_uri: z21.string().describe("iamu://source/<id>@v<version>")
+        source_name: z22.string(),
+        source_section: z22.string(),
+        source_url: z22.string().nullable(),
+        source_version: z22.number(),
+        source_uri: z22.string().describe("iamu://source/<id>@v<version>")
       })),
-      gaps: z21.array(RetrievalGapSchema).optional(),
-      context_hint_needed: z21.boolean()
+      gaps: z22.array(RetrievalGapSchema).optional(),
+      context_hint_needed: z22.boolean()
     });
     GetConstraintsOutputSchema = mcpEnvelopeSchema(GetConstraintsDataSchema);
-    QueryDataSchema = z21.object({
-      results: z21.array(z21.object({
-        chunk_id: z21.string(),
-        content: z21.string(),
-        context_header: z21.string(),
-        context_text: z21.string().nullable(),
+    QueryDataSchema = z22.object({
+      results: z22.array(z22.object({
+        chunk_id: z22.string(),
+        content: z22.string(),
+        context_header: z22.string(),
+        context_text: z22.string().nullable(),
         authority_level: AuthorityLevelSchema,
-        source_name: z21.string(),
-        source_id: z21.string(),
-        source_uri: z21.string(),
-        source_version: z21.number(),
-        score: z21.number(),
-        verified: z21.boolean(),
-        trust: z21.enum(["hard", "soft", "unknown"])
+        source_name: z22.string(),
+        source_id: z22.string(),
+        source_uri: z22.string(),
+        source_version: z22.number(),
+        score: z22.number(),
+        verified: z22.boolean(),
+        trust: z22.enum(["hard", "soft", "unknown"])
       })),
-      result_count: z21.number().int().nonnegative(),
-      query_time_ms: z21.number().int().nonnegative().optional(),
-      gaps: z21.array(RetrievalGapSchema).optional(),
-      context_hint_needed: z21.boolean()
+      result_count: z22.number().int().nonnegative(),
+      query_time_ms: z22.number().int().nonnegative().optional(),
+      gaps: z22.array(RetrievalGapSchema).optional(),
+      context_hint_needed: z22.boolean()
     });
     QueryOutputSchema = mcpEnvelopeSchema(QueryDataSchema);
-    ListFindingsDataSchema = z21.object({
-      findings: z21.array(FindingSummarySchema),
-      total_returned: z21.number().int().nonnegative()
+    ListFindingsDataSchema = z22.object({
+      findings: z22.array(FindingSummarySchema),
+      total_returned: z22.number().int().nonnegative()
     });
     ListFindingsOutputSchema = mcpEnvelopeSchema(ListFindingsDataSchema);
-    ListScenariosDataSchema = z21.object({
-      scenarios: z21.array(ScenarioSummarySchema)
+    ListScenariosDataSchema = z22.object({
+      scenarios: z22.array(ScenarioSummarySchema)
     });
     ListScenariosOutputSchema = mcpEnvelopeSchema(ListScenariosDataSchema);
-    GetProjectDataSchema = z21.object({
-      id: z21.string(),
-      slug: z21.string().nullable(),
-      name: z21.string(),
-      cloud_linked: z21.boolean(),
-      cloud_project_id: z21.string().nullable(),
+    GetProjectDataSchema = z22.object({
+      id: z22.string(),
+      slug: z22.string().nullable(),
+      name: z22.string(),
+      cloud_linked: z22.boolean(),
+      cloud_project_id: z22.string().nullable(),
       created_at: isoTimestamp.nullable(),
-      capabilities_count: z21.number().int().nonnegative(),
-      outlines_count: z21.number().int().nonnegative(),
-      scenarios_count: z21.number().int().nonnegative(),
-      walkthroughs_count: z21.number().int().nonnegative(),
-      personas_count: z21.number().int().nonnegative()
+      capabilities_count: z22.number().int().nonnegative(),
+      outlines_count: z22.number().int().nonnegative(),
+      scenarios_count: z22.number().int().nonnegative(),
+      walkthroughs_count: z22.number().int().nonnegative(),
+      personas_count: z22.number().int().nonnegative()
     });
     GetProjectOutputSchema = mcpEnvelopeSchema(GetProjectDataSchema);
-    CreateScenarioDataSchema = z21.object({
-      scenario_id: z21.string(),
-      outline_id: z21.string(),
-      persona_id: z21.string(),
-      was_existing: z21.boolean(),
+    CreateScenarioDataSchema = z22.object({
+      scenario_id: z22.string(),
+      outline_id: z22.string(),
+      persona_id: z22.string(),
+      was_existing: z22.boolean(),
       created_at: isoTimestamp,
       brief_generated_at: isoTimestamp.nullable()
     });
     CreateScenarioOutputSchema = mcpEnvelopeSchema(CreateScenarioDataSchema);
-    PrepareWalkthroughDataSchema = z21.object({
-      walkthrough_id: z21.string(),
-      scenario_id: z21.string(),
-      target_url: z21.string(),
-      lenses: z21.array(z21.string()),
-      persona: z21.object({
-        id: z21.string(),
-        name: z21.string(),
-        slug: z21.string().nullable()
+    PrepareWalkthroughDataSchema = z22.object({
+      walkthrough_id: z22.string(),
+      scenario_id: z22.string(),
+      target_url: z22.string(),
+      lenses: z22.array(z22.string()),
+      persona: z22.object({
+        id: z22.string(),
+        name: z22.string(),
+        slug: z22.string().nullable()
       }),
-      outline: z21.object({
-        id: z21.string(),
-        slug: z21.string().nullable(),
-        title: z21.string()
+      outline: z22.object({
+        id: z22.string(),
+        slug: z22.string().nullable(),
+        title: z22.string()
       }),
-      mode: z21.enum(["local", "cloud"]),
-      cloud_mirrored: z21.boolean(),
+      mode: z22.enum(["local", "cloud"]),
+      cloud_mirrored: z22.boolean(),
       mirror_status: MirrorStatusSchema,
-      run_dir: z21.string().nullable(),
+      run_dir: z22.string().nullable(),
       /** Persona-specific first-person brief — markdown body of the scenario file. */
-      brief: z21.string(),
+      brief: z22.string(),
       /** Full composed walking prompt: persona + outline + lenses +
        *  evaluation philosophy. This is the text the walker should adopt
        *  before driving the browser; `brief` alone lacks the philosophy
        *  + lens guidance. */
-      prompt_text: z21.string(),
+      prompt_text: z22.string(),
       /** Withheld during walker stage (always empty here). Populated by
        *  `get_judge_input` once the walk completes. */
-      human_tests: z21.array(z21.string())
+      human_tests: z22.array(z22.string())
     });
     PrepareWalkthroughOutputSchema = mcpEnvelopeSchema(PrepareWalkthroughDataSchema);
-    PersonaSummarySchema = z21.object({
-      id: z21.string(),
-      slug: z21.string(),
-      name: z21.string(),
-      role: z21.string(),
+    PersonaSummarySchema = z22.object({
+      id: z22.string(),
+      slug: z22.string(),
+      name: z22.string(),
+      role: z22.string(),
       /** First 200 chars of context/background. */
-      context_preview: z21.string().nullable(),
-      status: z21.enum(["active", "archived"]),
+      context_preview: z22.string().nullable(),
+      status: z22.enum(["active", "archived"]),
       created_at: isoTimestamp,
-      cloud_mirrored: z21.boolean()
+      cloud_mirrored: z22.boolean()
     });
-    OutlineSummarySchema = z21.object({
-      id: z21.string(),
-      slug: z21.string(),
-      name: z21.string(),
-      description: z21.string().nullable(),
-      primary_capability_id: z21.string().nullable(),
-      primary_capability_slug: z21.string().nullable(),
+    OutlineSummarySchema = z22.object({
+      id: z22.string(),
+      slug: z22.string(),
+      name: z22.string(),
+      description: z22.string().nullable(),
+      primary_capability_id: z22.string().nullable(),
+      primary_capability_slug: z22.string().nullable(),
       /** Capability slugs (denormalized for agent display). */
-      additional_capabilities: z21.array(z21.string()),
-      task_criticality: z21.string().nullable(),
+      additional_capabilities: z22.array(z22.string()),
+      task_criticality: z22.string().nullable(),
       created_at: isoTimestamp,
-      cloud_mirrored: z21.boolean()
+      cloud_mirrored: z22.boolean()
     });
-    CapabilitySummarySchema = z21.object({
-      id: z21.string(),
-      slug: z21.string(),
-      name: z21.string(),
-      description: z21.string().nullable(),
+    CapabilitySummarySchema = z22.object({
+      id: z22.string(),
+      slug: z22.string(),
+      name: z22.string(),
+      description: z22.string().nullable(),
       /** Number of outlines with this capability as primary. Cloud-only;
        *  null in local mode (filesystem walk would be too expensive). */
-      outline_count: z21.number().int().nonnegative().nullable(),
+      outline_count: z22.number().int().nonnegative().nullable(),
       created_at: isoTimestamp,
-      cloud_mirrored: z21.boolean()
+      cloud_mirrored: z22.boolean()
     });
-    ListPersonasDataSchema = z21.object({
-      personas: z21.array(PersonaSummarySchema)
+    ListPersonasDataSchema = z22.object({
+      personas: z22.array(PersonaSummarySchema)
     });
     ListPersonasOutputSchema = mcpEnvelopeSchema(ListPersonasDataSchema);
-    ListOutlinesDataSchema = z21.object({
-      outlines: z21.array(OutlineSummarySchema)
+    ListOutlinesDataSchema = z22.object({
+      outlines: z22.array(OutlineSummarySchema)
     });
     ListOutlinesOutputSchema = mcpEnvelopeSchema(ListOutlinesDataSchema);
-    ListCapabilitiesDataSchema = z21.object({
-      capabilities: z21.array(CapabilitySummarySchema)
+    ListCapabilitiesDataSchema = z22.object({
+      capabilities: z22.array(CapabilitySummarySchema)
     });
     ListCapabilitiesOutputSchema = mcpEnvelopeSchema(ListCapabilitiesDataSchema);
-    GetPersonaDataSchema = z21.object({
-      id: z21.string(),
-      slug: z21.string(),
-      name: z21.string(),
-      role: z21.string(),
-      context: z21.string().nullable(),
-      disposition: z21.string().nullable(),
-      brief: z21.string().nullable(),
-      status: z21.enum(["active", "archived"]),
-      body: z21.string(),
+    GetPersonaDataSchema = z22.object({
+      id: z22.string(),
+      slug: z22.string(),
+      name: z22.string(),
+      role: z22.string(),
+      context: z22.string().nullable(),
+      disposition: z22.string().nullable(),
+      brief: z22.string().nullable(),
+      status: z22.enum(["active", "archived"]),
+      body: z22.string(),
       created_at: isoTimestamp,
       updated_at: isoTimestamp.nullable(),
-      cloud_mirrored: z21.boolean(),
-      resource_uri: z21.string()
+      cloud_mirrored: z22.boolean(),
+      resource_uri: z22.string()
     });
     GetPersonaOutputSchema = mcpEnvelopeSchema(GetPersonaDataSchema);
-    GetOutlineDataSchema = z21.object({
-      id: z21.string(),
-      slug: z21.string(),
-      name: z21.string(),
-      description: z21.string().nullable(),
-      narrative: z21.string(),
-      primary_capability_id: z21.string().nullable(),
-      primary_capability_slug: z21.string().nullable(),
-      additional_capabilities: z21.array(z21.string()),
-      human_tests: z21.array(z21.object({ id: z21.string(), question: z21.string() })),
-      tension: z21.string().nullable(),
-      situation_roles: z21.array(z21.object({ role: z21.string(), stake: z21.string() })).nullable(),
-      task_criticality: z21.string().nullable(),
-      complexity_level: z21.string().nullable(),
+    GetOutlineDataSchema = z22.object({
+      id: z22.string(),
+      slug: z22.string(),
+      name: z22.string(),
+      description: z22.string().nullable(),
+      narrative: z22.string(),
+      primary_capability_id: z22.string().nullable(),
+      primary_capability_slug: z22.string().nullable(),
+      additional_capabilities: z22.array(z22.string()),
+      human_tests: z22.array(z22.object({ id: z22.string(), question: z22.string() })),
+      tension: z22.string().nullable(),
+      situation_roles: z22.array(z22.object({ role: z22.string(), stake: z22.string() })).nullable(),
+      task_criticality: z22.string().nullable(),
+      complexity_level: z22.string().nullable(),
       created_at: isoTimestamp,
       updated_at: isoTimestamp.nullable(),
-      cloud_mirrored: z21.boolean(),
-      resource_uri: z21.string()
+      cloud_mirrored: z22.boolean(),
+      resource_uri: z22.string()
     });
     GetOutlineOutputSchema = mcpEnvelopeSchema(GetOutlineDataSchema);
-    GetFindingDataSchema = z21.object({
-      id: z21.string(),
-      slug: z21.string().nullable(),
-      title: z21.string().nullable(),
+    GetFindingDataSchema = z22.object({
+      id: z22.string(),
+      slug: z22.string().nullable(),
+      title: z22.string().nullable(),
       type: FindingTypeSchema,
-      severity: z21.enum(["critical", "major", "minor", "observation"]).nullable(),
-      kind: z21.enum(["canonical", "observation"]),
-      ui_fact: z21.string().nullable(),
-      consequence: z21.string().nullable(),
-      description: z21.string().nullable(),
-      citations: z21.array(z21.string()),
-      walkthrough_id: z21.string().nullable(),
-      scenario_id: z21.string(),
-      persona_id: z21.string().nullable(),
-      run: z21.string().nullable(),
-      triage_status: z21.string(),
-      triage_note: z21.string().nullable(),
-      fix_status: z21.string(),
-      lens: z21.string().nullable(),
-      compliance_impact: z21.string().nullable(),
-      task_impact: z21.string().nullable(),
-      confidence: z21.string().nullable(),
-      regulatory_weight: z21.string().nullable(),
-      human_test_id: z21.string().nullable(),
-      walkthrough_step_id: z21.string().nullable(),
-      canonical_id: z21.string().nullable(),
+      severity: z22.enum(["critical", "major", "minor", "observation"]).nullable(),
+      kind: z22.enum(["canonical", "observation"]),
+      ui_fact: z22.string().nullable(),
+      consequence: z22.string().nullable(),
+      description: z22.string().nullable(),
+      citations: z22.array(z22.string()),
+      walkthrough_id: z22.string().nullable(),
+      scenario_id: z22.string(),
+      persona_id: z22.string().nullable(),
+      run: z22.string().nullable(),
+      triage_status: z22.string(),
+      triage_note: z22.string().nullable(),
+      fix_status: z22.string(),
+      lens: z22.string().nullable(),
+      compliance_impact: z22.string().nullable(),
+      task_impact: z22.string().nullable(),
+      confidence: z22.string().nullable(),
+      regulatory_weight: z22.string().nullable(),
+      human_test_id: z22.string().nullable(),
+      walkthrough_step_id: z22.string().nullable(),
+      canonical_id: z22.string().nullable(),
       recorded_at: isoTimestamp.nullable(),
       updated_at: isoTimestamp.nullable(),
-      cloud_mirrored: z21.boolean(),
+      cloud_mirrored: z22.boolean(),
       mirror_status: MirrorStatusSchema,
-      resource_uri: z21.string()
+      resource_uri: z22.string()
     });
     GetFindingOutputSchema = mcpEnvelopeSchema(GetFindingDataSchema);
-    CreatePersonaDataSchema = z21.object({
-      persona_id: z21.string(),
-      slug: z21.string(),
-      was_existing: z21.boolean(),
+    CreatePersonaDataSchema = z22.object({
+      persona_id: z22.string(),
+      slug: z22.string(),
+      was_existing: z22.boolean(),
       created_at: isoTimestamp,
       brief_generated_at: isoTimestamp.nullable()
     });
     CreatePersonaOutputSchema = mcpEnvelopeSchema(CreatePersonaDataSchema);
-    CreateOutlineDataSchema = z21.object({
-      outline_id: z21.string(),
-      slug: z21.string(),
-      primary_capability_id: z21.string().nullable(),
-      primary_capability_slug: z21.string().nullable(),
-      was_existing: z21.boolean(),
+    CreateOutlineDataSchema = z22.object({
+      outline_id: z22.string(),
+      slug: z22.string(),
+      primary_capability_id: z22.string().nullable(),
+      primary_capability_slug: z22.string().nullable(),
+      was_existing: z22.boolean(),
       created_at: isoTimestamp
     });
     CreateOutlineOutputSchema = mcpEnvelopeSchema(CreateOutlineDataSchema);
-    CreateCapabilityDataSchema = z21.object({
-      capability_id: z21.string(),
-      slug: z21.string(),
-      was_existing: z21.boolean(),
+    CreateCapabilityDataSchema = z22.object({
+      capability_id: z22.string(),
+      slug: z22.string(),
+      was_existing: z22.boolean(),
       created_at: isoTimestamp
     });
     CreateCapabilityOutputSchema = mcpEnvelopeSchema(CreateCapabilityDataSchema);
-    RecordStepDataSchema = z21.object({
-      step_id: z21.string(),
-      step_index: z21.number().int().nonnegative(),
-      walkthrough_id: z21.string(),
-      persona_reasoning: z21.string(),
+    RecordStepDataSchema = z22.object({
+      step_id: z22.string(),
+      step_index: z22.number().int().nonnegative(),
+      walkthrough_id: z22.string(),
+      persona_reasoning: z22.string(),
       recorded_at: isoTimestamp,
       /** Set when a screenshot_path was provided. */
-      screenshot_uri: z21.string().nullable(),
+      screenshot_uri: z22.string().nullable(),
       /** Capture failure modes (per-field) — see fingerprint shape in
        *  `./types/fingerprint.ts`. Optional; null
        *  when fingerprint capture didn't run. */
-      fingerprint: stepFingerprintSchema.or(z21.object({
-        dom_hash: z21.string().nullable(),
-        ax_hash: z21.string().nullable(),
-        screenshot_hash: z21.string().nullable(),
-        url_template: z21.string().nullable()
+      fingerprint: stepFingerprintSchema.or(z22.object({
+        dom_hash: z22.string().nullable(),
+        ax_hash: z22.string().nullable(),
+        screenshot_hash: z22.string().nullable(),
+        url_template: z22.string().nullable()
       })).nullable()
     });
     RecordStepOutputSchema = mcpEnvelopeSchema(RecordStepDataSchema);
-    RecordFindingDataSchema = z21.object({
-      finding_id: z21.string(),
-      slug: z21.string().nullable(),
+    RecordFindingDataSchema = z22.object({
+      finding_id: z22.string(),
+      slug: z22.string().nullable(),
       type: FindingTypeSchema,
-      severity: z21.enum(["critical", "major", "minor", "observation"]).nullable(),
-      kind: z21.literal("observation"),
-      ui_fact: z21.string(),
-      consequence: z21.string(),
-      citations: z21.array(z21.string()),
-      scenario_id: z21.string(),
-      walkthrough_id: z21.string(),
-      persona_id: z21.string().nullable(),
-      triage_status: z21.literal("open"),
-      fix_status: z21.literal("open"),
-      lens: z21.string().nullable(),
+      severity: z22.enum(["critical", "major", "minor", "observation"]).nullable(),
+      kind: z22.literal("observation"),
+      ui_fact: z22.string(),
+      consequence: z22.string(),
+      citations: z22.array(z22.string()),
+      scenario_id: z22.string(),
+      walkthrough_id: z22.string(),
+      persona_id: z22.string().nullable(),
+      triage_status: z22.literal("open"),
+      fix_status: z22.literal("open"),
+      lens: z22.string().nullable(),
       recorded_at: isoTimestamp,
-      resource_uri: z21.string()
+      resource_uri: z22.string()
     });
     RecordFindingOutputSchema = mcpEnvelopeSchema(RecordFindingDataSchema);
     CompleteWalkthroughDataSchema = canonicalWalkthroughSchema;
     CompleteWalkthroughOutputSchema = mcpEnvelopeSchema(CompleteWalkthroughDataSchema);
-    GetJudgeInputDataSchema = z21.object({
-      walkthrough_id: z21.string(),
-      judge_prompt: z21.object({
-        id: z21.string(),
-        version: z21.string(),
-        text: z21.string()
+    GetJudgeInputDataSchema = z22.object({
+      walkthrough_id: z22.string(),
+      judge_prompt: z22.object({
+        id: z22.string(),
+        version: z22.string(),
+        text: z22.string()
       }),
-      scenario: z21.object({}).passthrough(),
-      outline_context: z21.object({}).passthrough(),
-      steps: z21.array(z21.unknown()),
-      findings: z21.array(z21.unknown()),
-      human_tests: z21.array(z21.object({
-        id: z21.string(),
-        question: z21.string()
+      scenario: z22.object({}).passthrough(),
+      outline_context: z22.object({}).passthrough(),
+      steps: z22.array(z22.unknown()),
+      findings: z22.array(z22.unknown()),
+      human_tests: z22.array(z22.object({
+        id: z22.string(),
+        question: z22.string()
       }))
     });
     GetJudgeInputOutputSchema = mcpEnvelopeSchema(GetJudgeInputDataSchema);
-    RecordJudgeResultDataSchema = z21.object({
-      walkthrough_id: z21.string(),
+    RecordJudgeResultDataSchema = z22.object({
+      walkthrough_id: z22.string(),
       persisted_at: isoTimestamp,
-      canonical_path: z21.string(),
-      report_path: z21.string()
+      canonical_path: z22.string(),
+      report_path: z22.string()
     });
     RecordJudgeResultOutputSchema = mcpEnvelopeSchema(RecordJudgeResultDataSchema);
   }
@@ -2350,6 +2410,9 @@ function configPath(projectRoot) {
 function contextPath(projectRoot) {
   return path2.join(iamuDir(projectRoot), "context.yml");
 }
+function testabilityPath(projectRoot) {
+  return path2.join(iamuDir(projectRoot), "testability.md");
+}
 function entityDirPath(projectRoot, type2) {
   return path2.join(iamuDir(projectRoot), ENTITY_DIRS[type2]);
 }
@@ -5293,6 +5356,37 @@ var init_context2 = __esm({
   }
 });
 
+// ../../packages/local-store/dist/testability.js
+import { promises as fs5 } from "fs";
+async function readTestability(projectRoot) {
+  const p = testabilityPath(projectRoot);
+  let raw;
+  try {
+    raw = await fs5.readFile(p, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    throw err;
+  }
+  const parsed = parseFrontmatter(raw);
+  const result = testabilityFrontmatterSchema.safeParse(parsed.frontmatter);
+  if (!result.success) {
+    throw new Error(`testability: invalid frontmatter in ${p}: ${result.error.issues.map((i) => `${i.path.join(".") || "root"}: ${i.message}`).join("; ")}`);
+  }
+  return {
+    frontmatter: result.data,
+    body: parsed.body
+  };
+}
+var init_testability2 = __esm({
+  "../../packages/local-store/dist/testability.js"() {
+    "use strict";
+    init_dist();
+    init_markdown();
+    init_paths();
+  }
+});
+
 // ../../packages/local-store/dist/hash.js
 import { createHash } from "crypto";
 function hashNormalizedContent(raw) {
@@ -5326,7 +5420,7 @@ var init_server_reason = __esm({
 
 // ../../packages/local-store/dist/file-lock.js
 import { randomUUID as randomUUID3 } from "crypto";
-import { promises as fs5 } from "fs";
+import { promises as fs6 } from "fs";
 import os from "os";
 import path4 from "path";
 function takeoverFilePathFor(lockPath) {
@@ -5363,7 +5457,7 @@ function pidIsDead(rec) {
 async function isStale(lockPath, rec, staleMs, now) {
   if (rec === null) {
     try {
-      const stat3 = await fs5.stat(lockPath);
+      const stat3 = await fs6.stat(lockPath);
       if (stat3.size === 0) {
         const mtime = stat3.birthtimeMs && stat3.birthtimeMs > 0 ? stat3.birthtimeMs : stat3.mtimeMs;
         if (now - mtime <= staleMs) {
@@ -5388,7 +5482,7 @@ async function tryCreateMarker(markerPath, token) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    const handle = await fs5.open(markerPath, "wx", 420);
+    const handle = await fs6.open(markerPath, "wx", 420);
     try {
       await handle.writeFile(JSON.stringify(record));
       await handle.sync();
@@ -5407,7 +5501,7 @@ async function tryCreateLock(lockPath, token) {
 }
 async function readRecord(markerPath) {
   try {
-    return parseLockRecord(await fs5.readFile(markerPath, "utf8"));
+    return parseLockRecord(await fs6.readFile(markerPath, "utf8"));
   } catch {
     return null;
   }
@@ -5417,7 +5511,7 @@ async function tryTakeover(lockPath, token, expected, opts) {
   if (!await tryCreateMarker(takeoverPath, token)) {
     const holder = await readRecord(takeoverPath);
     if (await isStale(takeoverPath, holder, opts.staleMs, opts.now())) {
-      await fs5.unlink(takeoverPath).catch(() => {
+      await fs6.unlink(takeoverPath).catch(() => {
       });
     }
     return null;
@@ -5426,7 +5520,7 @@ async function tryTakeover(lockPath, token, expected, opts) {
     const current = await readRecord(lockPath);
     let present = true;
     try {
-      await fs5.access(lockPath);
+      await fs6.access(lockPath);
     } catch {
       present = false;
     }
@@ -5437,11 +5531,11 @@ async function tryTakeover(lockPath, token, expected, opts) {
       return null;
     if (!await isStale(lockPath, current, opts.staleMs, opts.now()))
       return null;
-    await fs5.unlink(lockPath).catch(() => {
+    await fs6.unlink(lockPath).catch(() => {
     });
     return await tryCreateLock(lockPath, token);
   } finally {
-    await fs5.unlink(takeoverPath).catch(() => {
+    await fs6.unlink(takeoverPath).catch(() => {
     });
   }
 }
@@ -5458,13 +5552,13 @@ async function acquireLockFile(lockPath, opts) {
   const token = randomUUID3();
   const deadline = opts.now() + opts.timeoutMs;
   let lastHolderPid;
-  await fs5.mkdir(path4.dirname(lockPath), { recursive: true });
+  await fs6.mkdir(path4.dirname(lockPath), { recursive: true });
   for (; ; ) {
     if (await tryCreateLock(lockPath, token))
       return token;
     let raw = null;
     try {
-      raw = await fs5.readFile(lockPath, "utf8");
+      raw = await fs6.readFile(lockPath, "utf8");
     } catch (err) {
       if (err.code === "ENOENT")
         continue;
@@ -5491,13 +5585,13 @@ async function acquireLockFile(lockPath, opts) {
 }
 async function releaseLockFile(lockPath, token) {
   try {
-    const rec = parseLockRecord(await fs5.readFile(lockPath, "utf8"));
+    const rec = parseLockRecord(await fs6.readFile(lockPath, "utf8"));
     if (rec?.token !== token)
       return;
-    const recheck = parseLockRecord(await fs5.readFile(lockPath, "utf8"));
+    const recheck = parseLockRecord(await fs6.readFile(lockPath, "utf8"));
     if (recheck?.token !== token)
       return;
-    await fs5.unlink(lockPath);
+    await fs6.unlink(lockPath);
   } catch {
   }
 }
@@ -5566,10 +5660,10 @@ var init_file_lock = __esm({
 });
 
 // ../../packages/local-store/dist/sync-tracking.js
-import { promises as fs6 } from "fs";
+import { promises as fs7 } from "fs";
 async function readLastPush(projectRoot) {
   try {
-    const raw = await fs6.readFile(lastPushPath(projectRoot), "utf8");
+    const raw = await fs7.readFile(lastPushPath(projectRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -5616,7 +5710,7 @@ async function forgetLastPush(projectRoot, entityId) {
 }
 async function readCloudBase(projectRoot) {
   try {
-    const raw = await fs6.readFile(cloudBasePath(projectRoot), "utf8");
+    const raw = await fs7.readFile(cloudBasePath(projectRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -5717,7 +5811,7 @@ function isRetryQueueEntry(value) {
 async function readRetryQueueDetailed(projectRoot) {
   let raw;
   try {
-    raw = await fs6.readFile(retryQueuePath(projectRoot), "utf8");
+    raw = await fs7.readFile(retryQueuePath(projectRoot), "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { entries: [], warnings: [], corruptedLines: [] };
@@ -5773,7 +5867,7 @@ function canonicalJsonString(val) {
 async function readQueueAndPreserveCorrupted(projectRoot) {
   const { entries, corruptedLines } = await readRetryQueueDetailed(projectRoot);
   if (corruptedLines && corruptedLines.length > 0) {
-    await fs6.appendFile(retryQueueCorruptedPath(projectRoot), corruptedLines.map((l) => `${l}
+    await fs7.appendFile(retryQueueCorruptedPath(projectRoot), corruptedLines.map((l) => `${l}
 `).join(""), "utf8");
   }
   return entries;
@@ -5823,7 +5917,7 @@ var init_sync_tracking = __esm({
 });
 
 // ../../packages/local-store/dist/entity.js
-import { promises as fs7 } from "fs";
+import { promises as fs8 } from "fs";
 import path5 from "path";
 async function resolveEntityPath(projectRoot, type2, slugOrUuid) {
   const isSlug = slugSchema.safeParse(slugOrUuid).success;
@@ -5832,7 +5926,7 @@ async function resolveEntityPath(projectRoot, type2, slugOrUuid) {
     return null;
   const direct = entityFilePath(projectRoot, type2, slugOrUuid);
   try {
-    await fs7.access(direct);
+    await fs8.access(direct);
     return direct;
   } catch {
   }
@@ -5841,7 +5935,7 @@ async function resolveEntityPath(projectRoot, type2, slugOrUuid) {
   const dir = entityDirPath(projectRoot, type2);
   let entries;
   try {
-    entries = await fs7.readdir(dir);
+    entries = await fs8.readdir(dir);
   } catch {
     return null;
   }
@@ -5850,7 +5944,7 @@ async function resolveEntityPath(projectRoot, type2, slugOrUuid) {
       continue;
     const abs = path5.join(dir, name);
     try {
-      const raw = await fs7.readFile(abs, "utf8");
+      const raw = await fs8.readFile(abs, "utf8");
       const { frontmatter } = parseFrontmatter(raw);
       if (typeof frontmatter.id === "string" && frontmatter.id.toLowerCase() === slugOrUuid.toLowerCase()) {
         return abs;
@@ -5867,7 +5961,7 @@ async function readEntity(projectRoot, type2, slugOrUuid) {
   const abs = await resolveEntityPath(projectRoot, type2, slugOrUuid);
   if (!abs)
     return null;
-  const raw = await fs7.readFile(abs, "utf8");
+  const raw = await fs8.readFile(abs, "utf8");
   const { frontmatter, body } = parseFrontmatter(raw);
   const schema2 = entityFrontmatterSchemas[type2];
   const parsed = schema2.parse(frontmatter);
@@ -5895,7 +5989,7 @@ async function writeEntity(projectRoot, type2, frontmatter, body) {
 }
 async function entityExists(projectRoot, type2, slug) {
   try {
-    await fs7.access(entityFilePath(projectRoot, type2, slug));
+    await fs8.access(entityFilePath(projectRoot, type2, slug));
     return true;
   } catch {
     return false;
@@ -5905,7 +5999,7 @@ async function listEntities(projectRoot, type2) {
   const dir = entityDirPath(projectRoot, type2);
   let names;
   try {
-    names = await fs7.readdir(dir);
+    names = await fs8.readdir(dir);
   } catch (err) {
     if (err.code === "ENOENT") {
       return { entities: [], warnings: [] };
@@ -5920,7 +6014,7 @@ async function listEntities(projectRoot, type2) {
       continue;
     const abs = path5.join(dir, name);
     try {
-      const raw = await fs7.readFile(abs, "utf8");
+      const raw = await fs8.readFile(abs, "utf8");
       const { frontmatter, body } = parseFrontmatter(raw);
       const parsed = schema2.parse(frontmatter);
       entities.push({
@@ -6035,14 +6129,14 @@ var init_guidance2 = __esm({
 });
 
 // ../../packages/local-store/dist/finding-match.js
-import { promises as fs8 } from "fs";
+import { promises as fs9 } from "fs";
 import path6 from "path";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 async function readScenarioFindings(projectRoot, scenarioSlug) {
   const dir = entityDirPath(projectRoot, "finding");
   let names;
   try {
-    names = await fs8.readdir(dir);
+    names = await fs9.readdir(dir);
   } catch {
     return [];
   }
@@ -6052,7 +6146,7 @@ async function readScenarioFindings(projectRoot, scenarioSlug) {
       continue;
     const file = path6.join(dir, name);
     try {
-      const { frontmatter } = parseFrontmatter(await fs8.readFile(file, "utf8"));
+      const { frontmatter } = parseFrontmatter(await fs9.readFile(file, "utf8"));
       const fm = frontmatter;
       if (fm.scenario === scenarioSlug)
         out.push({ file, frontmatter: fm });
@@ -6092,7 +6186,7 @@ async function suppressionRules(projectRoot, outlineSlug) {
 }
 async function scenarioOutline(projectRoot, scenarioSlug) {
   try {
-    const raw = await fs8.readFile(path6.join(entityDirPath(projectRoot, "scenario"), `${scenarioSlug}.md`), "utf8");
+    const raw = await fs9.readFile(path6.join(entityDirPath(projectRoot, "scenario"), `${scenarioSlug}.md`), "utf8");
     const outline = parseFrontmatter(raw).frontmatter.outline;
     return typeof outline === "string" ? outline : null;
   } catch {
@@ -6205,7 +6299,7 @@ async function recordMatches(projectRoot, runId, scenarioSlug, answer) {
     const target = byId.get(m.finding_id);
     if (!target)
       continue;
-    const raw = await fs8.readFile(target, "utf8");
+    const raw = await fs9.readFile(target, "utf8");
     const updated = setFrontmatterScalar(raw, "canonical_id", m.canonical_id);
     if (updated !== raw)
       await atomicWriteFile(target, updated);
@@ -6215,7 +6309,7 @@ async function recordMatches(projectRoot, runId, scenarioSlug, answer) {
     const target = byId.get(s.finding_id);
     if (!target)
       continue;
-    const raw = await fs8.readFile(target, "utf8");
+    const raw = await fs9.readFile(target, "utf8");
     const updated = setFrontmatterScalar(raw, "suppressed_by_guidance", s.guidance_id);
     if (updated !== raw)
       await atomicWriteFile(target, updated);
@@ -6233,7 +6327,7 @@ async function setCanonicalFixStatus(projectRoot, scenarioSlug, canonicalId, sta
   for (const f of await readScenarioFindings(projectRoot, scenarioSlug)) {
     if (f.frontmatter.canonical_id !== canonicalId)
       continue;
-    const raw = await fs8.readFile(f.file, "utf8");
+    const raw = await fs9.readFile(f.file, "utf8");
     const updated = setFrontmatterScalar(raw, "fix_status", status2);
     if (updated !== raw)
       await atomicWriteFile(f.file, updated);
@@ -6241,7 +6335,7 @@ async function setCanonicalFixStatus(projectRoot, scenarioSlug, canonicalId, sta
 }
 async function readMatches(projectRoot, runId) {
   try {
-    const raw = await fs8.readFile(path6.join(runDir(projectRoot, runId), MATCHES_FILE), "utf8");
+    const raw = await fs9.readFile(path6.join(runDir(projectRoot, runId), MATCHES_FILE), "utf8");
     const parsed = matchesFileSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : null;
   } catch {
@@ -6258,32 +6352,32 @@ var init_finding_match = __esm({
     init_paths();
     init_walkthrough_canonical2();
     MATCHES_FILE = "matches.json";
-    matchesFileSchema = z22.object({
-      matches: z22.array(z22.object({
-        finding_id: z22.string().min(1),
-        canonical_id: z22.string().min(1).nullable(),
-        reasoning: z22.string().default("")
+    matchesFileSchema = z23.object({
+      matches: z23.array(z23.object({
+        finding_id: z23.string().min(1),
+        canonical_id: z23.string().min(1).nullable(),
+        reasoning: z23.string().default("")
       })),
-      rechecked_fixed: z22.array(z22.object({
-        canonical_id: z22.string().min(1),
-        step_ids: z22.array(z22.string().min(1)).min(1),
-        reasoning: z22.string().default("")
+      rechecked_fixed: z23.array(z23.object({
+        canonical_id: z23.string().min(1),
+        step_ids: z23.array(z23.string().min(1)).min(1),
+        reasoning: z23.string().default("")
       })).default([]),
       /**
        * Findings of this run that an active `not_relevant` tester guidance
        * rule covers. Kept, flagged: `suppressed_by_guidance` on the file.
        */
-      suppressed: z22.array(z22.object({
-        finding_id: z22.string().min(1),
-        guidance_id: z22.string().min(1),
-        reasoning: z22.string().default("")
+      suppressed: z23.array(z23.object({
+        finding_id: z23.string().min(1),
+        guidance_id: z23.string().min(1),
+        reasoning: z23.string().default("")
       })).default([])
     });
   }
 });
 
 // ../../packages/local-store/dist/runs.js
-import { promises as fs9 } from "fs";
+import { promises as fs10 } from "fs";
 import path7 from "path";
 async function openRun(projectRoot, scenarioSlug, options = {}) {
   const now = options.now ?? /* @__PURE__ */ new Date();
@@ -6292,9 +6386,9 @@ async function openRun(projectRoot, scenarioSlug, options = {}) {
   const stepsDir = path7.join(absPath, "steps");
   const fingerprintsDir = path7.join(absPath, "fingerprints");
   const screenshotsDir = path7.join(absPath, "screenshots");
-  await fs9.mkdir(stepsDir, { recursive: true });
-  await fs9.mkdir(fingerprintsDir, { recursive: true });
-  await fs9.mkdir(screenshotsDir, { recursive: true });
+  await fs10.mkdir(stepsDir, { recursive: true });
+  await fs10.mkdir(fingerprintsDir, { recursive: true });
+  await fs10.mkdir(screenshotsDir, { recursive: true });
   return {
     runId,
     absPath,
@@ -6309,14 +6403,14 @@ function padStepNumber(n) {
 }
 async function writeStep(runDirAbs, step) {
   const stepsDir = path7.join(runDirAbs, "steps");
-  await fs9.mkdir(stepsDir, { recursive: true });
+  await fs10.mkdir(stepsDir, { recursive: true });
   const filename = `${padStepNumber(step.step_number)}.json`;
   await atomicWriteFile(path7.join(stepsDir, filename), JSON.stringify(step, null, 2) + "\n");
 }
 async function listRuns(projectRoot) {
   const dir = runsDir(projectRoot);
   try {
-    const entries = await fs9.readdir(dir, { withFileTypes: true });
+    const entries = await fs10.readdir(dir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch (err) {
     if (err.code === "ENOENT")
@@ -6328,7 +6422,7 @@ async function listIncompleteRuns(projectRoot) {
   const incomplete = [];
   for (const runId of await listRuns(projectRoot)) {
     try {
-      const manifest = JSON.parse(await fs9.readFile(path7.join(runsDir(projectRoot), runId, "walkthrough.json"), "utf8"));
+      const manifest = JSON.parse(await fs10.readFile(path7.join(runsDir(projectRoot), runId, "walkthrough.json"), "utf8"));
       if (manifest.status !== "completed")
         incomplete.push(runId);
     } catch {
@@ -6346,7 +6440,7 @@ var init_runs = __esm({
 });
 
 // ../../packages/local-store/dist/fix-state.js
-import { promises as fs10 } from "fs";
+import { promises as fs11 } from "fs";
 import path8 from "path";
 function toMillis(iso) {
   if (!iso)
@@ -6452,7 +6546,7 @@ function summarizeRerun(findings2, runs, states) {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await fs10.readFile(file, "utf8"));
+    return JSON.parse(await fs11.readFile(file, "utf8"));
   } catch {
     return null;
   }
@@ -7025,19 +7119,19 @@ var init_journey_diff = __esm({
 
 // ../../packages/local-store/dist/walkthrough-canonical.js
 import { createHash as createHash2, randomUUID as randomUUID5 } from "crypto";
-import { promises as fs11 } from "fs";
+import { promises as fs12 } from "fs";
 import path9 from "path";
 async function readStepsForRun(projectRoot, runId) {
   const runDirPath = runDir(projectRoot, runId);
   const stepsDir = path9.join(runDirPath, "steps");
   try {
-    const names = await fs11.readdir(stepsDir);
+    const names = await fs12.readdir(stepsDir);
     const jsonFiles = names.filter((n) => n.endsWith(".json")).sort();
     if (jsonFiles.length > 0) {
       const out2 = [];
       for (const name of jsonFiles) {
         try {
-          const raw2 = await fs11.readFile(path9.join(stepsDir, name), "utf8");
+          const raw2 = await fs12.readFile(path9.join(stepsDir, name), "utf8");
           const parsed = JSON.parse(raw2);
           if (parsed.step_number == null) {
             const numFromName = Number.parseInt(name.replace(/\.json$/, ""), 10);
@@ -7054,7 +7148,7 @@ async function readStepsForRun(projectRoot, runId) {
   const stepsPath = path9.join(runDirPath, "steps.jsonl");
   let raw;
   try {
-    raw = await fs11.readFile(stepsPath, "utf8");
+    raw = await fs12.readFile(stepsPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT")
       return [];
@@ -7079,7 +7173,7 @@ async function readFindingsForRun(projectRoot, runId) {
   const findingsDir = entityDirPath(projectRoot, "finding");
   let names;
   try {
-    names = await fs11.readdir(findingsDir);
+    names = await fs12.readdir(findingsDir);
   } catch (err) {
     if (err.code === "ENOENT")
       return [];
@@ -7090,7 +7184,7 @@ async function readFindingsForRun(projectRoot, runId) {
     if (!name.endsWith(".md") || name.startsWith("."))
       continue;
     const filePath = path9.join(findingsDir, name);
-    const raw = await fs11.readFile(filePath, "utf8");
+    const raw = await fs12.readFile(filePath, "utf8");
     try {
       const { frontmatter, body } = parseFrontmatter(raw);
       const fm = frontmatter;
@@ -7121,7 +7215,7 @@ async function resolveCanonicalIds(projectRoot, scenarioSlug, currentRunId, curr
   const findingsDir = entityDirPath(projectRoot, "finding");
   let allNames;
   try {
-    allNames = await fs11.readdir(findingsDir);
+    allNames = await fs12.readdir(findingsDir);
   } catch {
     allNames = [];
   }
@@ -7129,7 +7223,7 @@ async function resolveCanonicalIds(projectRoot, scenarioSlug, currentRunId, curr
     if (!name.endsWith(".md") || name.startsWith("."))
       continue;
     try {
-      const raw = await fs11.readFile(path9.join(findingsDir, name), "utf8");
+      const raw = await fs12.readFile(path9.join(findingsDir, name), "utf8");
       const { frontmatter } = parseFrontmatter(raw);
       const fm = frontmatter;
       if (!fm.scenario || fm.scenario !== scenarioSlug)
@@ -7157,7 +7251,7 @@ async function resolveCanonicalIds(projectRoot, scenarioSlug, currentRunId, curr
             continue;
           const candidatePath = path9.join(findingsDir, name);
           try {
-            const candidateRaw = await fs11.readFile(candidatePath, "utf8");
+            const candidateRaw = await fs12.readFile(candidatePath, "utf8");
             const { frontmatter: cFm } = parseFrontmatter(candidateRaw);
             if (cFm.id === f.frontmatter.id) {
               targetPath = candidatePath;
@@ -7168,7 +7262,7 @@ async function resolveCanonicalIds(projectRoot, scenarioSlug, currentRunId, curr
         }
         if (targetPath) {
           await withFileLock(targetPath, async () => {
-            const raw = await fs11.readFile(targetPath, "utf8");
+            const raw = await fs12.readFile(targetPath, "utf8");
             const updated = raw.replace(/^(---\n[\s\S]*?)(---\n)/m, `$1canonical_id: ${canonicalId}
 $2`);
             if (updated !== raw) {
@@ -7304,7 +7398,7 @@ async function compareWithBaseline(projectRoot, scenarioSlug, currentRunId, curr
       continue;
     try {
       const mPath = path9.join(runDir(projectRoot, rid), "walkthrough.json");
-      const raw = await fs11.readFile(mPath, "utf8");
+      const raw = await fs12.readFile(mPath, "utf8");
       const m = JSON.parse(raw);
       if (m.scenario_slug === scenarioSlug && m.status === "completed") {
         baselineRunId = rid;
@@ -7387,7 +7481,7 @@ async function updateFixStatus(projectRoot, slug, status2) {
     const findingsDir = entityDirPath(projectRoot, "finding");
     const filePath = path9.join(findingsDir, `${slug}.md`);
     await withFileLock(filePath, async () => {
-      const raw = await fs11.readFile(filePath, "utf8");
+      const raw = await fs12.readFile(filePath, "utf8");
       const updated = raw.replace(/^(fix_status:\s*).*$/m, `$1${status2}`);
       if (updated !== raw) {
         await atomicWriteFile(filePath, updated);
@@ -7403,7 +7497,7 @@ fix_status: ${status2}`);
 async function listRunsInternal(projectRoot) {
   const dir = path9.join(projectRoot, "iamu", ".runs");
   try {
-    const names = await fs11.readdir(dir);
+    const names = await fs12.readdir(dir);
     return names.filter((n) => !n.startsWith(".")).sort();
   } catch {
     return [];
@@ -7585,7 +7679,7 @@ __export(walkthrough_mirror_exports, {
   walkthroughBundleSchema: () => walkthroughBundleSchema
 });
 import { createHash as createHash3 } from "crypto";
-import { promises as fs12 } from "fs";
+import { promises as fs13 } from "fs";
 import path10 from "path";
 function toCloudRunUuid(runId) {
   if (UUID_RE.test(runId))
@@ -7638,7 +7732,7 @@ function buildPushUrl(cloudApiUrl, cloudProjectId) {
 async function readLocalManifest(projectRoot, runId) {
   const p = path10.join(runDir(projectRoot, runId), "walkthrough.json");
   try {
-    const raw = await fs12.readFile(p, "utf8");
+    const raw = await fs13.readFile(p, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -7647,7 +7741,7 @@ async function readLocalManifest(projectRoot, runId) {
 async function readLocalReport(projectRoot, runId) {
   const p = path10.join(runDir(projectRoot, runId), "report.md");
   try {
-    return await fs12.readFile(p, "utf8");
+    return await fs13.readFile(p, "utf8");
   } catch (err) {
     if (err.code === "ENOENT")
       return "";
@@ -7658,7 +7752,7 @@ async function readScreenshotBytes(projectRoot, runId) {
   const dir = path10.join(runDir(projectRoot, runId), SCREENSHOTS_DIR);
   let names;
   try {
-    names = await fs12.readdir(dir);
+    names = await fs13.readdir(dir);
   } catch (err) {
     if (err.code === "ENOENT")
       return /* @__PURE__ */ new Map();
@@ -7674,7 +7768,7 @@ async function readScreenshotBytes(projectRoot, runId) {
     const contentType = EXT_TO_CONTENT_TYPE[ext === ".jpeg" ? ".jpeg" : ext];
     if (!contentType)
       continue;
-    const bytes = await fs12.readFile(path10.join(dir, name));
+    const bytes = await fs13.readFile(path10.join(dir, name));
     out.set(seq2, { bytes, filename: name, contentType });
   }
   return out;
@@ -7682,7 +7776,7 @@ async function readScreenshotBytes(projectRoot, runId) {
 async function readVerdictsJson(projectRoot, runId) {
   const filePath = path10.join(runDir(projectRoot, runId), "verdicts.json");
   try {
-    const raw = await fs12.readFile(filePath, "utf-8");
+    const raw = await fs13.readFile(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -7693,7 +7787,7 @@ async function readProvenance(projectRoot, runId, verdicts) {
     return verdicts.provenance;
   const filePath = path10.join(runDir(projectRoot, runId), "canonical.json");
   try {
-    const raw = await fs12.readFile(filePath, "utf-8");
+    const raw = await fs13.readFile(filePath, "utf-8");
     const data = JSON.parse(raw);
     return data.provenance ?? null;
   } catch {
@@ -7702,7 +7796,7 @@ async function readProvenance(projectRoot, runId, verdicts) {
 }
 async function readCanonicalExtras(projectRoot, runId) {
   try {
-    const data = JSON.parse(await fs12.readFile(path10.join(runDir(projectRoot, runId), "canonical.json"), "utf-8"));
+    const data = JSON.parse(await fs13.readFile(path10.join(runDir(projectRoot, runId), "canonical.json"), "utf-8"));
     const strings = (v) => Array.isArray(v) && v.every((x) => typeof x === "string") ? v : void 0;
     const verification = bundleVerificationSchema.safeParse(data.verification);
     return {
@@ -8441,7 +8535,7 @@ var init_refs = __esm({
 });
 
 // ../../packages/local-store/dist/sync/types.js
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 function toRef(d) {
   return { type: d.type, id: d.id, label: d.label };
 }
@@ -8506,17 +8600,17 @@ var init_types = __esm({
     DEFAULT_TIMEOUT_MS4 = 3e4;
     MAX_BATCH_BYTES = 6 * 1024 * 1024;
     BASE_HASH_BYTES = 96;
-    importConflictSchema = z23.object({
-      type: z23.string(),
-      id: z23.string(),
-      base_hash: z23.string().nullish(),
-      cloud_hash: z23.string(),
-      cloud_updated_at: z23.string().nullish(),
-      cloud_changed_by: z23.string().nullish()
+    importConflictSchema = z24.object({
+      type: z24.string(),
+      id: z24.string(),
+      base_hash: z24.string().nullish(),
+      cloud_hash: z24.string(),
+      cloud_updated_at: z24.string().nullish(),
+      cloud_changed_by: z24.string().nullish()
     });
-    importResponseSchema = z23.object({
-      imported: z23.number().int().min(0),
-      conflicts: z23.array(importConflictSchema).optional()
+    importResponseSchema = z24.object({
+      imported: z24.number().int().min(0),
+      conflicts: z24.array(importConflictSchema).optional()
     });
   }
 });
@@ -8767,7 +8861,7 @@ var init_push = __esm({
 });
 
 // ../../packages/local-store/dist/sync/context.js
-import { promises as fs13 } from "fs";
+import { promises as fs14 } from "fs";
 async function syncContext(target) {
   const { projectRoot } = target;
   const summary = zeroContext();
@@ -8775,7 +8869,7 @@ async function syncContext(target) {
   const conflicts = [];
   let raw;
   try {
-    raw = await fs13.readFile(contextPath(projectRoot), "utf8");
+    raw = await fs14.readFile(contextPath(projectRoot), "utf8");
   } catch (err) {
     if (err.code === "ENOENT")
       return { summary, errors, conflicts };
@@ -8985,7 +9079,7 @@ var init_git_branches = __esm({
 });
 
 // ../../packages/local-store/dist/deletions.js
-import { promises as fs14 } from "fs";
+import { promises as fs15 } from "fs";
 import path12 from "path";
 function describeDeletionCount(type2, n) {
   const nouns = {
@@ -9013,7 +9107,7 @@ function summarizeDeletions(items) {
 }
 async function readPushedEntities(projectRoot) {
   try {
-    const raw = await fs14.readFile(pushedEntitiesPath(projectRoot), "utf8");
+    const raw = await fs15.readFile(pushedEntitiesPath(projectRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return {};
@@ -9052,7 +9146,7 @@ async function rememberPushedEntities(projectRoot, known) {
 }
 async function readLenient(projectRoot, relPath) {
   try {
-    const raw = await fs14.readFile(path12.join(projectRoot, relPath), "utf8");
+    const raw = await fs15.readFile(path12.join(projectRoot, relPath), "utf8");
     const fm = parseFrontmatter(raw).frontmatter;
     if (typeof fm.id !== "string" || fm.id.length === 0)
       return null;
@@ -9478,7 +9572,7 @@ var init_deletions2 = __esm({
 });
 
 // ../../packages/local-store/dist/sync/scan.js
-import { promises as fs15 } from "fs";
+import { promises as fs16 } from "fs";
 function blockedRef(refs, blocked) {
   if (!refs)
     return null;
@@ -9574,7 +9668,7 @@ async function scanPending(projectRoot) {
         continue;
       let bytes;
       try {
-        bytes = await fs15.readFile(entity.absPath, "utf8");
+        bytes = await fs16.readFile(entity.absPath, "utf8");
       } catch {
         continue;
       }
@@ -9635,7 +9729,7 @@ var init_scan = __esm({
 });
 
 // ../../packages/local-store/dist/sync/walkthroughs.js
-import { promises as fs16 } from "fs";
+import { promises as fs17 } from "fs";
 import nodePath from "path";
 async function syncWalkthroughs(projectRoot, deps, unpushableScenarios = /* @__PURE__ */ new Set()) {
   const summary = zeroWalkthroughs();
@@ -9663,7 +9757,7 @@ async function syncWalkthroughs(projectRoot, deps, unpushableScenarios = /* @__P
     const manifestPath = nodePath.join(runDir(projectRoot, runId), "walkthrough.json");
     let manifestRaw;
     try {
-      manifestRaw = await fs16.readFile(manifestPath, "utf8");
+      manifestRaw = await fs17.readFile(manifestPath, "utf8");
     } catch {
       continue;
     }
@@ -10002,7 +10096,7 @@ var init_disconnect = __esm({
 });
 
 // ../../packages/local-store/dist/status.js
-import { promises as fs17 } from "fs";
+import { promises as fs18 } from "fs";
 import path13 from "path";
 async function countType(projectRoot, type2) {
   const result = await listEntities(projectRoot, type2);
@@ -10013,7 +10107,7 @@ async function countType(projectRoot, type2) {
     if (typeof id !== "string" || typeof slug !== "string")
       continue;
     try {
-      const raw = await fs17.readFile(entity.absPath, "utf8");
+      const raw = await fs18.readFile(entity.absPath, "utf8");
       contentHashes.set(id, hashNormalizedContent(raw));
     } catch {
     }
@@ -10107,7 +10201,7 @@ async function countContext(projectRoot, opts = {
     return base;
   let pending = true;
   try {
-    const bytes = await fs17.readFile(contextPath(projectRoot), "utf8");
+    const bytes = await fs18.readFile(contextPath(projectRoot), "utf8");
     const hash = hashNormalizedContent(bytes);
     pending = opts.lastPush["context:root"] !== hash;
   } catch {
@@ -10129,7 +10223,7 @@ async function countWalkthroughs(projectRoot, opts = { cloudLinked: false, lastP
     const manifestPath = path13.join(projectRoot, "iamu", ".runs", runId, "walkthrough.json");
     let completed = false;
     try {
-      const raw = await fs17.readFile(manifestPath, "utf8");
+      const raw = await fs18.readFile(manifestPath, "utf8");
       const manifest = JSON.parse(raw);
       completed = manifest.status === "completed";
     } catch {
@@ -10149,7 +10243,7 @@ async function getProjectStatus(projectRoot, opts = {}) {
   const config = await readConfig(projectRoot);
   const iamuPath = iamuDir(projectRoot);
   try {
-    await fs17.access(iamuPath);
+    await fs18.access(iamuPath);
   } catch {
     throw new Error(`status: iamu/ directory missing at ${iamuPath}`);
   }
@@ -10331,13 +10425,13 @@ var init_status = __esm({
 });
 
 // ../../packages/local-store/dist/prune.js
-import { promises as fs18 } from "fs";
+import { promises as fs19 } from "fs";
 import path14 from "path";
 async function getDirectoryStats(dirPath) {
   let bytes = 0;
   let count = 0;
   try {
-    const entries = await fs18.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs19.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path14.join(dirPath, entry.name);
       if (entry.isDirectory()) {
@@ -10346,7 +10440,7 @@ async function getDirectoryStats(dirPath) {
         count += sub.count;
       } else if (entry.isFile()) {
         try {
-          const s = await fs18.stat(fullPath);
+          const s = await fs19.stat(fullPath);
           bytes += s.size;
           count += 1;
         } catch {
@@ -10362,12 +10456,12 @@ async function getScreenshotsStats(screenshotsDir) {
   let count = 0;
   const paths = [];
   try {
-    const entries = await fs18.readdir(screenshotsDir, { withFileTypes: true });
+    const entries = await fs19.readdir(screenshotsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && (entry.name.endsWith(".png") || entry.name.endsWith(".jpg") || entry.name.endsWith(".jpeg") || entry.name.endsWith(".webp"))) {
         const fullPath = path14.join(screenshotsDir, entry.name);
         try {
-          const s = await fs18.stat(fullPath);
+          const s = await fs19.stat(fullPath);
           bytes += s.size;
           count += 1;
           paths.push(fullPath);
@@ -10388,7 +10482,7 @@ async function pruneRuns(projectRoot, opts = {}) {
     let scenarioSlug;
     try {
       const manifestPath = path14.join(dirPath, "walkthrough.json");
-      const raw = await fs18.readFile(manifestPath, "utf-8");
+      const raw = await fs19.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.scenario_slug)
         scenarioSlug = parsed.scenario_slug;
@@ -10400,7 +10494,7 @@ async function pruneRuns(projectRoot, opts = {}) {
     }
     if (!timestamp2 || Number.isNaN(timestamp2.getTime())) {
       try {
-        const st = await fs18.stat(dirPath);
+        const st = await fs19.stat(dirPath);
         timestamp2 = st.mtime;
       } catch {
         timestamp2 = /* @__PURE__ */ new Date();
@@ -10440,7 +10534,7 @@ async function pruneRuns(projectRoot, opts = {}) {
     if (opts.screenshotsOnly) {
       if (!opts.dryRun) {
         for (const shotPath of shotStats.paths) {
-          await fs18.unlink(shotPath).catch(() => {
+          await fs19.unlink(shotPath).catch(() => {
           });
         }
       }
@@ -10457,7 +10551,7 @@ async function pruneRuns(projectRoot, opts = {}) {
     } else {
       const dirStats = await getDirectoryStats(c.dirPath);
       if (!opts.dryRun) {
-        await fs18.rm(c.dirPath, { recursive: true, force: true });
+        await fs19.rm(c.dirPath, { recursive: true, force: true });
       }
       prunedRuns.push({
         runId: c.runId,
@@ -10489,7 +10583,7 @@ var init_prune = __esm({
 
 // ../../packages/local-store/dist/explore-map.js
 import { randomBytes as randomBytes2 } from "crypto";
-import { promises as fs19 } from "fs";
+import { promises as fs20 } from "fs";
 import path15 from "path";
 function templateToken(token) {
   if (token === "")
@@ -10585,13 +10679,13 @@ function mapPath(projectRoot, id) {
 }
 async function writeExploreMap(projectRoot, map2) {
   const file = mapPath(projectRoot, map2.id);
-  await fs19.mkdir(path15.dirname(file), { recursive: true });
+  await fs20.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 raw = await fs20.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}`);
@@ -10600,7 +10694,7 @@ async function readExploreMap(projectRoot, id) {
 }
 async function listExploreMaps(projectRoot) {
   try {
-    const entries = await fs19.readdir(exploreDir(projectRoot), {
+    const entries = await fs20.readdir(exploreDir(projectRoot), {
       withFileTypes: true
     });
     return entries.filter((e) => e.isDirectory() && isValidExploreId(e.name)).map((e) => e.name).sort();
@@ -10698,6 +10792,127 @@ async function readAllRunSteps(projectRoot) {
   }
   return out;
 }
+function matchSurfaceCapabilities(place, capabilities) {
+  const normPlace = place.length > 1 ? place.replace(/\/+$/, "") : place;
+  const matchedCaps = /* @__PURE__ */ new Map();
+  for (const cap of capabilities) {
+    if (!cap.paths || cap.paths.length === 0)
+      continue;
+    for (const rawPath of cap.paths) {
+      if (!rawPath)
+        continue;
+      const cleanPath = rawPath.length > 1 ? rawPath.replace(/\/+$/, "") : rawPath;
+      let isMatch = false;
+      if (cleanPath === "/") {
+        isMatch = normPlace === "/" || normPlace.startsWith("/?") || normPlace.startsWith("/#");
+      } else {
+        isMatch = normPlace === cleanPath || normPlace.startsWith(`${cleanPath}/`) || normPlace.startsWith(`${cleanPath}?`) || normPlace.startsWith(`${cleanPath}#`);
+      }
+      if (isMatch) {
+        const prevLen = matchedCaps.get(cap.slug) ?? -1;
+        if (cleanPath.length > prevLen) {
+          matchedCaps.set(cap.slug, cleanPath.length);
+        }
+      }
+    }
+  }
+  if (matchedCaps.size > 0) {
+    return Array.from(matchedCaps.entries()).sort((a, b) => b[1] - a[1]).map(([slug]) => slug);
+  }
+  const firstSegment = normPlace.replace(/^\/+/, "").split(/[/\\?#]/)[0];
+  if (firstSegment) {
+    const slugMatches = [];
+    for (const c of capabilities) {
+      if (c.slug === firstSegment || c.slug.toLowerCase() === firstSegment.toLowerCase()) {
+        slugMatches.push(c.slug);
+      }
+    }
+    if (slugMatches.length > 0)
+      return slugMatches;
+  }
+  return [];
+}
+function summarizeCapabilityCoverage(surfaces, capabilities, outlines = []) {
+  const capMap = /* @__PURE__ */ new Map();
+  for (const c of capabilities) {
+    capMap.set(c.slug, []);
+  }
+  const unassigned = [];
+  for (const s of surfaces) {
+    const matchedSlugs = matchSurfaceCapabilities(s.place, capabilities);
+    if (matchedSlugs.length > 0) {
+      for (const slug of matchedSlugs) {
+        capMap.get(slug)?.push(s);
+      }
+    } else {
+      unassigned.push(s);
+    }
+  }
+  const primaryCounts = /* @__PURE__ */ new Map();
+  const secondaryCounts = /* @__PURE__ */ new Map();
+  for (const o of outlines) {
+    if (o.primary_capability) {
+      primaryCounts.set(o.primary_capability, (primaryCounts.get(o.primary_capability) ?? 0) + 1);
+    }
+    if (Array.isArray(o.additional_capabilities)) {
+      for (const add of o.additional_capabilities) {
+        if (add) {
+          secondaryCounts.set(add, (secondaryCounts.get(add) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  const summaries = capabilities.map((c) => {
+    const owned = capMap.get(c.slug) ?? [];
+    const reached = owned.filter((s) => s.status === "reached").length;
+    const unreached = owned.length - reached;
+    const coverage_pct = owned.length > 0 ? Math.round(reached / owned.length * 100) : 0;
+    const primary = primaryCounts.get(c.slug) ?? 0;
+    const secondary = secondaryCounts.get(c.slug) ?? 0;
+    return {
+      slug: c.slug,
+      title: c.title,
+      area: c.area ?? null,
+      total_surfaces: owned.length,
+      reached_surfaces: reached,
+      unreached_surfaces: unreached,
+      coverage_pct,
+      primary_scenarios: primary,
+      secondary_scenarios: secondary,
+      surfaces: owned
+    };
+  });
+  summaries.sort((a, b) => {
+    const aUntested = a.primary_scenarios === 0 && a.unreached_surfaces > 0;
+    const bUntested = b.primary_scenarios === 0 && b.unreached_surfaces > 0;
+    if (aUntested !== bUntested)
+      return aUntested ? -1 : 1;
+    if (a.coverage_pct !== b.coverage_pct)
+      return a.coverage_pct - b.coverage_pct;
+    return a.slug.localeCompare(b.slug);
+  });
+  return {
+    capabilities: summaries,
+    unassigned_surfaces: unassigned
+  };
+}
+async function readCapabilityCoverage(projectRoot, coverage) {
+  const [capsResult, outlinesResult] = await Promise.all([
+    listEntities(projectRoot, "capability"),
+    listEntities(projectRoot, "outline")
+  ]);
+  const caps = capsResult.entities.map((e) => ({
+    slug: e.frontmatter.slug,
+    title: e.frontmatter.title,
+    area: e.frontmatter.area ?? null,
+    paths: e.frontmatter.paths ?? []
+  }));
+  const outlines = outlinesResult.entities.map((e) => ({
+    primary_capability: e.frontmatter.primary_capability,
+    additional_capabilities: e.frontmatter.additional_capabilities ?? []
+  }));
+  return summarizeCapabilityCoverage(coverage.surfaces, caps, outlines);
+}
 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}`;
@@ -10742,6 +10957,7 @@ var init_explore_map = __esm({
   "../../packages/local-store/dist/explore-map.js"() {
     "use strict";
     init_atomic();
+    init_entity();
     init_paths();
     init_revisit();
     init_runs();
@@ -10754,7 +10970,7 @@ var init_explore_map = __esm({
 });
 
 // ../../packages/local-store/dist/human-test-link.js
-import { promises as fs20 } from "fs";
+import { promises as fs21 } from "fs";
 import path16 from "path";
 function humanTestLinks(verdicts) {
   const best = /* @__PURE__ */ new Map();
@@ -10778,7 +10994,7 @@ async function linkFindingsToHumanTests(projectRoot, runId, verdicts) {
   const dir = entityDirPath(projectRoot, "finding");
   let names;
   try {
-    names = await fs20.readdir(dir);
+    names = await fs21.readdir(dir);
   } catch {
     return [];
   }
@@ -10790,7 +11006,7 @@ async function linkFindingsToHumanTests(projectRoot, runId, verdicts) {
     let raw;
     let fm;
     try {
-      raw = await fs20.readFile(file, "utf8");
+      raw = await fs21.readFile(file, "utf8");
       fm = parseFrontmatter(raw).frontmatter;
     } catch {
       continue;
@@ -11021,14 +11237,14 @@ var init_cloud_client = __esm({
 });
 
 // ../../packages/local-store/dist/last-pull.js
-import { promises as fs21 } from "fs";
+import { promises as fs22 } from "fs";
 import path17 from "path";
 function lastPullPath(projectRoot) {
   return path17.join(cacheDir(projectRoot), "last-pull.json");
 }
 async function readLastPull(projectRoot) {
   try {
-    const raw = await fs21.readFile(lastPullPath(projectRoot), "utf8");
+    const raw = await fs22.readFile(lastPullPath(projectRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -11314,7 +11530,7 @@ var init_frontmatter2 = __esm({
 });
 
 // ../../packages/local-store/dist/pull/write.js
-import { promises as fs22 } from "fs";
+import { promises as fs23 } from "fs";
 async function loadLocalIndex(projectRoot, type2) {
   const byId = /* @__PURE__ */ new Map();
   const bySlug = /* @__PURE__ */ new Map();
@@ -11343,7 +11559,7 @@ async function classifyExisting(projectRoot, type2, cloudId, localSlug, targetSl
   if (localSlug !== targetSlug)
     return "untracked";
   const lastSynced = localIndex.lastPushById[cloudId];
-  const bytes = await fs22.readFile(entityFilePath(projectRoot, type2, localSlug), "utf8");
+  const bytes = await fs23.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) {
@@ -11404,13 +11620,13 @@ async function writeOrSkip(projectRoot, type2, cloudId, slug, frontmatter, body,
   }
   if (existingSlugForId && existingSlugForId !== slug) {
     try {
-      await fs22.unlink(entityFilePath(projectRoot, type2, existingSlugForId));
+      await fs23.unlink(entityFilePath(projectRoot, type2, existingSlugForId));
       localIndex.bySlug.delete(existingSlugForId);
     } catch {
     }
   }
   await writeEntity(projectRoot, type2, frontmatter, text);
-  const bytes = await fs22.readFile(entityFilePath(projectRoot, type2, slug), "utf8");
+  const bytes = await fs23.readFile(entityFilePath(projectRoot, type2, slug), "utf8");
   const hash = hashNormalizedContent(bytes);
   localIndex.byId.set(cloudId, slug);
   localIndex.bySlug.set(slug, cloudId);
@@ -11464,7 +11680,7 @@ var init_write = __esm({
 });
 
 // ../../packages/local-store/dist/pull/entities.js
-import { promises as fs23 } from "fs";
+import { promises as fs24 } from "fs";
 function buildContextFrontmatter(payload) {
   const cloudCtx = payload.context ?? {};
   const glossary = (payload.glossary ?? []).map((g) => ({
@@ -11519,7 +11735,7 @@ async function pullContext(projectRoot, cloud, projectId, mode, result) {
   const frontmatter = buildContextFrontmatter(payload);
   let hasLocal = false;
   try {
-    await fs23.access(contextPath(projectRoot));
+    await fs24.access(contextPath(projectRoot));
     hasLocal = true;
   } catch {
     hasLocal = false;
@@ -11549,7 +11765,7 @@ async function pullContext(projectRoot, cloud, projectId, mode, result) {
       frontmatter,
       notes_body: existingNotes
     });
-    const bytes = await fs23.readFile(contextPath(projectRoot), "utf8");
+    const bytes = await fs24.readFile(contextPath(projectRoot), "utf8");
     const hash = hashNormalizedContent(bytes);
     await recordLastPull(projectRoot, "context:root", hash);
     await recordLastPush(projectRoot, "context:root", hash);
@@ -12069,6 +12285,7 @@ var init_dist2 = __esm({
     init_bootstrap();
     init_config2();
     init_context2();
+    init_testability2();
     init_connect();
     init_disconnect();
     init_status();
@@ -12972,11 +13189,24 @@ import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk6 from "chalk";
 function getVersion() {
+  if ("0.2.0-beta.17") {
+    return "0.2.0-beta.17";
+  }
   try {
     const thisDir = dirname3(fileURLToPath2(import.meta.url));
-    const pkgPath = resolve2(thisDir, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
-    return pkg.version ?? "0.0.0";
+    for (const rel of [".", "..", "../.."]) {
+      const pkgPath = resolve2(thisDir, rel, "package.json");
+      if (existsSync5(pkgPath)) {
+        const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+        if (pkg.name === "@iamu-dev/iamu" && pkg.version) {
+          return pkg.version;
+        }
+        if (pkg.version && pkg.version !== "0.0.0") {
+          return pkg.version;
+        }
+      }
+    }
+    return "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -14866,17 +15096,12 @@ __export(start_run_exports, {
   startRun: () => startRun,
   testabilityTarget: () => testabilityTarget
 });
-import fs24 from "fs/promises";
 import path20 from "path";
 import chalk12 from "chalk";
 async function testabilityTarget(projectRoot) {
   try {
-    const raw = await fs24.readFile(
-      path20.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;
+    const doc = await readTestability(projectRoot);
+    return doc?.frontmatter.target_url ?? null;
   } catch {
     return null;
   }
@@ -15504,7 +15729,7 @@ var init_fatal = __esm({
 
 // src/sync-mcp/tools.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 function getProjectRoot() {
   const root = findProjectRoot(process.cwd());
   if (!root)
@@ -15745,7 +15970,7 @@ function createSyncServer() {
   server.tool(
     "iamu_requests_claim",
     "Claim one work request before working on it. Takes an exclusive lease (2h, renewable by re-claiming) so no teammate's agent does the same work. Returns the full payload: the finding's ui_fact and consequence with its local finding ids, or the scenario and target URL, plus `next` \u2014 the skill step to run. Fails with lease_held when someone else is on it.",
-    { id: z24.string().uuid().describe("Request id from iamu_requests") },
+    { id: z25.string().uuid().describe("Request id from iamu_requests") },
     async ({ id }) => {
       try {
         const linked = await resolveLinkedCloudClient();
@@ -16405,11 +16630,14 @@ var init_serve = __esm({
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
+  createDraftTestabilityContent: () => createDraftTestabilityContent,
+  detectTargetPort: () => detectTargetPort,
+  detectTargetUrl: () => detectTargetUrl,
   init: () => init,
   setupCommand: () => setupCommand
 });
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, readdir, writeFile as writeFile3 } from "fs/promises";
 import { basename as basename2, join as join5 } from "path";
 import { isCancel as isCancel3, multiselect, select as select3 } from "@clack/prompts";
 import chalk18 from "chalk";
@@ -16437,6 +16665,81 @@ function setupCommand(projectRoot, hosts) {
   if (hosts.every((h) => h.value === "claude")) return "/iamu:init";
   return "/iamu-setup   (Claude Code: /iamu:init)";
 }
+function detectTargetPort(projectRoot) {
+  if (process.env.PORT) {
+    const p = Number.parseInt(process.env.PORT, 10);
+    if (!Number.isNaN(p) && p > 0 && p <= 65535) return p;
+  }
+  for (const envFile of [".env.local", ".env.development", ".env"]) {
+    const fullPath = join5(projectRoot, envFile);
+    if (existsSync7(fullPath)) {
+      try {
+        const content = readFileSync5(fullPath, "utf-8");
+        for (const line of content.split("\n")) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+          const [key, ...rest] = trimmed.split("=");
+          const k = key.trim();
+          const val = rest.join("=").trim().replace(/^["']|["']$/g, "");
+          if (k === "PORT" || k === "VITE_PORT") {
+            const p = Number.parseInt(val, 10);
+            if (!Number.isNaN(p) && p > 0 && p <= 65535) return p;
+          }
+          if (k === "NEXT_PUBLIC_APP_URL" || k === "APP_URL") {
+            try {
+              const url = new URL(val);
+              if (url.port) return Number.parseInt(url.port, 10);
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const pkgPath = join5(projectRoot, "package.json");
+  if (existsSync7(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      const scripts = pkg.scripts || {};
+      for (const script of Object.values(scripts)) {
+        if (typeof script !== "string") continue;
+        const portMatch = script.match(/(?:-p|--port(?:=|\s+))(\d+)/);
+        if (portMatch) {
+          const p = Number.parseInt(portMatch[1], 10);
+          if (!Number.isNaN(p) && p > 0 && p <= 65535) return p;
+        }
+      }
+      const allDeps = {
+        ...pkg.dependencies || {},
+        ...pkg.devDependencies || {}
+      };
+      if ("astro" in allDeps) return 4321;
+      if ("vite" in allDeps) return 5173;
+    } catch {
+    }
+  }
+  for (const f of ["astro.config.mjs", "astro.config.ts", "astro.config.js"]) {
+    if (existsSync7(join5(projectRoot, f))) return 4321;
+  }
+  for (const f of [
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cjs"
+  ]) {
+    if (existsSync7(join5(projectRoot, f))) return 5173;
+  }
+  return void 0;
+}
+function detectTargetUrl(projectRoot) {
+  const port = detectTargetPort(projectRoot);
+  return port ? `http://localhost:${port}` : "http://localhost:3000";
+}
+function createDraftTestabilityContent(targetUrl = "http://localhost:3000") {
+  const doc = emptyTestability(targetUrl);
+  return serializeFrontmatter(doc.frontmatter, doc.body);
+}
 async function init(opts) {
   const options = typeof opts === "string" ? { name: opts } : opts ?? {};
   const projectRoot = process.cwd();
@@ -16454,12 +16757,86 @@ async function init(opts) {
     console.log();
   }
   let freshInit = false;
+  const backfilled = [];
   if (existsSync7(join5(iamuDir2, "config.json"))) {
-    const config2 = await readConfig(projectRoot);
-    if (!options.json) {
-      console.log(
-        chalk18.yellow("  iamu/ already exists") + chalk18.dim(` (${config2?.project_name ?? "unknown"})`)
+    const testabilityPath2 = join5(iamuDir2, "testability.md");
+    if (!existsSync7(testabilityPath2)) {
+      const targetUrl = detectTargetUrl(projectRoot);
+      await writeFile3(
+        testabilityPath2,
+        createDraftTestabilityContent(targetUrl)
+      );
+      backfilled.push("testability.md");
+    }
+    const contextPath2 = join5(iamuDir2, "context.yml");
+    if (!existsSync7(contextPath2)) {
+      await writeFile3(
+        contextPath2,
+        serializeFrontmatter(
+          { status: "draft", schema_version: 1, name: projectName },
+          ""
+        )
       );
+      backfilled.push("context.yml");
+    }
+    const gitignorePath = join5(iamuDir2, ".gitignore");
+    if (!existsSync7(gitignorePath)) {
+      await writeFile3(gitignorePath, GITIGNORE_CONTENT);
+      backfilled.push(".gitignore");
+    }
+    const cacheDirPath = join5(iamuDir2, ".cache");
+    if (!existsSync7(cacheDirPath)) {
+      await mkdir4(cacheDirPath, { recursive: true });
+      backfilled.push(".cache/");
+    }
+    const runsDirPath = join5(iamuDir2, ".runs");
+    if (!existsSync7(runsDirPath)) {
+      await mkdir4(runsDirPath, { recursive: true });
+    }
+    for (const type2 of ENTITY_TYPES) {
+      const sub = join5(iamuDir2, ENTITY_DIRS[type2]);
+      if (!existsSync7(sub)) {
+        await mkdir4(sub, { recursive: true });
+      }
+      const keep = join5(sub, ".gitkeep");
+      if (!existsSync7(keep)) {
+        try {
+          const files = await readdir(sub);
+          if (files.length === 0) {
+            await writeFile3(keep, "");
+          }
+        } catch {
+          await writeFile3(keep, "");
+        }
+      }
+    }
+    const promptTemplates2 = loadPromptTemplates();
+    const promptsDir2 = join5(iamuDir2, ".prompts");
+    const missingPrompts = [];
+    if (!existsSync7(promptsDir2)) {
+      missingPrompts.push(".prompts/");
+    } else {
+      for (const [name] of promptTemplates2) {
+        if (!existsSync7(join5(promptsDir2, name))) {
+          missingPrompts.push(name);
+        }
+      }
+    }
+    if (missingPrompts.length > 0) {
+      if (missingPrompts.includes(".prompts/")) {
+        backfilled.push(".prompts/");
+      } else {
+        backfilled.push(...missingPrompts.map((p) => `.prompts/${p}`));
+      }
+    }
+    if (!options.json) {
+      if (backfilled.length > 0) {
+        console.log(
+          `  ${symbols.success} Scaffolding verified (backfilled missing ${backfilled.join(", ")})`
+        );
+      } else {
+        console.log(`  ${symbols.success} Scaffolding up to date`);
+      }
     }
   } else {
     freshInit = true;
@@ -16475,33 +16852,12 @@ async function init(opts) {
         ""
       )
     );
-    const testabilityPath = join5(iamuDir2, "testability.md");
-    if (!existsSync7(testabilityPath)) {
+    const testabilityPath2 = join5(iamuDir2, "testability.md");
+    if (!existsSync7(testabilityPath2)) {
+      const targetUrl = detectTargetUrl(projectRoot);
       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)
-`
-        )
+        testabilityPath2,
+        createDraftTestabilityContent(targetUrl)
       );
     }
   }
@@ -16511,7 +16867,13 @@ Audited and populated during /iamu:init.
   for (const [name, content] of promptTemplates) {
     await writeFile3(join5(promptsDir, name), content);
   }
-  const detected = detectHosts(projectRoot);
+  const detectedInstalled = detectInstalledHosts(projectRoot);
+  const detectedWorkspace = detectHosts(projectRoot);
+  const detectedMap = /* @__PURE__ */ new Map();
+  for (const h of [...detectedInstalled, ...detectedWorkspace]) {
+    detectedMap.set(h.value, h);
+  }
+  const detected = Array.from(detectedMap.values());
   if (!options.json && detected.length > 0) {
     console.log(
       chalk18.dim("  Detected: ") + detected.map((h) => h.name).join(", ") + chalk18.dim(" (pre-selected)")
@@ -16620,6 +16982,7 @@ Audited and populated during /iamu:init.
           projectName,
           projectRoot,
           fresh: freshInit,
+          backfilled,
           tools: selectedHosts.map((h) => h.name),
           skillsCount: totalSkills,
           commandsCount: totalCommands,
@@ -16721,6 +17084,7 @@ var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_dist2();
+    init_dist();
     init_claude_plugin();
     init_registry();
     init_cloud_url();
@@ -16788,6 +17152,25 @@ async function status(opts) {
   const incompleteRuns = await listIncompleteRuns(projectRoot);
   const { rerun } = await computeFixStates(projectRoot);
   const staleSkills = await findStaleSkills(projectRoot);
+  let exploreSummary = null;
+  try {
+    const maps = await listExploreMaps(projectRoot);
+    if (maps.length > 0) {
+      const latestMapId = maps.at(-1);
+      const map2 = await readExploreMap(projectRoot, latestMapId);
+      if (map2) {
+        const steps = await readAllRunSteps(projectRoot);
+        const cov = exploreCoverage(map2, steps);
+        exploreSummary = {
+          map_id: latestMapId,
+          total_surfaces: cov.surfaces.length,
+          reached_surfaces: cov.reached,
+          unreached_surfaces: cov.unreached
+        };
+      }
+    }
+  } catch {
+  }
   if (opts.json) {
     console.log(
       JSON.stringify(
@@ -16811,6 +17194,7 @@ async function status(opts) {
             last: runs.at(-1) ?? null,
             incomplete: incompleteRuns
           },
+          explore: exploreSummary,
           rerun: rerun.map((r) => ({
             ...r,
             command: rerunCommand(projectRoot, r.scenario)
@@ -16898,6 +17282,11 @@ async function status(opts) {
       )
     );
   }
+  if (exploreSummary) {
+    console.log(
+      `  ${padRight("product map", 14)} ${chalk19.cyan(String(exploreSummary.total_surfaces))} surfaces (${chalk19.green(`${exploreSummary.reached_surfaces} reached`)} \xB7 ${chalk19.yellow(`${exploreSummary.unreached_surfaces} unreached`)})`
+    );
+  }
   if (projectStatus.requests && projectStatus.requests.open > 0) {
     console.log(
       chalk19.cyan(
@@ -17200,7 +17589,7 @@ var init_browse_driver = __esm({
 });
 
 // src/commands/step-numbering.ts
-import { open, readdir, unlink } from "fs/promises";
+import { open, readdir as readdir2, unlink } from "fs/promises";
 import path22 from "path";
 function stepFileName(stepNumber2) {
   return `${String(stepNumber2).padStart(3, "0")}.json`;
@@ -17209,7 +17598,7 @@ function stepLimitMessage(maxSteps, runId) {
   return `Step limit of ${maxSteps} reached for run "${runId}". To prevent runaway agent loops, step aborted. Complete the walk with \`iamu complete\` or increase the limit with --max-steps <n>.`;
 }
 async function peekNextStepNumber(stepsDir) {
-  const files = await readdir(stepsDir).catch(() => []);
+  const files = await readdir2(stepsDir).catch(() => []);
   let max = 0;
   for (const f of files) {
     const m = /^(\d+)\.json$/.exec(f);
@@ -18278,7 +18667,7 @@ async function checkTargetHealth(targetUrl) {
     const res = await fetch(targetUrl, {
       method: "GET",
       redirect: "manual",
-      signal: AbortSignal.timeout(3e3)
+      signal: AbortSignal.timeout(1e3)
     });
     if ([301, 302, 303, 307, 308].includes(res.status)) {
       const location = res.headers.get("location") || "";
@@ -18392,21 +18781,20 @@ async function checkProjectHarnesses(projectRoot) {
 }
 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 doc = await readTestability(projectRoot);
+    if (!doc) {
+      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 };
+    }
+    const { frontmatter } = doc;
+    const targetUrl = frontmatter.target_url;
     const details = [];
     if (targetUrl) details.push(`Target: ${targetUrl}`);
     if (frontmatter.dev_command) {
@@ -19403,6 +19791,19 @@ async function update(opts) {
       console.log(`  ${symbols.success} ${promptsUpdated} prompts updated`);
     }
   }
+  if (existsSync11(iamuDir2)) {
+    const testabilityPath2 = join8(iamuDir2, "testability.md");
+    if (!existsSync11(testabilityPath2)) {
+      const targetUrl = detectTargetUrl(projectRoot);
+      await writeFile4(
+        testabilityPath2,
+        createDraftTestabilityContent(targetUrl)
+      );
+      console.log(
+        `  ${symbols.success} Repaired testability contract: created iamu/testability.md (draft)`
+      );
+    }
+  }
   const { hosts: targetHosts, error } = resolveTargetHosts(
     projectRoot,
     opts?.host
@@ -19458,6 +19859,7 @@ var init_update = __esm({
     init_mcp_config();
     init_context4();
     init_skills();
+    init_init();
     init_templates();
   }
 });
@@ -19483,11 +19885,13 @@ function defaultFrontmatter(type2, id, slug, name, opts) {
       };
     case "outline": {
       const tests = Array.isArray(opts.humanTest) ? opts.humanTest : opts.humanTest ? [opts.humanTest] : [];
+      const additionalCaps = Array.isArray(opts.additionalCapabilities) ? opts.additionalCapabilities : typeof opts.additionalCapabilities === "string" ? opts.additionalCapabilities.split(",").map((s) => s.trim()).filter(Boolean) : [];
       return {
         ...base,
         title: name,
         ...description,
         ...opts.capability ? { primary_capability: opts.capability } : {},
+        ...additionalCaps.length > 0 ? { additional_capabilities: additionalCaps } : {},
         ...opts.tension ? { tension: opts.tension } : {},
         ...opts.narrative ? { narrative: opts.narrative } : {},
         ...tests.length > 0 ? {
@@ -19498,8 +19902,16 @@ function defaultFrontmatter(type2, id, slug, name, opts) {
         } : {}
       };
     }
-    case "capability":
-      return { ...base, title: name, ...description };
+    case "capability": {
+      const capPaths = Array.isArray(opts.paths) ? opts.paths : typeof opts.paths === "string" ? opts.paths.split(",").map((s) => s.trim()).filter(Boolean) : [];
+      return {
+        ...base,
+        title: name,
+        ...description,
+        ...capPaths.length > 0 ? { paths: capPaths } : {},
+        ...opts.area ? { area: opts.area.trim() } : {}
+      };
+    }
     case "source":
       return {
         ...base,
@@ -20094,7 +20506,6 @@ __export(explore_exports, {
   exploreList: () => exploreList,
   exploreRun: () => exploreRun
 });
-import { promises as fs28 } from "fs";
 import path26 from "path";
 import chalk27 from "chalk";
 function fail2(message, json2) {
@@ -20112,12 +20523,8 @@ function positiveInt(raw, fallback, flag) {
 }
 async function testabilityTarget2(projectRoot) {
   try {
-    const raw = await fs28.readFile(
-      path26.join(projectRoot, "iamu", "testability.md"),
-      "utf8"
-    );
-    const { frontmatter } = parseFrontmatter(raw);
-    return typeof frontmatter.target_url === "string" ? frontmatter.target_url : null;
+    const doc = await readTestability(projectRoot);
+    return doc?.frontmatter.target_url ?? null;
   } catch {
     return null;
   }
@@ -20299,8 +20706,17 @@ async function exploreCoverageCommand(mapId, opts) {
     return;
   }
   const cov = exploreCoverage(map2, await readAllRunSteps(ctx.projectRoot));
+  const capReport = await readCapabilityCoverage(ctx.projectRoot, cov);
   if (opts.json) {
-    console.log(JSON.stringify(cov));
+    console.log(
+      JSON.stringify({
+        ...cov,
+        ...capReport.capabilities.length > 0 ? {
+          capabilities: capReport.capabilities,
+          unassigned_surfaces: capReport.unassigned_surfaces
+        } : {}
+      })
+    );
     return;
   }
   console.log(
@@ -20310,26 +20726,122 @@ async function exploreCoverageCommand(mapId, opts) {
   console.log(
     `  ${chalk27.green(`${cov.reached} reached`)} \xB7 ${chalk27.yellow(`${cov.place_only} URL reached, view unclear`)} \xB7 ${chalk27.red(`${cov.unreached} never reached`)}`
   );
-  const section = (title, rows, color) => {
-    if (rows.length === 0) return;
-    console.log(`
-  ${color(title)}`);
-    for (const r of rows) {
+  if (capReport.capabilities.length > 0) {
+    console.log(chalk27.bold("\n  CAPABILITY COVERAGE"));
+    console.log(
+      chalk27.dim(
+        "  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+      )
+    );
+    console.log(
+      chalk27.dim(
+        `  ${"Capability".padEnd(24)} ${"Surfaces".padStart(8)}   ${"Coverage".padStart(8)}   ${"Scenarios (1\xB0 / 2\xB0)"}`
+      )
+    );
+    console.log(
+      chalk27.dim(
+        "  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+      )
+    );
+    for (const cap of capReport.capabilities) {
+      const title = cap.slug.padEnd(24);
+      const surfaces = `${cap.reached_surfaces}/${cap.total_surfaces}`.padStart(
+        8
+      );
+      const covStr = `${cap.coverage_pct}%`.padStart(8);
+      const scenarios = `${cap.primary_scenarios} / ${cap.secondary_scenarios}`;
+      const untestedFlag = cap.primary_scenarios === 0 && cap.unreached_surfaces > 0 ? chalk27.yellow("  (untested)") : "";
+      const covColored = cap.coverage_pct === 100 ? chalk27.green(covStr) : cap.coverage_pct === 0 ? chalk27.red(covStr) : chalk27.yellow(covStr);
       console.log(
-        `    ${r.key.padEnd(32)} ${r.label}${chalk27.dim(`  (depth ${r.depth})`)}`
+        `  ${title} ${surfaces}   ${covColored}   ${scenarios}${untestedFlag}`
       );
     }
-  };
-  section(
-    "Never reached by a run",
-    cov.surfaces.filter((s) => s.status === "unreached"),
-    chalk27.red
-  );
-  section(
-    "URL reached, but no step names this view",
-    cov.surfaces.filter((s) => s.status === "place_only"),
-    chalk27.yellow
-  );
+    if (capReport.unassigned_surfaces.length > 0) {
+      const unassigned = capReport.unassigned_surfaces;
+      const reached = unassigned.filter((s) => s.status === "reached").length;
+      const pct = Math.round(reached / unassigned.length * 100);
+      console.log(
+        chalk27.dim(
+          `  ${"(Unassigned)".padEnd(24)} ${`${reached}/${unassigned.length}`.padStart(8)}   ${`${pct}%`.padStart(8)}   -`
+        )
+      );
+    }
+    console.log(
+      chalk27.dim(
+        "  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+      )
+    );
+    const hasGaps = capReport.capabilities.some((c) => c.unreached_surfaces > 0) || capReport.unassigned_surfaces.some((s) => s.status !== "reached");
+    if (hasGaps) {
+      console.log(chalk27.red("\n  UNREACHED SURFACES (Gaps)"));
+      for (const cap of capReport.capabilities) {
+        const gaps = cap.surfaces.filter((s) => s.status !== "reached");
+        if (gaps.length === 0) continue;
+        console.log(`    ${chalk27.bold(cap.slug)}:`);
+        for (const s of gaps) {
+          console.log(
+            `      ${chalk27.red("\u25CB")} ${s.key.padEnd(32)} ${s.label}${chalk27.dim(` (depth ${s.depth})`)}`
+          );
+        }
+      }
+      const unassignedGaps = capReport.unassigned_surfaces.filter(
+        (s) => s.status !== "reached"
+      );
+      if (unassignedGaps.length > 0) {
+        console.log(chalk27.dim("    (Unassigned):"));
+        for (const s of unassignedGaps) {
+          console.log(
+            `      ${chalk27.dim("\u25CB")} ${s.key.padEnd(32)} ${s.label}${chalk27.dim(` (depth ${s.depth})`)}`
+          );
+        }
+      }
+    }
+    if (opts.all) {
+      console.log(chalk27.green("\n  REACHED SURFACES"));
+      for (const cap of capReport.capabilities) {
+        const reached = cap.surfaces.filter((s) => s.status === "reached");
+        if (reached.length === 0) continue;
+        console.log(`    ${chalk27.bold(cap.slug)}:`);
+        for (const s of reached) {
+          console.log(
+            `      ${chalk27.green("\u2713")} ${s.key.padEnd(32)} ${s.label}${chalk27.dim(` (depth ${s.depth})`)}`
+          );
+        }
+      }
+      const unassignedReached = capReport.unassigned_surfaces.filter(
+        (s) => s.status === "reached"
+      );
+      if (unassignedReached.length > 0) {
+        console.log(chalk27.dim("    (Unassigned):"));
+        for (const s of unassignedReached) {
+          console.log(
+            `      ${chalk27.green("\u2713")} ${s.key.padEnd(32)} ${s.label}${chalk27.dim(` (depth ${s.depth})`)}`
+          );
+        }
+      }
+    }
+  } else {
+    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}${chalk27.dim(`  (depth ${r.depth})`)}`
+        );
+      }
+    };
+    section(
+      "Never reached by a run",
+      cov.surfaces.filter((s) => s.status === "unreached"),
+      chalk27.red
+    );
+    section(
+      "URL reached, but no step names this view",
+      cov.surfaces.filter((s) => s.status === "place_only"),
+      chalk27.yellow
+    );
+  }
   if (cov.run_only_places.length > 0) {
     console.log(`
   ${chalk27.cyan("Walked by runs, not in the map")}`);
@@ -20889,17 +21401,13 @@ async function instructionsWalk(opts) {
   }
   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 doc = await readTestability(projectRoot);
+    if (doc) {
+      if (!targetUrl && doc.frontmatter.target_url) {
+        targetUrl = doc.frontmatter.target_url;
       }
-      const fromFm = Array.isArray(
-        frontmatter.untestable_boundaries
-      ) ? frontmatter.untestable_boundaries.filter(Boolean) : [];
-      const fromBody = extractUntestableBoundaries(body);
+      const fromFm = doc.frontmatter.untestable_boundaries ?? [];
+      const fromBody = extractUntestableBoundaries(doc.body);
       untestableBoundaries.push(
         ...Array.from(/* @__PURE__ */ new Set([...fromFm, ...fromBody]))
       );
@@ -21256,7 +21764,7 @@ var summary_exports = {};
 __export(summary_exports, {
   summaryCommand: () => summaryCommand
 });
-import { promises as fs29 } from "fs";
+import { promises as fs28 } from "fs";
 import path28 from "path";
 import chalk30 from "chalk";
 async function summaryCommand(runIdArg, opts) {
@@ -21283,7 +21791,7 @@ async function summaryCommand(runIdArg, opts) {
         }
         raw = Buffer.concat(chunks).toString("utf8");
       } else {
-        raw = await fs29.readFile(path28.resolve(projectRoot, opts.file), "utf8");
+        raw = await fs28.readFile(path28.resolve(projectRoot, opts.file), "utf8");
       }
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.what_worked)) {
@@ -21451,10 +21959,10 @@ __export(evaluate_exports, {
   evaluate: () => evaluate,
   evaluateRecord: () => evaluateRecord
 });
-import { promises as fs30 } from "fs";
+import { promises as fs29 } from "fs";
 import path29 from "path";
 import chalk32 from "chalk";
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 function formatIssues(error) {
   return error.issues.map(
     (i) => `${i.path.length > 0 ? i.path.join(".") : "(root)"}: ${i.message}`
@@ -21486,7 +21994,7 @@ async function evaluate(runId, opts) {
   const canonicalPath = path29.join(runDirPath, "canonical.json");
   let canonical;
   try {
-    const raw = await fs30.readFile(canonicalPath, "utf8");
+    const raw = await fs29.readFile(canonicalPath, "utf8");
     canonical = JSON.parse(raw);
   } catch {
     commandError(
@@ -21543,7 +22051,7 @@ async function evaluate(runId, opts) {
   };
   const prompt = composeJudgePrompt(input);
   const promptFilePath = opts?.promptFile ?? path29.join(runDirPath, "judge_prompt.md");
-  await fs30.writeFile(promptFilePath, prompt, "utf8");
+  await fs29.writeFile(promptFilePath, prompt, "utf8");
   if (opts?.json) {
     console.log(
       JSON.stringify(
@@ -21570,7 +22078,7 @@ async function evaluateRecord(runId, opts) {
   const canonicalPath = path29.join(runDirPath, "canonical.json");
   let canonical;
   try {
-    const raw = await fs30.readFile(canonicalPath, "utf8");
+    const raw = await fs29.readFile(canonicalPath, "utf8");
     canonical = JSON.parse(raw);
   } catch {
     commandError(`No canonical.json for run: ${runId}`, opts);
@@ -21592,7 +22100,7 @@ async function evaluateRecord(runId, opts) {
       }
       raw = Buffer.concat(chunks).toString("utf8");
     } else {
-      raw = await fs30.readFile(opts.file, "utf8");
+      raw = await fs29.readFile(opts.file, "utf8");
     }
     parsedFile = JSON.parse(raw);
   } catch (err) {
@@ -21715,28 +22223,28 @@ var init_evaluate = __esm({
     init_context4();
     init_live_run_client();
     init_view_results();
-    verdictValueSchema = z25.enum(["yes", "partial", "no", "not_applicable"]);
-    idList = z25.array(z25.string()).optional();
-    verdictEntrySchema = z25.object({
-      human_test_id: z25.string().min(1).optional(),
-      id: z25.string().min(1).optional(),
+    verdictValueSchema = z26.enum(["yes", "partial", "no", "not_applicable"]);
+    idList = z26.array(z26.string()).optional();
+    verdictEntrySchema = z26.object({
+      human_test_id: z26.string().min(1).optional(),
+      id: z26.string().min(1).optional(),
       verdict: verdictValueSchema,
-      reasoning: z25.string(),
+      reasoning: z26.string(),
       grounding_step_ids: idList,
       grounding_finding_ids: idList
     }).refine((v) => Boolean(v.human_test_id ?? v.id), {
       message: "must carry human_test_id (or id)",
       path: ["human_test_id"]
     });
-    verdictsFileSchema = z25.object({
-      verdicts: z25.array(verdictEntrySchema).optional(),
-      human_tests: z25.array(verdictEntrySchema).optional(),
-      overall: z25.object({ answer: z25.string(), reasoning: z25.string() }).passthrough().optional(),
-      provenance: z25.object({
-        judge_mode: z25.string().optional(),
-        prompt_id: z25.string().optional(),
-        prompt_version: z25.string().optional(),
-        model: z25.string().optional()
+    verdictsFileSchema = z26.object({
+      verdicts: z26.array(verdictEntrySchema).optional(),
+      human_tests: z26.array(verdictEntrySchema).optional(),
+      overall: z26.object({ answer: z26.string(), reasoning: z26.string() }).passthrough().optional(),
+      provenance: z26.object({
+        judge_mode: z26.string().optional(),
+        prompt_id: z26.string().optional(),
+        prompt_version: z26.string().optional(),
+        model: z26.string().optional()
       }).passthrough().optional()
     });
   }
@@ -21764,7 +22272,7 @@ __export(complete_exports, {
   screenshotSizeWarning: () => screenshotSizeWarning,
   validateCanonicalWalkthrough: () => validateCanonicalWalkthrough
 });
-import { promises as fs31 } from "fs";
+import { promises as fs30 } from "fs";
 import path30 from "path";
 import chalk33 from "chalk";
 async function complete(runId, opts) {
@@ -21791,7 +22299,7 @@ async function complete(runId, opts) {
   const walkerSummary = await readWalkerSummary(run.runDirPath);
   let judgeReported;
   try {
-    const verdictsRaw = await fs31.readFile(
+    const verdictsRaw = await fs30.readFile(
       path30.join(run.runDirPath, "verdicts.json"),
       "utf8"
     );
@@ -21844,7 +22352,7 @@ async function loadRun(runId, opts) {
   if (!resolved) return null;
   const { projectRoot, runDirPath } = resolved;
   try {
-    await fs31.access(runDirPath);
+    await fs30.access(runDirPath);
   } catch {
     commandError(`Run not found: ${runId}`, opts);
     return null;
@@ -21853,7 +22361,7 @@ async function loadRun(runId, opts) {
   let manifest;
   try {
     manifest = JSON.parse(
-      await fs31.readFile(manifestPath, "utf8")
+      await fs30.readFile(manifestPath, "utf8")
     );
   } catch {
     commandError(`No walkthrough.json found for run: ${runId}`, opts);
@@ -21865,7 +22373,7 @@ async function reportAlreadyCompleted(run, opts) {
   const { runId, manifest } = run;
   if (opts?.json) {
     try {
-      const raw = await fs31.readFile(
+      const raw = await fs30.readFile(
         path30.join(run.runDirPath, "canonical.json"),
         "utf8"
       );
@@ -22055,14 +22563,14 @@ async function screenshotSizeWarning(runDirPath, viewport) {
   const dir = path30.join(runDirPath, "screenshots");
   let first;
   try {
-    first = (await fs31.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 fs31.open(path30.join(dir, first), "r");
+    const handle = await fs30.open(path30.join(dir, first), "r");
     try {
       const head = Buffer.alloc(24);
       const { bytesRead } = await handle.read(head, 0, 24, 0);
@@ -22079,7 +22587,7 @@ async function screenshotSizeWarning(runDirPath, viewport) {
 async function readWalkerSummary(runDirPath) {
   try {
     const data = JSON.parse(
-      await fs31.readFile(path30.join(runDirPath, "summary.json"), "utf8")
+      await fs30.readFile(path30.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;
@@ -22188,7 +22696,7 @@ function validateCanonicalWalkthrough(canonical) {
 async function applyRecordedVerdicts(canonical, runDirPath) {
   try {
     const recorded = JSON.parse(
-      await fs31.readFile(path30.join(runDirPath, "verdicts.json"), "utf8")
+      await fs30.readFile(path30.join(runDirPath, "verdicts.json"), "utf8")
     );
     if (Array.isArray(recorded.verdicts)) {
       return applyVerdicts(canonical, recorded);
@@ -22376,14 +22884,14 @@ __export(match_exports, {
   match: () => match,
   matchRecord: () => matchRecord
 });
-import { promises as fs32 } from "fs";
+import { promises as fs31 } from "fs";
 import path31 from "path";
 import chalk34 from "chalk";
 async function completedManifest2(runDirPath, runId, opts) {
   let manifest;
   try {
     manifest = JSON.parse(
-      await fs32.readFile(path31.join(runDirPath, "walkthrough.json"), "utf8")
+      await fs31.readFile(path31.join(runDirPath, "walkthrough.json"), "utf8")
     );
   } catch {
     commandError(`Run not found: ${runId}`, opts);
@@ -22414,10 +22922,10 @@ async function match(runId, opts) {
   const prompt = needed ? composeMatchPrompt(input) : null;
   const promptFilePath = opts?.promptFile ?? path31.join(runDirPath, "match_prompt.md");
   if (prompt) {
-    await fs32.writeFile(promptFilePath, prompt, "utf8");
+    await fs31.writeFile(promptFilePath, prompt, "utf8");
   } else {
     try {
-      await fs32.unlink(promptFilePath);
+      await fs31.unlink(promptFilePath);
     } catch {
     }
   }
@@ -22471,7 +22979,7 @@ async function matchRecord(runId, opts) {
       }
       raw = Buffer.concat(chunks).toString("utf8");
     } else {
-      raw = await fs32.readFile(opts.file, "utf8");
+      raw = await fs31.readFile(opts.file, "utf8");
     }
     answer = JSON.parse(raw);
   } catch (err) {
@@ -22851,6 +23359,12 @@ function registerProjectCommands(program) {
     "--description <text>",
     "One-line description (capability, outline)"
   ).option("--capability <slug>", "Primary capability slug (outline only)").option(
+    "--additional-capabilities <slugs>",
+    "Secondary capability slugs, comma-separated (outline only)"
+  ).option(
+    "--paths <paths>",
+    "Route patterns owned by this capability, comma-separated (capability only)"
+  ).option("--area <name>", "Visual grouping category (capability only)").option(
     "--tension <text>",
     "Structural tension driving this situation (outline only)"
   ).option(
@@ -22912,10 +23426,12 @@ Examples:
   );
   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);
-  });
+  ).option("--json", "Output as JSON").option("--all", "List all surfaces, including reached ones").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));