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

package/dist/bin.js

@@ -522,6 +522,7 @@ var init_finding = __esm({
     DISMISS_REASONS = [
       "not_relevant",
       "walker_error",
+      "out_of_scope",
       "duplicate"
     ];
     dismissReasonSchema = z9.enum(DISMISS_REASONS);
@@ -571,11 +572,12 @@ var init_finding = __esm({
       addressed_at: isoTimestamp.nullish(),
       /**
        * Why a `dismissed` finding was dismissed: `not_relevant` (by design,
-       * out of scope), `walker_error` (the walker misread the product) or
-       * `duplicate`. Absent means `not_relevant`. The first two also create
-       * a tester guidance rule.
+       * out of scope), `walker_error` (the walker misread the product),
+       * `out_of_scope` or `duplicate`. Absent means `not_relevant`.
        */
       dismiss_reason: dismissReasonSchema.nullish(),
+      /** Finding slug or id this repeats when `dismiss_reason` is `duplicate`. */
+      duplicate_of: z9.string().nullish(),
       /**
        * The active tester guidance rule this finding matches, set by
        * `iamu match-record`. The finding is kept — the rule flagged it,
@@ -698,7 +700,11 @@ var init_guidance = __esm({
   "../../packages/protocol/dist/schemas/frontmatter/guidance.js"() {
     "use strict";
     init_common();
-    GUIDANCE_KINDS = ["not_relevant", "walker_error"];
+    GUIDANCE_KINDS = [
+      "not_relevant",
+      "walker_error",
+      "out_of_scope"
+    ];
     guidanceKindSchema = z10.enum(GUIDANCE_KINDS);
     guidanceStatusSchema = z10.enum(["active", "retired"]);
     guidanceScopeSchema = z10.object({
@@ -1598,6 +1604,7 @@ var init_walkthrough_canonical = __esm({
     canonicalStepSchema = z22.object({
       id: z22.string(),
       step_number: z22.number().int(),
+      timestamp: z22.string().optional(),
       url: z22.string().optional(),
       /** The walker's short name for the screen. */
       surface: z22.string().optional(),
@@ -5835,9 +5842,9 @@ function pidIsDead(rec) {
 async function isStale(lockPath, rec, staleMs, now) {
   if (rec === null) {
     try {
-      const stat3 = await fs6.stat(lockPath);
-      if (stat3.size === 0) {
-        const mtime = stat3.birthtimeMs && stat3.birthtimeMs > 0 ? stat3.birthtimeMs : stat3.mtimeMs;
+      const stat4 = await fs6.stat(lockPath);
+      if (stat4.size === 0) {
+        const mtime = stat4.birthtimeMs && stat4.birthtimeMs > 0 ? stat4.birthtimeMs : stat4.mtimeMs;
         if (now - mtime <= staleMs) {
           return false;
         }
@@ -6838,13 +6845,13 @@ function fenceTracker() {
   };
 }
 function cleanName(raw, legacy) {
-  let s = raw.replace(/\s+#+\s*$/, "").replace(/[*_`]/g, "").replace(/[‘’]/g, "'").replace(/[“”]/g, '"').replace(/\s+/g, " ").trim();
+  let s = raw.replace(/\\(["'])/g, "$1").replace(/\s+#+\s*$/, "").replace(/[*_`]/g, "").replace(/[‘’]/g, "'").replace(/[“”]/g, '"').replace(/\s+/g, " ").trim();
   if (legacy)
     s = s.replace(LEGACY_ID, "");
-  return s.replace(/[.:]+$/, "").trim();
+  return s.replace(/[.:—–-]+$/, "").trim();
 }
 function normaliseRuleName(raw, legacy = false) {
-  return cleanName(raw, legacy).toLowerCase();
+  return cleanName(raw, legacy).replace(/["'\\]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
 }
 function scanLines(text) {
   const inFence = fenceTracker();
@@ -6913,7 +6920,7 @@ function rulesInText(text, opts = {}) {
       continue;
     if (l.heading) {
       const { level, text: h } = l.heading;
-      if (level >= 2 && level <= 4) {
+      if (level >= 2 && level <= 5) {
         let end2 = i + 1;
         while (end2 < to) {
           const next = lines[end2].heading;
@@ -6932,25 +6939,30 @@ function rulesInText(text, opts = {}) {
       headings.push(l.heading);
       continue;
     }
-    const item = LIST_ITEM.exec(l.text);
-    const rest = item ? l.text.slice(item[0].length) : l.text.trimStart();
+    const unquoted = l.text.replace(/^\s*>\s?/, "");
+    const item = LIST_ITEM.exec(unquoted);
+    const rest = item ? unquoted.slice(item[0].length) : unquoted.trimStart();
     const bold = BOLD_LEAD.exec(rest);
     if (!bold)
       continue;
     const inner = bold[2].trim();
-    if (!/[.:]$/.test(inner) && !bold[3])
+    const afterBold = rest.slice(bold[0].length);
+    const hasStop = /[.:!?—–]$/.test(inner) || Boolean(bold[3]) || afterBold.trim() === "";
+    if (!hasStop)
       continue;
     const prev = i === 0 ? null : lines[i - 1];
-    const startsParagraph = !prev || prev.text.trim() === "" || Boolean(prev.heading);
+    const prevUnquoted = prev ? prev.text.replace(/^\s*>\s?/, "") : "";
+    const startsParagraph = !prev || prevUnquoted.trim() === "" || Boolean(prev.heading);
     if (!item && !startsParagraph)
       continue;
     const indent = item ? item[1].length : 0;
     let end = i + 1;
     while (end < to) {
       const n = lines[end];
-      if (n.heading || !n.fenced && n.text.trim() === "")
+      const nUnquoted = n.text.replace(/^\s*>\s?/, "");
+      if (n.heading || !n.fenced && nUnquoted.trim() === "")
         break;
-      const nItem = LIST_ITEM.exec(n.text);
+      const nItem = LIST_ITEM.exec(nUnquoted);
       if (item && nItem && nItem[1].length <= indent)
         break;
       end++;
@@ -6975,7 +6987,19 @@ function matchRuleName(rules, citation, legacy = false) {
     section: normaliseRuleName(citation.slice(0, at), legacy),
     name: normaliseRuleName(citation.slice(at + 1), legacy)
   } : null;
-  return rules.filter((r) => r.name.toLowerCase() === whole || scoped !== null && r.name.toLowerCase() === scoped.name && (r.section ?? "").toLowerCase() === scoped.section);
+  const exact = rules.filter((r) => {
+    const rName = normaliseRuleName(r.name, legacy);
+    const rSec = normaliseRuleName(r.section ?? "", legacy);
+    return rName === whole || scoped !== null && rName === scoped.name && rSec === scoped.section;
+  });
+  if (exact.length > 0)
+    return exact;
+  const leadOf = (s) => normaliseRuleName(s.split(/\s*(?::|—|–|\s-\s)\s*/)[0] ?? "", legacy);
+  return rules.filter((r) => {
+    const rLead = leadOf(r.name);
+    const rSec = normaliseRuleName(r.section ?? "", legacy);
+    return rLead.length > 0 && rLead === whole || scoped !== null && rLead.length > 0 && rLead === scoped.name && rSec === scoped.section;
+  });
 }
 async function findRule(entries, citation) {
   const seen = /* @__PURE__ */ new Map();
@@ -7009,6 +7033,27 @@ async function citationFor(entries, match2) {
   const alone = await findRule(entries, { rule: match2.name, file: match2.file });
   return alone.length === 1 || !match2.section ? match2.name : `${match2.section} > ${match2.name}`;
 }
+async function canonicalRulesInFile(file) {
+  if (file.kind !== "design")
+    return [];
+  let text;
+  try {
+    text = await fs10.readFile(file.abs, "utf8");
+  } catch {
+    return [];
+  }
+  const legacy = file.path === LEGACY_DESIGN_DOC;
+  const rules = rulesInText(text, { legacy, heading: file.heading }) ?? [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of rules) {
+    const key = normaliseRuleName(r.name, legacy);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return rules.map((r) => {
+    const key = normaliseRuleName(r.name, legacy);
+    return (counts.get(key) ?? 0) === 1 || !r.section ? r.name : `${r.section} > ${r.name}`;
+  });
+}
 async function resolveRule(entries, citation) {
   const matches = await findRule(entries, citation);
   if (matches.length === 1)
@@ -7035,7 +7080,7 @@ var init_design_rules = __esm({
     LEGACY_ID = new RegExp(`^${LEGACY_ID_PATTERN}\\s+`);
     HEADING = /^(#{1,6})\s+(.+?)\s*$/;
     LIST_ITEM = /^(\s*)(?:[-*+]|\d+[.)])\s+/;
-    BOLD_LEAD = /^(\*\*|__)(.+?)\1\s*([.:])?/;
+    BOLD_LEAD = /^(\*\*|__)(.+?)\1(?:\s*([.:—–]|\s-\s))?/;
     sameFile = (f, file) => {
       const want = file.trim().replace(/\\/g, "/");
       return f.entry === want || f.path === want;
@@ -7723,15 +7768,15 @@ async function entryProblem(projectRoot, entry) {
   if (!isInsideProjectRoot(projectRoot, abs)) {
     return `Path escapes project root: ${rel}`;
   }
-  let stat3;
+  let stat4;
   try {
-    stat3 = await fs13.stat(abs);
+    stat4 = await fs13.stat(abs);
   } catch {
     return `Not found: ${rel}`;
   }
   if (!heading)
     return null;
-  if (!stat3.isFile())
+  if (!stat4.isFile())
     return `${rel} is a folder; a section needs a file`;
   const text = await fs13.readFile(abs, "utf8");
   if (sectionLines(text, heading))
@@ -8707,7 +8752,14 @@ async function isProposalStale(projectRoot, p) {
 }
 async function readDesignContext(projectRoot, opts = {}) {
   const state = await readDesignSources(projectRoot);
-  const files = selectDesignFiles(state.file.files, opts.urls).map((e) => resolveDesignFile(projectRoot, e));
+  const files = await Promise.all(selectDesignFiles(state.file.files, opts.urls).map(async (e) => {
+    const resolved = resolveDesignFile(projectRoot, e);
+    if (resolved.kind === "design") {
+      const rules = await canonicalRulesInFile(resolved);
+      return rules.length > 0 ? { ...resolved, rules } : resolved;
+    }
+    return resolved;
+  }));
   const proposals = [];
   for (const p of await listDesignProposals(projectRoot)) {
     proposals.push({
@@ -9636,7 +9688,7 @@ async function suppressionRules(projectRoot, outlineSlug) {
   if (!outlineSlug)
     return [];
   try {
-    return (await activeGuidanceFor(projectRoot, { outline: outlineSlug })).filter((r) => r.kind === "not_relevant").map((r) => ({ id: r.id, rule: r.rule }));
+    return (await activeGuidanceFor(projectRoot, { outline: outlineSlug })).filter((r) => r.kind === "not_relevant" || r.kind === "out_of_scope").map((r) => ({ id: r.id, rule: r.rule }));
   } catch {
     return [];
   }
@@ -10537,6 +10589,63 @@ async function readDesignerIgnored(projectRoot) {
   return readForWrite(projectRoot).catch(() => []);
 }
 async function ignoreDesignerIssue(projectRoot, runId, issueId, opts = {}) {
+  const reasonGiven = opts.reason?.trim() || null;
+  const when = opts.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const cascadeDismissSiblings = async (targetFm, note) => {
+    const cid = targetFm.canonical_id;
+    if (!cid)
+      return;
+    const { entities } = await listEntities(projectRoot, "finding").catch(() => ({ entities: [] }));
+    for (const sibling of entities) {
+      if (sibling.frontmatter.id === targetFm.id)
+        continue;
+      if (sibling.frontmatter.canonical_id !== cid)
+        continue;
+      if (sibling.frontmatter.triage_status === "dismissed")
+        continue;
+      await writeEntity(projectRoot, "finding", {
+        ...sibling.frontmatter,
+        triage_status: "dismissed",
+        dismiss_reason: "not_relevant",
+        triage_note: note,
+        updated_at: when
+      }, sibling.body);
+    }
+  };
+  const trimmedRef = issueId.trim().toUpperCase();
+  if (/^P\d+$/.test(trimmedRef)) {
+    const refs2 = await fs21.readFile(designerRefsFile(runDir(projectRoot, runId)), "utf8").then((raw) => JSON.parse(raw)).catch(() => null);
+    const findingId = refs2?.[trimmedRef];
+    const pFile = findingId ? await readEntity(projectRoot, "finding", findingId).catch(() => null) : null;
+    if (!pFile) {
+      throw new DesignerRecordError("unknown_designer_finding", `${runId} has no designer finding ${issueId}`);
+    }
+    const already = pFile.frontmatter.triage_status === "dismissed";
+    const note = reasonGiven ?? (pFile.frontmatter.triage_note?.trim() || "Dismissed via iamu designer-dismiss");
+    if (!already || reasonGiven && reasonGiven !== pFile.frontmatter.triage_note) {
+      await writeEntity(projectRoot, "finding", {
+        ...pFile.frontmatter,
+        triage_status: "dismissed",
+        dismiss_reason: "not_relevant",
+        triage_note: note,
+        updated_at: when
+      }, pFile.body);
+      await cascadeDismissSiblings(pFile.frontmatter, note);
+    }
+    return {
+      entry: {
+        title: pFile.frontmatter.title ?? pFile.frontmatter.slug,
+        screen: pFile.frontmatter.screen ?? null,
+        what: pFile.frontmatter.what ?? "",
+        severity: pFile.frontmatter.severity ?? void 0,
+        reason: reasonGiven ?? pFile.frontmatter.triage_note ?? null,
+        run: runId,
+        issue: trimmedRef,
+        at: when
+      },
+      already
+    };
+  }
   const record = await readDesignerRecord(projectRoot, runId);
   if (!record) {
     throw new DesignerRecordError("not_judged", `Run ${runId} has no designer's review to dismiss a finding of`);
@@ -10546,8 +10655,6 @@ async function ignoreDesignerIssue(projectRoot, runId, issueId, opts = {}) {
   if (!issue) {
     throw new DesignerRecordError("unknown_designer_finding", `${runId} has no designer finding ${issueId}`);
   }
-  const reasonGiven = opts.reason?.trim() || null;
-  const when = opts.now ?? (/* @__PURE__ */ new Date()).toISOString();
   const file = issue.finding_id ? await readEntity(projectRoot, "finding", issue.finding_id).catch(() => null) : null;
   if (file) {
     const already = file.frontmatter.triage_status === "dismissed";
@@ -10560,6 +10667,7 @@ async function ignoreDesignerIssue(projectRoot, runId, issueId, opts = {}) {
         triage_note: note,
         updated_at: when
       }, file.body);
+      await cascadeDismissSiblings(file.frontmatter, note);
     }
     return {
       entry: {
@@ -10926,6 +11034,7 @@ async function buildCanonical(projectRoot, manifest, completedAt, inputs) {
     return {
       id: `step-${stepNum}`,
       step_number: stepNum,
+      ...typeof s.timestamp === "string" && s.timestamp ? { timestamp: s.timestamp } : {},
       screen_title: s.action,
       // Step files record the path relative to the run directory
       // (`screenshots/step-1.png`); older ones recorded the bare file
@@ -11424,7 +11533,7 @@ async function assembleWalkthroughBundle(projectRoot, runId, opts = {}) {
       scenarioIdForPush = manifest.scenario_slug;
     }
   }
-  const bundleSteps = steps2.map((s) => {
+  const bundleSteps = steps2.map((s, idx) => {
     const shot = screenshots.get(s.step_number);
     const ref = shot ? {
       part_name: `screenshot_${s.step_number}`,
@@ -11432,7 +11541,7 @@ async function assembleWalkthroughBundle(projectRoot, runId, opts = {}) {
       content_type: shot.contentType
     } : null;
     return {
-      seq: s.step_number,
+      seq: idx + 1,
       title: s.action,
       persona_reasoning: s.note ?? null,
       grounding: s.grounding ?? null,
@@ -17054,9 +17163,9 @@ function withSessionStateLock(filePath, fn) {
     const now = Date.now();
     if (rec === null) {
       try {
-        const stat3 = statSync(targetPath);
-        if (stat3.size === 0) {
-          const mtime = stat3.birthtimeMs && stat3.birthtimeMs > 0 ? stat3.birthtimeMs : stat3.mtimeMs;
+        const stat4 = statSync(targetPath);
+        if (stat4.size === 0) {
+          const mtime = stat4.birthtimeMs && stat4.birthtimeMs > 0 ? stat4.birthtimeMs : stat4.mtimeMs;
           if (now - mtime <= staleMs)
             return false;
         }
@@ -18673,7 +18782,12 @@ async function buildSurfaceDossier(projectRoot, target, opts = {}) {
     seenDismissed.add(d.title);
     return true;
   });
-  const guidance = (await listEntities(projectRoot, "guidance")).entities.filter((g) => (g.frontmatter.status ?? "active") === "active").map((g) => g.body.trim().split(/\n\s*\n/)[0] ?? "").filter(Boolean);
+  const guidance = (await listEntities(projectRoot, "guidance")).entities.filter((g) => (g.frontmatter.status ?? "active") === "active").map((g) => {
+    const { rule, reason } = parseGuidanceBody(g.body);
+    if (!rule)
+      return "";
+    return reason ? `${rule} (${reason})` : rule;
+  }).filter(Boolean);
   const ids = new Set(allOnSurface.map((r) => r.fm.id));
   const directions = (await listDirections(projectRoot)).filter((d) => d.frontmatter.status !== "rejected" && d.frontmatter.absorbs.some((id) => ids.has(id))).map((d) => ({
     slug: d.frontmatter.slug,
@@ -20517,6 +20631,23 @@ async function buildRunDesignerInput(projectRoot, runId) {
   const ended = summary?.ended;
   const testability = testabilityPath(projectRoot);
   const pfm = persona?.frontmatter;
+  const outlineSlug = outline?.frontmatter.slug ?? scenario?.frontmatter.outline ?? null;
+  const guidanceRules = outlineSlug ? await activeGuidanceFor(projectRoot, { outline: outlineSlug }).catch(() => []) : (await listEntities(projectRoot, "guidance").catch(() => ({ entities: [] }))).entities.filter((g) => (g.frontmatter.status ?? "active") === "active").map((g) => {
+    const { rule, reason: reason2 } = parseGuidanceBody(g.body);
+    return { rule, reason: reason2 };
+  }).filter((g) => Boolean(g.rule));
+  const guidance = guidanceRules.map((r) => r.reason ? `${r.rule} (${r.reason})` : r.rule);
+  const designFiles = await Promise.all(docs.map(async (f) => {
+    const rules = f.kind === "design" ? f.rules ?? await canonicalRulesInFile(f) : void 0;
+    return {
+      entry: f.entry,
+      kind: f.kind,
+      abs: f.abs,
+      heading: f.heading,
+      applies_to: f.applies_to,
+      ...rules && rules.length > 0 ? { rules } : {}
+    };
+  }));
   const bundle = {
     run_id: runId,
     project_root: projectRoot,
@@ -20541,13 +20672,7 @@ async function buildRunDesignerInput(projectRoot, runId) {
       ended: ended && typeof ended.note === "string" ? { reached: ended.reached === true, note: ended.note } : null
     } : null,
     design: docs.length > 0 || proposals.length > 0 ? {
-      files: docs.map((f) => ({
-        entry: f.entry,
-        kind: f.kind,
-        abs: f.abs,
-        heading: f.heading,
-        applies_to: f.applies_to
-      })),
+      files: designFiles,
       proposals: proposals.map((p) => ({
         slug: p.slug,
         kind: p.kind,
@@ -20575,6 +20700,7 @@ async function buildRunDesignerInput(projectRoot, runId) {
         reason: e.reason
       }))
     ],
+    guidance,
     facts: context?.facts ? designerFacts(context.facts) : null,
     setup_notes: {
       file: existsSync5(testability) ? testability : null,
@@ -20623,6 +20749,9 @@ var init_designer_input = __esm({
     init_advice_input();
     init_design_facts();
     init_design_proposals();
+    init_design_rules();
+    init_entity();
+    init_guidance2();
     init_paths();
     init_review_issues();
     init_url_path();
@@ -20630,6 +20759,7 @@ var init_designer_input = __esm({
     init_designer_ignored();
     init_designer_ledger();
     init_walkthrough_canonical2();
+    init_dist();
     LONG_VISIT = 6;
     FRAMES_PER_VISIT = 8;
     FRAMES_PER_RUN = 24;
@@ -21941,15 +22071,15 @@ function resolveApiUrl(configured) {
   assertSecureApiUrl(url, configured ? "API URL" : "IAMU_API_URL");
   return url;
 }
-function parseStore(raw, path73) {
+function parseStore(raw, path74) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new CredentialsFileError(path73, "not valid JSON", err);
+    throw new CredentialsFileError(path74, "not valid JSON", err);
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new CredentialsFileError(path73, "expected a JSON object");
+    throw new CredentialsFileError(path74, "expected a JSON object");
   }
   return parsed;
 }
@@ -21957,26 +22087,26 @@ function isNotFound(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
 async function readCredentialsStore() {
-  const path73 = getCredentialsPath();
+  const path74 = getCredentialsPath();
   let raw;
   try {
-    raw = await readFile(path73, "utf-8");
+    raw = await readFile(path74, "utf-8");
   } catch (err) {
     if (isNotFound(err)) return {};
     warnUnreadableStoreOnce(err);
     throw err;
   }
   try {
-    return parseStore(raw, path73);
+    return parseStore(raw, path74);
   } catch (err) {
     warnUnreadableStoreOnce(err);
     throw err;
   }
 }
 async function writeCredentialsStore(store) {
-  const path73 = getCredentialsPath();
-  await mkdir(dirname(path73), { recursive: true, mode: 448 });
-  await atomicWriteFile(path73, `${JSON.stringify(store, null, 2)}
+  const path74 = getCredentialsPath();
+  await mkdir(dirname(path74), { recursive: true, mode: 448 });
+  await atomicWriteFile(path74, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
@@ -22004,16 +22134,16 @@ function resolveApiKey(apiUrl) {
     }
   }
   const normalized = url.replace(/\/+$/, "");
-  for (const path73 of candidatePaths) {
+  for (const path74 of candidatePaths) {
     let raw;
     try {
-      raw = readFileSync2(path73, "utf-8");
+      raw = readFileSync2(path74, "utf-8");
     } catch (err) {
       if (!isNotFound(err)) warnUnreadableStoreOnce(err);
       continue;
     }
     try {
-      const store = parseStore(raw, path73);
+      const store = parseStore(raw, path74);
       const entry = store[url] ?? store[normalized] ?? store[`${normalized}/`];
       if (typeof entry !== "object" || entry === null) continue;
       const token = entry.token;
@@ -22054,12 +22184,12 @@ var init_credentials = __esm({
        * @param reason - What is wrong with it.
        * @param cause - Underlying parse error, if any.
        */
-      constructor(path73, reason, cause) {
+      constructor(path74, reason, cause) {
         super(
-          `Credentials file ${path73} is corrupt (${reason}). Fix it by hand, or delete it and run \`iamu auth login\` again.`,
+          `Credentials file ${path74} is corrupt (${reason}). Fix it by hand, or delete it and run \`iamu auth login\` again.`,
           {
             cause,
-            suggestedAction: `Delete ${path73} and run \`iamu auth login\`, or set IAMU_TOKEN.`
+            suggestedAction: `Delete ${path74} and run \`iamu auth login\`, or set IAMU_TOKEN.`
           }
         );
       }
@@ -23028,8 +23158,8 @@ import { dirname as dirname3, join as join5, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk6 from "chalk";
 function getVersion() {
-  if ("0.8.0-beta.2") {
-    return "0.8.0-beta.2";
+  if ("0.8.0-beta.3") {
+    return "0.8.0-beta.3";
   }
   try {
     const thisDir = dirname3(fileURLToPath2(import.meta.url));
@@ -23141,16 +23271,16 @@ async function needsWrite(filePath, content) {
     return true;
   }
 }
-function isCliWrittenSkill(path73) {
+function isCliWrittenSkill(path74) {
   try {
-    return /^generatedBy:/m.test(readFileSync6(path73, "utf-8"));
+    return /^generatedBy:/m.test(readFileSync6(path74, "utf-8"));
   } catch {
     return false;
   }
 }
-function isCliWrittenPrompt(path73) {
+function isCliWrittenPrompt(path74) {
   try {
-    const content = readFileSync6(path73, "utf-8");
+    const content = readFileSync6(path74, "utf-8");
     return /^generatedBy:/m.test(content) || /^#\s+iamu:/m.test(content) || /^description:\s*.*iamu/im.test(content);
   } catch {
     return false;
@@ -23162,8 +23292,8 @@ function planSkillFiles(hosts, projectRoot, version2) {
   for (const host of hosts) {
     if (pluginProvidesSkills(host, projectRoot)) {
       for (const name of skillTemplates.keys()) {
-        const path73 = join5(host.getSkillsDir(projectRoot), name, "SKILL.md");
-        if (isCliWrittenSkill(path73)) files.push({ host, path: path73, content: null });
+        const path74 = join5(host.getSkillsDir(projectRoot), name, "SKILL.md");
+        if (isCliWrittenSkill(path74)) files.push({ host, path: path74, content: null });
       }
     } else if (host.supportsSkills) {
       const skillsDir = host.getSkillsDir(projectRoot);
@@ -25193,13 +25323,13 @@ function git(args2, cwd) {
 }
 function hashFile(absPath) {
   const hash = createHash5("sha256");
-  const stat3 = lstatSync(absPath);
-  if (stat3.isSymbolicLink()) {
+  const stat4 = lstatSync(absPath);
+  if (stat4.isSymbolicLink()) {
     hash.update(`symlink:${readlinkSync(absPath)}`);
     return hash.digest("hex");
   }
-  if (!stat3.isFile()) {
-    hash.update(`${stat3.isDirectory() ? "dir" : "other"}`);
+  if (!stat4.isFile()) {
+    hash.update(`${stat4.isDirectory() ? "dir" : "other"}`);
     return hash.digest("hex");
   }
   const fd = openSync3(absPath, "r");
@@ -31460,12 +31590,20 @@ function awaitingSteps(projectRoot, findings2) {
 }
 function defaultRule(kind, findings2) {
   const titles = findings2.map((f) => f.frontmatter.title ?? f.frontmatter.ui_fact ?? f.slug).join("; ");
-  return kind === "walker_error" ? `Earlier walkers got this wrong: ${titles}` : `Don't report: ${titles}`;
+  if (kind === "walker_error") {
+    return `Earlier walkers got this wrong: ${titles}`;
+  }
+  if (kind === "out_of_scope") {
+    return `Handled outside system; don't report: ${titles}`;
+  }
+  return `Don't report: ${titles}`;
 }
 async function resolveScope(projectRoot, flag, findings2, opts) {
   if (flag === "project") return {};
+  const withScenario = findings2.filter((f) => Boolean(f.frontmatter.scenario));
+  if (withScenario.length === 0) return {};
   const outlines = /* @__PURE__ */ new Set();
-  for (const f of findings2) {
+  for (const f of withScenario) {
     const scenario = await safeReadEntity(
       projectRoot,
       "scenario",
@@ -31506,6 +31644,47 @@ async function resolveScope(projectRoot, flag, findings2, opts) {
   }
   return { capability };
 }
+async function resolveDesignerRefInTriage(projectRoot, ref) {
+  const m = /^(?:([^#]+)#)?([DP]\d+)$/i.exec(ref.trim());
+  if (!m) return null;
+  const runPart = m[1]?.trim();
+  const code = (m[2] ?? "").toUpperCase();
+  const targetRunId = resolveRunId(projectRoot, runPart);
+  if (!targetRunId) return null;
+  if (code.startsWith("P")) {
+    const refsRaw = await fs62.readFile(
+      path59.join(runDir(projectRoot, targetRunId), DESIGNER_REFS_FILE),
+      "utf8"
+    ).catch(() => null);
+    if (!refsRaw) return null;
+    try {
+      const parsed = JSON.parse(refsRaw);
+      const findingId = parsed[code];
+      if (findingId) {
+        return await readEntity(
+          projectRoot,
+          "finding",
+          findingId
+        );
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  const rec = await readDesignerRecord(projectRoot, targetRunId).catch(
+    () => null
+  );
+  const issue = rec?.issues.find((i) => i.id.toUpperCase() === code);
+  if (issue?.finding_id) {
+    return await readEntity(
+      projectRoot,
+      "finding",
+      issue.finding_id
+    );
+  }
+  return null;
+}
 async function triage(refs2, opts) {
   const ctx = await resolveProject(opts);
   if (!ctx) return;
@@ -31545,42 +31724,39 @@ async function triage(refs2, opts) {
     }
     reason = opts.reason;
   }
-  if (status2.data === "dismissed") {
-    reason ??= "not_relevant";
-    if (!opts.note?.trim()) {
+  if (opts.duplicateOf !== void 0) {
+    if (status2.data !== "dismissed") {
+      commandError("--duplicate-of applies only to --status dismissed", {
+        ...opts,
+        code: "invalid_duplicate_of_usage",
+        fix: `iamu triage ${refs2.join(" ")} --status dismissed --duplicate-of ${opts.duplicateOf}`
+      });
+      return;
+    }
+    if (reason && reason !== "duplicate") {
       commandError(
-        "Dismissing needs --note naming why (by design, out of scope, what the walker misread, duplicate of \u2026) \u2014 it teaches the next walk",
+        `--duplicate-of requires --reason duplicate \u2014 got "${reason}"`,
         {
           ...opts,
-          code: "missing_dismiss_note",
-          fix: `iamu triage ${refs2.join(" ")} --status dismissed --note "by design"`
+          code: "invalid_duplicate_of_usage",
+          fix: `iamu triage ${refs2.join(" ")} --status dismissed --reason duplicate --duplicate-of ${opts.duplicateOf}`
         }
       );
       return;
     }
+    reason = "duplicate";
+  }
+  if (status2.data === "dismissed") {
+    reason ??= "not_relevant";
   }
   const isSweep = opts.sweep !== void 0 && opts.sweep !== false;
   const sweepQuery = typeof opts.sweep === "string" ? opts.sweep.trim() : "";
   if (isSweep && status2.data !== "dismissed" && status2.data !== "wont_fix") {
-    commandError(
-      "--sweep applies only when dismissing (--status dismissed or wont_fix)",
-      {
-        ...opts,
-        code: "invalid_sweep_usage",
-        fix: `iamu triage ${refs2.join(" ")} --status dismissed --note "by design" --sweep`
-      }
-    );
-    return;
-  }
-  if (isSweep && status2.data === "wont_fix" && !opts.note?.trim()) {
-    commandError(
-      "Dismissing with --sweep needs --note naming why \u2014 it teaches the whole project",
-      {
-        ...opts,
-        code: "missing_dismiss_note",
-        fix: `iamu triage ${refs2.join(" ")} --status wont_fix --note "by design" --sweep`
-      }
-    );
+    commandError("--sweep applies only when dismissing (--status dismissed)", {
+      ...opts,
+      code: "invalid_sweep_usage",
+      fix: `iamu triage ${refs2.join(" ")} --status dismissed --sweep`
+    });
     return;
   }
   if (isSweep && opts.scope !== void 0) {
@@ -31623,6 +31799,9 @@ async function triage(refs2, opts) {
         "finding",
         ref
       );
+      if (!entity) {
+        entity = await resolveDesignerRefInTriage(projectRoot, ref);
+      }
     } catch (err) {
       commandError(
         `Finding ${ref} does not validate: ${err instanceof Error ? err.message.split("\n")[0] : String(err)} \u2014 run \`iamu validate --all\``,
@@ -31699,29 +31878,25 @@ async function triage(refs2, opts) {
   }
   const allTargets = [...loaded, ...swept];
   const persona = allTargets.filter((f) => isPersonaFinding(f.frontmatter));
-  if (!isSweep && opts.rule !== void 0 && persona.length < loaded.length) {
-    commandError(
-      "--rule teaches the walker, and a designer finding is not the walker's: dismiss it without --rule (later designer's reviews are told not to raise it again)",
-      {
-        ...opts,
-        code: "rule_for_designer_finding",
-        fix: `iamu triage ${refs2.join(" ")} --status dismissed --note "<why>"`
-      }
-    );
-    return;
-  }
   const effectiveReason = reason ?? (isSweep ? "not_relevant" : null);
-  const teaches = (status2.data === "dismissed" || isSweep && status2.data === "wont_fix") && (effectiveReason === "not_relevant" || effectiveReason === "walker_error") && opts.guidance !== false && (persona.length > 0 || isSweep);
+  const duplicateTarget = status2.data === "dismissed" && effectiveReason === "duplicate" ? opts.duplicateOf?.trim() || null : null;
+  const teaches = (status2.data === "dismissed" || isSweep && status2.data === "wont_fix") && (effectiveReason === "not_relevant" || effectiveReason === "walker_error" || effectiveReason === "out_of_scope") && opts.guidance !== false && (persona.length > 0 || isSweep || opts.rule !== void 0);
   let scope = {};
   if (teaches && !isSweep) {
-    const resolved = await resolveScope(projectRoot, scopeFlag, persona, opts);
+    const scopeTargets = persona.length > 0 ? persona : allTargets;
+    const resolved = await resolveScope(
+      projectRoot,
+      scopeFlag,
+      scopeTargets,
+      opts
+    );
     if (!resolved) return;
     scope = resolved;
   }
   let guidance = null;
   if (teaches && effectiveReason) {
     const ruleSources = allTargets.length > 0 ? allTargets : persona;
-    const ruleText = opts.rule?.trim() || (sweepQuery && ruleSources.length === 0 ? effectiveReason === "walker_error" ? `Earlier walkers got this wrong: ${sweepQuery}` : `Don't report: ${sweepQuery}` : defaultRule(effectiveReason, ruleSources));
+    const ruleText = opts.rule?.trim() || (sweepQuery && ruleSources.length === 0 ? effectiveReason === "walker_error" ? `Earlier walkers got this wrong: ${sweepQuery}` : effectiveReason === "out_of_scope" ? `Handled outside system; don't report: ${sweepQuery}` : `Don't report: ${sweepQuery}` : defaultRule(effectiveReason, ruleSources));
     const rule = await createGuidanceRule(projectRoot, {
       kind: effectiveReason,
       rule: ruleText,
@@ -31762,7 +31937,8 @@ async function triage(refs2, opts) {
       updated_at: now,
       addressed_at: addressedAt(f.frontmatter),
       dismiss_reason: status2.data === "dismissed" ? effectiveReason : null,
-      ...isSweep && guidance ? { suppressed_by_guidance: guidance.id } : {}
+      duplicate_of: duplicateTarget,
+      ...(isSweep || !isPersonaFinding(f.frontmatter)) && guidance ? { suppressed_by_guidance: guidance.id } : {}
     };
     if (opts.note !== void 0) fm.triage_note = opts.note.trim();
     await writeEntity(projectRoot, "finding", fm, f.body);
@@ -31790,6 +31966,7 @@ async function triage(refs2, opts) {
         updated_at: now,
         addressed_at: addressedAt(c.frontmatter),
         dismiss_reason: status2.data === "dismissed" ? effectiveReason : null,
+        duplicate_of: duplicateTarget,
         ...isSweep && guidance ? { suppressed_by_guidance: guidance.id } : {},
         ...opts.note !== void 0 ? { triage_note: opts.note.trim() } : {}
       },
@@ -32877,7 +33054,7 @@ var init_browse_driver = __esm({
 });
 
 // src/commands/step-numbering.ts
-import { open, readdir, unlink } from "fs/promises";
+import { open, readdir, stat as stat2, unlink } from "fs/promises";
 import path61 from "path";
 function stepFileName(stepNumber2) {
   return `${String(stepNumber2).padStart(3, "0")}.json`;
@@ -32890,7 +33067,16 @@ async function peekNextStepNumber(stepsDir) {
   let max = 0;
   for (const f of files) {
     const m = /^(\d+)\.json$/.exec(f);
-    if (m) max = Math.max(max, Number(m[1]));
+    if (!m) continue;
+    const fullPath = path61.join(stepsDir, f);
+    const st = await stat2(fullPath).catch(() => null);
+    if (!st) continue;
+    if (st.size === 0 && Date.now() - st.mtimeMs > STALE_RESERVATION_MS) {
+      await unlink(fullPath).catch(() => {
+      });
+      continue;
+    }
+    max = Math.max(max, Number(m[1]));
   }
   return max + 1;
 }
@@ -32913,13 +33099,21 @@ async function reserveStepFile(stepsDir, limit) {
       };
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
+      const st = await stat2(stepPath).catch(() => null);
+      if (st && st.size === 0 && Date.now() - st.mtimeMs > STALE_RESERVATION_MS) {
+        await unlink(stepPath).catch(() => {
+        });
+        continue;
+      }
       candidate = Math.max(candidate + 1, await peekNextStepNumber(stepsDir));
     }
   }
 }
+var STALE_RESERVATION_MS;
 var init_step_numbering = __esm({
   "src/commands/step-numbering.ts"() {
     "use strict";
+    STALE_RESERVATION_MS = 2e3;
   }
 });
 
@@ -32931,7 +33125,7 @@ __export(step_exports, {
   recordStep: () => recordStep,
   stepCommand: () => stepCommand
 });
-import { copyFile, mkdir as mkdir4, rename, stat as stat2 } from "fs/promises";
+import { copyFile, mkdir as mkdir4, rename, stat as stat3 } from "fs/promises";
 import path62 from "path";
 import chalk30 from "chalk";
 function parseMaxSteps(val) {
@@ -32961,9 +33155,10 @@ async function recordStep(input) {
     runId: input.runId
   });
   const { stepNumber: stepNumber2, stepPath } = reservation;
+  let parsedStep;
+  let finalScreenshotPath = null;
   try {
     let screenshotRef = null;
-    let finalScreenshotPath = null;
     if (shotSource) {
       const destName = `step-${stepNumber2}.png`;
       const destPath = path62.join(screenshotsDir, destName);
@@ -32979,7 +33174,7 @@ async function recordStep(input) {
       }
       screenshotRef = path62.posix.join("screenshots", destName);
     }
-    const parsedStep = runStepSchema.parse({
+    parsedStep = runStepSchema.parse({
       step_number: stepNumber2,
       timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
       action: input.action.trim(),
@@ -32991,33 +33186,33 @@ async function recordStep(input) {
       ...input.extra ? { extra: input.extra } : {}
     });
     await writeStep(runDirPath, parsedStep);
-    let cancelled = false;
-    try {
-      const liveRes = await sendLiveStep(
-        input.projectRoot,
-        input.runId,
-        parsedStep,
-        finalScreenshotPath
-      );
-      if (liveRes.cancelled) {
-        cancelled = true;
-      }
-    } catch {
-    }
-    return {
-      step: parsedStep,
-      stepPath,
-      screenshotPath: finalScreenshotPath,
-      cancelled
-    };
   } catch (err) {
     await reservation.release();
     throw err;
   }
+  let cancelled = false;
+  try {
+    const liveRes = await sendLiveStep(
+      input.projectRoot,
+      input.runId,
+      parsedStep,
+      finalScreenshotPath
+    );
+    if (liveRes.cancelled) {
+      cancelled = true;
+    }
+  } catch {
+  }
+  return {
+    step: parsedStep,
+    stepPath,
+    screenshotPath: finalScreenshotPath,
+    cancelled
+  };
 }
 async function existingShot(shot) {
   const resolved = path62.resolve(shot);
-  const isFile = await stat2(resolved).then((s) => s.isFile()).catch(() => false);
+  const isFile = await stat3(resolved).then((s) => s.isFile()).catch(() => false);
   if (!isFile) {
     throw new Error(
       `Screenshot not found: ${resolved} \u2014 save the screenshot first, or omit --shot.`
@@ -33353,6 +33548,7 @@ function chromeArgs(opts, port, headless, viewport) {
     `--window-size=${win.width},${win.height}`,
     "--no-first-run",
     "--no-default-browser-check",
+    "--disable-features=Translate",
     "--password-store=basic",
     "--use-mock-keychain",
     ...headless ? ["--headless=new", "--disable-dev-shm-usage", "--disable-gpu"] : [],
@@ -38352,7 +38548,7 @@ async function crawlFrom(page, opts, origin, takeBlocked) {
   const byKey = /* @__PURE__ */ new Map();
   const byPlaceView = /* @__PURE__ */ new Map();
   const signatureOf = (s) => exploreSignature(s.headings, s.title);
-  function addSurface(state, place, view, path73, depth) {
+  function addSurface(state, place, view, path74, depth) {
     const key = exploreSurfaceKey(place, view);
     const surface = {
       key,
@@ -38364,7 +38560,7 @@ async function crawlFrom(page, opts, origin, takeBlocked) {
       headings: state.headings,
       fields: state.fields,
       depth,
-      path: path73,
+      path: path74,
       actions: []
     };
     surfaces.push(surface);
@@ -38382,9 +38578,9 @@ ${surface.signature}`, key);
     });
     await settle(page, settleMs);
   }
-  async function replay(path73) {
-    if (!("goto" in (path73[0] ?? {}))) await goto(opts.startUrl);
-    for (const step of path73) {
+  async function replay(path74) {
+    if (!("goto" in (path74[0] ?? {}))) await goto(opts.startUrl);
+    for (const step of path74) {
       if ("goto" in step) {
         await goto(step.goto);
       } else {
@@ -38508,8 +38704,8 @@ ${sig}`, key);
               if (stats.surfaces >= budget.max_surfaces) {
                 stats.truncated = true;
               } else {
-                const path73 = !sameDoc && view === null ? [{ goto: after.url }] : [...surface.path, ...via, click];
-                addSurface(after, place, view, path73, surface.depth + 1);
+                const path74 = !sameDoc && view === null ? [{ goto: after.url }] : [...surface.path, ...via, click];
+                addSurface(after, place, view, path74, surface.depth + 1);
               }
             }
           }
@@ -39434,7 +39630,9 @@ function guidanceLine(r) {
   return r.reason ? `- ${rule} (${r.reason.replace(/\s+/g, " ")})` : `- ${rule}`;
 }
 function guidanceSection(rules) {
-  const notRelevant = rules.filter((r) => r.kind === "not_relevant");
+  const notRelevant = rules.filter(
+    (r) => r.kind === "not_relevant" || r.kind === "out_of_scope"
+  );
   const misreads = rules.filter((r) => r.kind === "walker_error");
   if (notRelevant.length === 0 && misreads.length === 0) return [];
   const out2 = ["", "Tester guidance \u2014 the team's decisions from earlier runs:"];
@@ -39521,7 +39719,8 @@ function composeWalkerPrompt(p) {
       "Squinting Guardrails:",
       "\u2022 If the exact target record/option is not available, apply the approximation strategy above to pick the closest plausible entity within the domain flow.",
       "\u2022 Squinting does NOT permit drifting to unrelated settings, account profiles, or off-target pages. Stay strictly within the scenario journey.",
-      "\u2022 If the system is completely empty or unseeded, and your persona role cannot create data, do NOT report false product bugs about the empty state. End the walk as blocked (below)."
+      "\u2022 If the system is completely empty or unseeded, and your persona role cannot create data, do NOT report false product bugs about the empty state. End the walk as blocked (below).",
+      "\u2022 If the expected state includes seeded defects inside an inspected subject (e.g. an embedded app preview, screenshot, submission, or failing check that your persona is supposed to review or flag), treat those defects as the subject data to act on \u2014 never report them as bugs in the host product itself."
     ].filter(Boolean) : [],
     ...p.untestableBoundaries && p.untestableBoundaries.length > 0 ? [
       "",
@@ -41098,6 +41297,235 @@ var init_designer = __esm({
   }
 });
 
+// src/commands/post-walk.ts
+var post_walk_exports = {};
+__export(post_walk_exports, {
+  postWalk: () => postWalk
+});
+import { existsSync as existsSync23, promises as fs71 } from "fs";
+import path73 from "path";
+import chalk49 from "chalk";
+async function captureStageJson(fn) {
+  const captured = [];
+  const origLog = console.log;
+  const origErr = console.error;
+  console.log = (...args2) => {
+    captured.push(args2.map(String).join(" "));
+  };
+  console.error = () => {
+  };
+  try {
+    await fn();
+  } finally {
+    console.log = origLog;
+    console.error = origErr;
+  }
+  const last = captured[captured.length - 1];
+  if (!last) return null;
+  try {
+    return JSON.parse(last);
+  } catch {
+    return null;
+  }
+}
+async function postWalk(runIdArg, opts = {}) {
+  const ctx = await resolveProject(opts);
+  if (!ctx) return;
+  const { projectRoot } = ctx;
+  const runId = resolveRunId(projectRoot, runIdArg ?? opts.run);
+  if (!runId) {
+    commandError(
+      "Run ID is required. Pass <run-id>, specify --run <run-id>, or start a run first.",
+      {
+        ...opts,
+        code: "missing_run_id",
+        fix: "iamu status --json"
+      }
+    );
+    return;
+  }
+  const runDirPath = resolveRunDir(projectRoot, runId, opts);
+  if (!runDirPath) return;
+  const manifestPath = path73.join(runDirPath, "walkthrough.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(
+      await fs71.readFile(manifestPath, "utf8")
+    );
+  } catch {
+    commandError(`Run not found: ${runId}`, {
+      ...opts,
+      code: "run_not_found",
+      fix: "iamu status --json"
+    });
+    return;
+  }
+  if (manifest.status !== "completed") {
+    await captureStageJson(
+      () => complete(runId, { prompt: false, push: false, json: true })
+    );
+    if (process.exitCode && process.exitCode !== 0) return;
+    manifest = JSON.parse(
+      await fs71.readFile(manifestPath, "utf8")
+    );
+  }
+  if (manifest.blocked) {
+    const blockedResult = {
+      run_id: runId,
+      status: "blocked",
+      blocked: manifest.blocked,
+      recorded: [],
+      stages: null
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(blockedResult, null, 2));
+    } else {
+      console.log(
+        `  ${chalk49.yellow("!")} Run ${runId} is blocked: ${manifest.blocked.reason}`
+      );
+    }
+    return;
+  }
+  const recordedNow = [];
+  const matchesAnswerPath = path73.join(runDirPath, "matches.json");
+  if (existsSync23(matchesAnswerPath)) {
+    const res = await captureStageJson(
+      () => matchRecord(runId, { file: matchesAnswerPath, json: true })
+    );
+    if (res && !process.exitCode) {
+      recordedNow.push("match");
+      await fs71.unlink(matchesAnswerPath).catch(() => {
+      });
+    }
+  }
+  const judgeAnswerPath = path73.join(runDirPath, "judge_answer.json");
+  if (existsSync23(judgeAnswerPath)) {
+    const res = await captureStageJson(
+      () => evaluateRecord(runId, { file: judgeAnswerPath, json: true })
+    );
+    if (res && !process.exitCode) {
+      recordedNow.push("evaluate");
+      await fs71.unlink(judgeAnswerPath).catch(() => {
+      });
+    }
+  }
+  const adviseAnswerPath = path73.join(runDirPath, "advise_answer.json");
+  if (!opts.critic && !existsSync23(path73.join(runDirPath, ADVICE_FILE)) && existsSync23(adviseAnswerPath)) {
+    const res = await captureStageJson(
+      () => adviseRecord(runId, { file: adviseAnswerPath, json: true })
+    );
+    if (res && !process.exitCode) {
+      recordedNow.push("advise");
+      await fs71.unlink(adviseAnswerPath).catch(() => {
+      });
+    }
+  }
+  const designerAnswerPath = path73.join(runDirPath, DESIGNER_ANSWER_FILE);
+  if (!existingDesignerFile(runDirPath)) {
+    if (opts.critic) {
+      await captureStageJson(
+        () => designerRecord(runId, { skipped: "--critic", json: true })
+      );
+      recordedNow.push("designer(skipped)");
+    } else if (opts.ux === false) {
+      await captureStageJson(
+        () => designerRecord(runId, { skipped: "--no-ux", json: true })
+      );
+      recordedNow.push("designer(skipped)");
+    } else if (existsSync23(designerAnswerPath)) {
+      const res = await captureStageJson(
+        () => designerRecord(runId, {
+          file: designerAnswerPath,
+          byOrchestrator: opts.byOrchestrator,
+          json: true
+        })
+      );
+      if (res && !process.exitCode) {
+        recordedNow.push("designer");
+        await fs71.unlink(designerAnswerPath).catch(() => {
+        });
+      }
+    }
+  }
+  const matchInfo = await captureStageJson(() => match(runId, { json: true }));
+  const evalRecorded = existsSync23(path73.join(runDirPath, "verdicts.json"));
+  const evalInfo = evalRecorded ? null : await captureStageJson(() => evaluate(runId, { json: true }));
+  const adviseRecorded = existsSync23(path73.join(runDirPath, ADVICE_FILE));
+  const adviseInfo = opts.critic || adviseRecorded ? null : await captureStageJson(() => advise(runId, { json: true }));
+  const designerRecorded = Boolean(existingDesignerFile(runDirPath));
+  const designerInfo = opts.critic || opts.ux === false || designerRecorded ? null : await captureStageJson(() => designer(runId, { json: true }));
+  const payload = {
+    run_id: runId,
+    status: "completed",
+    recorded: recordedNow,
+    stages: {
+      match: {
+        needed: Boolean(matchInfo?.needed),
+        prompt_file: matchInfo?.prompt_file ?? null,
+        prompt_file_abs: matchInfo?.prompt_file_abs ?? null,
+        answer_file_abs: matchesAnswerPath,
+        record_command: `iamu match-record ${runId} --file - <<'EOF'`
+      },
+      evaluate: {
+        needed: !evalRecorded,
+        recorded: evalRecorded,
+        prompt_file: evalInfo?.prompt_file ?? null,
+        prompt_file_abs: evalInfo?.prompt_file_abs ?? null,
+        answer_file_abs: judgeAnswerPath,
+        record_command: `iamu evaluate-record ${runId} --file - <<'EOF'`
+      },
+      advise: {
+        needed: Boolean(adviseInfo?.needed),
+        recorded: adviseRecorded,
+        reason: opts.critic ? "--critic" : adviseInfo?.reason ?? null,
+        prompt_file: adviseInfo?.prompt_file ?? null,
+        prompt_file_abs: adviseInfo?.prompt_file_abs ?? null,
+        answer_file_abs: adviseAnswerPath,
+        record_command: `iamu advise-record ${runId} --file - <<'EOF'`
+      },
+      designer: {
+        needed: Boolean(designerInfo?.needed),
+        recorded: designerRecorded,
+        reason: opts.critic ? "--critic" : opts.ux === false ? "--no-ux" : designerInfo?.reason ?? null,
+        prompt_file: designerInfo?.prompt_file ?? null,
+        prompt_file_abs: designerInfo?.prompt_file_abs ?? null,
+        answer_file_abs: designerAnswerPath,
+        key_screenshots: designerInfo?.key_screenshots ?? [],
+        offer_template: Boolean(designerInfo?.offer_template),
+        record_command: `iamu designer-record ${runId} --file - <<'EOF'`
+      }
+    }
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log();
+  console.log(
+    `  ${chalk49.green("\u2713")} Post-walk pipeline for ${chalk49.cyan(runId)}`
+  );
+  if (recordedNow.length > 0) {
+    console.log(`    Recorded: ${recordedNow.join(", ")}`);
+  }
+  for (const [name, s] of Object.entries(payload.stages)) {
+    const state = "recorded" in s && s.recorded ? chalk49.green("recorded") : s.needed ? chalk49.yellow(`needed (${s.prompt_file})`) : chalk49.dim("not needed");
+    console.log(`    ${name}: ${state}`);
+  }
+  console.log();
+}
+var init_post_walk = __esm({
+  "src/commands/post-walk.ts"() {
+    "use strict";
+    init_dist2();
+    init_advise();
+    init_complete();
+    init_context4();
+    init_designer();
+    init_evaluate();
+    init_match();
+  }
+});
+
 // src/commands/prune.ts
 var prune_exports = {};
 __export(prune_exports, {
@@ -41105,7 +41533,7 @@ __export(prune_exports, {
   prune: () => prune
 });
 import { confirm, isCancel as isCancel5 } from "@clack/prompts";
-import chalk49 from "chalk";
+import chalk50 from "chalk";
 function formatBytes(bytes) {
   if (bytes <= 0) return "0 B";
   if (bytes < 1024) return `${bytes} B`;
@@ -41151,7 +41579,7 @@ async function prune(opts = {}) {
     });
     if (preview.prunedRuns.length === 0) {
       console.log(
-        chalk49.dim("  No runs match the pruning criteria. Nothing to prune.")
+        chalk50.dim("  No runs match the pruning criteria. Nothing to prune.")
       );
       return preview;
     }
@@ -41160,7 +41588,7 @@ async function prune(opts = {}) {
       message: `Prune ${mode} ${preview.prunedRuns.length} run(s) and reclaim ${formatBytes(preview.totalBytesReclaimed)}?`
     });
     if (isCancel5(confirmed) || !confirmed) {
-      console.log(chalk49.yellow("  Pruning cancelled."));
+      console.log(chalk50.yellow("  Pruning cancelled."));
       return;
     }
   }
@@ -41171,14 +41599,14 @@ async function prune(opts = {}) {
   }
   if (result.dryRun) {
     console.log(
-      chalk49.cyan(
+      chalk50.cyan(
         `
   [DRY RUN] Would prune ${result.prunedRuns.length} of ${result.totalRunsScanned} run(s):`
       )
     );
   } else {
     console.log(
-      chalk49.bold(
+      chalk50.bold(
         `
   ${symbols.success} Pruned ${result.prunedRuns.length} of ${result.totalRunsScanned} run(s):`
       )
@@ -41186,18 +41614,18 @@ async function prune(opts = {}) {
   }
   if (result.prunedRuns.length === 0) {
     console.log(
-      chalk49.dim("    No runs matched the pruning criteria. Nothing pruned.")
+      chalk50.dim("    No runs matched the pruning criteria. Nothing pruned.")
     );
   } else {
     for (const run of result.prunedRuns) {
       const mode = run.fullyDeleted ? "removed" : "screenshots purged";
       const count = run.screenshotsDeleted > 0 ? `${run.screenshotsDeleted} screenshots, ` : "";
       console.log(
-        `    ${chalk49.dim("\u2022")} ${chalk49.bold(run.runId)} ${chalk49.dim(`(${run.scenarioSlug ?? "unknown scenario"})`)}: ${chalk49.yellow(formatBytes(run.bytesReclaimed))} (${count}${mode})`
+        `    ${chalk50.dim("\u2022")} ${chalk50.bold(run.runId)} ${chalk50.dim(`(${run.scenarioSlug ?? "unknown scenario"})`)}: ${chalk50.yellow(formatBytes(run.bytesReclaimed))} (${count}${mode})`
       );
     }
     console.log(
-      chalk49.dim(
+      chalk50.dim(
         `
   Total reclaimed: ${formatBytes(result.totalBytesReclaimed)} (${result.totalScreenshotsDeleted} screenshots deleted)
 `
@@ -41218,9 +41646,9 @@ var init_prune2 = __esm({
 // src/bin.ts
 init_dist();
 init_context4();
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { resolve as resolve3 } from "path";
-import chalk52 from "chalk";
+import chalk53 from "chalk";
 import { Command } from "commander";
 
 // src/commands/register-cloud.ts
@@ -41510,12 +41938,12 @@ function registerFindingsCommands(program2) {
       await findings2(opts);
     }
   );
-  program2.command("triage [findings...]").helpGroup("Findings:").description("Set findings' triage status").requiredOption(
-    "--status <status>",
-    "open, addressed, deferred, wont_fix or dismissed"
-  ).option("--note <text>", "Why \u2014 required when dismissing").option(
+  program2.command("triage [findings...]").helpGroup("Findings:").description("Set findings' triage status").requiredOption("--status <status>", "open, addressed or dismissed").option("--note <text>", "Optional triage note or reason").option(
     "--reason <reason>",
-    "Dismiss reason: not_relevant (default), walker_error or duplicate"
+    "Dismiss reason: not_relevant (default), walker_error, out_of_scope or duplicate"
+  ).option(
+    "--duplicate-of <finding>",
+    "Finding slug or id this repeats (implies --reason duplicate)"
   ).option(
     "--rule <text>",
     `Guidance rule text (default: "Don't report: <title>")`
@@ -41527,7 +41955,7 @@ function registerFindingsCommands(program2) {
     "Project-wide sweep ('we never want X'): dismiss all matching open persona & designer findings across every scenario/surface and record a project-wide guidance rule"
   ).option("--no-guidance", "Dismiss without writing a tester guidance rule").option("--json", "Output as JSON").addHelpText(
     "after",
-    "\nDismissing as not_relevant or walker_error teaches the walker: it writes a\ntester guidance rule (skip it with --no-guidance)."
+    "\nDismissing as not_relevant, walker_error, or out_of_scope teaches the walker: it writes a\ntester guidance rule (skip it with --no-guidance)."
   ).action(
     async (refs2, opts) => {
       const { triage: triage2 } = await Promise.resolve().then(() => (init_triage(), triage_exports));
@@ -41626,9 +42054,9 @@ function registerProjectCommands(program2) {
     "after",
     "\nExamples:\n  $ iamu validate --all\n  $ iamu validate --all --fix --dry-run\n  $ iamu validate iamu/personas/maria.md"
   ).action(
-    async (path73, opts) => {
+    async (path74, opts) => {
       const { validate: validate2 } = await Promise.resolve().then(() => (init_validate(), validate_exports));
-      await validate2(path73, opts);
+      await validate2(path74, opts);
     }
   );
   program2.command("update").helpGroup("Project:").description("Update and repair agent skills and prompts to latest version").option(
@@ -42070,6 +42498,20 @@ function registerWalkthroughCommands(program2) {
       await complete2(runId, opts);
     }
   );
+  program2.command("post-walk [run-id]").helpGroup("Walkthrough:").description(
+    "Complete a run, record staged answers, and prepare post-walk prompts"
+  ).option("--run <run-id>", "Run ID (or pass as positional argument)").option("--critic", "Skip advisor and mark designer skipped (--critic)").option("--no-ux", "Mark designer's review skipped (--no-ux)").option(
+    "--by-orchestrator",
+    "Mark recorded designer answer as written by the orchestrator"
+  ).option("--json", "Output post-walk status and prompt paths as JSON").addHelpText(
+    "after",
+    "\nExamples:\n  $ iamu post-walk <run-id> --json\n  $ iamu post-walk <run-id> --critic --json"
+  ).action(
+    async (runId, opts) => {
+      const { postWalk: postWalk2 } = await Promise.resolve().then(() => (init_post_walk(), post_walk_exports));
+      await postWalk2(runId, opts);
+    }
+  );
   program2.command("match [run-id]").helpGroup("Walkthrough:").description(
     "Compose the prompt that links this run's findings to earlier ones"
   ).option("--run <run-id>", "Run ID (or pass as positional argument)").option("--json", "Output the match input bundle as JSON").option("--prompt-file <path>", "Write the generated prompt to a file").action(
@@ -42228,7 +42670,7 @@ init_logger();
 // src/ui/panic.ts
 init_dist();
 init_logger();
-import chalk50 from "chalk";
+import chalk51 from "chalk";
 var handlersRegistered = false;
 var customSigintHandler = null;
 function logFatalAndExit(title, errOrReason) {
@@ -42248,16 +42690,16 @@ function logFatalAndExit(title, errOrReason) {
     process.exit(1);
   }
   if (isVerbose()) {
-    console.error(chalk50.red(`
+    console.error(chalk51.red(`
   ${title}:`));
     console.error(
       errOrReason instanceof Error ? errOrReason.stack || errOrReason : errOrReason
     );
   } else {
-    console.error(chalk50.red(`
+    console.error(chalk51.red(`
   Fatal Error: ${msg}`));
     console.error(
-      chalk50.dim(
+      chalk51.dim(
         "  Run with --verbose or DEBUG=1 to view the full stack trace.\n"
       )
     );
@@ -42276,7 +42718,7 @@ function setupProcessHandlers() {
       }
       process.exit(130);
     } else {
-      console.error(chalk50.dim("\n  Operation cancelled."));
+      console.error(chalk51.dim("\n  Operation cancelled."));
       process.exit(130);
     }
   });
@@ -42302,7 +42744,7 @@ function setupProcessHandlers() {
 import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join12 } from "path";
-import chalk51 from "chalk";
+import chalk52 from "chalk";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function getIamuHome() {
   return process.env.IAMU_HOME || join12(homedir4(), ".iamu");
@@ -42387,7 +42829,7 @@ async function checkForUpdate(currentVersion) {
 function printUpdateNotice(currentVersion, latestVersion) {
   console.error();
   console.error(
-    `  ${chalk51.yellow("Update available:")} ${chalk51.dim(currentVersion)} \u2192 ${chalk51.green(latestVersion)}  ${chalk51.dim("(run: npm i -g @iamu-dev/iamu)")}`
+    `  ${chalk52.yellow("Update available:")} ${chalk52.dim(currentVersion)} \u2192 ${chalk52.green(latestVersion)}  ${chalk52.dim("(run: npm i -g @iamu-dev/iamu)")}`
   );
 }
 
@@ -42418,7 +42860,7 @@ var program = new Command().name("iamu").description(
   const effectiveCwd = root.cwd || process.env.IAMU_DIR || process.env.IAMU_CWD;
   if (effectiveCwd) {
     const targetDir = resolve3(process.cwd(), effectiveCwd);
-    if (!existsSync23(targetDir)) {
+    if (!existsSync24(targetDir)) {
       commandError(`Directory does not exist: ${effectiveCwd}`, {
         ...root,
         code: "directory_not_found",
@@ -42441,7 +42883,7 @@ var program = new Command().name("iamu").description(
     }
   }
   if (root.color === false || process.env.NO_COLOR) {
-    chalk52.level = 0;
+    chalk53.level = 0;
   }
   if (root.verbose) {
     process.env.IAMU_VERBOSE = "1";