@jevitate/cli 0.23.0 → 0.25.0

package/dist/bin.js

@@ -10,16 +10,36 @@ import { mkdir, stat } from "node:fs/promises";
 
 // ../domain/dist/content-hash.js
 import { createHash } from "node:crypto";
-function canonical(value) {
+function compareUtf16CodeUnits(a, b2) {
+  const length = Math.min(a.length, b2.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = a.charCodeAt(index) - b2.charCodeAt(index);
+    if (difference !== 0)
+      return difference < 0 ? -1 : 1;
+  }
+  return a.length === b2.length ? 0 : a.length < b2.length ? -1 : 1;
+}
+function canonicalJson(value) {
   if (value === null || typeof value !== "object")
     return JSON.stringify(value);
   if (Array.isArray(value))
-    return `[${value.map(canonical).join(",")}]`;
+    return `[${value.map(canonicalJson).join(",")}]`;
+  const entries = Object.entries(value).sort(([a], [b2]) => compareUtf16CodeUnits(a, b2));
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+}
+function legacyCanonicalJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(legacyCanonicalJson).join(",")}]`;
   const entries = Object.entries(value).sort(([a], [b2]) => a.localeCompare(b2));
-  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${legacyCanonicalJson(v)}`).join(",")}}`;
 }
 function contentHash(value) {
-  return createHash("sha256").update(canonical(value)).digest("hex");
+  return createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+function legacyContentHash(value) {
+  return createHash("sha256").update(legacyCanonicalJson(value)).digest("hex");
 }
 function sha256(text2) {
   return createHash("sha256").update(text2, "utf8").digest("hex");
@@ -3611,8 +3631,8 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   const _normalized = cached(() => normalizeDef(def));
   const memo2 = globalConfig.memoizer;
   const generateFastpass = (shape3) => {
-    const normalized = _normalized.value;
-    const syms = normalized.symbolKeys;
+    const normalized2 = _normalized.value;
+    const syms = normalized2.symbolKeys;
     const doc = new Doc(["payload", "ctx"], { shape: shape3, inst, memo: memo2, syms });
     const parseStr = (k) => `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
     const prefixStr = (id, k) => `
@@ -3630,11 +3650,11 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
     let counter = 0;
-    for (const key2 of normalized.allKeys) {
+    for (const key2 of normalized2.allKeys) {
       ids[key2] = `key_${counter++}`;
     }
     doc.write(memo2 ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);
-    for (const key2 of normalized.allKeys) {
+    for (const key2 of normalized2.allKeys) {
       if (key2 === "__proto__")
         continue;
       const id = ids[key2];
@@ -19463,23 +19483,23 @@ function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
     return schema ? z.any() : z.never();
   }
-  let normalized;
+  let normalized2;
   try {
-    normalized = JSON.parse(JSON.stringify(schema));
+    normalized2 = JSON.parse(JSON.stringify(schema));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
-  const version2 = detectVersion(normalized, params?.defaultTarget);
-  const defs = normalized.$defs || normalized.definitions || {};
+  const version2 = detectVersion(normalized2, params?.defaultTarget);
+  const defs = normalized2.$defs || normalized2.definitions || {};
   const ctx = {
     version: version2,
     defs,
     refs: /* @__PURE__ */ new Map(),
     processing: /* @__PURE__ */ new Set(),
-    rootSchema: normalized,
+    rootSchema: normalized2,
     registry: params?.registry ?? globalRegistry
   };
-  return convertSchema(normalized, ctx);
+  return convertSchema(normalized2, ctx);
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/visit.js
@@ -21403,15 +21423,15 @@ function asNumber(value) {
   return numericValue;
 }
 function normalizeObject(obj, normalizer) {
-  const normalized = {};
+  const normalized2 = {};
   for (const u in obj) {
     if (hasOwnProperty(obj, u)) {
       const v = obj[u];
       if (v === void 0 || v === null) continue;
-      normalized[normalizer(u)] = asNumber(v);
+      normalized2[normalizer(u)] = asNumber(v);
     }
   }
-  return normalized;
+  return normalized2;
 }
 function formatOffset(offset2, format) {
   const hours = Math.trunc(Math.abs(offset2 / 60)), minutes = Math.trunc(Math.abs(offset2 % 60)), sign = offset2 >= 0 ? "+" : "-";
@@ -22412,7 +22432,7 @@ var Duration = class _Duration {
    * @private
    */
   static normalizeUnit(unit) {
-    const normalized = {
+    const normalized2 = {
       year: "years",
       years: "years",
       quarter: "quarters",
@@ -22432,8 +22452,8 @@ var Duration = class _Duration {
       millisecond: "milliseconds",
       milliseconds: "milliseconds"
     }[unit ? unit.toLowerCase() : unit];
-    if (!normalized) throw new InvalidUnitError(unit);
-    return normalized;
+    if (!normalized2) throw new InvalidUnitError(unit);
+    return normalized2;
   }
   /**
    * Check if an object is a Duration. Works across context boundaries
@@ -24336,7 +24356,7 @@ var orderedWeekUnits = [
 ];
 var orderedOrdinalUnits = ["year", "ordinal", "hour", "minute", "second", "millisecond"];
 function normalizeUnit(unit) {
-  const normalized = {
+  const normalized2 = {
     year: "year",
     years: "year",
     month: "month",
@@ -24362,8 +24382,8 @@ function normalizeUnit(unit) {
     weekyears: "weekYear",
     ordinal: "ordinal"
   }[unit.toLowerCase()];
-  if (!normalized) throw new InvalidUnitError(unit);
-  return normalized;
+  if (!normalized2) throw new InvalidUnitError(unit);
+  return normalized2;
 }
 function normalizeUnitWithLocalWeeks(unit) {
   switch (unit.toLowerCase()) {
@@ -24662,9 +24682,9 @@ var DateTime = class _DateTime {
       return _DateTime.invalid(unsupportedZone(zoneToUse));
     }
     const loc = Locale.fromObject(opts);
-    const normalized = normalizeObject(obj, normalizeUnitWithLocalWeeks);
-    const { minDaysInFirstWeek, startOfWeek } = usesLocalWeekValues(normalized, loc);
-    const tsNow = Settings.now(), offsetProvis = !isUndefined(opts.specificOffset) ? opts.specificOffset : zoneToUse.offset(tsNow), containsOrdinal = !isUndefined(normalized.ordinal), containsGregorYear = !isUndefined(normalized.year), containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber;
+    const normalized2 = normalizeObject(obj, normalizeUnitWithLocalWeeks);
+    const { minDaysInFirstWeek, startOfWeek } = usesLocalWeekValues(normalized2, loc);
+    const tsNow = Settings.now(), offsetProvis = !isUndefined(opts.specificOffset) ? opts.specificOffset : zoneToUse.offset(tsNow), containsOrdinal = !isUndefined(normalized2.ordinal), containsGregorYear = !isUndefined(normalized2.year), containsGregorMD = !isUndefined(normalized2.month) || !isUndefined(normalized2.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized2.weekYear || normalized2.weekNumber;
     if ((containsGregor || containsOrdinal) && definiteWeekDef) {
       throw new ConflictingSpecificationError(
         "Can't mix weekYear/weekNumber units with year/month/day or ordinals"
@@ -24673,7 +24693,7 @@ var DateTime = class _DateTime {
     if (containsGregorMD && containsOrdinal) {
       throw new ConflictingSpecificationError("Can't mix ordinal dates with month/day");
     }
-    const useWeekData = definiteWeekDef || normalized.weekday && !containsGregor;
+    const useWeekData = definiteWeekDef || normalized2.weekday && !containsGregor;
     let units, defaultValues, objNow = tsToObj(tsNow, offsetProvis);
     if (useWeekData) {
       units = orderedWeekUnits;
@@ -24689,29 +24709,29 @@ var DateTime = class _DateTime {
     }
     let foundFirst = false;
     for (const u of units) {
-      const v = normalized[u];
+      const v = normalized2[u];
       if (!isUndefined(v)) {
         foundFirst = true;
       } else if (foundFirst) {
-        normalized[u] = defaultValues[u];
+        normalized2[u] = defaultValues[u];
       } else {
-        normalized[u] = objNow[u];
+        normalized2[u] = objNow[u];
       }
     }
-    const higherOrderInvalid = useWeekData ? hasInvalidWeekData(normalized, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? hasInvalidOrdinalData(normalized) : hasInvalidGregorianData(normalized), invalid = higherOrderInvalid || hasInvalidTimeData(normalized);
+    const higherOrderInvalid = useWeekData ? hasInvalidWeekData(normalized2, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? hasInvalidOrdinalData(normalized2) : hasInvalidGregorianData(normalized2), invalid = higherOrderInvalid || hasInvalidTimeData(normalized2);
     if (invalid) {
       return _DateTime.invalid(invalid);
     }
-    const gregorian = useWeekData ? weekToGregorian(normalized, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? ordinalToGregorian(normalized) : normalized, [tsFinal, offsetFinal] = objToTS(gregorian, offsetProvis, zoneToUse), inst = new _DateTime({
+    const gregorian = useWeekData ? weekToGregorian(normalized2, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? ordinalToGregorian(normalized2) : normalized2, [tsFinal, offsetFinal] = objToTS(gregorian, offsetProvis, zoneToUse), inst = new _DateTime({
       ts: tsFinal,
       zone: zoneToUse,
       o: offsetFinal,
       loc
     });
-    if (normalized.weekday && containsGregor && obj.weekday !== inst.weekday) {
+    if (normalized2.weekday && containsGregor && obj.weekday !== inst.weekday) {
       return _DateTime.invalid(
         "mismatched weekday",
-        `you can't specify both a weekday of ${normalized.weekday} and a date of ${inst.toISO()}`
+        `you can't specify both a weekday of ${normalized2.weekday} and a date of ${inst.toISO()}`
       );
     }
     if (!inst.isValid) {
@@ -25360,9 +25380,9 @@ var DateTime = class _DateTime {
    */
   set(values2) {
     if (!this.isValid) return this;
-    const normalized = normalizeObject(values2, normalizeUnitWithLocalWeeks);
-    const { minDaysInFirstWeek, startOfWeek } = usesLocalWeekValues(normalized, this.loc);
-    const settingWeekStuff = !isUndefined(normalized.weekYear) || !isUndefined(normalized.weekNumber) || !isUndefined(normalized.weekday), containsOrdinal = !isUndefined(normalized.ordinal), containsGregorYear = !isUndefined(normalized.year), containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber;
+    const normalized2 = normalizeObject(values2, normalizeUnitWithLocalWeeks);
+    const { minDaysInFirstWeek, startOfWeek } = usesLocalWeekValues(normalized2, this.loc);
+    const settingWeekStuff = !isUndefined(normalized2.weekYear) || !isUndefined(normalized2.weekNumber) || !isUndefined(normalized2.weekday), containsOrdinal = !isUndefined(normalized2.ordinal), containsGregorYear = !isUndefined(normalized2.year), containsGregorMD = !isUndefined(normalized2.month) || !isUndefined(normalized2.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized2.weekYear || normalized2.weekNumber;
     if ((containsGregor || containsOrdinal) && definiteWeekDef) {
       throw new ConflictingSpecificationError(
         "Can't mix weekYear/weekNumber units with year/month/day or ordinals"
@@ -25374,15 +25394,15 @@ var DateTime = class _DateTime {
     let mixed;
     if (settingWeekStuff) {
       mixed = weekToGregorian(
-        { ...gregorianToWeek(this.c, minDaysInFirstWeek, startOfWeek), ...normalized },
+        { ...gregorianToWeek(this.c, minDaysInFirstWeek, startOfWeek), ...normalized2 },
         minDaysInFirstWeek,
         startOfWeek
       );
-    } else if (!isUndefined(normalized.ordinal)) {
-      mixed = ordinalToGregorian({ ...gregorianToOrdinal(this.c), ...normalized });
+    } else if (!isUndefined(normalized2.ordinal)) {
+      mixed = ordinalToGregorian({ ...gregorianToOrdinal(this.c), ...normalized2 });
     } else {
-      mixed = { ...this.toObject(), ...normalized };
-      if (isUndefined(normalized.day)) {
+      mixed = { ...this.toObject(), ...normalized2 };
+      if (isUndefined(normalized2.day)) {
         mixed.day = Math.min(daysInMonth(mixed.year, mixed.month), mixed.day);
       }
     }
@@ -28116,8 +28136,8 @@ function idFromDigest(bytes) {
 function extensionIdForPath(absDir, platform2 = process.platform) {
   if (platform2 !== "win32")
     return idFromDigest(Buffer.from(absDir, "utf8"));
-  const normalized = /^[a-z]:/.test(absDir) ? absDir[0].toUpperCase() + absDir.slice(1) : absDir;
-  return idFromDigest(Buffer.from(normalized, "utf16le"));
+  const normalized2 = /^[a-z]:/.test(absDir) ? absDir[0].toUpperCase() + absDir.slice(1) : absDir;
+  return idFromDigest(Buffer.from(normalized2, "utf16le"));
 }
 function extensionIdForKey(base64Key) {
   return idFromDigest(Buffer.from(base64Key.replace(/\s+/g, ""), "base64"));
@@ -33945,18 +33965,18 @@ function stepIdsOf(rec) {
         ids.add(s3.stepId);
   return ids;
 }
-function canonicalJson(v) {
+function canonicalJson2(v) {
   if (Array.isArray(v))
-    return `[${v.map(canonicalJson).join(",")}]`;
+    return `[${v.map(canonicalJson2).join(",")}]`;
   if (v !== null && typeof v === "object") {
     const o = v;
-    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`).join(",")}}`;
+    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson2(o[k])}`).join(",")}}`;
   }
   return JSON.stringify(v) ?? "null";
 }
 function seededRandom(rec) {
   let h = 2166136261;
-  const text2 = canonicalJson(rec);
+  const text2 = canonicalJson2(rec);
   for (let i = 0; i < text2.length; i++) {
     h ^= text2.charCodeAt(i);
     h = Math.imul(h, 16777619) >>> 0;
@@ -37195,8 +37215,8 @@ function isSecretField(inputType, autocomplete, hints) {
     const raw = list2[i];
     if (typeof raw !== "string" || raw === "")
       continue;
-    const normalized = raw.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([A-Za-z])([0-9])/g, "$1 $2").replace(/[_\-.:[\]/]+/g, " ").toLowerCase();
-    if (credential.test(normalized))
+    const normalized2 = raw.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([A-Za-z])([0-9])/g, "$1 $2").replace(/[_\-.:[\]/]+/g, " ").toLowerCase();
+    if (credential.test(normalized2))
       return true;
   }
   return false;
@@ -38621,8 +38641,8 @@ async function readSnapshot(page, opts) {
 // ../explore/dist/settle-config.js
 var DEFAULT_LONG_POLL_MS = 5e3;
 function globToRegExp2(glob) {
-  const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
+  const escaped2 = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped2}$`);
 }
 function urlMatcher(patterns) {
   const compiled = (patterns ?? []).map((p) => ({ full: p.includes("://"), re: globToRegExp2(p) }));
@@ -39557,6 +39577,31 @@ function visibleBusyIndicatorContainer() {
   }
   return null;
 }
+function visibleBusyIndicatorText() {
+  const shown2 = (el) => {
+    const r = el.getBoundingClientRect();
+    const s3 = window.getComputedStyle(el);
+    return r.width > 0 && r.height > 0 && s3.visibility !== "hidden" && s3.display !== "none" && s3.opacity !== "0";
+  };
+  const progressbar = '[role="progressbar"]:not([aria-valuenow])';
+  const selectors = ['[aria-busy="true"]', progressbar, '[class*="spinner" i]', '[class*="animate-spin" i]'];
+  const notificationContainer = '[role="alert"], [data-sonner-toast], [class*="toast" i], [class*="snackbar" i], [class*="notification" i]';
+  const timerLabel = /timer|countdown|auto.?close/i;
+  const isNotificationTimer = (el) => el.closest(notificationContainer) !== null || timerLabel.test(`${el.getAttribute("aria-label") ?? ""} ${el.getAttribute("title") ?? ""}`);
+  const words3 = (el) => el === null ? "" : (el.getAttribute("aria-label") ?? el.innerText ?? el.textContent ?? "").replace(/\s+/g, " ").trim();
+  for (const sel of selectors) {
+    for (const el of Array.from(document.querySelectorAll(sel))) {
+      if (!shown2(el))
+        continue;
+      if (sel === progressbar && isNotificationTimer(el))
+        continue;
+      const own2 = words3(el);
+      const text2 = own2 !== "" ? own2 : words3(el.closest('[role="status"], [aria-live]:not([aria-live="off"])'));
+      return text2 === "" ? null : text2.slice(0, 200);
+    }
+  }
+  return null;
+}
 function pendingEvidence(pending, now2) {
   return [...pending].sort((a, b2) => a.startedAt - b2.startedAt).map((r) => ({ endpoint: endpointOf(r.method, r.url), url: redactUrl(r.url), ageMs: Math.max(0, now2 - r.startedAt) }));
 }
@@ -40808,7 +40853,8 @@ async function perceive(page, opts = {}) {
       const busySince = clock.now();
       const remaining = Math.max(1, ceiling - (clock.now() - started));
       const gone = await clockBounded(page.waitForFunction(visibleBusyIndicator, true, { timeout: remaining, polling: "raf" }).then(() => true, (e) => !(e instanceof Error && e.name === "TimeoutError")), remaining, false);
-      if (!gone && !ignoreNoProgress(busy) && !ignoreNoProgress(hangRoute(page.url()))) {
+      const busyText = gone ? null : await page.evaluate(visibleBusyIndicatorText).catch(() => null);
+      if (!gone && !ignoreNoProgress(busy) && !(busyText !== null && ignoreDeclared(busyText)) && !ignoreNoProgress(hangRoute(page.url()))) {
         stuckBusy = busy;
         stuckBusyContainer = await page.evaluate(visibleBusyIndicatorContainer).catch(() => null);
         const now2 = await page.evaluate(visibleBusyIndicator).catch(() => null);
@@ -42172,6 +42218,7 @@ async function judgeGoalCompletion(judge, input2) {
       ...input2.signInFacts === void 0 ? [] : [`SIGN-IN (observed by code, trusted): ${input2.signInFacts}`],
       ...input2.saveFacts === void 0 ? [] : [`SAVE (observed by code, trusted): ${input2.saveFacts}`],
       ...input2.writeFacts === void 0 ? [] : [`WRITES (observed by code, trusted): ${input2.writeFacts}`],
+      ...input2.readBackFacts === void 0 ? [] : [`READ-BACK (observed by code, trusted): ${input2.readBackFacts}`],
       ...input2.pageStatus === void 0 || input2.pageStatus === "" ? [] : [`PAGE STATUS (untrusted): ${input2.pageStatus}`],
       `VISIBLE PAGE TEXT (untrusted): ${input2.pageText.replace(/\s+/g, " ").slice(0, GOAL_TEXT_CHARS)}`,
       ...input2.fieldValues === void 0 || input2.fieldValues.length === 0 ? [] : [
@@ -44090,6 +44137,7 @@ var MAX_REPEAT_TYPE_SIGNALS = 3;
 var MAX_QUIET_WAITS = 3;
 var MAX_MOVING_SCROLLS = 12;
 var LAST_CHANCE_NOTE = "no progress: the last steps left the page unchanged and you have seen the whole page \u2014 act on a visible control, report the answer, or say done/blocked now";
+var LAST_CHANCE_NO_WRITE_NOTE = "no progress: the last steps left the page unchanged and you have seen the whole page, but no write of this run has succeeded yet \u2014 the goal asks for a change the app must receive: go back and press the control that submits it (Import, Save, Send\u2026), or say blocked if the app offers none";
 
 // ../explore/dist/run-depth.js
 var OPEN_ENDED_MIN_ACTIONS = 12;
@@ -44964,11 +45012,11 @@ function hostProbe(signals = createResourceSignals(), thresholds = DEFAULT_PRESS
 function initHost(ctx, cfg) {
   ctx.probeHost = cfg.hostProbe ?? hostProbe();
   ctx.judgeHost = async () => cfg.hostHealth === void 0 ? { host: await ctx.probeHost(), starved: null } : cfg.hostHealth.judge();
-  ctx.degradedStop = (finding3, detail, starved) => {
-    cfg.hostHealth?.markDegraded({ finding: finding3, detail, step: Math.max(0, ctx.transcript.entries().length - 1) }, starved);
+  ctx.degradedStop = (finding4, detail, starved) => {
+    cfg.hostHealth?.markDegraded({ finding: finding4, detail, step: Math.max(0, ctx.transcript.entries().length - 1) }, starved);
     ctx.failure = {
       kind: "degraded-environment",
-      message: `environment-degraded ${finding3} (${detail}) while the host was starved: ${starved} \u2014 not an app finding`
+      message: `environment-degraded ${finding4} (${detail}) while the host was starved: ${starved} \u2014 not an app finding`
     };
     ctx.stop = "inconclusive";
   };
@@ -45379,6 +45427,7 @@ function initLoopState(ctx) {
   ctx.fixtureAttached = false;
   ctx.hang = void 0;
   ctx.outcome = null;
+  ctx.actionableControl = null;
   ctx.incomplete = null;
   ctx.endedOnRejectedDone = false;
 }
@@ -45607,6 +45656,7 @@ var OBSERVED_PAGE_CHARS = 2e4;
 var MIN_QUOTE_CHARS = 3;
 var MAX_OBSERVED_FIELDS = 40;
 var OBSERVED_FIELD_CHARS = 500;
+var MAX_READ_BACK_VALUES = 50;
 var MAX_OBSERVED_CONTROLS = 120;
 var HEADING_CHARS = 200;
 function controlFields(controls) {
@@ -45696,6 +45746,21 @@ var ObservedPages = class {
         this.#sourceRoute.set(v, pending.route);
     }
   }
+  /**
+   * #671: values the run typed into a field on one document load. A field holding one shows the run's
+   * own entry, never what the app kept: retyping a sent message into its composer after a reload is
+   * not a read-back.
+   */
+  #typedOn = null;
+  /** #671: the run typed `value` into a field (a message composer too) on document load `document`. */
+  noteTypedOn(value, document2) {
+    const v = fold(redactContext(value, this.secrets).slice(0, OBSERVED_FIELD_CHARS));
+    if (document2 === void 0 || v === "")
+      return;
+    if (this.#typedOn?.document !== document2)
+      this.#typedOn = { document: document2, values: /* @__PURE__ */ new Set() };
+    this.#typedOn.values.add(v);
+  }
   /** #647: the run's sent values (folded) that no page loaded from the server since has shown. */
   unreadWrites() {
     return this.#unread;
@@ -45720,10 +45785,19 @@ var ObservedPages = class {
       this.#sourceRoute.delete(v);
     }
     this.#readBackCount += back.length;
+    for (const v of back)
+      if (this.#readBackValues.length < MAX_READ_BACK_VALUES)
+        this.#readBackValues.push(v);
     return back;
   }
   /** #645: how many sent values a page loaded from the server has shown again. */
   #readBackCount = 0;
+  /** #667: the sent values (folded) read back so far, bounded. */
+  #readBackValues = [];
+  /** #667: the sent values (folded) a page loaded from the server has shown again. */
+  readBackValues() {
+    return this.#readBackValues;
+  }
   /**
    * #645: the app was seen to keep what the run's writes sent — at least one value was read back and
    * none is still unread. Code evidence the page judgment lacks (see `groundDone`).
@@ -45766,7 +45840,9 @@ var ObservedPages = class {
         this.#topNav = nav;
     }
     this.#settleSent(page.text);
-    this.readBack(headings2.document, [page.text, ...kept.map((f2) => f2.value)].join("\n"), url2);
+    const typed = this.#typedOn !== null && this.#typedOn.document === headings2.document ? [...this.#typedOn.values] : [];
+    const appFields = kept.map((f2) => f2.value).filter((value) => !typed.some((t) => fold(value).includes(t)));
+    this.readBack(headings2.document, [page.text, ...appFields].join("\n"), url2);
     if (page.text.trim() === "" && kept.length === 0)
       return;
     const same = (p) => JSON.stringify(p.fields ?? []) === JSON.stringify(page.fields ?? []) && p.heading === page.heading && p.title === page.title && p.status === page.status && JSON.stringify(p.controls ?? []) === JSON.stringify(page.controls ?? []) && JSON.stringify(p.contentLinks ?? []) === JSON.stringify(page.contentLinks ?? []) && p.inventoryIncomplete === page.inventoryIncomplete;
@@ -46431,7 +46507,7 @@ var ABSENCE_GOAL = /\bwhether\b|\b(?:is|are) there\b|\bthere (?:is|are) (?:no|no
 function goalAdmitsAbsence(goal) {
   return ABSENCE_GOAL.test(goal);
 }
-var WRITE_GOAL = /(?:^\s*|[.!?;:]\s+|\b(?:then|and|please)\s+)(?:record|save|create|add|invite|submit|send|post|publish|register|book|schedule)\b/i;
+var WRITE_GOAL = /(?:^\s*|[.!?;:]\s+|\b(?:then|and|please)\s+)(?:record|save|create|add|invite|submit|send|post|publish|register|book|schedule|import|upload|update|change|edit|rename|delete|remove)\b/i;
 function goalAsksToWrite(goal) {
   return WRITE_GOAL.test(goal);
 }
@@ -46718,7 +46794,7 @@ function busyIndicatorOf(hang) {
     return null;
   if (hang.element !== void 0 && hang.element !== "")
     return hang.element;
-  const m = /^a busy indicator \((.+)\) never went away within \d+ms(?: \(still so after .*\))?$/.exec(hang.detail.trim());
+  const m = /^a busy indicator \((.+)\) never went away within \d+ms(?: \((?:still so after|the page stopped showing work) .*\))?$/.exec(hang.detail.trim());
   return m?.[1] ?? null;
 }
 function legacySelectorForm(indicator) {
@@ -46939,8 +47015,8 @@ async function recordCoverageHang(p) {
     ...p.perceive === void 0 ? {} : { perceive: p.perceive },
     ...p.safety === void 0 ? {} : { safety: p.safety }
   });
-  const finding3 = hangFinding(hang, p.steps, index, reproduction);
-  p.found.set(fingerprint2, { ...finding3, repro: { ...finding3.repro, recording: p.recording } });
+  const finding4 = hangFinding(hang, p.steps, index, reproduction);
+  p.found.set(fingerprint2, { ...finding4, repro: { ...finding4.repro, recording: p.recording } });
   return "recorded";
 }
 
@@ -48130,6 +48206,7 @@ function initGuards(ctx, cfg) {
   ctx.jobWaitedMs = 0;
   ctx.overlayWaitedMs = 0;
   ctx.hangWorkWaitedMs = 0;
+  ctx.hangWorkSince = null;
   ctx.documentedBudgetMs = 0;
 }
 
@@ -48275,6 +48352,7 @@ function newStep(ctx, input2) {
         if (proposedDone)
           writes = jobWritesOf(ctx);
         const writeFacts = writes !== void 0 && saved === null && writesAllSucceeded(writes) ? writes.facts : void 0;
+        const readBackFacts = ctx.observed.readBackConfirmed() ? readBackFactsOf(ctx.observed.readBackValues(), pageText) : void 0;
         const judged = await judgeGoalCompletion(cfg.judge, {
           goal: cfg.goal,
           url: snap.url,
@@ -48285,6 +48363,7 @@ function newStep(ctx, input2) {
           ...signIn === null ? {} : { signInFacts: signIn.facts },
           ...saved === null ? {} : { saveFacts: saved.facts },
           ...writeFacts === void 0 ? {} : { writeFacts },
+          ...readBackFacts === void 0 ? {} : { readBackFacts },
           fieldValues: fieldValuesOf(snap.controls, ctx.isBound)
         }).catch(() => ({ goalMet: null, goalIsSignIn: null, goalIsSave: null, goalIsWrites: null }));
         goalMet = judged.goalMet;
@@ -48315,6 +48394,11 @@ function newStep(ctx, input2) {
   };
   return { ...input2, record: record2, signIn, pendingNote, acceptedBy, groundGoal };
 }
+function readBackFactsOf(values2, pageText) {
+  const text2 = pageText.toLowerCase();
+  const shown2 = values2.filter((v) => text2.includes(v)).length;
+  return `every value this run's writes sent (${values2.length}) was shown again on a page loaded from the server after the write \u2014 the app kept them; this page shows ${shown2} of them`;
+}
 
 // ../explore/dist/goal-loop/min-effort.js
 function deferEnding(ctx, step, ending) {
@@ -48363,87 +48447,8 @@ function unreadShown(ctx, step) {
   return ctx.observed.unreadShownIn(shownOn(step));
 }
 
-// ../explore/dist/goal-loop/handle-report.js
-async function handleReport(ctx, step) {
-  const { cfg } = ctx;
-  const { snap, record: record2 } = step;
-  if (ctx.replyGoal) {
-    if (ctx.awaitingReply && ctx.lastTurn !== null && ctx.replyWaitedMs < ctx.replyWaitMs) {
-      const t0 = ctx.now();
-      const listen = ctx.replyWaitMs - ctx.replyWaitedMs;
-      const reply = await waitForReply(ctx.page, { secrets: ctx.secrets, ...ctx.lastTurn, timeoutMs: listen, ceilingMs: listen, quietMs: ctx.replyQuietMs });
-      ctx.replyWaitedMs += ctx.now() - t0;
-      if (reply.received) {
-        ctx.conversation.latestReply = reply.text;
-        ctx.replies.add(snap.url, reply.text);
-        ctx.awaitingReply = false;
-        ctx.busyWaitedMs = 0;
-        ctx.history.push(`waited for the reply \u2192 reply: ${quote(reply.text, 300)}`);
-      }
-    }
-    ctx.noteReplyText(snap.url, await readPageText(ctx.page, ctx.secrets));
-  }
-  const replyPages = ctx.replyGoal ? ctx.replies.pages() : null;
-  if (replyPages === null)
-    await readBackProbe(ctx, step);
-  const verdict = replyPages !== null && replyPages.length === 0 ? {
-    accept: false,
-    reason: ctx.preSend === null ? "no reply observed: no message was sent yet \u2014 text on the page before the conversation is not a reply" : `no reply observed: no new message appeared after the send within the reply wait (${Math.round(ctx.replyWaitMs / 1e3)}s)`,
-    answer: null
-  } : await reportAnswer(cfg.gen, {
-    goal: cfg.goal,
-    url: snap.url,
-    pages: replyPages ?? ctx.observed.pages(),
-    history: ctx.history,
-    secrets: ctx.secrets,
-    judge: cfg.judge,
-    vetoes: ctx.vetoes,
-    // #238: "none exists" is an answer only on observed pages that cover the app enough.
-    ...replyPages === null ? { topNav: ctx.observed.topNavigation(), ownInputs: ctx.observed.ownInputs(), unreadWrites: ctx.observed.unreadWrites() } : {}
-  }).then((v) => v.accept && ctx.writeGoal && !ctx.wroteOk && v.answer.absent !== true ? { accept: false, reason: UNSAVED_WRITE_REASON, answer: v.answer } : v).catch((e) => ({ accept: false, reason: `no answer could be generated: ${firstLine(e)}`, answer: null }));
-  if (verdict.accept) {
-    const deferred = deferEnding(ctx, step, "report");
-    if (deferred !== null) {
-      ctx.deferredAnswer = verdict.answer;
-      record2(false, deferred, { answer: verdict.answer, origin: "engine" });
-      return "continue";
-    }
-  }
-  if (verdict.accept) {
-    const on = replyPages === null ? "the observed pages" : "the reply observed after the send";
-    record2(true, `report accepted: answer grounded on ${on} (${verdict.answer.evidence.length} claim(s))`, {
-      answer: verdict.answer
-    });
-    ctx.answer = verdict.answer;
-    ctx.outcome = { status: "completed", verifiedBy: "grounded-answer" };
-    ctx.stop = "done";
-    return "stop";
-  }
-  if (verdict.unconfirmedWrite === true && !ctx.readBackAsked) {
-    ctx.readBackAsked = true;
-    ctx.history.push(`report deferred: ${verdict.reason}`);
-    record2(false, `report deferred: ${verdict.reason}`, { answer: verdict.answer, origin: "engine" });
-    return "continue";
-  }
-  ctx.reportRejections += 1;
-  for (const e of verdict.answer?.evidence ?? [])
-    if (e.grounded)
-      ctx.reportClaims.push(e);
-  ctx.lastReportNotFound = verdict.answer === null && verdict.reason === NO_ANSWER_REASON || verdict.notAnswer === true;
-  ctx.lastAbsenceUncovered = verdict.absenceUncovered === true ? verdict.reason : null;
-  ctx.history.push(`report rejected: ${verdict.reason} \u2014 find the answer on the page before reporting`);
-  record2(false, `report rejected (${ctx.reportRejections}/${MAX_REPORT_REJECTIONS}): ${verdict.reason}`, {
-    answer: verdict.answer
-  });
-  if (ctx.reportRejections >= MAX_REPORT_REJECTIONS && deferEnding(ctx, step, "report") === null) {
-    ctx.incomplete = `the model reported an answer ${ctx.reportRejections} times, but ${verdict.reason}`;
-    ctx.stop = "blocked";
-    return "stop";
-  }
-  return "continue";
-}
-
 // ../explore/dist/goal-loop/handle-done.js
+var NO_WRITE_YET = "no write of this run has succeeded yet \u2014 the goal asks for a change the app must receive: go back and press the control that submits it (Import, Save, Send\u2026)";
 async function unreadWriteHold(ctx, step, outcome) {
   if (outcome.status === "completed" && outcome.verifiedBy === "success-condition")
     return null;
@@ -48535,12 +48540,13 @@ async function handleDone(ctx, step) {
       }
     }
     ctx.doneRejections += 1;
-    ctx.history.push(`done rejected: ${verdict.reason} \u2014 keep working toward the goal`);
-    record2(false, `done rejected (${ctx.doneRejections}/${MAX_DONE_REJECTIONS}): ${verdict.reason}`, {
+    const why = ctx.writeGoal && !ctx.wroteOk ? `${verdict.reason}; ${NO_WRITE_YET}` : verdict.reason;
+    ctx.history.push(`done rejected: ${why} \u2014 keep working toward the goal`);
+    record2(false, `done rejected (${ctx.doneRejections}/${MAX_DONE_REJECTIONS}): ${why}`, {
       ...judgments === void 0 ? {} : { judgments }
     });
     if (ctx.doneRejections >= MAX_DONE_REJECTIONS) {
-      ctx.incomplete = `the model proposed done ${ctx.doneRejections} times, but ${verdict.reason}`;
+      ctx.incomplete = `the model proposed done ${ctx.doneRejections} times, but ${why}`;
       ctx.endedOnRejectedDone = true;
       ctx.stop = "done";
       return "stop";
@@ -48550,7 +48556,146 @@ async function handleDone(ctx, step) {
   return "next";
 }
 
+// ../explore/dist/goal-loop/handle-report.js
+async function handleReport(ctx, step) {
+  const { cfg } = ctx;
+  const { snap, record: record2 } = step;
+  if (ctx.replyGoal) {
+    if (ctx.awaitingReply && ctx.lastTurn !== null && ctx.replyWaitedMs < ctx.replyWaitMs) {
+      const t0 = ctx.now();
+      const listen = ctx.replyWaitMs - ctx.replyWaitedMs;
+      const reply = await waitForReply(ctx.page, { secrets: ctx.secrets, ...ctx.lastTurn, timeoutMs: listen, ceilingMs: listen, quietMs: ctx.replyQuietMs });
+      ctx.replyWaitedMs += ctx.now() - t0;
+      if (reply.received) {
+        ctx.conversation.latestReply = reply.text;
+        ctx.replies.add(snap.url, reply.text);
+        ctx.awaitingReply = false;
+        ctx.busyWaitedMs = 0;
+        ctx.history.push(`waited for the reply \u2192 reply: ${quote(reply.text, 300)}`);
+      }
+    }
+    ctx.noteReplyText(snap.url, await readPageText(ctx.page, ctx.secrets));
+  }
+  const replyPages = ctx.replyGoal ? ctx.replies.pages() : null;
+  if (replyPages === null)
+    await readBackProbe(ctx, step);
+  const verdict = replyPages !== null && replyPages.length === 0 ? {
+    accept: false,
+    reason: ctx.preSend === null ? "no reply observed: no message was sent yet \u2014 text on the page before the conversation is not a reply" : `no reply observed: no new message appeared after the send within the reply wait (${Math.round(ctx.replyWaitMs / 1e3)}s)`,
+    answer: null
+  } : await reportAnswer(cfg.gen, {
+    goal: cfg.goal,
+    url: snap.url,
+    pages: replyPages ?? ctx.observed.pages(),
+    history: ctx.history,
+    secrets: ctx.secrets,
+    judge: cfg.judge,
+    vetoes: ctx.vetoes,
+    // #238: "none exists" is an answer only on observed pages that cover the app enough.
+    ...replyPages === null ? { topNav: ctx.observed.topNavigation(), ownInputs: ctx.observed.ownInputs(), unreadWrites: ctx.observed.unreadWrites() } : {}
+  }).then((v) => v.accept && ctx.writeGoal && !ctx.wroteOk && v.answer.absent !== true ? { accept: false, reason: UNSAVED_WRITE_REASON, answer: v.answer } : v).catch((e) => ({ accept: false, reason: `no answer could be generated: ${firstLine(e)}`, answer: null }));
+  if (verdict.accept) {
+    const deferred = deferEnding(ctx, step, "report");
+    if (deferred !== null) {
+      ctx.deferredAnswer = verdict.answer;
+      record2(false, deferred, { answer: verdict.answer, origin: "engine" });
+      return "continue";
+    }
+  }
+  if (verdict.accept) {
+    const on = replyPages === null ? "the observed pages" : "the reply observed after the send";
+    record2(true, `report accepted: answer grounded on ${on} (${verdict.answer.evidence.length} claim(s))`, {
+      answer: verdict.answer
+    });
+    ctx.answer = verdict.answer;
+    ctx.outcome = { status: "completed", verifiedBy: "grounded-answer" };
+    ctx.stop = "done";
+    return "stop";
+  }
+  if (verdict.unconfirmedWrite === true && !ctx.readBackAsked) {
+    ctx.readBackAsked = true;
+    ctx.history.push(`report deferred: ${verdict.reason}`);
+    record2(false, `report deferred: ${verdict.reason}`, { answer: verdict.answer, origin: "engine" });
+    return "continue";
+  }
+  ctx.reportRejections += 1;
+  for (const e of verdict.answer?.evidence ?? [])
+    if (e.grounded)
+      ctx.reportClaims.push(e);
+  ctx.lastReportNotFound = verdict.answer === null && verdict.reason === NO_ANSWER_REASON || verdict.notAnswer === true;
+  ctx.lastAbsenceUncovered = verdict.absenceUncovered === true ? verdict.reason : null;
+  const noWrite = ctx.writeGoal && !ctx.wroteOk && verdict.reason !== UNSAVED_WRITE_REASON;
+  const why = noWrite ? `${verdict.reason}; ${NO_WRITE_YET}` : verdict.reason;
+  ctx.history.push(`report rejected: ${why} \u2014 ${noWrite ? "make the change first, then report" : "find the answer on the page before reporting"}`);
+  record2(false, `report rejected (${ctx.reportRejections}/${MAX_REPORT_REJECTIONS}): ${why}`, {
+    answer: verdict.answer
+  });
+  if (ctx.reportRejections >= MAX_REPORT_REJECTIONS && deferEnding(ctx, step, "report") === null) {
+    ctx.incomplete = `the model reported an answer ${ctx.reportRejections} times, but ${verdict.reason}`;
+    ctx.stop = "blocked";
+    return "stop";
+  }
+  return "continue";
+}
+
 // ../explore/dist/goal-loop/handle-blocked.js
+var RECOVERY_TURNS = /* @__PURE__ */ new WeakMap();
+function takeRecoveryTurn(ctx) {
+  const turn = RECOVERY_TURNS.get(ctx);
+  if (turn === void 0 || !turn.pending)
+    return null;
+  turn.pending = false;
+  return turn.safe;
+}
+function resumeIdentity(e) {
+  return JSON.stringify(e.resume);
+}
+var NON_FORWARD = /^(?:back|go back|previous|return|cancel|close|dismiss|×|x|←|‹|arrow[- ]?left)\b/i;
+var DIRECTIVE = /\b(?:choose|select|pick|apply|submit|continue|confirm|save|open|click|press|start|create|send|next|review|accept|approve|add|complete|proceed|generate|upload|finish|sign|log|book|buy|upgrade|run|try|edit|set)\b/i;
+var normalized = (text2) => text2.replace(/\s+/g, " ").trim().toLowerCase();
+var escaped = (text2) => text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function instructionText(controls, visibleText) {
+  const counts2 = /* @__PURE__ */ new Map();
+  for (const c of controls) {
+    const label2 = normalized(c.name);
+    if (label2 !== "")
+      counts2.set(label2, (counts2.get(label2) ?? 0) + 1);
+  }
+  let text2 = normalized(visibleText);
+  for (const [label2, count] of counts2)
+    for (let i = 0; i < count; i++) {
+      const matches2 = [...text2.matchAll(new RegExp(`\\b${escaped(label2)}\\b`, "g"))];
+      const last = matches2.at(-1);
+      if (last?.index === void 0)
+        break;
+      text2 = `${text2.slice(0, last.index)} ${text2.slice(last.index + last[0].length)}`.replace(/\s+/g, " ").trim();
+    }
+  return text2;
+}
+function primaryForwardControl(ctx, step) {
+  const goalTerms = terms(ctx.goalText);
+  if (goalTerms.size === 0)
+    return null;
+  const instruction = instructionText(step.modelControls, step.visibleText);
+  const instructionTerms = terms(instruction);
+  if (instructionTerms.size === 0 || !DIRECTIVE.test(instruction))
+    return null;
+  for (const control of step.modelControls) {
+    if (!control.enabled)
+      continue;
+    const name = control.name.trim();
+    if (name === "" || NON_FORWARD.test(name))
+      continue;
+    if (ctx.depth.tried(step.snap.url, name))
+      continue;
+    const controlTerms = terms(name);
+    if (controlTerms.size === 0)
+      continue;
+    if ([...controlTerms].some((t) => goalTerms.has(t)) && [...controlTerms].every((t) => instructionTerms.has(t)))
+      return control;
+  }
+  return null;
+}
 async function handleBlocked(ctx, step) {
   const { modelControls, record: record2 } = step;
   const job = await readInProgressStatus(ctx.page);
@@ -48600,16 +48745,221 @@ async function handleBlocked(ctx, step) {
     ctx.stop = "inconclusive";
     return "stop";
   }
+  const forward = ctx.actionAttempts > 0 ? primaryForwardControl(ctx, step) : null;
+  if (forward !== null) {
+    ctx.earlyBlocked += 1;
+    if (ctx.earlyBlocked <= MAX_EARLY_BLOCKED_REFUSALS) {
+      const reason = `blocked refused: ${quote(forward.name || forward.summary, 60)} is an obvious forward control, still untried on this page, and it matches the goal and the page's instruction \u2014 use it before giving up`;
+      ctx.history.push(reason);
+      record2(false, reason, { origin: "engine" });
+      return "continue";
+    }
+    record2(false, `model blocked while ${quote(forward.name || forward.summary, 60)} remained untried`, { origin: "engine" });
+    ctx.failure = {
+      kind: "insufficient-coverage",
+      message: `the model gave up while ${quote(forward.name || forward.summary, 60)} \u2014 the obvious forward control the goal and the page's instruction name \u2014 was still untried after earlier actions \u2014 too little exploration to conclude the goal cannot be done`
+    };
+    ctx.stop = "inconclusive";
+    return "stop";
+  }
   const deferred = deferEnding(ctx, step, "blocked");
   if (deferred !== null) {
     record2(false, deferred, { origin: "engine" });
     return "continue";
   }
+  const evidence = await collectActionableControlEvidence(ctx.page, { screenshots: false }).catch(() => []);
+  const safe = evidence.filter((e) => e.kind === "safe" && e.name !== "");
+  const turn = RECOVERY_TURNS.get(ctx);
+  if ((turn === void 0 || !turn.given) && safe.length > 0) {
+    RECOVERY_TURNS.set(ctx, { safe, given: true, pending: true });
+    const note = `blocked: one recovery turn is available through the safe control(s) ${safe.map((e) => `${quote(e.name, 40)} (${e.locator})`).join(", ")} \u2014 act through one of them or the run ends blocked`;
+    ctx.history.push(note);
+    record2(false, note, { origin: "engine" });
+    return "continue";
+  }
   record2(true, "model blocked");
-  ctx.incomplete = `the model reported the goal cannot be advanced from this page${ctx.lastRefusal === null ? "" : ` (${ctx.lastRefusal})`}`;
+  const turnSafe = turn !== void 0 && turn.given && turn.safe.length > 0 ? turn.safe : null;
+  const excluded = evidence.filter((e) => e.kind !== "safe");
+  const classes = [...new Set(excluded.map((e) => e.kind))].join(", ");
+  const best = turnSafe !== null ? turnSafe[0] : excluded.find((e) => e.kind !== "hidden" && e.kind !== "disabled") ?? evidence[0];
+  if (best !== void 0) {
+    const captured = (await collectActionableControlEvidence(ctx.page).catch(() => evidence)).find((e) => e.locator === best.locator);
+    ctx.actionableControl = actionableControlOutcome(captured ?? best);
+  }
+  const refusal = ctx.lastRefusal === null ? "" : ` (${ctx.lastRefusal})`;
+  const base = `the model reported the goal cannot be advanced from this page${refusal}`;
+  const recovery = turnSafe !== null ? `the one recovery turn through the safe control ${turnSafe.map(resumeIdentity).join(", ")} did not advance the goal` : `no visible enabled safe control is available to recover through${classes === "" ? "" : ` (excluded control classes: ${classes})`}${best === void 0 ? "" : `; resume identity ${resumeIdentity(best)}`}`;
+  const cause = ctx.blockingCause();
+  ctx.incomplete = cause === null || base.includes(cause) ? `${base}; ${recovery}` : `${base} \u2014 last blocker: ${cause}; ${recovery}`;
   ctx.stop = "blocked";
   return "stop";
 }
+var RECOVERY_SELECTOR = [
+  "a[href]",
+  "button",
+  "input:not([type=hidden])",
+  "select",
+  "textarea",
+  "[role=button]",
+  "[role=link]",
+  "[role=menuitem]",
+  "[role=tab]",
+  "[role=checkbox]",
+  "[role=radio]",
+  "[role=switch]",
+  "[contenteditable=true]"
+].join(", ");
+var APPROVAL = /\b(?:approve|approval|authorize|authorise|accept|grant|sign[ -]?off|confirm)\b/i;
+var SAFE_PREDICATE = "visible && enabled && !ambiguous && !destructive && !financial && !approval";
+function readRecoveryCandidates(els) {
+  const nameOf = (el) => {
+    const aria = el.getAttribute("aria-label");
+    if (aria !== null && aria.trim() !== "")
+      return aria.replace(/\s+/g, " ").trim();
+    const labelled = el.getAttribute("aria-labelledby");
+    if (labelled !== null) {
+      const text2 = labelled.split(/\s+/).map((id) => document.getElementById(id)?.textContent ?? "").join(" ");
+      if (text2.trim() !== "")
+        return text2.replace(/\s+/g, " ").trim();
+    }
+    const title = el.getAttribute("title");
+    if (title !== null && title.trim() !== "")
+      return title.replace(/\s+/g, " ").trim();
+    if (el instanceof HTMLInputElement && el.type !== "password" && el.value !== "")
+      return el.value.replace(/\s+/g, " ").trim();
+    return (el.textContent ?? "").replace(/\s+/g, " ").trim();
+  };
+  return els.map((el) => {
+    const style = getComputedStyle(el);
+    const rect = el.getBoundingClientRect();
+    const visible3 = style.display !== "none" && style.visibility !== "hidden" && el.getClientRects().length > 0 && rect.width > 0 && rect.height > 0;
+    const disabled = el.disabled === true || el.getAttribute("aria-disabled") === "true";
+    return {
+      name: nameOf(el),
+      role: el.getAttribute("role") ?? el.tagName.toLowerCase(),
+      testId: el.getAttribute("data-testid") ?? el.getAttribute("data-test"),
+      id: el.id === "" ? null : el.id,
+      visible: visible3,
+      enabled: !disabled,
+      box: visible3 ? { x: rect.x + window.scrollX, y: rect.y + window.scrollY, width: rect.width, height: rect.height } : null
+    };
+  });
+}
+function classifyActionableControl(input2) {
+  if (!input2.visible)
+    return "hidden";
+  if (!input2.enabled)
+    return "disabled";
+  if (input2.duplicateName)
+    return "ambiguous";
+  const risk = controlRisk(input2.name, input2.role);
+  if (risk !== null && (risk.risk === "destructive" || risk.risk === "session-end"))
+    return "destructive";
+  if (risk !== null && risk.risk === "paid")
+    return "financial";
+  if (APPROVAL.test(input2.name))
+    return "approval";
+  return "safe";
+}
+function recoveryPredicate(kind) {
+  switch (kind) {
+    case "safe":
+      return SAFE_PREDICATE;
+    case "hidden":
+      return "visible";
+    case "disabled":
+      return "enabled";
+    case "ambiguous":
+      return "uniquely named";
+    case "destructive":
+      return "!destructive";
+    case "financial":
+      return "!financial";
+    case "approval":
+      return "!approval";
+  }
+}
+function recoveryLocator(c) {
+  if (c.testId !== null && c.testId !== "")
+    return `[data-testid="${c.testId}"]`;
+  if (c.id !== null && c.id !== "")
+    return `#${c.id}`;
+  const role = c.role === "" ? "*" : c.role;
+  return `${role}[name="${c.name.replace(/"/g, '\\"')}"]`;
+}
+var SAFE_CLAUSES = ["visible", "enabled", "!ambiguous", "!destructive", "!financial", "!approval"];
+function failingClause(kind) {
+  switch (kind) {
+    case "safe":
+      return null;
+    case "hidden":
+      return "visible";
+    case "disabled":
+      return "enabled";
+    case "ambiguous":
+      return "!ambiguous";
+    case "destructive":
+      return "!destructive";
+    case "financial":
+      return "!financial";
+    case "approval":
+      return "!approval";
+  }
+}
+function actionableControlOutcome(e) {
+  const missing = failingClause(e.kind);
+  return {
+    kind: "author_stopped_with_actionable_control",
+    candidate: {
+      locator: e.locator,
+      label: e.name,
+      visible: e.kind !== "hidden",
+      enabled: e.kind !== "disabled",
+      screenshot: e.screenshot,
+      resume: e.resume
+    },
+    satisfiedPredicates: SAFE_CLAUSES.filter((c) => c !== missing),
+    unsatisfiedPredicates: missing === null ? [] : [missing]
+  };
+}
+async function recoveryScreenshot(page, c) {
+  try {
+    const buf = c.box === null ? await page.screenshot({ animations: "disabled" }) : await page.screenshot({ clip: c.box, animations: "disabled" });
+    return `data:image/png;base64,${buf.toString("base64")}`;
+  } catch {
+    return null;
+  }
+}
+async function collectActionableControlEvidence(page, opts = {}) {
+  const candidates = await page.locator(RECOVERY_SELECTOR).evaluateAll(readRecoveryCandidates).catch(() => []);
+  const url2 = page.url();
+  const state = await snapshot(page).then((s3) => s3.signature, () => url2);
+  const visibleNames = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    if (c.visible && c.enabled && c.name !== "")
+      visibleNames.set(c.name, (visibleNames.get(c.name) ?? 0) + 1);
+  }
+  const out = [];
+  for (const c of candidates) {
+    const kind = classifyActionableControl({
+      name: c.name,
+      role: c.role,
+      visible: c.visible,
+      enabled: c.enabled,
+      duplicateName: c.name !== "" && (visibleNames.get(c.name) ?? 0) > 1
+    });
+    const locator = recoveryLocator(c);
+    out.push({
+      kind,
+      name: c.name,
+      locator,
+      screenshot: opts.screenshots === false ? null : await recoveryScreenshot(page, c),
+      predicate: recoveryPredicate(kind),
+      resume: { url: url2, state, locator }
+    });
+  }
+  return out;
+}
 
 // ../explore/dist/goal-loop/handle-idle.js
 async function handleWaitOrScroll(ctx, step) {
@@ -48922,6 +49272,7 @@ async function handleCodeTypedField(ctx, step) {
       ctx.valueLog.typed(control.name || control.summary, value);
       ctx.save.noteTyped(control.name || control.summary, value);
       ctx.observed.noteOwnInput(value);
+      ctx.observed.noteTypedOn(value, await documentOf(ctx.page));
       ctx.noteMutation(`type ${control.name}`, control.descriptor, snap.signature, at3, { field: keyOf(control), value });
       ctx.tracker.countAction();
       ctx.cleared(control);
@@ -49484,6 +49835,7 @@ async function handleFill(ctx, step) {
       ctx.typeProbe = { key: keyOf(control), label: quote(control.name || control.summary, 60), at: typedAt, background: typedBackground, state: typedState };
       ctx.recorder.fill(control.descriptor, text2, at3);
       ctx.valueLog.typed(control.name || control.summary, text2);
+      ctx.observed.noteTypedOn(text2, await documentOf(ctx.page));
       if (!ctx.isBound(control) && !isCredentialField(control) && !sendable(control)) {
         ctx.save.noteTyped(control.name || control.summary, text2);
         ctx.observed.noteOwnInput(text2);
@@ -49605,6 +49957,21 @@ async function statusWhilePending(page) {
   const status = await readInProgressStatus(page);
   return status === null ? null : `${status} while its request is in flight (within --job-wait-ms)`;
 }
+async function declaredBusy(page) {
+  const status = await readInProgressStatus(page);
+  return status?.startsWith("aria-busy region") === true ? `${status}, declared by the app (within --job-wait-ms)` : null;
+}
+function stoodAfterWork(ctx, workBudgetMs) {
+  const s3 = (ms) => `${Math.round(ms / 1e3)}s`;
+  const now2 = clock.now();
+  const since = ctx.hangWorkSince === null ? "" : `, ${s3(now2 - ctx.hangWorkSince)} since the first deferral`;
+  const last = monitorFor(ctx.page).completedSince(ctx.hangWorkSince ?? 0).filter((r) => r.resourceType !== "document" && r.ignored !== true).at(-1);
+  const activity = last === void 0 ? "no app request completed since" : `the app's last request completed ${s3(now2 - last.endedAt)} ago`;
+  if (ctx.hangWorkWaitedMs >= workBudgetMs) {
+    return `still so after ${s3(ctx.hangWorkWaitedMs)} of the page showing work${since} \u2014 past the ${s3(workBudgetMs)} job-wait budget; raise --job-wait-ms for longer jobs; ${activity}`;
+  }
+  return `the page stopped showing work code recognizes (an acknowledged or declared in-progress status, a documented wait, a pending request under a status, or requests completing) after ${s3(ctx.hangWorkWaitedMs)} of the ${s3(workBudgetMs)} job-wait budget${since}; ${activity}`;
+}
 async function checkHang(ctx, step) {
   const { perceiveStartedAt, perception, snap } = step;
   const documented = perception.hang !== null && perception.hang.kind !== "main-thread-unresponsive" ? await readDocumentedWait(ctx.page) : null;
@@ -49615,8 +49982,9 @@ async function checkHang(ctx, step) {
     const working = await readWorkingStatus(ctx.page) ?? (documented === null ? null : `a documented wait ("${documented.text}")`) ?? (perception.hang.kind === "ui-no-progress" ? await liveBusyWork(ctx.page, perception.busyWait) : null) ?? // #330: a request still in flight while the page SAYS it is working ("Designing variations…")
     // is the long job the operator sized with --job-wait-ms: waited out within that budget. Without
     // the flag a bare status is not enough (a stuck page looks exactly like that, #153).
-    (perception.hang.kind === "request-pending" && ctx.jobWaitExplicit ? await statusWhilePending(ctx.page) : null);
+    (perception.hang.kind === "request-pending" && ctx.jobWaitExplicit ? await statusWhilePending(ctx.page) : null) ?? (perception.hang.kind === "ui-no-progress" && ctx.jobWaitExplicit ? await declaredBusy(ctx.page) : null);
     if (working !== null) {
+      ctx.hangWorkSince ??= perceiveStartedAt;
       const w = await waitOutJob(ctx.page, Math.min(workBudgetMs - ctx.hangWorkWaitedMs, JOB_WAIT_SLICE_MS), stillShowsWork);
       ctx.hangWorkWaitedMs += clock.now() - perceiveStartedAt;
       const note = `not a hang yet (${perception.hang.kind}): the page shows ${working} \u2014 the app is still working; waited ${(w.waitedMs / 1e3).toFixed(1)}s (${w.cleared ? "the status cleared" : `still in progress; ${Math.round(ctx.hangWorkWaitedMs / 1e3)}s of the ${Math.round(workBudgetMs / 1e3)}s job-wait budget used`})`;
@@ -49656,7 +50024,7 @@ async function checkHang(ctx, step) {
     const heapNow = await sampleHeap(ctx.page, 1e3);
     const stood = ctx.hangWorkWaitedMs > 0 ? {
       ...perception.hang,
-      detail: `${perception.hang.detail} (still so after ${Math.round(ctx.hangWorkWaitedMs / 1e3)}s of the page showing work \u2014 past the ${Math.round(workBudgetMs / 1e3)}s job-wait budget; raise --job-wait-ms for longer jobs)`
+      detail: `${perception.hang.detail} (${stoodAfterWork(ctx, workBudgetMs)})`
     } : perception.hang;
     const withHost = { ...stood, host: judged.host };
     ctx.hang = {
@@ -49933,7 +50301,7 @@ async function checkProgress(ctx, step) {
     if (!ctx.lastChanceGiven) {
       ctx.lastChanceGiven = true;
       ctx.lastChanceTurn = true;
-      ctx.history.push(LAST_CHANCE_NOTE);
+      ctx.history.push(ctx.writeGoal && !ctx.wroteOk ? LAST_CHANCE_NO_WRITE_NOTE : LAST_CHANCE_NOTE);
     } else {
       ctx.stop = "no-progress";
       return "stop";
@@ -50137,7 +50505,12 @@ async function viewPage(ctx, step) {
 async function decideStep(ctx, step, view) {
   const { cfg } = ctx;
   const { perception, snap } = step;
-  const { modelControls, offered, unsubmitted, visibleText } = view;
+  const { offered, unsubmitted, visibleText } = view;
+  const recovery = takeRecoveryTurn(ctx);
+  const safeNames = new Set((recovery ?? []).map((e) => e.name).filter((n3) => n3 !== ""));
+  const modelControls = recovery === null ? view.modelControls : view.modelControls.filter((c) => safeNames.has(c.name));
+  if (recovery !== null)
+    ctx.history.push("recovery turn: act through one of the safe controls offered, or the run ends blocked");
   let decision;
   ctx.goalFocus.noteUrl(snap.url);
   const offGoal = ctx.goalFocus.offGoal(modelControls, ctx.chrome);
@@ -50388,6 +50761,7 @@ async function finishRun(ctx) {
     ...ctx.answer !== void 0 && finalOutcome.status === "completed" ? { answer: ctx.answer } : {},
     ...cause === null ? {} : { blockingCause: cause },
     ...missCause === void 0 ? {} : { missCause },
+    ...ctx.actionableControl === null ? {} : { actionableControl: ctx.actionableControl },
     ...ctx.endedOnRejectedDone && ctx.stop === "done" ? { doneRejected: true } : {},
     ...ctx.stop === "crashed" && ctx.failure !== void 0 ? { crash: buildCrashReport(ctx.failure, ctx.crashWatch.signals(), ctx.heap.samples(), { host: await ctx.probeHost() }) } : {}
   };
@@ -52443,7 +52817,7 @@ async function reproduceSeedHang(cfg, run, h) {
   });
 }
 function hangResult(run, h, reproduction) {
-  const finding3 = hangFinding(h.signal, run.transcript, h.recordingStepIndex, reproduction);
+  const finding4 = hangFinding(h.signal, run.transcript, h.recordingStepIndex, reproduction);
   return {
     // A hang whose replays could not run at all is `inconclusive`, never a non-reproduction.
     outcome: reproduction.status === "reproduced" ? "hang" : reproduction.status,
@@ -52453,8 +52827,8 @@ function hangResult(run, h, reproduction) {
     recording: run.recording,
     transcript: run.transcript,
     finalUrl: run.finalUrl,
-    hang: finding3,
-    reason: reproduction.withheld !== void 0 ? `${finding3.title} (${withheldReason(reproduction.withheld)})` : reproduction.attempts === 0 ? `${finding3.title} (unconfirmed: not replayed)` : `${finding3.title} (reproduced ${reproduction.reproduced}/${reproduction.attempts})`
+    hang: finding4,
+    reason: reproduction.withheld !== void 0 ? `${finding4.title} (${withheldReason(reproduction.withheld)})` : reproduction.attempts === 0 ? `${finding4.title} (unconfirmed: not replayed)` : `${finding4.title} (reproduced ${reproduction.reproduced}/${reproduction.attempts})`
   };
 }
 
@@ -53033,14 +53407,14 @@ function ownAssertion(s3) {
     return { field: "resume", assertion: s3.resume };
   return "expect" in s3 ? { field: "expect", assertion: s3.expect } : null;
 }
-function canonical2(d) {
+function canonical(d) {
   const sort = (v) => v !== null && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b2]) => a.localeCompare(b2)).map(([k, x]) => [k, sort(x)])) : v;
   return JSON.stringify(sort(d));
 }
 function isOwnTargetVisible(step) {
   if (!("expect" in step) || !("target" in step))
     return false;
-  return step.expect.kind === "visible" && canonical2(step.expect.target) === canonical2(step.target);
+  return step.expect.kind === "visible" && canonical(step.expect.target) === canonical(step.target);
 }
 function isNoClaimExpect(step) {
   if (!("expect" in step))
@@ -54930,10 +55304,10 @@ function bindParams(inputs, record2, request) {
   return params;
 }
 function recordFingerprint(outputs, record2) {
-  const canonical7 = {};
+  const canonical6 = {};
   for (const name of Object.keys(outputs.fields).sort())
-    canonical7[name] = record2[name] ?? null;
-  return `sha256:${createHash5("sha256").update(JSON.stringify(canonical7)).digest("hex")}`;
+    canonical6[name] = record2[name] ?? null;
+  return `sha256:${createHash5("sha256").update(JSON.stringify(canonical6)).digest("hex")}`;
 }
 function extractedNames(journey) {
   const names = /* @__PURE__ */ new Set();
@@ -58073,23 +58447,23 @@ function createFrontierContext(params, declared, safety, budget, overlay = null,
     const vp = ctx.sessions.page.viewportSize();
     if (!shouldCheckOverflow(vp?.width, params.overflow?.checkOverflow ?? false))
       return;
-    const finding3 = await detectOverflow(ctx.sessions.page, {
+    const finding4 = await detectOverflow(ctx.sessions.page, {
       viewport: vp ?? { width: 1280, height: 720 },
       ...params.overflow?.device === void 0 ? {} : { device: params.overflow.device },
       ...params.overflow?.toleranceCss === void 0 ? {} : { toleranceCss: params.overflow.toleranceCss },
       ...params.overflow?.ignoreSelectors === void 0 ? {} : { ignoreSelectors: params.overflow.ignoreSelectors },
       ...params.overflow?.secrets === void 0 ? {} : { secrets: params.overflow.secrets }
     });
-    if (finding3 !== null && !ctx.seenOverflow.has(finding3.fingerprint)) {
-      ctx.seenOverflow.add(finding3.fingerprint);
+    if (finding4 !== null && !ctx.seenOverflow.has(finding4.fingerprint)) {
+      ctx.seenOverflow.add(finding4.fingerprint);
       ctx.defects.push({
-        fingerprint: finding3.fingerprint,
+        fingerprint: finding4.fingerprint,
         kind: "horizontal-overflow",
         stateFingerprint: stateFp,
         url: url2,
-        reason: `horizontal-overflow: ${finding3.element.descriptor} overflows the ${finding3.viewport.width}px viewport by ${finding3.overflowPx}px at ${finding3.route}`,
+        reason: `horizontal-overflow: ${finding4.element.descriptor} overflows the ${finding4.viewport.width}px viewport by ${finding4.overflowPx}px at ${finding4.route}`,
         recording,
-        overflow: finding3
+        overflow: finding4
       });
     }
     const clipped = await detectClipping(ctx.sessions.page, {
@@ -60660,22 +61034,22 @@ function installOracle(ctx, params) {
       url: c.url,
       descriptor: c.element.descriptor
     }));
-    const finding3 = await detectOverflow(ctx.sessions.page, {
+    const finding4 = await detectOverflow(ctx.sessions.page, {
       viewport: vp ?? { width: 1280, height: 720 },
       ...params.overflow?.device === void 0 ? {} : { device: params.overflow.device },
       ...params.overflow?.toleranceCss === void 0 ? {} : { toleranceCss: params.overflow.toleranceCss },
       ...params.overflow?.ignoreSelectors === void 0 ? {} : { ignoreSelectors: params.overflow.ignoreSelectors },
       ...params.overflow?.secrets === void 0 ? {} : { secrets: params.overflow.secrets }
     });
-    if (finding3 === null)
+    if (finding4 === null)
       return clipped;
     const horizontal = {
       kind: "horizontal-overflow",
-      detail: `horizontal-overflow: ${finding3.element.descriptor} overflows the ${finding3.viewport.width}px viewport by ${finding3.overflowPx}px at ${finding3.route}`,
-      overflowPx: finding3.overflowPx,
-      route: finding3.route,
-      url: finding3.url,
-      descriptor: finding3.element.descriptor
+      detail: `horizontal-overflow: ${finding4.element.descriptor} overflows the ${finding4.viewport.width}px viewport by ${finding4.overflowPx}px at ${finding4.route}`,
+      overflowPx: finding4.overflowPx,
+      route: finding4.route,
+      url: finding4.url,
+      descriptor: finding4.element.descriptor
     };
     return [horizontal, ...clipped];
   };
@@ -60844,9 +61218,9 @@ function installOracle(ctx, params) {
       }
       const summary2 = f2.kind === "invariant" ? f2.invariantReason ?? f2.title : f2.kind === "markup-injection" ? f2.title : f2.signals.map((s3) => s3.detail).join("; ");
       const triage = await tryTriage(params.generation, { failureSummary: summary2, url: f2.url });
-      const { origin: _origin, ...finding3 } = f2;
+      const { origin: _origin, ...finding4 } = f2;
       ctx.defects.set(f2.fingerprint, {
-        ...finding3,
+        ...finding4,
         related: new Set(f2.related),
         epoch: ctx.segments.indexOf(ctx.recorder),
         firstSeenStep: step,
@@ -60924,9 +61298,9 @@ function installSessions(ctx, params) {
       perceive: ctx.perceiveOpts,
       ...params.safety === void 0 ? {} : { safety: params.safety }
     });
-    const finding3 = hangFinding(h, ctx.transcript.entries(), recordingStepIndex, reproduction);
+    const finding4 = hangFinding(h, ctx.transcript.entries(), recordingStepIndex, reproduction);
     const segment = ctx.segments.indexOf(ctx.recorder);
-    ctx.hangs.set(finding3.fingerprint, segment > 0 && partial2.ok ? { ...finding3, repro: { ...finding3.repro, recording: partial2.recording } } : finding3);
+    ctx.hangs.set(finding4.fingerprint, segment > 0 && partial2.ok ? { ...finding4, repro: { ...finding4.repro, recording: partial2.recording } } : finding4);
   };
   ctx.restartSpend = 0;
   ctx.restartAtSeed = async () => {
@@ -61066,21 +61440,21 @@ function createHuntContext(params) {
     }
     return warning;
   };
-  ctx.blockedConsequence = (finding3, candidate) => {
+  ctx.blockedConsequence = (finding4, candidate) => {
     const causedBy = blockedCauseOf(ctx.blockedRoots, candidate);
     if (causedBy === void 0)
       return false;
-    const known = ctx.blockedConsequences.get(finding3.fingerprint);
+    const known = ctx.blockedConsequences.get(finding4.fingerprint);
     if (known !== void 0) {
       if (!known.occurrenceSteps.includes(candidate.step))
         known.occurrenceSteps.push(candidate.step);
       return true;
     }
-    ctx.blockedConsequences.set(finding3.fingerprint, {
-      fingerprint: finding3.fingerprint,
-      kind: finding3.kind,
-      title: finding3.title,
-      route: finding3.route,
+    ctx.blockedConsequences.set(finding4.fingerprint, {
+      fingerprint: finding4.fingerprint,
+      kind: finding4.kind,
+      title: finding4.title,
+      route: finding4.route,
       firstSeenStep: candidate.step,
       occurrenceSteps: [candidate.step],
       causedBy
@@ -63059,9 +63433,9 @@ function hostStarvedFailure(failure3, health) {
 }
 
 // src/build-info.generated.ts
-var GENERATED_COMMIT = "ad72163";
-var GENERATED_TREE = "379caf5";
-var GENERATED_BUILT_AT = "2026-10-23T21:02:56.700Z";
+var GENERATED_COMMIT = "ffe0da9";
+var GENERATED_TREE = "bc64c13";
+var GENERATED_BUILT_AT = "2026-10-26T13:27:18.971Z";
 
 // src/version.ts
 import { readFileSync as readFileSync5 } from "node:fs";
@@ -63083,13 +63457,13 @@ function readCliVersion() {
 
 // src/engine.ts
 function bundledCommit() {
-  return true ? "ad72163" : void 0;
+  return true ? "ffe0da9" : void 0;
 }
 function bundledBuiltAt() {
-  return true ? "2026-10-23T21:02:56.700Z" : void 0;
+  return true ? "2026-10-26T13:27:18.971Z" : void 0;
 }
 function bundledTree() {
-  return true ? "379caf5" : void 0;
+  return true ? "bc64c13" : void 0;
 }
 function currentBuildTree() {
   return bundledTree() ?? GENERATED_TREE;
@@ -63732,12 +64106,12 @@ function substituteDeep(v, sub) {
   return v;
 }
 function fixtureSpecHash(spec, hooks) {
-  return sha256(canonical3({ spec: spec ?? null, hooks: hooks ?? null })).slice(0, 16);
+  return sha256(canonical2({ spec: spec ?? null, hooks: hooks ?? null })).slice(0, 16);
 }
-function canonical3(v) {
-  if (Array.isArray(v)) return `[${v.map(canonical3).join(",")}]`;
+function canonical2(v) {
+  if (Array.isArray(v)) return `[${v.map(canonical2).join(",")}]`;
   if (isRecord(v)) {
-    return `{${Object.keys(v).sort().filter((k) => v[k] !== void 0).map((k) => `${JSON.stringify(k)}:${canonical3(v[k])}`).join(",")}}`;
+    return `{${Object.keys(v).sort().filter((k) => v[k] !== void 0).map((k) => `${JSON.stringify(k)}:${canonical2(v[k])}`).join(",")}}`;
   }
   return JSON.stringify(v);
 }
@@ -63859,7 +64233,7 @@ var MissionFixtures = class {
     return redactUrl(redactText(text2, [...this.#opts.secrets ?? [], ...bound2, ...this.secrets()]));
   }
   identity() {
-    return `fx-${sha256(canonical3({ spec: this.#specHash, outputs: this.publicOutputs(), secret: [...this.#secretNames].sort() })).slice(0, 16)}`;
+    return `fx-${sha256(canonical2({ spec: this.#specHash, outputs: this.publicOutputs(), secret: [...this.#secretNames].sort() })).slice(0, 16)}`;
   }
   record() {
     return {
@@ -66535,10 +66909,10 @@ var QueryNode = freeze2({
       where: node2.where ? WhereNode.cloneWithOperation(node2.where, "And", operation) : WhereNode.create(operation)
     });
   },
-  cloneWithJoin(node2, join83) {
+  cloneWithJoin(node2, join84) {
     return freeze2({
       ...node2,
-      joins: node2.joins ? freeze2([...node2.joins, join83]) : freeze2([join83])
+      joins: node2.joins ? freeze2([...node2.joins, join84]) : freeze2([join84])
     });
   },
   cloneWithReturning(node2, selections) {
@@ -70194,8 +70568,8 @@ var WithSchemaTransformer = class extends OperationNodeTransformer {
       this.#collectSchemableIdsFromTableExpr(node2.table, schemableIds);
     }
     if ("joins" in node2 && node2.joins) {
-      for (const join83 of node2.joins) {
-        this.#collectSchemableIdsFromTableExpr(join83.table, schemableIds);
+      for (const join84 of node2.joins) {
+        this.#collectSchemableIdsFromTableExpr(join84.table, schemableIds);
       }
     }
     if ("using" in node2 && node2.using) {
@@ -78957,14 +79331,14 @@ var GitSourceManager = class {
 
 // ../sources/dist/hash.js
 import { createHash as createHash9 } from "node:crypto";
-function canonicalJson2(value) {
+function canonicalJson3(value) {
   if (value === null)
     return "null";
   if (Array.isArray(value))
-    return `[${value.map(canonicalJson2).join(",")}]`;
+    return `[${value.map(canonicalJson3).join(",")}]`;
   if (typeof value === "object") {
     const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b2]) => a < b2 ? -1 : a > b2 ? 1 : 0);
-    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson2(v)}`).join(",")}}`;
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson3(v)}`).join(",")}}`;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value))
@@ -78975,7 +79349,7 @@ function canonicalJson2(value) {
 }
 function canonicalJourneyHash(file2) {
   const validated = SharedJourneyFileSchema.parse(file2);
-  const hex3 = createHash9("sha256").update(canonicalJson2(validated), "utf8").digest("hex");
+  const hex3 = createHash9("sha256").update(canonicalJson3(validated), "utf8").digest("hex");
   return `sha256:${hex3}`;
 }
 
@@ -80681,6 +81055,15 @@ function journeyReviewHash(journey) {
   for (const k of BOOKKEEPING) delete metadata[k];
   return contentHash({ metadata, recording: journey.recording });
 }
+function journeyLegacyReviewHash(journey) {
+  const metadata = { ...journey.metadata };
+  for (const k of BOOKKEEPING) delete metadata[k];
+  return legacyContentHash({ metadata, recording: journey.recording });
+}
+function journeyApprovalMatches(journey) {
+  const approved = journey.metadata.approval?.contentHash;
+  return approved !== void 0 && (approved === journeyReviewHash(journey) || approved === journeyLegacyReviewHash(journey));
+}
 function targetOf3(step) {
   if (step.kind === "forEach") return step.items;
   return "target" in step ? step.target : void 0;
@@ -80887,7 +81270,7 @@ function buildChange(journey, hash3, snapshot2, stepIdOnly) {
   const idOnly = stepIdOnly ? { stepIdOnly: true } : {};
   if (snapshot2 === null || snapshot2 === void 0) {
     if (approval !== void 0) {
-      return { kind: "snapshot-missing", approvedHash: approval.contentHash, approvedAt: approval.at, changed: approval.contentHash !== hash3, ...idOnly };
+      return { kind: "snapshot-missing", approvedHash: approval.contentHash, approvedAt: approval.at, changed: !journeyApprovalMatches(journey), ...idOnly };
     }
     return journey.metadata.promoted ? { kind: "no-record" } : { kind: "first-approval" };
   }
@@ -81241,9 +81624,9 @@ var UnknownCatalogItemError = class extends Error {
     return this.kind === "persona" ? "E_UNKNOWN_PERSONA" : "E_UNKNOWN_JOB";
   }
 };
-function statusOf3(approval, hash3) {
+function statusOf3(approval, hash3, legacyHash) {
   if (approval === void 0) return "draft";
-  return approval.contentHash === hash3 ? "approved" : "stale";
+  return approval.contentHash === hash3 || approval.contentHash === legacyHash ? "approved" : "stale";
 }
 async function readJsonFile(path2) {
   const raw = await readFile8(path2, "utf8");
@@ -81308,7 +81691,7 @@ function catalogPersona(p, path2) {
     hasLogin: p.fields.login !== void 0,
     ...approval === void 0 ? {} : { approval },
     contentHash: hash3,
-    status: statusOf3(approval, hash3)
+    status: statusOf3(approval, hash3, personaLegacyContentHash(p.id, p.fields))
   };
 }
 function personaContentHash(id, fields) {
@@ -81316,6 +81699,11 @@ function personaContentHash(id, fields) {
   for (const [k, v] of Object.entries(fields)) if (k !== "approval" && !SESSION_KEYS.has(k)) described[k] = v;
   return contentHash(described);
 }
+function personaLegacyContentHash(id, fields) {
+  const described = { id };
+  for (const [k, v] of Object.entries(fields)) if (k !== "approval" && !SESSION_KEYS.has(k)) described[k] = v;
+  return legacyContentHash(described);
+}
 function jobList(raw, path2) {
   if (Array.isArray(raw)) return raw;
   if (isRecord(raw) && Array.isArray(raw.jobs)) return raw.jobs;
@@ -81338,13 +81726,17 @@ function catalogJobOf(job) {
     personas: [.../* @__PURE__ */ new Set([...job.personas ?? [], ...job.persona === void 0 ? [] : [job.persona]])],
     ...job.approval === void 0 ? {} : { approval: job.approval },
     contentHash: hash3,
-    status: statusOf3(job.approval, hash3)
+    status: statusOf3(job.approval, hash3, jobLegacyContentHash(job))
   };
 }
 function jobContentHash(job) {
   const { approval: _a3, ...rest } = job;
   return contentHash(rest);
 }
+function jobLegacyContentHash(job) {
+  const { approval: _a3, ...rest } = job;
+  return legacyContentHash(rest);
+}
 function catalogJourney(journey) {
   const m = journey.metadata;
   const hash3 = journeyReviewHash(journey);
@@ -81357,7 +81749,7 @@ function catalogJourney(journey) {
     ...m.persona === void 0 ? {} : { personaText: m.persona },
     ...m.approval === void 0 ? {} : { approval: m.approval },
     contentHash: hash3,
-    changedSinceApproval: m.promoted && m.approval !== void 0 && m.approval.contentHash !== hash3
+    changedSinceApproval: m.promoted && m.approval !== void 0 && !journeyApprovalMatches(journey)
   };
 }
 var CatalogLoader = class {
@@ -82860,12 +83252,12 @@ function healFloor(recorded, riskOf) {
   }
   return { floor: "healable", reason: "" };
 }
-function canonical4(v) {
+function canonical3(v) {
   if (Array.isArray(v))
-    return `[${v.map(canonical4).join(",")}]`;
+    return `[${v.map(canonical3).join(",")}]`;
   if (v !== null && typeof v === "object") {
     const o = v;
-    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonical4(o[k])}`).join(",")}}`;
+    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonical3(o[k])}`).join(",")}}`;
   }
   return JSON.stringify(v) ?? "undefined";
 }
@@ -82887,7 +83279,7 @@ function assertProofUntouched(before, after) {
   for (const k of /* @__PURE__ */ new Set([...Object.keys(b2), ...Object.keys(a)])) {
     if (free.has(k))
       continue;
-    if (canonical4(b2[k]) !== canonical4(a[k]))
+    if (canonical3(b2[k]) !== canonical3(a[k]))
       return { code: "proof-field-changed", detail: `the candidate changes the step's \`${k}\`` };
   }
   return null;
@@ -82898,15 +83290,15 @@ function assertRecordedProofUntouched(before, after) {
   for (const k of /* @__PURE__ */ new Set([...Object.keys(b2), ...Object.keys(a)])) {
     if (k === "step")
       continue;
-    if (canonical4(b2[k]) !== canonical4(a[k]))
+    if (canonical3(b2[k]) !== canonical3(a[k]))
       return { code: "proof-field-changed", detail: `the candidate changes the recorded step's \`${k}\`` };
   }
-  return canonical4(before.step) === canonical4(after.step) ? null : assertProofUntouched(before.step, after.step);
+  return canonical3(before.step) === canonical3(after.step) ? null : assertProofUntouched(before.step, after.step);
 }
 function assertRecordingProofUntouched(base, proposed) {
   const { pages: bp, ...bRest } = base;
   const { pages: pp, ...pRest } = proposed;
-  if (canonical4(bRest) !== canonical4(pRest))
+  if (canonical3(bRest) !== canonical3(pRest))
     return { code: "proof-field-changed", detail: "the revision changes the recording's own fields" };
   if (bp.length !== pp.length)
     return { code: "shape-changed", detail: `the revision has ${pp.length} pages; the Journey has ${bp.length}` };
@@ -82914,7 +83306,7 @@ function assertRecordingProofUntouched(base, proposed) {
   for (let i = 0; i < bp.length; i++) {
     const { steps: bs, ...bPage } = bp[i];
     const { steps: ps, ...pPage } = pp[i];
-    if (canonical4(bPage) !== canonical4(pPage))
+    if (canonical3(bPage) !== canonical3(pPage))
       return { code: "proof-field-changed", detail: `the revision changes page ${i + 1}` };
     if (bs.length !== ps.length)
       return { code: "shape-changed", detail: `the revision has ${ps.length} steps on page ${i + 1}; the Journey has ${bs.length}` };
@@ -83890,15 +84282,15 @@ function originOnly(url2) {
 var LOCKFILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "Cargo.lock", "poetry.lock", "Gemfile.lock", "composer.lock"]);
 var SECRET_EXTENSION = /\.(pem|key|p12|pfx)$/i;
 function isSkippedChangePath(path2) {
-  const normalized = path2.replace(/\\/g, "/");
-  const base = normalized.split("/").pop() ?? normalized;
+  const normalized2 = path2.replace(/\\/g, "/");
+  const base = normalized2.split("/").pop() ?? normalized2;
   if (base === ".env" || base.startsWith(".env."))
     return true;
   if (SECRET_EXTENSION.test(base))
     return true;
   if (LOCKFILES.has(base))
     return true;
-  return normalized.toLowerCase().split("/").some((segment) => segment.includes("secret"));
+  return normalized2.toLowerCase().split("/").some((segment) => segment.includes("secret"));
 }
 function extractChangeEvidence(diff2, notes) {
   const evidence = [];
@@ -84500,11 +84892,11 @@ async function removeFile(path2) {
   await assertNoSymlink(path2);
   await rm4(path2, { force: true });
 }
-function canonical5(v) {
-  if (Array.isArray(v)) return `[${v.map(canonical5).join(",")}]`;
+function canonical4(v) {
+  if (Array.isArray(v)) return `[${v.map(canonical4).join(",")}]`;
   if (v !== null && typeof v === "object") {
     const o = v;
-    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonical5(o[k])}`).join(",")}}`;
+    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonical4(o[k])}`).join(",")}}`;
   }
   return JSON.stringify(v) ?? "undefined";
 }
@@ -84529,7 +84921,7 @@ function proposalFloorViolation(stored, proposed) {
   for (let i = 0; i < after.length; i++) {
     const b2 = before[i];
     const a = after[i];
-    if (b2 !== void 0 && canonical5(b2.step) === canonical5(a.step)) continue;
+    if (b2 !== void 0 && canonical4(b2.step) === canonical4(a.step)) continue;
     for (const [which, rec] of [["before", b2?.recorded], ["after", a.recorded]]) {
       if (rec === void 0) return `step ${i + 1} is not in the stored Journey`;
       const floor = healFloor(rec, riskOf);
@@ -90939,9 +91331,9 @@ async function attachDefectEvidence(result, opts) {
       continue;
     }
     const signal = defectSignalText(d, secrets);
-    const finding3 = findFinding(mission, fp);
-    const recording = finding3?.recording ?? mission.recording;
-    if (finding3 === void 0 || recording === null) {
+    const finding4 = findFinding(mission, fp);
+    const recording = finding4?.recording ?? mission.recording;
+    if (finding4 === void 0 || recording === null) {
       byFp.set(fp, { screenshots: [], signal, skipped: "the defect has no repro Recording to replay" });
       continue;
     }
@@ -90959,9 +91351,9 @@ async function attachDefectEvidence(result, opts) {
       fp,
       await replayWithEvidence({
         recording,
-        stepIndex: finding3.repro.recordingStepIndex,
-        fingerprints: [fp, ...finding3.related ?? []],
-        signalCheckable: SIGNAL_KINDS.has(finding3.kind),
+        stepIndex: finding4.repro.recordingStepIndex,
+        fingerprints: [fp, ...finding4.related ?? []],
+        signalCheckable: SIGNAL_KINDS.has(finding4.kind),
         signal,
         seedUrl: mission.target.seedUrl,
         allowlist: mission.target.allowlist,
@@ -92548,6 +92940,7 @@ async function runExploration(opts) {
       timing: mission.run.timing,
       outcome: goalOutcome,
       runOutcome: mission.run.outcome,
+      ...mission.run.actionableControl === void 0 ? {} : { actionableControl: mission.run.actionableControl },
       ...mission.run.answer === void 0 ? {} : { answer: mission.run.answer },
       ...mission.run.partialReport === void 0 ? {} : { partialReport: mission.run.partialReport },
       depth: mission.run.depth,
@@ -96259,8 +96652,8 @@ async function runVerifyFix(opts) {
   const persisted = parsePersistedMission(raw);
   const replay = replayAllowlist(persisted.target.allowlist, opts);
   const mission = replay.override === void 0 ? persisted : { ...persisted, target: { ...persisted.target, allowlist: [...replay.allowlist] } };
-  const finding3 = findFinding(mission, opts.fingerprint);
-  if (finding3 === void 0) {
+  const finding4 = findFinding(mission, opts.fingerprint);
+  if (finding4 === void 0) {
     throw new VerifyFixInputError(`no finding with fingerprint ${opts.fingerprint} in ${opts.resultPath}`);
   }
   const origin = assertAuthorizedExploreTarget(mission.target.seedUrl, mission.target.allowlist);
@@ -96278,8 +96671,8 @@ async function runVerifyFix(opts) {
     ...target.settle === void 0 ? {} : { settleConfig: target.settle },
     ...target.hangs === void 0 ? {} : { hangConfig: target.hangs }
   };
-  const found = finding3.recording ?? mission.recording;
-  if (found === null) throw new VerifyFixInputError(`finding ${finding3.fingerprint} has no Recording to replay`);
+  const found = finding4.recording ?? mission.recording;
+  if (found === null) throw new VerifyFixInputError(`finding ${finding4.fingerprint} has no Recording to replay`);
   const branch = recordedBranchOf(raw?.result);
   let prefix;
   if (branch !== void 0) {
@@ -96292,7 +96685,7 @@ async function runVerifyFix(opts) {
   }
   const recording = prefix === void 0 ? found : anchoredRecording(found);
   try {
-    assertSameExtensionBuild(recording.extensions, opts.browser, `finding ${finding3.fingerprint}`);
+    assertSameExtensionBuild(recording.extensions, opts.browser, `finding ${finding4.fingerprint}`);
   } catch (e) {
     throw new VerifyFixInputError(e instanceof Error ? e.message : String(e));
   }
@@ -96325,9 +96718,9 @@ async function runVerifyFix(opts) {
   const authTokenValues = [...invariantAuthTokens?.values() ?? []];
   const primaryActor = mission.target.actors?.find((a) => a.role === "primary")?.name;
   const fx = missionFixtures(mission, opts.fixtureFlags ?? {}, storageState, [...opts.secrets ?? [], ...authTokenValues], target.personas);
-  const declared = finding3.kind === "invariant" && finding3.invariantId !== void 0 && invariantSpec !== void 0 ? {
+  const declared = finding4.kind === "invariant" && finding4.invariantId !== void 0 && invariantSpec !== void 0 ? {
     spec: invariantSpec,
-    id: finding3.invariantId,
+    id: finding4.invariantId,
     allowlist: mission.target.allowlist,
     baseUrl: mission.target.seedUrl,
     ...invariantAuthTokens === void 0 || invariantAuthTokens.size === 0 ? {} : { authTokens: invariantAuthTokens },
@@ -96356,10 +96749,10 @@ async function runVerifyFix(opts) {
   const replaySession = fx === void 0 ? branchOpen : fixtureReplayOpener(branchOpen, fx, recording.fixture?.outputs ?? mission.fixtures?.outputs ?? {});
   let result;
   try {
-    if (finding3.kind === "server-log") {
-      if (finding3.serverLog === void 0) {
+    if (finding4.kind === "server-log") {
+      if (finding4.serverLog === void 0) {
         result = {
-          fingerprint: finding3.fingerprint,
+          fingerprint: finding4.fingerprint,
           verdict: "inconclusive",
           observedFingerprints: [],
           replay: { outcome: "failed", at: -1, error: "not replayed" },
@@ -96368,13 +96761,13 @@ async function runVerifyFix(opts) {
       } else {
         result = await verifyServerLogDefect({
           recording,
-          recordingStepIndex: finding3.repro.recordingStepIndex,
-          fingerprint: finding3.fingerprint,
-          sources: finding3.serverLog.sources,
-          matcher: finding3.serverLog.matcher,
-          normalizedMessage: finding3.serverLog.normalizedMessage,
-          drainMs: finding3.serverLog.drainMs,
-          ...finding3.serverLog.scope === void 0 ? {} : { scope: finding3.serverLog.scope },
+          recordingStepIndex: finding4.repro.recordingStepIndex,
+          fingerprint: finding4.fingerprint,
+          sources: finding4.serverLog.sources,
+          matcher: finding4.serverLog.matcher,
+          normalizedMessage: finding4.serverLog.normalizedMessage,
+          drainMs: finding4.serverLog.drainMs,
+          ...finding4.serverLog.scope === void 0 ? {} : { scope: finding4.serverLog.scope },
           // #142 follow-up: an explicit --allow-log-cmd wins; otherwise the operator's own
           // ~/.jevitate/targets.json entry for this origin may opt in (never an MCP argument).
           allowLogCmd: opts.allowLogCmd === true || target.allowLogCmd === true,
@@ -96388,15 +96781,15 @@ async function runVerifyFix(opts) {
         fixtureBaseDir: journeyFixtureBaseDir(),
         perceive: perceiveOpts,
         recording,
-        recordingStepIndex: finding3.repro.recordingStepIndex,
-        fingerprint: finding3.fingerprint,
-        defectKind: finding3.kind,
+        recordingStepIndex: finding4.repro.recordingStepIndex,
+        fingerprint: finding4.fingerprint,
+        defectKind: finding4.kind,
         ...declared === void 0 ? {} : { invariant: declared },
-        ...finding3.hang === void 0 ? {} : { hang: finding3.hang },
+        ...finding4.hang === void 0 ? {} : { hang: finding4.hang },
         // #153: never re-send a paid/destructive write unless the operator opted in.
         safety: { ...target.safety ?? {}, ...opts.hangReplayWrites === true ? { hangReplayWrites: true } : {} },
         writtenBy: recordedWriters(raw),
-        ...finding3.occurrences === void 0 ? {} : { occurrences: finding3.occurrences },
+        ...finding4.occurrences === void 0 ? {} : { occurrences: finding4.occurrences },
         ...opts.settleCeilingMs === void 0 ? {} : { settleCeilingMs: opts.settleCeilingMs },
         ...opts.replays === void 0 ? {} : { replays: opts.replays },
         ...opts.actionDeltas === true ? { actionDeltas: true, secrets: [...opts.secrets ?? [], ...authTokenValues] } : {},
@@ -96414,18 +96807,18 @@ async function runVerifyFix(opts) {
   let shotFields = {};
   if (opts.browser?.recordVideo !== void 0 || opts.screenshots !== void 0) {
     const secrets = [...opts.secrets ?? [], ...authTokenValues];
-    const stored = persistedDefect(raw, finding3.fingerprint);
+    const stored = persistedDefect(raw, finding4.fingerprint);
     const storedEvidence = stored !== void 0 && isRecord(stored.evidence) ? stored.evidence : void 0;
     const beforeVideo = typeof storedEvidence?.videoPath === "string" ? storedEvidence.videoPath : void 0;
     const beforeShots = Array.isArray(storedEvidence?.screenshots) ? storedEvidence.screenshots.filter((x) => typeof x === "string") : [];
-    const shots = opts.screenshots === void 0 ? void 0 : new RunScreenshots({ spec: opts.screenshots, dir: screenshotsDirFor(opts.screenshots, vfArtifact), secrets, title: `verify-fix ${finding3.fingerprint}` });
+    const shots = opts.screenshots === void 0 ? void 0 : new RunScreenshots({ spec: opts.screenshots, dir: screenshotsDirFor(opts.screenshots, vfArtifact), secrets, title: `verify-fix ${finding4.fingerprint}` });
     const verdictCard = () => result.verdict === "fixed" ? { text: "After the fix: the defect no longer reproduces", ok: true } : { text: `After: ${result.verdict === "still-reproduces" ? "still reproduces" : result.verdict}`, ok: false };
     const after = prefix !== void 0 ? { screenshots: [], skipped: "a finding from a Journey branch point: the after-clip replay does not replay the prefix" } : fx !== void 0 || observers.length > 0 ? { screenshots: [], skipped: fx !== void 0 ? "the run used mission fixtures: the after-clip replay does not restore them" : "a cross-actor defect: no after-clip replay" } : await replayWithEvidence({
       recording,
-      stepIndex: finding3.repro.recordingStepIndex,
-      fingerprints: [finding3.fingerprint, ...finding3.related ?? []],
-      signalCheckable: signalCheckable(finding3.kind),
-      signal: defectSignalText(stored ?? { kind: finding3.kind, ...finding3.title === void 0 ? {} : { title: finding3.title } }, secrets),
+      stepIndex: finding4.repro.recordingStepIndex,
+      fingerprints: [finding4.fingerprint, ...finding4.related ?? []],
+      signalCheckable: signalCheckable(finding4.kind),
+      signal: defectSignalText(stored ?? { kind: finding4.kind, ...finding4.title === void 0 ? {} : { title: finding4.title } }, secrets),
       seedUrl: mission.target.seedUrl,
       allowlist: mission.target.allowlist,
       ...storageState === void 0 ? {} : { storageState },
@@ -96454,7 +96847,7 @@ async function runVerifyFix(opts) {
     ...stale === void 0 ? {} : { failure: { kind: "journey-stale", message: stale.message } },
     ...evidence === void 0 ? {} : { evidence },
     ...shotFields,
-    ...finding3.title === void 0 ? {} : { title: finding3.title },
+    ...finding4.title === void 0 ? {} : { title: finding4.title },
     ...replay.override === void 0 ? {} : { allowlistOverride: replay.override },
     ...fx === void 0 ? {} : { fixtures: { ...fx.record(), missionIdentity: mission.fixtures?.identity ?? "none" } },
     // Every replay closed its own session (finalizing its video) before verifyFix returned.
@@ -96554,17 +96947,17 @@ function ledgerAdd(opts) {
   } catch (e) {
     throw new LedgerError("E_LEDGER_INPUT", `${opts.resultPath}: ${e instanceof Error ? e.message : String(e)}`);
   }
-  const finding3 = findFinding(mission, opts.fingerprint);
+  const finding4 = findFinding(mission, opts.fingerprint);
   const result = isRecord(raw) && isRecord(raw.result) ? raw.result : {};
-  const item = finding3 === void 0 ? void 0 : rawFinding(result, finding3.fingerprint);
-  if (finding3 === void 0 || item === void 0) {
+  const item = finding4 === void 0 ? void 0 : rawFinding(result, finding4.fingerprint);
+  if (finding4 === void 0 || item === void 0) {
     throw new LedgerError("E_LEDGER_INPUT", `no finding with fingerprint ${opts.fingerprint} in ${opts.resultPath}`);
   }
   const ownRecording = isRecord(item.repro) && item.repro.recording !== void 0;
   if (!ownRecording && mission.recording === null) {
-    throw new LedgerError("E_LEDGER_INPUT", `finding ${finding3.fingerprint} has no Recording to replay \u2014 nothing verify-fix could re-check`);
+    throw new LedgerError("E_LEDGER_INPUT", `finding ${finding4.fingerprint} has no Recording to replay \u2014 nothing verify-fix could re-check`);
   }
-  const list2 = finding3.kind === "hang" ? "hangs" : "defects";
+  const list2 = finding4.kind === "hang" ? "hangs" : "defects";
   const persistedFixtures = isRecord(result.fixtures) ? result.fixtures : void 0;
   const material = {
     ...typeof result.schemaVersion === "number" ? { schemaVersion: result.schemaVersion } : {},
@@ -96574,7 +96967,7 @@ function ledgerAdd(opts) {
     recording: ownRecording ? null : mission.recording,
     defects: list2 === "defects" ? [item] : [],
     hangs: list2 === "hangs" ? [item] : [],
-    ...finding3.kind === "invariant" && mission.invariantSpec !== void 0 ? { invariantSpec: mission.invariantSpec } : {},
+    ...finding4.kind === "invariant" && mission.invariantSpec !== void 0 ? { invariantSpec: mission.invariantSpec } : {},
     // The fixture's spec, hook HASHES and non-secret outputs — what a replay restores; hooks are never stored.
     ...persistedFixtures === void 0 ? {} : {
       fixtures: {
@@ -96591,14 +96984,14 @@ function ledgerAdd(opts) {
   };
   assertNoSecrets(material, opts.secrets ?? []);
   const dir = ledgerDir(opts.regressionsDir);
-  const path2 = entryPath(dir, finding3.fingerprint);
+  const path2 = entryPath(dir, finding4.fingerprint);
   const previous = existsSync20(path2) ? readEntry(path2) : void 0;
   const ticket = opts.ticket ?? previous?.ledger.ticket;
   const meta3 = {
     version: LEDGER_ENTRY_VERSION,
-    fingerprint: finding3.fingerprint,
-    kind: finding3.kind,
-    ...finding3.title === void 0 ? {} : { title: finding3.title },
+    fingerprint: finding4.fingerprint,
+    kind: finding4.kind,
+    ...finding4.title === void 0 ? {} : { title: finding4.title },
     ...ticket === void 0 ? {} : { ticket },
     addedAt: previous?.ledger.addedAt ?? (opts.nowIso ?? (() => clock.nowIso()))(),
     source: {
@@ -96610,16 +97003,16 @@ function ledgerAdd(opts) {
     addedBy: currentEngineInfo()
   };
   const entry = { ledger: meta3, result: material };
-  const check3 = findFinding(parsePersistedMission(entry), finding3.fingerprint);
-  if (check3 === void 0) throw new LedgerError("E_LEDGER_INPUT", `finding ${finding3.fingerprint} did not survive into its ledger entry`);
+  const check3 = findFinding(parsePersistedMission(entry), finding4.fingerprint);
+  if (check3 === void 0) throw new LedgerError("E_LEDGER_INPUT", `finding ${finding4.fingerprint} did not survive into its ledger entry`);
   mkdirSync9(dir, { recursive: true });
   writeFileSync12(path2, `${JSON.stringify(entry, null, 2)}
 `, "utf8");
   return {
     entryPath: path2,
-    fingerprint: finding3.fingerprint,
-    kind: finding3.kind,
-    ...finding3.title === void 0 ? {} : { title: finding3.title },
+    fingerprint: finding4.fingerprint,
+    kind: finding4.kind,
+    ...finding4.title === void 0 ? {} : { title: finding4.title },
     ...ticket === void 0 ? {} : { ticket },
     updated: previous !== void 0
   };
@@ -96837,14 +97230,14 @@ function realSecureIO() {
       return readMaskedLine(process.stdin, process.stdout, message2);
     },
     async persist(key2, value) {
-      const { mkdir: mkdir38, writeFile: writeFile45, readFile: readFile41 } = await import("node:fs/promises");
+      const { mkdir: mkdir40, writeFile: writeFile47, readFile: readFile46 } = await import("node:fs/promises");
       const { dirname: dirname34 } = await import("node:path");
       const path2 = resolveDataDir(["credentials.json"]);
-      await mkdir38(dirname34(path2), { recursive: true });
+      await mkdir40(dirname34(path2), { recursive: true });
       let existing = {};
       let raw;
       try {
-        raw = await readFile41(path2, "utf8");
+        raw = await readFile46(path2, "utf8");
       } catch (err) {
         const missing = typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
         if (!missing) throw err;
@@ -96857,7 +97250,7 @@ function realSecureIO() {
         }
       }
       existing[key2] = value;
-      await writeFile45(path2, JSON.stringify(existing, null, 2), { mode: 384 });
+      await writeFile47(path2, JSON.stringify(existing, null, 2), { mode: 384 });
     }
   };
 }
@@ -97241,7 +97634,7 @@ function makeFinding(input2, rubric, evidence) {
   if (!Number.isInteger(occurrences3) || occurrences3 < 1) {
     throw new UxFindingError(`occurrences for '${entry.id}' must be a positive integer, got ${occurrences3}`);
   }
-  const finding3 = {
+  const finding4 = {
     rubricItemId: entry.id,
     citation: { source: entry.citation.source, ref: entry.citation.ref },
     severity: input2.severity,
@@ -97261,7 +97654,7 @@ function makeFinding(input2, rubric, evidence) {
     ...input2.quality ? { quality: { ...input2.quality } } : {},
     ...input2.predictedAttention ? { predictedAttention: input2.predictedAttention } : {}
   };
-  return Object.freeze(finding3);
+  return Object.freeze(finding4);
 }
 
 // ../ux/dist/redact.js
@@ -97722,9 +98115,9 @@ function dedupeObjectiveFindings(items, rubric) {
 }
 
 // ../ux/dist/recommend.js
-function evidenceSummaryFor(finding3, evidence) {
+function evidenceSummaryFor(finding4, evidence) {
   const parts2 = [];
-  for (const ref of finding3.evidenceRefs) {
+  for (const ref of finding4.evidenceRefs) {
     if (ref.id.startsWith("control:")) {
       const idx = Number(ref.id.slice("control:".length));
       const c = evidence.controls.find((ctrl) => ctrl.index === idx);
@@ -97736,19 +98129,19 @@ function evidenceSummaryFor(finding3, evidence) {
   }
   return parts2.join(" | ").slice(0, 4e3);
 }
-async function recommend(gen, finding3, evidence, secrets = []) {
+async function recommend(gen, finding4, evidence, secrets = []) {
   const input2 = {
-    principle: finding3.rubricItemId,
-    citationSource: finding3.citation.source,
-    citationRef: finding3.citation.ref,
-    judgmentSummary: finding3.recommendation,
-    evidenceSummary: evidenceSummaryFor(finding3, evidence),
+    principle: finding4.rubricItemId,
+    citationSource: finding4.citation.source,
+    citationRef: finding4.citation.ref,
+    judgmentSummary: finding4.recommendation,
+    evidenceSummary: evidenceSummaryFor(finding4, evidence),
     appClass: evidence.appContext.appClass
   };
   assertNoSecretInPayload(input2, secrets);
   const result = await gen.generate("ux.recommendation", input2);
   const body = result.output.recommendation.trim();
-  return `${body} (${finding3.citation.source}: ${finding3.citation.ref})`;
+  return `${body} (${finding4.citation.source}: ${finding4.citation.ref})`;
 }
 
 // ../ux/dist/a11y.js
@@ -98095,7 +98488,7 @@ function makeSignalFinding(input2) {
     ...input2.evidence.requests.map((r) => ({ id: `request:${r.id}` })),
     ...input2.evidence.screenshot === void 0 ? [] : [{ id: `screenshot:${input2.evidence.screenshot}` }]
   ];
-  const finding3 = {
+  const finding4 = {
     rubricItemId: rule.id,
     citation: { ...rule.citation },
     severity: rule.severity,
@@ -98113,7 +98506,7 @@ function makeSignalFinding(input2) {
     screenIds: [...input2.screenIds ?? [input2.screenId]],
     signal: input2.evidence
   };
-  return Object.freeze(finding3);
+  return Object.freeze(finding4);
 }
 
 // ../ux/dist/signals/shared.js
@@ -99871,9 +100264,9 @@ async function analyzeClaims(request, deps) {
     const dupOptions = /* @__PURE__ */ new Map();
     for (const d of group) {
       const i = indexOf.get(d);
-      const finding3 = describeDraft(d, prose[i]);
-      questions[`grade::${i}::need`] = { kind: "noul", instructions: prompts.grade.need.replace("{finding}", finding3).replace("{persona}", persona2) };
-      questions[`grade::${i}::ship`] = { kind: "noul", instructions: prompts.grade.ship.replace("{finding}", finding3).replace("{feature}", feature(d)) };
+      const finding4 = describeDraft(d, prose[i]);
+      questions[`grade::${i}::need`] = { kind: "noul", instructions: prompts.grade.need.replace("{finding}", finding4).replace("{persona}", persona2) };
+      questions[`grade::${i}::ship`] = { kind: "noul", instructions: prompts.grade.ship.replace("{finding}", finding4).replace("{feature}", feature(d)) };
       const earlier = drafts.slice(0, i).map((e, j) => ({ e, j })).filter(({ e }) => d.target !== void 0 && e.target !== void 0 && controlKey2(d.target) === controlKey2(e.target) && e.screen.route === d.screen.route || e.type === d.type && e.screen.route === d.screen.route).map(({ j }) => j).slice(0, MAX_CHOICE_OPTIONS - 1);
       if (earlier.length > 0) {
         dupOptions.set(i, earlier);
@@ -99881,7 +100274,7 @@ async function analyzeClaims(request, deps) {
           kind: "choice",
           options: ["new", ...earlier.map((j) => `same:${j}`)],
           descriptions: Object.fromEntries([["new", "a different problem"], ...earlier.map((j) => [`same:${j}`, describeDraft(drafts[j], prose[j])])]),
-          instructions: prompts.duplicate.replace("{finding}", finding3)
+          instructions: prompts.duplicate.replace("{finding}", finding4)
         };
       }
     }
@@ -99930,9 +100323,9 @@ async function analyzeClaims(request, deps) {
     const impact = d.friction?.impact ?? v.impact ?? "confused";
     const severity2 = v.severity ?? (d.friction === void 0 ? "minor" : IMPACT_SEVERITY2[d.friction.impact]);
     const evidenceRefs = d.target !== void 0 ? [{ id: `control:${d.target.index}` }] : (v.quotes ?? []).length > 0 ? [{ id: "visibleText" }] : [{ id: "url" }];
-    let finding3;
+    let finding4;
     try {
-      finding3 = makeFinding({
+      finding4 = makeFinding({
         rubricItemId,
         evidenceRefs,
         severity: severity2,
@@ -99951,8 +100344,8 @@ async function analyzeClaims(request, deps) {
       if (deps.polish === true) {
         if (deps.gen === void 0)
           throw new Error("polish requested without a generation gateway");
-        const polished = await recommend(deps.gen, finding3, d.screen.red, secrets);
-        finding3 = Object.freeze({ ...finding3, recommendation: polished });
+        const polished = await recommend(deps.gen, finding4, d.screen.red, secrets);
+        finding4 = Object.freeze({ ...finding4, recommendation: polished });
       }
     } catch (cause) {
       return { kind: "failed", reason: `claim finding failed: ${message(cause)}`, screenId: d.screen.raw.screenId, rubricItemId };
@@ -99965,7 +100358,7 @@ async function analyzeClaims(request, deps) {
       ...d.target === void 0 ? {} : { target: label(d.target) }
     };
     built.set(i, Object.freeze({
-      ...finding3,
+      ...finding4,
       claim: claim2,
       impact,
       ...grade === void 0 ? {} : { grade },
@@ -99974,7 +100367,7 @@ async function analyzeClaims(request, deps) {
     const r = root2(i);
     if (r !== i) {
       const list2 = contributions.get(r) ?? [];
-      list2.push({ rubricItemId, observation: finding3.observation, confidence: finding3.confidence, occurrences: finding3.occurrences, citation: finding3.citation, ...finding3.quality ? { quality: finding3.quality } : {} });
+      list2.push({ rubricItemId, observation: finding4.observation, confidence: finding4.confidence, occurrences: finding4.occurrences, citation: finding4.citation, ...finding4.quality ? { quality: finding4.quality } : {} });
       contributions.set(r, list2);
     }
   }
@@ -100005,8 +100398,8 @@ async function analyzeClaims(request, deps) {
       if (ok2.length === 0)
         continue;
       a11yEvaluated += ok2.length;
-      for (const finding3 of deps.a11yChecker(s3.red, request.rubric).findings)
-        a11yFound.push({ finding: finding3, refs: s3.red.refs });
+      for (const finding4 of deps.a11yChecker(s3.red, request.rubric).findings)
+        a11yFound.push({ finding: finding4, refs: s3.red.refs });
     }
   }
   const ledger = summarizeLedger(records);
@@ -100811,14 +101204,14 @@ var CREDENTIAL_KEY2 = /pass|secret|token|otp|totp|pin|cvc|cvv|card|auth|session|
 var MAX_DIGEST_BODY = 64e3;
 var CredentialBody = class extends Error {
 };
-function canonical6(v) {
-  if (Array.isArray(v)) return v.map(canonical6);
+function canonical5(v) {
+  if (Array.isArray(v)) return v.map(canonical5);
   if (v !== null && typeof v === "object") {
     const out = {};
     for (const k of Object.keys(v).sort()) {
       if (CREDENTIAL_KEY2.test(k)) throw new CredentialBody();
       if (VOLATILE_KEY.test(k)) continue;
-      out[k] = canonical6(v[k]);
+      out[k] = canonical5(v[k]);
     }
     return out;
   }
@@ -100835,7 +101228,7 @@ function payloadDigest(method, endpoint2, body, secrets) {
     value = Object.fromEntries(new URLSearchParams(body));
   }
   try {
-    const canon = JSON.stringify(canonical6(value));
+    const canon = JSON.stringify(canonical5(value));
     return createHash12("sha256").update(`${method.toUpperCase()} ${endpoint2}
 ${canon}`).digest("hex").slice(0, 32);
   } catch {
@@ -104264,10 +104657,17 @@ import { existsSync as existsSync25 } from "node:fs";
 import { copyFile as copyFile4, lstat as lstat4, mkdir as mkdir25, open as open3, readdir as readdir9, readFile as readFile24, rename as rename4, rm as rm10, writeFile as writeFile29 } from "node:fs/promises";
 import { basename as basename15, dirname as dirname24, join as join56, resolve as resolve18, sep as sep7 } from "node:path";
 
+// src/catalog-contract-identity.ts
+var CATALOG_CONTRACT_IDENTITY = {
+  "kind": "jevitate.catalog-contract",
+  "version": "2.0.0",
+  "manifestSha256": "c1292a8727d7dc0dbe1d63dc768d34b6cc94ae60fab3a67aeb0a53837e1735ad"
+};
+
 // src/catalog-bundle.ts
 var BUNDLE_KIND = "journeeze.catalog-bundle";
 var BUNDLE_VERSION = 1;
-var BUNDLE_MINOR = 1;
+var BUNDLE_MINOR = 2;
 var CatalogBundleInputError = class extends CatalogInputError {
   constructor(issues) {
     super(`the catalog cannot be exported as a Journeeze bundle (${issues.length} problem(s)): ${issues.join("; ")}`);
@@ -104632,7 +105032,7 @@ function bundleChecks(input2, journeys, warn) {
         if (outcome.outcome !== "clean") why = `the run was ${outcome.outcome}, and a baseline comes only from a clean run`;
         else if (journeyId === void 0 || journeyHash === void 0) why = "the item names no Journey review hash";
         else if (cj === void 0) why = `Journey ${journeyId} is not in the bundle`;
-        else if (cj.approval?.contentHash !== journeyHash || cj.contentHash !== journeyHash) why = `it was measured on a Journey revision (${journeyHash.slice(0, 12)}\u2026) that is not ${journeyId}'s approved one`;
+        else if (cj.approval?.contentHash !== journeyHash || cj.changedSinceApproval) why = `it was measured on a Journey revision (${journeyHash.slice(0, 12)}\u2026) that is not ${journeyId}'s approved one`;
         else {
           const b2 = bundleBaseline(item.baseline, cj.journey);
           if ("drop" in b2) why = b2.drop;
@@ -104686,13 +105086,13 @@ function bundleDemos(input2, journeys, warn) {
       warn.push(`${where}: its Journey is not in the bundle (not promoted, or left out) \u2014 the demo is left out`);
       continue;
     }
-    const approved = ex.cj.approval !== void 0 && ex.cj.approval.contentHash === ex.cj.contentHash;
+    const approved = ex.cj.approval !== void 0 && !ex.cj.changedSinceApproval;
     if (!approved) {
       warn.push(`${where}: its Journey changed since it was approved \u2014 the demo is left out (approve the Journey and its demo again)`);
       continue;
     }
-    if (d.renderedFrom !== ex.cj.contentHash) {
-      warn.push(`${where}: rendered from another version of its Journey (${d.renderedFrom.slice(0, 12)}, approved ${ex.cj.contentHash.slice(0, 12)}) \u2014 the demo is left out (run \`jevitate demo approve\` again)`);
+    if (d.renderedFrom !== ex.cj.approval.contentHash) {
+      warn.push(`${where}: rendered from another version of its Journey (${d.renderedFrom.slice(0, 12)}, approved ${ex.cj.approval.contentHash.slice(0, 12)}) \u2014 the demo is left out (run \`jevitate demo approve\` again)`);
       continue;
     }
     if (d.steps.length === 0 || d.steps.length > MEDIA_LIMITS.demoSteps) {
@@ -104844,6 +105244,7 @@ function buildCatalogBundle(input2) {
       version: BUNDLE_VERSION,
       minor: BUNDLE_MINOR,
       producer: { tool: "jevitate", version: input2.producer.version, ...commit === void 0 ? {} : { commit } },
+      catalogContract: CATALOG_CONTRACT_IDENTITY,
       product: { name: input2.productName },
       catalog: { personas, jobs, journeys: journeys.map((j) => j.entry) },
       ...shown2.demos.length === 0 ? {} : { demos: shown2.demos },
@@ -105531,7 +105932,7 @@ ${route ?? ""}
 ${key2}`, "utf8").digest("hex").slice(0, 16);
     const step = first.index + 1;
     const fix = s3.route !== void 0 && route !== void 0 && s3.route !== route ? s3.fix.split(s3.route).join(route) : s3.fix;
-    const finding3 = {
+    const finding4 = {
       fingerprint: fingerprint2,
       kind: "ux",
       claim: "other",
@@ -105547,12 +105948,12 @@ ${key2}`, "utf8").digest("hex").slice(0, 16);
       recommendation: fix,
       locator: { element: s3.element, attribute: s3.attribute, testId: s3.testId, fix, steps: s3.occurrences.length }
     };
-    const issues = findingIssues(finding3);
+    const issues = findingIssues(finding4);
     if (issues.length > 0) {
-      warnings.push(findingDropWarning(fingerprint2, finding3.kind, issues));
+      warnings.push(findingDropWarning(fingerprint2, finding4.kind, issues));
       continue;
     }
-    findings.push(finding3);
+    findings.push(finding4);
   }
   return { findings, warnings };
 }
@@ -107534,8 +107935,51 @@ function registerLocatorHealthCommand(program2, deps) {
 }
 
 // src/report-cli.ts
-import { mkdir as mkdir27, writeFile as writeFile32 } from "node:fs/promises";
+import { mkdir as mkdir28, readFile as readFile28, writeFile as writeFile33 } from "node:fs/promises";
 import { join as join58 } from "node:path";
+
+// src/journeeze-hint.ts
+import { createHash as createHash18 } from "node:crypto";
+import { mkdir as mkdir27, readFile as readFile27, rename as rename6, writeFile as writeFile32 } from "node:fs/promises";
+async function loadJourneezeHintPreference(path2 = resolveDataDir(["config.json"])) {
+  try {
+    const parsed = JSON.parse(await readFile27(path2, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const hints = parsed.hints;
+    if (hints === null || typeof hints !== "object" || Array.isArray(hints)) return {};
+    const value = hints.journeeze;
+    if (value === false) return { enabled: false };
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return {};
+    const record2 = value;
+    return { ...record2.enabled === false ? { enabled: false } : {}, ...typeof record2.dismissedSignal === "string" ? { dismissedSignal: record2.dismissedSignal } : {} };
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+function decideJourneezeHint(signal, preference = {}) {
+  const authors = [...new Set(signal.journeyAuthors.map((author) => author.trim()).filter(Boolean))].sort();
+  const reasons = [
+    ...signal.sharedSource ? ["shared Journey source configured"] : [],
+    ...authors.length >= 2 ? [`${authors.length} Journey/approval authors`] : [],
+    ...signal.unresolvedFindings >= 3 ? [`${signal.unresolvedFindings} persistent unresolved findings`] : [],
+    ...signal.strictReviewApproved ? ["human-approved strict Journey review"] : []
+  ];
+  const eligible = signal.sharedSource || reasons.length >= 2;
+  const hash3 = createHash18("sha256").update(JSON.stringify({ sharedSource: signal.sharedSource, authors, unresolvedFindings: signal.unresolvedFindings, strictReviewApproved: signal.strictReviewApproved })).digest("hex");
+  return { show: preference.enabled !== false && eligible && preference.dismissedSignal !== hash3, signal: hash3, reasons };
+}
+function renderJourneezeHint(signal, preference = {}, context = { isTTY: process.stdout.isTTY === true }) {
+  const env = context.env ?? process.env;
+  if (context.isTTY !== true || context.json === true || (context.mcp ?? inMcpInvocation()) || CI_ENV_MARKERS.some((key2) => env[key2] !== void 0)) return null;
+  const decision = decideJourneezeHint(signal, preference);
+  if (!decision.show) return null;
+  return `
+Tip: Journeeze can coordinate this shared testing work (${decision.reasons.join(", ")}). Run \`jevitate connect journeeze\` to connect it.
+`;
+}
+
+// src/report-cli.ts
 function emit3(program2, envelope, exitCode) {
   emitJsonOrRefusal(program2, envelope, exitCode);
 }
@@ -107544,6 +107988,25 @@ function failure2(program2, err, code) {
   else emit3(program2, fail(code, err instanceof Error ? err.message : String(err)));
 }
 var collect3 = (v, prev) => [...prev, v];
+async function hasSharedSource() {
+  try {
+    const raw = JSON.parse(await readFile28(join58(process.cwd(), "jevitate.lock"), "utf8"));
+    return raw !== null && typeof raw === "object" && !Array.isArray(raw) && Array.isArray(raw.sources) && raw.sources.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function reportJourneezeHint(json2) {
+  try {
+    return renderJourneezeHint(
+      { sharedSource: await hasSharedSource(), journeyAuthors: [], unresolvedFindings: 0, strictReviewApproved: false },
+      await loadJourneezeHintPreference(),
+      { isTTY: process.stdout.isTTY === true, json: json2 }
+    ) ?? "";
+  } catch {
+    return "";
+  }
+}
 function registerReportCommands(program2, deps) {
   program2.command("report").description("one deduped defect list for a target across every mode and run (markdown + JSON envelope)").option("--target <origin|name>", "the target: an origin (or URL on it), a suite target name, or a registered mission target").option("--since <run|date>", "only runs that started at/after this ISO date or this run").option("--dir <dir>", "results dir to read (repeatable). Default: this project's runs \u2014 its .jevitate/logs plus every run recorded for it in ~/.jevitate/run-index.jsonl (including --out dirs); with --target, every .jevitate/logs dir (project and ~/.jevitate) and the 0.1.0 recordings/ux-reports dirs too", collect3, []).option("--baseline <run|tag|last>", "add a diff section against a baseline: a run, a `baseline tag`, or `last` (the previous run per target+mode)").option("--tag <key=value>", "only runs carrying this tag (repeatable; every tag must match)", collect3, []).option("--out <dir>", "also write report.md and report.json here").option("--json", "emit the JSON envelope instead of markdown").action(async function() {
     const o = this.opts();
@@ -107559,14 +108022,14 @@ function registerReportCommands(program2, deps) {
         ...deps.baselinesDir === void 0 ? {} : { baselinesDir: deps.baselinesDir }
       });
       if (o.out !== void 0) {
-        await mkdir27(o.out, { recursive: true });
-        await writeFile32(join58(o.out, "report.md"), report2.markdown, "utf8");
-        await writeFile32(join58(o.out, "report.json"), `${JSON.stringify(ok(report2), null, 2)}
+        await mkdir28(o.out, { recursive: true });
+        await writeFile33(join58(o.out, "report.md"), report2.markdown, "utf8");
+        await writeFile33(join58(o.out, "report.json"), `${JSON.stringify(ok(report2), null, 2)}
 `, "utf8");
       }
       if (o.json) emit3(program2, ok(report2), 0);
       else {
-        program2.configureOutput().writeOut?.(report2.markdown);
+        program2.configureOutput().writeOut?.(`${report2.markdown}${await reportJourneezeHint(o.json)}`);
         process.exitCode = 0;
       }
     } catch (err) {
@@ -107747,7 +108210,7 @@ async function collectAllMissingKeys(store, io, opts = {}) {
 }
 
 // src/init-mcp.ts
-import { readFile as readFile27, writeFile as writeFile33, mkdir as mkdir28 } from "node:fs/promises";
+import { readFile as readFile29, writeFile as writeFile34, mkdir as mkdir29 } from "node:fs/promises";
 import { homedir as realHomedir2 } from "node:os";
 import { join as join59, dirname as dirname26 } from "node:path";
 var MCP_SERVER_NAME = "jevitate";
@@ -107880,7 +108343,7 @@ async function registerMcp(runtimes, paths, opts = {}) {
   for (const unit of units) {
     let existing;
     try {
-      existing = await readFile27(unit.path, "utf8");
+      existing = await readFile29(unit.path, "utf8");
     } catch {
       existing = void 0;
     }
@@ -107890,8 +108353,8 @@ async function registerMcp(runtimes, paths, opts = {}) {
       entry.instruction = renderPrintConfig(unit.harness);
     }
     if (!opts.dryRun && result.content !== void 0) {
-      await mkdir28(dirname26(unit.path), { recursive: true });
-      await writeFile33(unit.path, result.content, "utf8");
+      await mkdir29(dirname26(unit.path), { recursive: true });
+      await writeFile34(unit.path, result.content, "utf8");
     }
     report2.push(entry);
   }
@@ -108211,7 +108674,7 @@ function registerProfileCommands(program2, deps) {
 }
 
 // src/site-cli.ts
-import { readFile as readFile28 } from "node:fs/promises";
+import { readFile as readFile30 } from "node:fs/promises";
 function registerSiteCommands(program2, deps) {
   const site = program2.command("site").description("per-site policies for Journey runs: human-like pacing, throttles, run budgets and quiet hours");
   const sitePolicy = site.command("policy").description("read or set a site's policy (the site is the Journey's origin, e.g. https://app.example.com)");
@@ -108269,7 +108732,7 @@ function registerSiteCommands(program2, deps) {
     const { account, db, file: file2, json: json2 } = this.opts();
     let policy;
     try {
-      const raw = await readFile28(file2, "utf8");
+      const raw = await readFile30(file2, "utf8");
       policy = SitePolicySchema.parse(JSON.parse(raw));
     } catch (err) {
       emitJson(program2, fail("E_INVALID_POLICY", String(err)));
@@ -108297,7 +108760,7 @@ function registerSiteCommands(program2, deps) {
     const { account, db, script, seed, json: json2 } = this.opts();
     let plannedScript;
     try {
-      const raw = await readFile28(script, "utf8");
+      const raw = await readFile30(script, "utf8");
       plannedScript = parsePlannedScript(raw);
     } catch (err) {
       emitJson(program2, fail("E_INVALID_SCRIPT", String(err)));
@@ -108333,12 +108796,12 @@ function registerSiteCommands(program2, deps) {
 }
 
 // src/recording-cli.ts
-import { readFile as readFile29, writeFile as writeFile34 } from "node:fs/promises";
+import { readFile as readFile31, writeFile as writeFile35 } from "node:fs/promises";
 import { resolve as resolvePath14 } from "node:path";
 import * as clack from "@clack/prompts";
 function registerRecordingCommands(program2, deps) {
   async function readTakeJson(file2) {
-    const raw = await readFile29(file2, "utf8");
+    const raw = await readFile31(file2, "utf8");
     let json2;
     try {
       json2 = JSON.parse(raw);
@@ -108357,7 +108820,7 @@ function registerRecordingCommands(program2, deps) {
     return { recording: parsed.recording, values: new Map(Object.entries(parsed.values)) };
   }
   async function readRecordingOrTake(file2) {
-    const raw = await readFile29(file2, "utf8");
+    const raw = await readFile31(file2, "utf8");
     const json2 = JSON.parse(raw);
     if (json2 !== null && typeof json2 === "object" && !Array.isArray(json2) && "recording" in json2) {
       return AuthoringTakeSchema.parse(json2).recording;
@@ -108432,7 +108895,7 @@ function registerRecordingCommands(program2, deps) {
       }
       const result = applyPostdoc(takes[0], diff2, decisions);
       if (out !== void 0) {
-        await writeFile34(out, `${JSON.stringify(result, null, 2)}
+        await writeFile35(out, `${JSON.stringify(result, null, 2)}
 `, "utf8");
       }
       if (json2) {
@@ -108510,7 +108973,7 @@ var DraftSaveError = class extends Error {
 async function saveDraft(draft, out, journeysDir) {
   const steps = draft.recording.pages.reduce((n3, p) => n3 + p.steps.length, 0);
   if (out !== void 0) {
-    await writeFile34(out, `${JSON.stringify(draft, null, 2)}
+    await writeFile35(out, `${JSON.stringify(draft, null, 2)}
 `, "utf8");
     return { id: draft.metadata.id, path: resolvePath14(out), savedTo: "file", promoted: false, steps };
   }
@@ -108609,7 +109072,7 @@ async function loadDecisions(file2) {
   let raw;
   let parsed;
   try {
-    raw = await readFile29(file2, "utf8");
+    raw = await readFile31(file2, "utf8");
     parsed = JSON.parse(raw);
   } catch (err) {
     throw new DecisionsParseError(err);
@@ -108686,9 +109149,9 @@ function targetsOpts(deps) {
   const file2 = deps.explore?.targetsConfigPath;
   return file2 === void 0 ? {} : { targetsFile: file2 };
 }
-function lintFindingLine(finding3) {
-  const message2 = finding3.message.replace(/^step \d+: /, "");
-  return `${finding3.level}  ${finding3.step === void 0 ? "" : `step ${finding3.step}  `}${finding3.rule}  ${message2}${finding3.fix === void 0 ? "" : ` \u2014 fix: ${finding3.fix}`}`;
+function lintFindingLine(finding4) {
+  const message2 = finding4.message.replace(/^step \d+: /, "");
+  return `${finding4.level}  ${finding4.step === void 0 ? "" : `step ${finding4.step}  `}${finding4.rule}  ${message2}${finding4.fix === void 0 ? "" : ` \u2014 fix: ${finding4.fix}`}`;
 }
 var FULL_FLAG_HELP = "#496: show every detail section: catalog analysis, the full lint list, locator health, provenance, the full change diff";
 var DEPRECATED_DIR_HELP = "deprecated: use --journeys-dir <path> (same meaning); default: the repo's .jevitate/journeys, outside a repo ~/.jevitate/journeys";
@@ -108780,7 +109243,7 @@ function registerJourneyFind(journey, program2, deps) {
 import { existsSync as existsSync27 } from "node:fs";
 
 // src/journey-annotate-api.ts
-import { mkdir as mkdir29, readFile as readFile30, rm as rm12, writeFile as writeFile35 } from "node:fs/promises";
+import { mkdir as mkdir30, readFile as readFile32, rm as rm12, writeFile as writeFile36 } from "node:fs/promises";
 import { dirname as dirname28, join as join62 } from "node:path";
 var EVIDENCE_TEXT_CHARS = 1500;
 var AnnotationDraftNotFoundError = class extends Error {
@@ -108928,8 +109391,8 @@ async function annotateJourney(opts) {
   });
   assertNoSecretInPayload(draft, secrets, "journey annotation draft");
   const draftPath = annotationDraftPath(opts.dir, opts.id);
-  await mkdir29(dirname28(draftPath), { recursive: true, mode: 448 });
-  await writeFile35(draftPath, `${JSON.stringify(draft, null, 2)}
+  await mkdir30(dirname28(draftPath), { recursive: true, mode: 448 });
+  await writeFile36(draftPath, `${JSON.stringify(draft, null, 2)}
 `, { mode: 384 });
   return {
     id: opts.id,
@@ -108952,7 +109415,7 @@ async function readAnnotationDraft(dir, id) {
   const draftPath = annotationDraftPath(dir, id);
   let raw;
   try {
-    raw = await readFile30(draftPath, "utf8");
+    raw = await readFile32(draftPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       throw new AnnotationDraftNotFoundError(`no annotation draft for journey '${id}' (${draftPath}) \u2014 run \`jevitate journey annotate ${id}\` first`);
@@ -109807,8 +110270,8 @@ var jevReadinessAnalyzer = {
 // src/journey-stale-api.ts
 function isStepIdOnlyStale(journey, snapshot2) {
   const approval = journey.metadata.approval;
-  if (approval === void 0 || approval.contentHash === journeyReviewHash(journey)) return false;
-  if (snapshot2 !== null && journeyReviewHash(snapshot2) === approval.contentHash) return isStepIdOnlyChange(snapshot2, journey);
+  if (approval === void 0 || journeyApprovalMatches(journey)) return false;
+  if (snapshot2 !== null && [journeyReviewHash(snapshot2), journeyLegacyReviewHash(snapshot2)].includes(approval.contentHash)) return isStepIdOnlyChange(snapshot2, journey);
   return isStepIdOnlyChange(approval.contentHash, journey);
 }
 async function listStaleJourneys(req) {
@@ -109822,7 +110285,7 @@ async function listStaleJourneys(req) {
     const approval = journey.metadata.approval;
     if (approval === void 0) continue;
     const contentHash2 = journeyReviewHash(journey);
-    const hashStale = approval.contentHash !== contentHash2;
+    const hashStale = !journeyApprovalMatches(journey);
     const links = journeyLinks(catalog, catalogJourney(journey));
     const catalogStale = !hashStale && links.linked && [links.job?.status, links.persona?.status].includes("stale");
     if (!hashStale && !catalogStale) continue;
@@ -109891,6 +110354,35 @@ async function reviewJourneyById(journeysDir, id, opts = {}) {
 }
 
 // src/journey-verify.ts
+async function planJourneyVerification(opts) {
+  const journey = await new JourneyRegistry(new FsJourneyStore(opts.dir)).get(opts.id);
+  if (!journey) throw new UnknownJourneyError(`unknown journey '${opts.id}'`);
+  const sites = journeyAssertions(journey);
+  const checkOf = new Map(sites.map((site) => [assertionSiteKey(site), describeCheck(site.check)]));
+  const plan2 = planJourneyMutations(journey, {
+    ...opts.readRequests === void 0 ? {} : { readRequests: opts.readRequests },
+    params: opts.params
+  });
+  const pairs = plan2.pairs.map((pair) => ({ ...pair, check: checkOf.get(pair.site) ?? "unknown assertion" }));
+  const assertions = sites.map((site) => {
+    const key2 = assertionSiteKey(site);
+    return { site: key2, check: describeCheck(site.check), mutations: pairs.filter((pair) => pair.site === key2).map((pair) => pair.mutation) };
+  });
+  return {
+    journeyId: journey.metadata.id,
+    journeyHash: journeyContentHash(journey),
+    mutations: plan2.mutations,
+    pairs,
+    assertions,
+    summary: {
+      mutations: plan2.mutations.length,
+      pairs: pairs.length,
+      assertions: assertions.length,
+      unpaired: assertions.filter((assertion) => assertion.mutations.length === 0).length,
+      minimumReplays: plan2.mutations.length + 1
+    }
+  };
+}
 function verifyExitCode(verdict) {
   return verdict === "proven" ? 0 : verdict === "insensitive" ? 1 : 2;
 }
@@ -110593,7 +111085,7 @@ function registerJourneyReadiness(journey, program2, deps) {
 
 // src/journey-bundle.ts
 import { existsSync as existsSync30 } from "node:fs";
-import { mkdir as mkdir30, readFile as readFile31, writeFile as writeFile36 } from "node:fs/promises";
+import { mkdir as mkdir31, readFile as readFile33, writeFile as writeFile37 } from "node:fs/promises";
 import { join as join63, resolve as resolve19 } from "node:path";
 var BundleStaleError = class extends Error {
   constructor(changed) {
@@ -110784,9 +111276,9 @@ async function buildJourneyBundle(opts, deps = {}) {
     verdict: receipt.verdict,
     generatedAt: clock.nowIso()
   };
-  await mkdir30(out, { recursive: true });
-  await writeFile36(bundlePath, renderJourneyBundle(receipt, entries, catalog, drafts), "utf8");
-  await writeFile36(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await mkdir31(out, { recursive: true });
+  await writeFile37(bundlePath, renderJourneyBundle(receipt, entries, catalog, drafts), "utf8");
+  await writeFile37(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return { out, files: [bundlePath, manifestPath], verdict: receipt.verdict };
 }
@@ -110794,7 +111286,7 @@ async function checkJourneyBundle(dir, opts, deps = {}) {
   const review = deps.review ?? reviewJourneyById;
   const catalogOf = deps.loadCatalog ?? loadCatalog;
   const manifestPath = join63(resolve19(dir), "manifest.json");
-  const manifest = JSON.parse(await readFile31(manifestPath, "utf8"));
+  const manifest = JSON.parse(await readFile33(manifestPath, "utf8"));
   const reviewOpts = { strict: true, ...opts.catalogDir === void 0 ? {} : { catalogDir: opts.catalogDir }, ...opts.targetsFile === void 0 ? {} : { targetsFile: opts.targetsFile } };
   const changed = [];
   for (const recorded of manifest.journeys) {
@@ -110861,7 +111353,7 @@ function registerJourneyBundle(journey, program2, deps) {
 }
 
 // src/journey-cli/promote.ts
-import { readFile as readFile32 } from "node:fs/promises";
+import { readFile as readFile34 } from "node:fs/promises";
 
 // src/review-render-options.ts
 function processTerminal2() {
@@ -110933,7 +111425,7 @@ function registerJourneyPromote(journey, program2, deps) {
       if (reviewSheet !== void 0) {
         let text2;
         try {
-          text2 = await readFile32(reviewSheet, "utf8");
+          text2 = await readFile34(reviewSheet, "utf8");
         } catch (e) {
           emitJson(program2, fail("E_JOURNEY_REVIEW_ARGS", `cannot read --review-sheet ${reviewSheet}: ${e instanceof Error ? e.message : String(e)}`));
           return;
@@ -110990,7 +111482,7 @@ function registerJourneyPromote(journey, program2, deps) {
       } else if (err instanceof WeakJourneyError) {
         if (!json2) {
           const out = program2.configureOutput().writeOut;
-          for (const finding3 of err.findings) out?.(`${lintFindingLine(finding3)}
+          for (const finding4 of err.findings) out?.(`${lintFindingLine(finding4)}
 `);
         }
         emitJson(program2, fail("E_JOURNEY_WEAK", String(err.message)));
@@ -111010,7 +111502,22 @@ function registerJourneyPromote(journey, program2, deps) {
 }
 
 // src/journey-cli/review.ts
-import { writeFile as writeFile37 } from "node:fs/promises";
+import { readFile as readFile35, writeFile as writeFile38 } from "node:fs/promises";
+import { join as join64 } from "node:path";
+async function reviewJourneezeHint(json2, outFile) {
+  if (json2 || outFile !== void 0) return "";
+  try {
+    const raw = JSON.parse(await readFile35(join64(process.cwd(), "jevitate.lock"), "utf8"));
+    const sharedSource = raw !== null && typeof raw === "object" && !Array.isArray(raw) && Array.isArray(raw.sources) && raw.sources.length > 0;
+    return renderJourneezeHint(
+      { sharedSource, journeyAuthors: [], unresolvedFindings: 0, strictReviewApproved: false },
+      await loadJourneezeHintPreference(),
+      { isTTY: process.stdout.isTTY === true, json: json2 }
+    ) ?? "";
+  } catch {
+    return "";
+  }
+}
 function registerJourneyReview(journey, program2, deps) {
   withProjectFlags(journey.command("review [id]")).description(
     "a human-readable review sheet for promotion sign-off: summary, steps, side effects, inputs (names only), proof, change since last approval, content hash. #467: --stale (no id) lists every promoted Journey whose approval is stale, labelling step-id-only changes"
@@ -111051,14 +111558,14 @@ function registerJourneyReview(journey, program2, deps) {
       const renderOpts = reviewRenderOptions({ full: full === true, toFile: outFile !== void 0 });
       const rendered = json2 ? `${JSON.stringify(review, null, 2)}
 ` : markdown ? renderReviewMarkdown(review, renderOpts) : renderReviewText(review, renderOpts);
-      if (outFile !== void 0) await writeFile37(outFile, rendered, { mode: 384 });
+      if (outFile !== void 0) await writeFile38(outFile, rendered, { mode: 384 });
       if (json2) {
         emitJson(program2, strict === true ? Object.assign(ok(review), { strict: strictVerdict }) : ok(review));
       } else if (outFile !== void 0) {
         program2.configureOutput().writeOut?.(`review sheet for journey '${review.id}' written to ${outFile} (content hash ${review.contentHash})
 `);
       } else {
-        program2.configureOutput().writeOut?.(rendered);
+        program2.configureOutput().writeOut?.(`${rendered}${await reviewJourneezeHint(false, outFile)}`);
       }
       emitUsageLine(program2, review.jev);
       process.exitCode = strict === true && !strictVerdict.passed ? EXIT_CODES.defects : 0;
@@ -111084,8 +111591,8 @@ function registerJourneyReview(journey, program2, deps) {
 import { existsSync as existsSync31 } from "node:fs";
 
 // src/journey-migrate-api.ts
-import { readdir as readdir11, readFile as readFile33, writeFile as writeFile38 } from "node:fs/promises";
-import { join as join64 } from "node:path";
+import { readdir as readdir11, readFile as readFile36, writeFile as writeFile39 } from "node:fs/promises";
+import { join as join65 } from "node:path";
 async function migrateStepIds(req) {
   const store = new FsJourneyStore(req.journeysDir);
   const journeys = [];
@@ -111100,7 +111607,7 @@ async function migrateStepIds(req) {
     if (!req.dryRun) await store.put(after);
     journeys.push({ id: meta3.id, stepsMinted, anchorsLinked, needsReapproval: before.metadata.promoted });
   }
-  const recordings = req.projectDir === null ? [] : await migrateRegressions(join64(req.projectDir, "regressions"), req.dryRun);
+  const recordings = req.projectDir === null ? [] : await migrateRegressions(join65(req.projectDir, "regressions"), req.dryRun);
   return {
     dryRun: req.dryRun,
     journeys,
@@ -111121,11 +111628,11 @@ async function migrateRegressions(dir, dryRun) {
   }
   const out = [];
   for (const name of names) {
-    const path2 = join64(dir, name);
-    const rec = RecordingSchema.parse(JSON.parse(await readFile33(path2, "utf8")));
+    const path2 = join65(dir, name);
+    const rec = RecordingSchema.parse(JSON.parse(await readFile36(path2, "utf8")));
     const next = ensureStepIds(rec);
     if (next === rec) continue;
-    if (!dryRun) await writeFile38(path2, `${JSON.stringify(RecordingSchema.parse(next), null, 2)}
+    if (!dryRun) await writeFile39(path2, `${JSON.stringify(RecordingSchema.parse(next), null, 2)}
 `);
     out.push({ path: path2, stepsMinted: countRecIds(next) - countRecIds(rec) });
   }
@@ -111379,7 +111886,7 @@ function registerJourneyMigrate(journey, program2, deps) {
 }
 
 // src/journey-cli/lint.ts
-import { writeFile as writeFile39 } from "node:fs/promises";
+import { writeFile as writeFile40 } from "node:fs/promises";
 
 // src/journey-anchor-api.ts
 async function load(dir, id) {
@@ -111546,16 +112053,16 @@ function renderJourneyLintSarif(input2) {
     shortDescription: { text: rule.id },
     defaultConfiguration: { level: rule.level }
   }));
-  const results = input2.findings.map((finding3) => ({
-    ruleId: finding3.rule,
-    level: finding3.level,
-    message: { text: finding3.fix === void 0 ? finding3.message : `${finding3.message} \u2014 fix: ${finding3.fix}` },
-    ...finding3.fix === void 0 ? {} : { properties: { fix: finding3.fix } },
+  const results = input2.findings.map((finding4) => ({
+    ruleId: finding4.rule,
+    level: finding4.level,
+    message: { text: finding4.fix === void 0 ? finding4.message : `${finding4.message} \u2014 fix: ${finding4.fix}` },
+    ...finding4.fix === void 0 ? {} : { properties: { fix: finding4.fix } },
     locations: [
       {
         logicalLocations: [
           { name: input2.id, kind: "module" },
-          ...finding3.step === void 0 ? [] : [{ name: `step ${finding3.step}`, kind: "function" }]
+          ...finding4.step === void 0 ? [] : [{ name: `step ${finding4.step}`, kind: "function" }]
         ]
       }
     ]
@@ -111573,7 +112080,7 @@ function renderJourneyLintSarif(input2) {
 }
 
 // src/journey-link-hints.ts
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 var MAX_LISTED = 10;
 function listed(ids) {
   return ids.length <= MAX_LISTED ? ids.join(", ") : `${ids.slice(0, MAX_LISTED).join(", ")}, \u2026 (${ids.length - MAX_LISTED} more: jevitate catalog status)`;
@@ -111582,7 +112089,7 @@ async function loadLinkCatalog(catalogDir) {
   const empty = { dir: catalogDir, personasFile: null, jobsFile: null, personas: [], jobs: [], journeys: [] };
   if (catalogDir === null) return empty;
   try {
-    const loader = new CatalogLoader({ catalogDir, journeysDir: join65(catalogDir, "journeys") });
+    const loader = new CatalogLoader({ catalogDir, journeysDir: join66(catalogDir, "journeys") });
     const [{ file: personasFile, personas }, { file: jobsFile, jobs }] = await Promise.all([loader.loadPersonas(), loader.loadJobs()]);
     return { ...empty, personasFile, jobsFile, personas, jobs };
   } catch {
@@ -111649,7 +112156,7 @@ function registerJourneyLint(journey, program2, deps) {
       const result = { ...linted, findings: [...linted.findings, ...linkFindings], warnings: linted.warnings + linkFindings.length };
       if (sarif !== void 0) {
         const log = renderJourneyLintSarif({ id: result.id, findings: result.findings, version: currentEngineInfo().version });
-        await writeFile39(sarif, `${JSON.stringify(log, null, 2)}
+        await writeFile40(sarif, `${JSON.stringify(log, null, 2)}
 `);
       }
       if (json2) {
@@ -111667,7 +112174,7 @@ function registerJourneyLint(journey, program2, deps) {
 `);
           }
         }
-        for (const finding3 of result.findings) out?.(`${lintFindingLine(finding3)}
+        for (const finding4 of result.findings) out?.(`${lintFindingLine(finding4)}
 `);
         out?.(`${result.errors} error(s), ${result.warnings} warning(s) \u2014 journey '${result.id}'
 `);
@@ -111686,14 +112193,38 @@ function registerJourneyLint(journey, program2, deps) {
 // src/journey-cli/verify.ts
 import { existsSync as existsSync32 } from "node:fs";
 function registerJourneyVerify(journey, program2, deps) {
-  withReplayAllowFlag(withEnvironmentFlags(withBrowserLaunchFlags(withFixtureFlags(withProjectFlags(journey.command("verify <id>")))))).description("prove each assertion of a Journey can fail: --mutate replays it with each write step skipped or blocked, and each checked fill emptied").option("--mutate", "run the mutation proof (required)").option("--dir <path>", DEPRECATED_DIR_HELP).option("--param <kv>", "param as key=value (repeatable)", collectParam, {}).option("--storage-state <file>", "Playwright storageState JSON to start each replay authenticated (as journey run)").option("--json", "emit a JSON envelope").action(async function(id) {
+  withReplayAllowFlag(withEnvironmentFlags(withBrowserLaunchFlags(withFixtureFlags(withProjectFlags(journey.command("verify <id>")))))).description("preview or prove that each Journey assertion fails when its outcome is absent").option("--mutate", "run the mutation proof").option("--plan", "print the static mutation/assertion plan without opening a browser").option("--dir <path>", DEPRECATED_DIR_HELP).option("--param <kv>", "param as key=value (repeatable)", collectParam, {}).option("--storage-state <file>", "Playwright storageState JSON to start each replay authenticated (as journey run)").option("--json", "emit a JSON envelope").action(async function(id) {
     const locationFlags = this.opts();
     const layout = journeyLayout(program2, deps, { dir: locationFlags.dir, project: locationFlags.project, journeysDir: locationFlags.journeysDir });
     if (layout === null) return;
     const verifyJourneysDir = layout.journeysDir;
-    const { mutate, param, storageState: storageStateFlag, json: json2, env: envName, baseUrl } = this.opts();
-    if (mutate !== true) {
-      emitJson(program2, fail("E_JOURNEY_VERIFY_ARGS", "journey verify needs --mutate (the mutation proof is the only verification it runs today)"));
+    const { mutate, plan: plan2, param, storageState: storageStateFlag, json: json2, env: envName, baseUrl } = this.opts();
+    if (mutate === true === (plan2 === true)) {
+      emitJson(program2, fail("E_JOURNEY_VERIFY_ARGS", "journey verify needs exactly one of --plan or --mutate"));
+      return;
+    }
+    if (plan2 === true) {
+      try {
+        const report2 = await planJourneyVerification({ dir: verifyJourneysDir, id, params: param });
+        if (json2) emitJson(program2, ok(withEngine(report2)));
+        else {
+          const out = program2.configureOutput().writeOut;
+          for (const mutation2 of report2.mutations) {
+            const sites = report2.pairs.filter((pair) => pair.mutation === mutation2.id).map((pair) => pair.site);
+            out?.(`${mutation2.id} (step ${mutation2.step}) -> ${sites.length === 0 ? "unpaired" : sites.join(", ")}
+`);
+          }
+          for (const assertion of report2.assertions) if (assertion.mutations.length === 0) out?.(`unpaired ${assertion.site} ${assertion.check}
+`);
+          out?.(
+            `planned \u2014 journey '${report2.journeyId}': ${report2.summary.mutations} mutations, ${report2.summary.pairs} pairs, ${report2.summary.assertions} assertions, ${report2.summary.unpaired} unpaired, at least ${report2.summary.minimumReplays} replays
+`
+          );
+        }
+      } catch (err) {
+        if (err instanceof UnknownJourneyError) emitJson(program2, fail("E_UNKNOWN_JOURNEY", String(err.message)));
+        else throw err;
+      }
       return;
     }
     let environment;
@@ -111835,7 +112366,7 @@ function registerJourneyAnchors(journey, program2, deps) {
 
 // src/source-api.ts
 import { execFile as execFile6 } from "node:child_process";
-import { mkdir as mkdir31 } from "node:fs/promises";
+import { mkdir as mkdir32 } from "node:fs/promises";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile6);
 var NotPromotedError = class extends Error {
@@ -111873,7 +112404,7 @@ async function requireEntry(lockPath, name) {
 }
 async function addSource(deps, req) {
   const mgr = mgrOf(deps);
-  await mkdir31(deps.sourcesDir, { recursive: true });
+  await mkdir32(deps.sourcesDir, { recursive: true });
   const pinnedCommit = await mgr.add(req.name, req.gitUrl);
   const manifest = await loadManifest(mgr.resolveDir(req.name));
   const touSurface = surfaceForAck(manifest, req.gitUrl);
@@ -112290,7 +112821,7 @@ review or edit it, then apply it: jevitate journey annotate ${id} --approve
 
 // src/journey-demo-cli.ts
 import { existsSync as existsSync34 } from "node:fs";
-import { join as join66, resolve as resolvePath15 } from "node:path";
+import { join as join67, resolve as resolvePath15 } from "node:path";
 function registerJourneyDemoCommand(journey, program2, deps) {
   withScreenshotsFlag(withEnvironmentFlags(withDemoFlags(withBrowserLaunchFlags(withEmulationFlags(withFixtureFlags(withProjectFlags(journey.command("demo <id>")))))))).description(
     "replay a Journey as a narrated demo (goal, step objectives as captions, target highlights) \u2192 a WebM video with .vtt subtitles and/or a Markdown step-by-step guide with screenshots; a Journey that no longer replays fails (exit 1)"
@@ -112333,9 +112864,9 @@ function registerJourneyDemoCommand(journey, program2, deps) {
     let video = videoFlag === void 0 ? void 0 : resolvePath15(videoFlag);
     let guide = guideFlag === void 0 ? void 0 : resolvePath15(guideFlag);
     if (video === void 0 && guide === void 0) {
-      const folder = join66(logsDirFor(), `journey-demo-${id.replace(/[^A-Za-z0-9._-]/g, "_")}-${artifactStamp(clock.nowIso())}`);
-      video = join66(folder, "demo.webm");
-      guide = join66(folder, "guide.md");
+      const folder = join67(logsDirFor(), `journey-demo-${id.replace(/[^A-Za-z0-9._-]/g, "_")}-${artifactStamp(clock.nowIso())}`);
+      video = join67(folder, "demo.webm");
+      guide = join67(folder, "guide.md");
     }
     try {
       const result = await withSiteGate(
@@ -112428,7 +112959,7 @@ function registerJourneyCommands(program2, deps) {
 }
 
 // src/project-where.ts
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 function render(data) {
   const dir = (p) => p ?? "(none)";
   return [
@@ -112445,7 +112976,7 @@ function registerWhere(program2, deps) {
     const { project, journeysDir, json: json2 } = this.opts();
     const layout = journeyLayout(program2, deps, { project, journeysDir });
     if (layout === null) return;
-    const logsDir = layout.projectDir === null ? logsRoot() : join67(layout.projectDir, "logs");
+    const logsDir = layout.projectDir === null ? logsRoot() : join68(layout.projectDir, "logs");
     const data = { ...layout, logsDir };
     if (json2 === true) {
       emitJson(program2, ok(data));
@@ -113263,7 +113794,7 @@ function resolveSecretArgs(values2, env, flag) {
 }
 
 // src/multi-run-cli.ts
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 var MULTI_RUN_ATTRS = /* @__PURE__ */ new Set(["repeat", "minAgreement", "persona", "personas", "out", "json"]);
 function forwardedArgv(cmd, omit3 = /* @__PURE__ */ new Set()) {
   const opts = cmd.opts();
@@ -113311,7 +113842,7 @@ function lastEnvelope(lines) {
 }
 async function runExploreMultiRun(args) {
   const { cmd, plan: plan2 } = args;
-  const outDir = args.out ?? join68(logsDirFor((args.nowIso ?? (() => clock.nowIso()))()), `multi-${artifactStamp((args.nowIso ?? (() => clock.nowIso()))())}`);
+  const outDir = args.out ?? join69(logsDirFor((args.nowIso ?? (() => clock.nowIso()))()), `multi-${artifactStamp((args.nowIso ?? (() => clock.nowIso()))())}`);
   const omit3 = /* @__PURE__ */ new Set([...plan2.personas === null ? [] : ["storageState"], ...args.authPreflight === void 0 ? [] : ["authCheck"]]);
   const base = [...forwardedArgv(cmd, omit3), ...args.authPreflight === void 0 ? [] : ["--auth-check", "off"]];
   return runMultiRun({
@@ -113350,9 +113881,9 @@ import { resolve as resolvePath16 } from "node:path";
 
 // src/campaign-api.ts
 import { existsSync as existsSync37, readFileSync as readFileSync36 } from "node:fs";
-import { mkdir as mkdir32, writeFile as writeFile40 } from "node:fs/promises";
+import { mkdir as mkdir33, writeFile as writeFile41 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname29, isAbsolute as isAbsolute11, join as join69, resolve as resolve21 } from "node:path";
+import { dirname as dirname29, isAbsolute as isAbsolute11, join as join70, resolve as resolve21 } from "node:path";
 
 // src/campaign-preflight.ts
 import { basename as basename17 } from "node:path";
@@ -113477,7 +114008,7 @@ async function validateCampaignSpec(raw, specPath, opts) {
   if (!parsed.success) throw new CampaignSpecError(parsed.error.issues.map((i) => `${at2(i.path)}: ${i.message}`));
   const spec = parsed.data;
   const base = dirname29(resolve21(specPath));
-  const abs = (p) => p.startsWith("~/") ? join69(homedir5(), p.slice(2)) : isAbsolute11(p) ? p : resolve21(base, p);
+  const abs = (p) => p.startsWith("~/") ? join70(homedir5(), p.slice(2)) : isAbsolute11(p) ? p : resolve21(base, p);
   const problems = [];
   let environment;
   try {
@@ -113663,8 +114194,8 @@ function commonArgs(plan2, job) {
 async function runCampaign(plan2, opts) {
   const now2 = opts.nowIso ?? (() => clock.nowIso());
   const startedAt = now2();
-  const outDir = opts.outDir ?? join69(logsDirFor(startedAt), `campaign-${artifactStamp(startedAt)}`);
-  await mkdir32(outDir, { recursive: true });
+  const outDir = opts.outDir ?? join70(logsDirFor(startedAt), `campaign-${artifactStamp(startedAt)}`);
+  await mkdir33(outDir, { recursive: true });
   const ai = opts.real === true ? ["--real"] : opts.fakeAi === true ? ["--fake-ai"] : [];
   const discovery = [];
   const replaySlowness = [];
@@ -113722,8 +114253,8 @@ async function runCampaign(plan2, opts) {
     }
   }
   const preflight = opts.preflight === void 0 ? void 0 : opts.preflight === "skip" ? { ok: true, problems: [], skipped: true } : preflightOf(preflightProblems);
-  const resultPath = join69(outDir, "campaign.json");
-  const reportPath = join69(outDir, "campaign.md");
+  const resultPath = join70(outDir, "campaign.json");
+  const reportPath = join70(outDir, "campaign.md");
   if (preflight !== void 0 && !preflight.ok) {
     const refused = {
       ...plan2.name === void 0 ? {} : { name: plan2.name },
@@ -113736,7 +114267,7 @@ async function runCampaign(plan2, opts) {
       missions: [],
       resultPath
     };
-    await writeFile40(resultPath, `${JSON.stringify(refused, null, 2)}
+    await writeFile41(resultPath, `${JSON.stringify(refused, null, 2)}
 `, "utf8");
     throw new CampaignPreflightError(preflight.problems, resultPath);
   }
@@ -113757,7 +114288,7 @@ async function runCampaign(plan2, opts) {
           });
           continue;
         }
-        const runDir = join69(outDir, job.id, `${anchor2.atStep}-${strategy}`);
+        const runDir = join70(outDir, job.id, `${anchor2.atStep}-${strategy}`);
         const argv = [
           "explore",
           "--from-journey",
@@ -113849,9 +114380,9 @@ async function runCampaign(plan2, opts) {
     missionOutcome,
     exitCode: exitCodeForOutcome(missionOutcome)
   };
-  await writeFile40(resultPath, `${JSON.stringify(result, null, 2)}
+  await writeFile41(resultPath, `${JSON.stringify(result, null, 2)}
 `, "utf8");
-  await writeFile40(reportPath, campaignMarkdown(result, report2.markdown), "utf8");
+  await writeFile41(reportPath, campaignMarkdown(result, report2.markdown), "utf8");
   return result;
 }
 function campaignMarkdown(r, reportMarkdown) {
@@ -114016,7 +114547,7 @@ var GOAL_RUN_OPTIONS = {
   ),
   jobWaitMs: () => new Option(
     "--job-wait-ms <ms>",
-    `goal and usability: while the page shows an in-progress status ("Simulating\u2026", aria-busy, a job "is running"), waits keep waiting with backoff \u2014 and a model 'blocked' is deferred \u2014 up to this budget (default: --reply-ceiling-ms, 180000); it also bounds a busy indicator the app visibly keeps working behind (live progress, a job poll) before it is a hang, and a wait the page documents ("usually takes a minute") can raise it`
+    `goal and usability: while the page shows an in-progress status ("Simulating\u2026", aria-busy, a job "is running"), waits keep waiting with backoff \u2014 and a model 'blocked' is deferred \u2014 up to this budget (default: --reply-ceiling-ms, 180000); it also bounds a busy indicator the app visibly keeps working behind (live progress, a job poll) or declares (aria-busy, when this flag is set) before it is a hang, and a wait the page documents ("usually takes a minute") can raise it`
   ).argParser(positiveIntArg),
   deny: () => new Option(
     "--deny <pattern>",
@@ -114052,7 +114583,7 @@ var GOAL_RUN_OPTIONS = {
   settleIgnore: () => new Option("--settle-ignore <pattern>", "a request URL pattern the target marks as background (never pending work; repeatable, * wildcard)").default([]).argParser(collect7),
   longPollMs: () => new Option("--long-poll-ms <n>", "a request pending this long on an interactive page is a long-poll (default 5000)").argParser(nonNegativeIntArg),
   apiPrefix: () => new Option("--api-prefix <path>", "a path prefix whose requests are the app's API in the timing summary (repeatable), e.g. /api/").default([]).argParser(collect7),
-  ignoreNoProgress: () => new Option("--ignore-no-progress <pattern>", "a route / action label / busy indicator where ui-no-progress is expected (repeatable, * wildcard)").default([]).argParser(collect7),
+  ignoreNoProgress: () => new Option("--ignore-no-progress <pattern>", "a route / action label / busy indicator (its description or visible words) where ui-no-progress is expected (repeatable, * wildcard)").default([]).argParser(collect7),
   allowSecretCmd: () => new Option(
     "--allow-secret-cmd",
     "opt-in: a --secret-field <descriptor>=cmd:<command> may run its command (in a shell, at type time, 60s timeout) and type its output (operator-declared only; refused otherwise)"
@@ -115577,11 +116108,11 @@ import { resolve as resolve24 } from "node:path";
 
 // src/sweep-api.ts
 import { existsSync as existsSync40, mkdirSync as mkdirSync11, readFileSync as readFileSync37, realpathSync as realpathSync5, statSync as statSync12, writeFileSync as writeFileSync13 } from "node:fs";
-import { basename as basename19, dirname as dirname31, extname as extname2, join as join71, resolve as resolve23 } from "node:path";
+import { basename as basename19, dirname as dirname31, extname as extname2, join as join72, resolve as resolve23 } from "node:path";
 
 // src/mcp-paths.ts
 import { existsSync as existsSync39, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename18, dirname as dirname30, isAbsolute as isAbsolute12, join as join70, relative as relative10, resolve as resolve22, sep as sep10 } from "node:path";
+import { basename as basename18, dirname as dirname30, isAbsolute as isAbsolute12, join as join71, relative as relative10, resolve as resolve22, sep as sep10 } from "node:path";
 var McpPathError = class extends Error {
   error = "invalid_args";
   constructor(message2) {
@@ -115600,7 +116131,7 @@ function realish(p) {
   for (; ; ) {
     if (existsSync39(head2)) {
       try {
-        return join70(realpathSync4(head2), ...tail);
+        return join71(realpathSync4(head2), ...tail);
       } catch {
         return p;
       }
@@ -115960,13 +116491,14 @@ var CLI_TOOL_SPECS = [
   },
   {
     name: "verify_journey",
-    description: "`jevitate journey verify <id> --mutate` (#402): prove each assertion can fail. Replays the Journey once (it must pass), then once per mutation \u2014 a write step skipped, its write request aborted, a typed value left empty \u2014 and reports each assertion as sensitive (failed for the right reason), insensitive (still passed: vacuous), cascade, not-applied or unpaired. Mutations only skip steps or abort the app's own writes; nothing is fabricated. Exit 1 when any paired assertion is insensitive, 2 when nothing could be proven. Set mutate: true.",
+    description: "`jevitate journey verify <id> --plan|--mutate` (#402): plan previews the exact mutations, assertion pairings, unpaired assertions and minimum replay count without opening a browser; mutate proves each assertion can fail by replaying the Journey once, then once per mutation. Mutations only skip steps, abort the app's own writes or alter checked non-secret inputs; nothing is fabricated. Set exactly one of plan or mutate.",
     command: {
       path: "journey verify",
       params: {
         id: pos(),
         ...EXTENSION,
         mutate: b("--mutate"),
+        plan: b("--plan"),
         params: { kind: "params", flag: "--param" },
         storageState: session("--storage-state"),
         fixtures: path("--fixtures"),
@@ -117425,7 +117957,7 @@ function aggregateSweep(args) {
     kind: "sweep",
     targetsPath: plan2.targetsPath,
     outDir: plan2.outDir,
-    resultPath: join71(plan2.outDir, "sweep.result.json"),
+    resultPath: join72(plan2.outDir, "sweep.result.json"),
     startedAt: args.startedAt,
     ...args.finishedAt === void 0 ? {} : { finishedAt: args.finishedAt },
     complete: args.complete && args.aborted === void 0,
@@ -117466,19 +117998,19 @@ async function awaitLowHostLoad(probe = hostProbe(), waitMs = HOST_STARVED_WAIT_
   }
 }
 function defaultSweepOutDir(iso = clock.nowIso()) {
-  return join71(logsDirFor(iso), `sweep-${artifactStamp(iso)}`);
+  return join72(logsDirFor(iso), `sweep-${artifactStamp(iso)}`);
 }
 async function runSweep(opts) {
   const { plan: plan2 } = opts;
   const now2 = opts.nowIso ?? (() => clock.nowIso());
   const startedAt = now2();
   mkdirSync11(plan2.outDir, { recursive: true });
-  const resultPath = join71(plan2.outDir, "sweep.result.json");
+  const resultPath = join72(plan2.outDir, "sweep.result.json");
   const rows = plan2.targets.map(() => void 0);
   const finished = [];
   const queue = [];
   plan2.targets.forEach((t, i) => {
-    const envelopePath = join71(plan2.outDir, t.id, "run.envelope.json");
+    const envelopePath = join72(plan2.outDir, t.id, "run.envelope.json");
     const prior = plan2.resume ? finishedEnvelope(envelopePath) : void 0;
     if (prior === void 0) {
       queue.push(i);
@@ -117500,9 +118032,9 @@ async function runSweep(opts) {
   });
   const runOne = async (i) => {
     const target = plan2.targets[i];
-    const runDir = join71(plan2.outDir, target.id);
+    const runDir = join72(plan2.outDir, target.id);
     mkdirSync11(runDir, { recursive: true });
-    const envelopePath = join71(runDir, "run.envelope.json");
+    const envelopePath = join72(runDir, "run.envelope.json");
     const attempt2 = async () => {
       try {
         return await opts.runOnce({ target, argv: targetArgv(plan2, target, runDir), runDir });
@@ -117978,13 +118510,13 @@ function registerAuthorJourneyCommands(program2, deps) {
 
 // src/demo-aspect-cli.ts
 import { existsSync as existsSync43 } from "node:fs";
-import { join as join74, resolve as resolvePath18 } from "node:path";
+import { join as join75, resolve as resolvePath18 } from "node:path";
 
 // src/demo-aspect-api.ts
 import { existsSync as existsSync42 } from "node:fs";
-import { mkdir as mkdir34, mkdtemp as mkdtemp5, readFile as readFile34, rm as rm13, writeFile as writeFile42 } from "node:fs/promises";
+import { mkdir as mkdir35, mkdtemp as mkdtemp5, readFile as readFile37, rm as rm13, writeFile as writeFile43 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import { dirname as dirname32, join as join73 } from "node:path";
+import { dirname as dirname32, join as join74 } from "node:path";
 
 // ../regression/dist/fingerprint.js
 function flattenWithUrls(rec) {
@@ -118129,8 +118661,8 @@ async function minimizeRecording(recording, reproduces) {
 }
 
 // ../regression/dist/commit.js
-import { join as join72 } from "node:path";
-import { mkdir as mkdir33, writeFile as writeFile41 } from "node:fs/promises";
+import { join as join73 } from "node:path";
+import { mkdir as mkdir34, writeFile as writeFile42 } from "node:fs/promises";
 var FlakyNotCommittableError = class extends Error {
 };
 async function commitRegression(dir, id, minimized, report2, bugSummary, oracle) {
@@ -118138,9 +118670,9 @@ async function commitRegression(dir, id, minimized, report2, bugSummary, oracle)
     throw new FlakyNotCommittableError(`refusing to commit '${id}': reproduction rate ${report2.rate} (${report2.reproducedCount}/${report2.attempts}) is flaky, not reproducible`);
   }
   const validated = RecordingSchema.parse(minimized);
-  await mkdir33(dir, { recursive: true });
-  const recordingPath = join72(dir, `${id}.recording.json`);
-  const metaPath = join72(dir, `${id}.meta.json`);
+  await mkdir34(dir, { recursive: true });
+  const recordingPath = join73(dir, `${id}.recording.json`);
+  const metaPath = join73(dir, `${id}.meta.json`);
   const meta3 = {
     id,
     capturedAtIso: clock.nowIso(),
@@ -118149,8 +118681,8 @@ async function commitRegression(dir, id, minimized, report2, bugSummary, oracle)
     bugSummary,
     ...oracle === void 0 ? {} : { oracle }
   };
-  await writeFile41(recordingPath, JSON.stringify(validated, null, 2) + "\n");
-  await writeFile41(metaPath, JSON.stringify(meta3, null, 2) + "\n");
+  await writeFile42(recordingPath, JSON.stringify(validated, null, 2) + "\n");
+  await writeFile42(metaPath, JSON.stringify(meta3, null, 2) + "\n");
   return { recordingPath, metaPath };
 }
 
@@ -118223,7 +118755,7 @@ function demoJourneyId(aspect) {
 }
 var DEMO_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
 function demoDraftPath(journeysDir, id) {
-  return join73(journeysDir, ".drafts", `${id}.demo.json`);
+  return join74(journeysDir, ".drafts", `${id}.demo.json`);
 }
 function demoDraftProblem(v) {
   if (v === null || typeof v !== "object" || Array.isArray(v)) return "not an object";
@@ -118244,7 +118776,7 @@ async function readDemoDraft(journeysDir, id) {
   const path2 = demoDraftPath(journeysDir, id);
   let raw;
   try {
-    raw = await readFile34(path2, "utf8");
+    raw = await readFile37(path2, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") throw new DemoDraftNotFoundError(`no demo draft '${id}' (${path2}) \u2014 make one with \`jevitate demo "<aspect>" --env <name>\``);
     throw err;
@@ -118324,16 +118856,16 @@ async function demoAspect(opts) {
   const maxReplays = opts.maxReplays ?? DEMO_MINIMIZE_MAX_REPLAYS;
   const now2 = opts.now ?? (() => clock.nowIso());
   const base = { id, aspect, environment: env.name ?? env.baseUrl };
-  const work = await mkdtemp5(join73(tmpdir5(), "jevitate-demo-aspect-"));
+  const work = await mkdtemp5(join74(tmpdir5(), "jevitate-demo-aspect-"));
   try {
     const authored = await runAuthorJourney({
       url: new URL(start, env.baseUrl).toString(),
       goal: aspect,
       successAssertion: opts.successAssertion,
       allowlist: env.allowedOrigins,
-      journeysDir: join73(work, "explored"),
+      journeysDir: join74(work, "explored"),
       // #369: the discovery take's own artifacts stay in the scratch dir with the rest.
-      outDir: join73(work, "explored-runs"),
+      outDir: join74(work, "explored-runs"),
       journeyId: id,
       journeyName: aspect,
       takes: 1,
@@ -118354,10 +118886,10 @@ async function demoAspect(opts) {
       ...opts.persona === void 0 ? {} : { persona: opts.persona },
       successCriteria: [{ description: `The success check holds: ${opts.successSpec}`, check: opts.successAssertion }]
     };
-    const scratch = new FsJourneyStore(join73(work, "candidates"));
+    const scratch = new FsJourneyStore(join74(work, "candidates"));
     const replayOk = async (recording2) => {
       await scratch.put({ metadata, recording: withSuccessAssert(recording2, opts.successAssertion) });
-      const run = await runJourneyProgrammatically({ dir: join73(work, "candidates"), id, params: {}, ...replayOpts(opts) });
+      const run = await runJourneyProgrammatically({ dir: join74(work, "candidates"), id, params: {}, ...replayOpts(opts) });
       return run.outcome === "ok";
     };
     const explored = withoutSuccessAssert(authored.journey.recording, opts.successAssertion);
@@ -118388,7 +118920,7 @@ async function demoAspect(opts) {
     };
     const recording = withSuccessAssert(minimized, opts.successAssertion);
     const journey = { metadata: { ...metadata, params: deriveParamSchema(recording).required, createdAtIso: now2() }, recording };
-    const stageDir = join73(work, "stage");
+    const stageDir = join74(work, "stage");
     await new FsJourneyStore(stageDir).put(journey);
     const annotated = await annotateJourney({ dir: stageDir, id, params: {}, gen: opts.gen, now: now2, ...replayOpts(opts) });
     if (annotated.replay.outcome !== "completed") {
@@ -118401,8 +118933,8 @@ async function demoAspect(opts) {
     }
     await store.put(journey);
     const draftPath = annotationDraftPath(opts.journeysDir, id);
-    await mkdir34(dirname32(draftPath), { recursive: true, mode: 448 });
-    await writeFile42(draftPath, `${JSON.stringify(annotations, null, 2)}
+    await mkdir35(dirname32(draftPath), { recursive: true, mode: 448 });
+    await writeFile43(draftPath, `${JSON.stringify(annotations, null, 2)}
 `, { mode: 384 });
     const record2 = {
       kind: "jevitate.demo.draft",
@@ -118416,7 +118948,7 @@ async function demoAspect(opts) {
       draft: outputsOf(demo)
     };
     assertNoSecretInPayload(record2, [], "demo draft record");
-    await writeFile42(recordPath, `${JSON.stringify(record2, null, 2)}
+    await writeFile43(recordPath, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
     return {
       ...base,
@@ -118445,8 +118977,8 @@ function renderDemo(dir, id, opts, annotations, draft, outDir, jzMask = false) {
     dir,
     id,
     params: {},
-    video: join73(outDir, "demo.webm"),
-    guide: join73(outDir, "guide.md"),
+    video: join74(outDir, "demo.webm"),
+    guide: join74(outDir, "guide.md"),
     annotations,
     draft,
     environment: opts.environment,
@@ -118524,7 +119056,7 @@ async function approveDemo(opts) {
       ...title === "" ? {} : { title },
       demo
     });
-    journeeze = { media: true, record: join73(opts.journeysDir, ".demos", opts.id), ...record2.leftOut.length === 0 ? {} : { leftOut: record2.leftOut } };
+    journeeze = { media: true, record: join74(opts.journeysDir, ".demos", opts.id), ...record2.leftOut.length === 0 ? {} : { leftOut: record2.leftOut } };
   } else {
     await clearApprovedDemo(opts.journeysDir, opts.id);
     journeeze = { media: false, reason: `environment '${environment}' does not declare synthetic: true \u2014 no demo media is exported to Journeeze` };
@@ -118594,7 +119126,7 @@ function withReplayFlags(cmd) {
 }
 function outDirFor(flag, id, kind) {
   if (flag !== void 0) return resolvePath18(flag);
-  return join74(logsDirFor(), `demo-${id}-${kind}-${artifactStamp(clock.nowIso())}`);
+  return join75(logsDirFor(), `demo-${id}-${kind}-${artifactStamp(clock.nowIso())}`);
 }
 function stepLines2(steps) {
   return steps.map((s3) => `  ${s3.number}. ${s3.objective ?? s3.step}${s3.expectedResult === void 0 ? "" : `
@@ -118779,8 +119311,8 @@ ${(j.leftOut ?? []).map((l2) => `  left out: ${l2}
 }
 
 // src/record-api.ts
-import { mkdir as mkdir35, writeFile as writeFile43 } from "node:fs/promises";
-import { join as join75 } from "node:path";
+import { mkdir as mkdir36, writeFile as writeFile44 } from "node:fs/promises";
+import { join as join76 } from "node:path";
 async function runRecording(opts) {
   const origin = assertAuthorizedExploreTarget(opts.url, opts.allowlist);
   const portFactory = opts.browserPortFactory ?? (() => new PlaywrightBrowserPort());
@@ -118803,10 +119335,10 @@ async function runRecording(opts) {
     const values2 = Object.fromEntries(authoring.values);
     const take = AuthoringTakeSchema.parse({ recording, values: values2 });
     const outDir = opts.outDir ?? logsDirFor();
-    await mkdir35(outDir, { recursive: true });
+    await mkdir36(outDir, { recursive: true });
     const iso = (opts.nowIso ?? (() => clock.nowIso()))();
-    const recordingPath = join75(outDir, `record-${iso.replace(/[:.]/g, "-")}.json`);
-    await writeFile43(recordingPath, `${JSON.stringify(take, null, 2)}
+    const recordingPath = join76(outDir, `record-${iso.replace(/[:.]/g, "-")}.json`);
+    await writeFile44(recordingPath, `${JSON.stringify(take, null, 2)}
 `, "utf8");
     const steps = recording.pages.reduce((n3, p) => n3 + p.steps.length, 0);
     return { recording, recordingPath, steps, pages: recording.pages.length, finalUrl };
@@ -118919,12 +119451,12 @@ function registerRecordCommands(program2, deps) {
 
 // src/regression-cli.ts
 import { existsSync as existsSync45 } from "node:fs";
-import { readFile as readFile36, writeFile as writeFile44 } from "node:fs/promises";
-import { join as join76 } from "node:path";
+import { readFile as readFile39, writeFile as writeFile45 } from "node:fs/promises";
+import { join as join77 } from "node:path";
 
 // src/regression-api.ts
 import { existsSync as existsSync44 } from "node:fs";
-import { readFile as readFile35 } from "node:fs/promises";
+import { readFile as readFile38 } from "node:fs/promises";
 var RegressionExistsError = class extends Error {
   code = "E_REGRESSION_EXISTS";
   constructor(id, dir) {
@@ -118950,9 +119482,9 @@ var NoOracleInResultError = class extends Error {
 };
 var RegressionHardSignalOracleError = class extends Error {
   code = "E_REGRESSION_HARD_SIGNAL";
-  constructor(resultPath, finding3) {
+  constructor(resultPath, finding4) {
     super(
-      `--fingerprint ${finding3.fingerprint} is a ${finding3.kind} defect in ${resultPath} \u2014 a hard signal with its own oracle, which 'regression capture' cannot turn into a page/success-check regression. Keep its repro material with 'jevitate ledger add ${resultPath} ${finding3.fingerprint}', then re-check it with 'jevitate ledger verify' or 'jevitate verify-fix ${finding3.fingerprint}'.`
+      `--fingerprint ${finding4.fingerprint} is a ${finding4.kind} defect in ${resultPath} \u2014 a hard signal with its own oracle, which 'regression capture' cannot turn into a page/success-check regression. Keep its repro material with 'jevitate ledger add ${resultPath} ${finding4.fingerprint}', then re-check it with 'jevitate ledger verify' or 'jevitate verify-fix ${finding4.fingerprint}'.`
     );
     this.name = "RegressionHardSignalOracleError";
   }
@@ -119014,14 +119546,14 @@ async function runRegressionCapture(opts) {
   if (opts.force !== true && existsSync44(recordingPath)) {
     throw new RegressionExistsError(opts.id, opts.regressionsDir);
   }
-  const raw = JSON.parse(await readFile35(opts.failingRecordingPath, "utf8"));
+  const raw = JSON.parse(await readFile38(opts.failingRecordingPath, "utf8"));
   const parsed = RecordingSchema.parse(raw);
   const recording = opts.anchored === true ? anchoredRecording(parsed) : parsed;
   const attempts = opts.attempts ?? 3;
   let missionResult;
   let persistedMission;
   if (opts.resultPath) {
-    const rawResult = JSON.parse(await readFile35(opts.resultPath, "utf8"));
+    const rawResult = JSON.parse(await readFile38(opts.resultPath, "utf8"));
     missionResult = rawResult;
     try {
       persistedMission = parsePersistedMission(rawResult);
@@ -119030,12 +119562,12 @@ async function runRegressionCapture(opts) {
     }
   }
   if (opts.fingerprint !== void 0 && persistedMission !== void 0) {
-    const finding3 = findFinding(persistedMission, opts.fingerprint);
-    if (finding3 !== void 0 && finding3.kind === "invariant" && finding3.invariantId !== void 0 && persistedMission.invariantSpec !== void 0) {
-      return captureInvariantRegression(opts, recording, persistedMission, finding3, attempts);
+    const finding4 = findFinding(persistedMission, opts.fingerprint);
+    if (finding4 !== void 0 && finding4.kind === "invariant" && finding4.invariantId !== void 0 && persistedMission.invariantSpec !== void 0) {
+      return captureInvariantRegression(opts, recording, persistedMission, finding4, attempts);
     }
-    if (finding3 !== void 0 && finding3.kind !== "invariant") {
-      throw new RegressionHardSignalOracleError(opts.resultPath, finding3);
+    if (finding4 !== void 0 && finding4.kind !== "invariant") {
+      throw new RegressionHardSignalOracleError(opts.resultPath, finding4);
     }
   }
   let working = recording;
@@ -119114,16 +119646,16 @@ async function captureNetworkCheckRegression(opts, recording, check3, attempts)
   };
   return commitRegression(opts.regressionsDir, opts.id, recording, report2, opts.bugSummary, { kind: "network", check: check3 });
 }
-async function captureInvariantRegression(opts, fallbackRecording, mission, finding3, attempts) {
+async function captureInvariantRegression(opts, fallbackRecording, mission, finding4, attempts) {
   const invariantSpec = mission.invariantSpec;
-  const invariantId = finding3.invariantId;
-  const recording = finding3.recording ?? mission.recording ?? fallbackRecording;
+  const invariantId = finding4.invariantId;
+  const recording = finding4.recording ?? mission.recording ?? fallbackRecording;
   assertAuthorizedExploreTarget(mission.target.seedUrl, mission.target.allowlist);
   const verifyResult = await verifyFix({
     fixtureBaseDir: journeyFixtureBaseDir(),
     recording,
-    recordingStepIndex: finding3.repro.recordingStepIndex,
-    fingerprint: finding3.fingerprint,
+    recordingStepIndex: finding4.repro.recordingStepIndex,
+    fingerprint: finding4.fingerprint,
     defectKind: "invariant",
     invariant: { spec: invariantSpec, id: invariantId, allowlist: mission.target.allowlist, baseUrl: mission.target.seedUrl },
     replays: attempts,
@@ -119141,16 +119673,16 @@ async function captureInvariantRegression(opts, fallbackRecording, mission, find
       rate: 1,
       label: "reproducible",
       fingerprint: { stepSignature: `invariant:${invariantId}` },
-      firstFailureAt: finding3.repro.recordingStepIndex
+      firstFailureAt: finding4.repro.recordingStepIndex
     };
     return commitRegression(opts.regressionsDir, opts.id, recording, report2, opts.bugSummary, {
       kind: "invariant",
       invariantId,
       invariantSpec,
-      recordingStepIndex: finding3.repro.recordingStepIndex,
+      recordingStepIndex: finding4.repro.recordingStepIndex,
       allowlist: mission.target.allowlist,
       baseUrl: mission.target.seedUrl,
-      defectFingerprint: finding3.fingerprint
+      defectFingerprint: finding4.fingerprint
     });
   }
   if (verifyResult.verdict === "intermittent") {
@@ -119173,8 +119705,8 @@ async function runRegressionRun(opts) {
   let recording;
   let meta3;
   try {
-    recording = RecordingSchema.parse(JSON.parse(await readFile35(recordingPath, "utf8")));
-    meta3 = JSON.parse(await readFile35(metaPath, "utf8"));
+    recording = RecordingSchema.parse(JSON.parse(await readFile38(recordingPath, "utf8")));
+    meta3 = JSON.parse(await readFile38(metaPath, "utf8"));
   } catch {
     throw new RegressionNotFoundError(opts.id, opts.regressionsDir);
   }
@@ -119272,17 +119804,17 @@ function registerRegressionCommands(program2, deps) {
     const opened = [];
     let fx;
     try {
-      const raw = JSON.parse(await readFile36(from, "utf8"));
+      const raw = JSON.parse(await readFile39(from, "utf8"));
       const recording = RecordingSchema.parse(raw);
       const captureEmulation = captureEmulationFlag ?? (recording.emulation === void 0 ? void 0 : recording.emulation.device !== void 0 ? { device: recording.emulation.device } : { viewport: recording.emulation.viewport });
       fx = regressionFixtures(
         flags,
         recording,
-        resultPath === void 0 ? void 0 : JSON.parse(await readFile36(resultPath, "utf8")),
+        resultPath === void 0 ? void 0 : JSON.parse(await readFile39(resultPath, "utf8")),
         storageState
       );
       const replayFixture = fx;
-      const branch = resultPath === void 0 ? void 0 : recordedBranchOf(JSON.parse(await readFile36(resultPath, "utf8")).result);
+      const branch = resultPath === void 0 ? void 0 : recordedBranchOf(JSON.parse(await readFile39(resultPath, "utf8")).result);
       const prefix = branch === void 0 ? void 0 : await branchPrefixOrRefuse(branch, param, storageState);
       if (prefix === null) return;
       const result = await runRegressionCapture({
@@ -119308,8 +119840,8 @@ function registerRegressionCommands(program2, deps) {
       }).then((r) => withEngine(r));
       await fx?.restore();
       if (branch !== void 0 && "metaPath" in result) {
-        const meta3 = JSON.parse(await readFile36(result.metaPath, "utf8"));
-        await writeFile44(result.metaPath, `${JSON.stringify({ ...meta3, branch }, null, 2)}
+        const meta3 = JSON.parse(await readFile39(result.metaPath, "utf8"));
+        await writeFile45(result.metaPath, `${JSON.stringify({ ...meta3, branch }, null, 2)}
 `);
       }
       const envelope = ok(fx === void 0 ? result : { ...result, fixtures: fx.record() });
@@ -119368,17 +119900,17 @@ function registerRegressionCommands(program2, deps) {
     }
     if (refuseUnsafeName(program2, id, "regression id")) return;
     const regressionsDir = resolveRegressionsDir(dir);
-    if (!existsSync45(join76(regressionsDir, `${id}.recording.json`))) {
+    if (!existsSync45(join77(regressionsDir, `${id}.recording.json`))) {
       const notFound = new RegressionNotFoundError(id, regressionsDir);
       emitJson(program2, fail(notFound.code, notFound.message));
       return;
     }
     const opened = [];
     try {
-      const recording = RecordingSchema.parse(JSON.parse(await readFile36(join76(regressionsDir, `${id}.recording.json`), "utf8")));
+      const recording = RecordingSchema.parse(JSON.parse(await readFile39(join77(regressionsDir, `${id}.recording.json`), "utf8")));
       let branch;
       try {
-        branch = recordedBranchOf(JSON.parse(await readFile36(join76(regressionsDir, `${id}.meta.json`), "utf8")));
+        branch = recordedBranchOf(JSON.parse(await readFile39(join77(regressionsDir, `${id}.meta.json`), "utf8")));
       } catch {
         branch = void 0;
       }
@@ -119652,9 +120184,9 @@ async function queueExploration(targets, queue, args) {
 }
 
 // ../inbox/dist/atomic.js
-import { open as open4, rename as rename6, rm as rm14 } from "node:fs/promises";
+import { open as open4, rename as rename7, rm as rm14 } from "node:fs/promises";
 import { randomBytes as randomBytes6 } from "node:crypto";
-import { dirname as dirname33, join as join77 } from "node:path";
+import { dirname as dirname33, join as join78 } from "node:path";
 
 // ../inbox/dist/durability.js
 function durableWritesEnabled(env = process.env) {
@@ -119667,7 +120199,7 @@ async function flushIfDurable(handle) {
 
 // ../inbox/dist/atomic.js
 async function writeFileAtomic(path2, data, mode = 384) {
-  const tmp = join77(dirname33(path2), `.${randomBytes6(8).toString("hex")}.tmp`);
+  const tmp = join78(dirname33(path2), `.${randomBytes6(8).toString("hex")}.tmp`);
   try {
     const handle = await open4(tmp, "wx", mode);
     try {
@@ -119676,7 +120208,7 @@ async function writeFileAtomic(path2, data, mode = 384) {
     } finally {
       await handle.close();
     }
-    await rename6(tmp, path2);
+    await rename7(tmp, path2);
   } catch (err) {
     await rm14(tmp, { force: true });
     throw err;
@@ -119684,9 +120216,9 @@ async function writeFileAtomic(path2, data, mode = 384) {
 }
 
 // ../inbox/dist/lock.js
-import { mkdir as mkdir36, open as open5, rename as rename7, rm as rm15, stat as stat6 } from "node:fs/promises";
+import { mkdir as mkdir37, open as open5, rename as rename8, rm as rm15, stat as stat6 } from "node:fs/promises";
 import { randomBytes as randomBytes7 } from "node:crypto";
-import { join as join78 } from "node:path";
+import { join as join79 } from "node:path";
 var LockTimeoutError = class extends Error {
   constructor(id) {
     super(`could not acquire inbox lock for '${id}'`);
@@ -119697,8 +120229,8 @@ async function withIdLock(dir, id, fn, opts = {}) {
   const staleMs = opts.staleMs ?? 3e4;
   const retryMs = opts.retryMs ?? 20;
   const maxWaitMs = opts.maxWaitMs ?? 1e4;
-  const lockPath = join78(dir, `${id}.lock`);
-  await mkdir36(dir, { recursive: true, mode: 448 });
+  const lockPath = join79(dir, `${id}.lock`);
+  await mkdir37(dir, { recursive: true, mode: 448 });
   const deadline = clock.now() + maxWaitMs;
   for (; ; ) {
     try {
@@ -119712,7 +120244,7 @@ async function withIdLock(dir, id, fn, opts = {}) {
         const st = await stat6(lockPath);
         if (clock.now() - st.mtimeMs > staleMs) {
           const claimed = `${lockPath}.reclaim.${randomBytes7(6).toString("hex")}`;
-          await rename7(lockPath, claimed);
+          await rename8(lockPath, claimed);
           await rm15(claimed, { force: true });
           continue;
         }
@@ -119805,8 +120337,8 @@ function resolveTransition(kind, action) {
 }
 
 // ../inbox/dist/store.js
-import { mkdir as mkdir37, open as open6, readFile as readFile37, readdir as readdir12, stat as stat7, unlink } from "node:fs/promises";
-import { join as join79 } from "node:path";
+import { mkdir as mkdir38, open as open6, readFile as readFile40, readdir as readdir12, stat as stat7, unlink } from "node:fs/promises";
+import { join as join80 } from "node:path";
 var InboxItemNotFoundError = class extends Error {
   constructor(id) {
     super(`inbox item not found: ${id}`);
@@ -119847,19 +120379,19 @@ var FsInboxStore = class {
     this.identity = typeof build === "string" ? { version: build } : { version: build.version, commit: build.commit, builtAt: build.builtAt };
   }
   hotPath(id) {
-    return join79(this.dir, `${id}.json`);
+    return join80(this.dir, `${id}.json`);
   }
   archivePath(id) {
-    return join79(this.dir, "archive", `${id}.json`);
+    return join80(this.dir, "archive", `${id}.json`);
   }
   archiveDir() {
-    return join79(this.dir, "archive");
+    return join80(this.dir, "archive");
   }
   /** Reads and validates the hot file, or null on ENOENT. Throws on malformed content (fail-closed). */
   async readHot(id) {
     let raw;
     try {
-      raw = await readFile37(this.hotPath(id), "utf8");
+      raw = await readFile40(this.hotPath(id), "utf8");
     } catch (err) {
       if (isNodeError(err, "ENOENT"))
         return null;
@@ -119871,7 +120403,7 @@ var FsInboxStore = class {
   async readArchive(id) {
     let raw;
     try {
-      raw = await readFile37(this.archivePath(id), "utf8");
+      raw = await readFile40(this.archivePath(id), "utf8");
     } catch (err) {
       if (isNodeError(err, "ENOENT"))
         return null;
@@ -119883,7 +120415,7 @@ var FsInboxStore = class {
     const validated = InboxItemSchema.parse(item);
     assertSafeInboxId(validated.id);
     await withIdLock(this.dir, validated.id, async () => {
-      await mkdir37(this.dir, { recursive: true, mode: 448 });
+      await mkdir38(this.dir, { recursive: true, mode: 448 });
       const serialized = JSON.stringify(validated);
       let fh;
       try {
@@ -119917,7 +120449,7 @@ var FsInboxStore = class {
       if (entry.startsWith("."))
         continue;
       try {
-        const raw = await readFile37(join79(this.dir, entry), "utf8");
+        const raw = await readFile40(join80(this.dir, entry), "utf8");
         const parsed = InboxItemSchema.parse(JSON.parse(raw));
         if (parsed.status === "pending")
           items.push(parsed);
@@ -119986,7 +120518,7 @@ var FsInboxStore = class {
       const decision = transition === "approved" || transition === "rejected" || transition === "resolved" ? transition : "resolved";
       updated.resolution = { by: "human", decision, at: now2 };
       const validated = InboxItemSchema.parse(updated);
-      await mkdir37(this.archiveDir(), { recursive: true, mode: 448 });
+      await mkdir38(this.archiveDir(), { recursive: true, mode: 448 });
       await writeFileAtomic(this.archivePath(id), JSON.stringify(validated));
       await unlink(this.hotPath(id));
       return validated;
@@ -120038,7 +120570,7 @@ var FsInboxStore = class {
           const updated = { ...item, status: "expired", resolvedAt: at3 };
           delete updated.humanInput;
           const validated = InboxItemSchema.parse(updated);
-          await mkdir37(this.archiveDir(), { recursive: true, mode: 448 });
+          await mkdir38(this.archiveDir(), { recursive: true, mode: 448 });
           await writeFileAtomic(this.archivePath(id), JSON.stringify(validated));
           await unlink(this.hotPath(id));
           return true;
@@ -120066,7 +120598,7 @@ var FsInboxStore = class {
     for (const entry of entries) {
       if (!entry.endsWith(".json") || entry.startsWith("."))
         continue;
-      const full = join79(this.dir, entry);
+      const full = join80(this.dir, entry);
       try {
         const st = await stat7(full);
         if (!st.isFile())
@@ -120261,17 +120793,17 @@ function isDefectStatus(v) {
   return typeof v === "string" && DEFECT_OUTCOME_STATUSES.includes(v);
 }
 function parseResultOutcome(missionOutcome, goalOutcome, defectStatus) {
-  const canonical7 = parseMissionOutcome(missionOutcome);
-  if (canonical7 !== null) {
+  const canonical6 = parseMissionOutcome(missionOutcome);
+  if (canonical6 !== null) {
     if (goalOutcome === void 0)
-      return { outcome: canonical7 };
+      return { outcome: canonical6 };
     if (!isGoalOutcome(goalOutcome))
       return null;
     if (defectStatus === void 0)
-      return foldGoalOutcome(goalOutcome) === canonical7 ? { outcome: canonical7, goalOutcome } : null;
+      return foldGoalOutcome(goalOutcome) === canonical6 ? { outcome: canonical6, goalOutcome } : null;
     if (!isDefectStatus(defectStatus))
       return null;
-    return goalMissionOutcome(goalOutcome, defectStatus) === canonical7 ? { outcome: canonical7, goalOutcome } : null;
+    return goalMissionOutcome(goalOutcome, defectStatus) === canonical6 ? { outcome: canonical6, goalOutcome } : null;
   }
   if (goalOutcome === void 0 && typeof missionOutcome === "string" && Object.hasOwn(LEGACY_GOAL_OUTCOMES, missionOutcome)) {
     return { outcome: LEGACY_GOAL_OUTCOMES[missionOutcome], goalOutcome: missionOutcome };
@@ -120345,8 +120877,8 @@ var tagsArg = (args) => {
 
 // src/mcp-tools/findings.ts
 import { existsSync as existsSync47 } from "node:fs";
-import { access, readFile as readFile38 } from "node:fs/promises";
-import { join as join80 } from "node:path";
+import { access, readFile as readFile41 } from "node:fs/promises";
+import { join as join81 } from "node:path";
 function findingTools(ctx) {
   const { deps, pathRoots, verifyFixImpl } = ctx;
   const resolveResultId = async (id, tool) => {
@@ -120389,7 +120921,7 @@ function findingTools(ctx) {
   const resultPathsFor = (resultId) => {
     const file2 = missionResultFileName(resultId);
     const dirs = deps.resultDirsFor?.(resultId) ?? [deps.recordingsDir, ...resultId.startsWith("usability-") ? [deps.uxReportsDir] : []];
-    return dirs.filter((d) => d !== void 0).map((d) => join80(d, file2));
+    return dirs.filter((d) => d !== void 0).map((d) => join81(d, file2));
   };
   const getMissionResult = async (args) => {
     if (!deps.recordingsDir) {
@@ -120401,7 +120933,7 @@ function findingTools(ctx) {
     let raw;
     for (const path2 of resultPathsFor(ref.resultId)) {
       try {
-        raw = await readFile38(path2, "utf8");
+        raw = await readFile41(path2, "utf8");
         break;
       } catch {
       }
@@ -121467,9 +121999,9 @@ function registerMissionCommands(program2, deps) {
 // src/ui-api.ts
 import { createServer } from "node:http";
 import { randomBytes as randomBytes8 } from "node:crypto";
-import { readFile as readFile39, realpath as realpath2 } from "node:fs/promises";
+import { readFile as readFile42, realpath as realpath2 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { join as join81, sep as sep11 } from "node:path";
+import { join as join82, sep as sep11 } from "node:path";
 import { spawn as spawn6 } from "node:child_process";
 var DEFAULT_PORT = 4180;
 var MAX_PORT_ATTEMPTS = 20;
@@ -121571,7 +122103,7 @@ async function startUiServer(deps) {
   const shouldOpen = deps.open ?? true;
   const indexHtmlPath = fileURLToPath4(new URL("../ui/index.html", import.meta.url));
   const appJsPath = fileURLToPath4(new URL("../ui/app.js", import.meta.url));
-  const screenshotsDir = join81(deps.inboxDir, "screenshots");
+  const screenshotsDir = join82(deps.inboxDir, "screenshots");
   const server = createServer();
   let boundPort = 0;
   function send(res, status, body, headers = {}) {
@@ -121583,7 +122115,7 @@ async function startUiServer(deps) {
   async function serveIndex(req, res) {
     const reqUrl = new URL(req.url ?? "/", `http://127.0.0.1:${boundPort}`);
     const t = reqUrl.searchParams.get("t");
-    const html = await readFile39(indexHtmlPath, "utf8");
+    const html = await readFile42(indexHtmlPath, "utf8");
     const headers = {
       "Content-Type": "text/html; charset=utf-8",
       "Content-Security-Policy": "default-src 'self'; img-src 'self'; style-src 'self' 'unsafe-inline'"
@@ -121596,7 +122128,7 @@ async function startUiServer(deps) {
     return 200;
   }
   async function serveAppJs(res) {
-    const js = await readFile39(appJsPath, "utf8");
+    const js = await readFile42(appJsPath, "utf8");
     res.writeHead(200, { "Content-Type": "text/javascript" });
     res.end(js);
     return 200;
@@ -121609,7 +122141,7 @@ async function startUiServer(deps) {
     } catch {
       return send(res, 404, { error: "not_found" });
     }
-    const candidate = join81(screenshotsDir, `${id}.png`);
+    const candidate = join82(screenshotsDir, `${id}.png`);
     let resolved;
     try {
       resolved = await realpath2(candidate);
@@ -121620,7 +122152,7 @@ async function startUiServer(deps) {
       return send(res, 404, { error: "not_found" });
     }
     try {
-      const data = await readFile39(resolved);
+      const data = await readFile42(resolved);
       res.writeHead(200, { "Content-Type": "image/png" });
       res.end(data);
       return 200;
@@ -121860,7 +122392,7 @@ function registerServeCommands(program2, deps, buildProgram2) {
 }
 
 // src/ux-cli.ts
-import { readFile as readFile40 } from "node:fs/promises";
+import { readFile as readFile43 } from "node:fs/promises";
 function registerUxCommands(program2, deps) {
   program2.command("ux <recording>").description("offline UX review of a saved Recording \u2014 ranked, cited usability findings").option("--app-class <class>", "app class for calibration (required), e.g. consumer|admin|internal").option(
     "--show <labels>",
@@ -121888,7 +122420,7 @@ function registerUxCommands(program2, deps) {
     }
     let recording;
     try {
-      recording = RecordingSchema.parse(JSON.parse(await readFile40(recordingPath, "utf8")));
+      recording = RecordingSchema.parse(JSON.parse(await readFile43(recordingPath, "utf8")));
     } catch (err) {
       emitJson(program2, fail("E_UX_INPUT", String(err instanceof Error ? err.message : err)));
       return;
@@ -121948,7 +122480,7 @@ function registerUxCommands(program2, deps) {
 
 // src/logs-retention.ts
 import { readFileSync as readFileSync39, readdirSync as readdirSync11, rmSync as rmSync2, rmdirSync as rmdirSync2, statSync as statSync13 } from "node:fs";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 var DEFAULT_LOGS_RETENTION = { ttlDays: 14, keepLatest: 50 };
 var LogsConfigError = class extends Error {
   code = "E_LOGS_CONFIG";
@@ -121990,8 +122522,8 @@ function runsIn(root2) {
   }
   const byKey = /* @__PURE__ */ new Map();
   for (const date5 of dates) {
-    for (const name of readdirSync11(join82(root2, date5))) {
-      const path2 = join82(root2, date5, name);
+    for (const name of readdirSync11(join83(root2, date5))) {
+      const path2 = join83(root2, date5, name);
       const key2 = `${date5}/${RUN_KEY.exec(name)?.[1] ?? name}`;
       const run = byKey.get(key2) ?? { paths: [], mtimeMs: 0 };
       run.paths.push(path2);
@@ -121999,7 +122531,7 @@ function runsIn(root2) {
       byKey.set(key2, run);
     }
   }
-  return { runs: [...byKey].map(([key2, r]) => ({ key: key2, ...r })), dateDirs: dates.map((d) => join82(root2, d)) };
+  return { runs: [...byKey].map(([key2, r]) => ({ key: key2, ...r })), dateDirs: dates.map((d) => join83(root2, d)) };
 }
 function pruneLogs(root2, retention, opts = {}) {
   const nowMs = opts.nowMs ?? clock.now();
@@ -122247,6 +122779,119 @@ function registerInboxCommands(program2, deps) {
   }
 }
 
+// src/acceptance-audit-cli.ts
+import { readFile as readFile45, mkdir as mkdir39, writeFile as writeFile46 } from "node:fs/promises";
+
+// src/acceptance-audit.ts
+import { access as access2, readFile as readFile44 } from "node:fs/promises";
+var CORE = [
+  ["requirements", "requirements"],
+  ["persona", "persona"],
+  ["source-journey", "sourceJourney"],
+  ["approved-hash", "approvedHash"],
+  ["verify-fix", "verifyFix"],
+  ["strict-review", "strictReview"]
+];
+async function finding3(asset, path2) {
+  if (path2 === void 0 || path2 === "") return { asset, state: "missing", reason: "no explicit local path supplied" };
+  try {
+    await access2(path2);
+  } catch {
+    return { asset, state: "missing", path: path2, reason: "local file does not exist" };
+  }
+  try {
+    if ((await readFile44(path2, "utf8")).trim() === "") return { asset, state: "inconclusive", path: path2, reason: "local file is empty" };
+  } catch {
+    return { asset, state: "inconclusive", path: path2, reason: "local file cannot be read as text" };
+  }
+  return { asset, state: "complete", path: path2 };
+}
+async function auditCoreAcceptanceAssets(assets) {
+  return Promise.all(CORE.map(([asset, key2]) => finding3(asset, assets[key2])));
+}
+
+// src/acceptance-audit-schema.ts
+var ACCEPTANCE_AUDIT_SCHEMA_VERSION = 1;
+function acceptanceAuditResult(request, findings) {
+  const passed = findings.every((finding4) => finding4.state === "complete");
+  return { schemaVersion: ACCEPTANCE_AUDIT_SCHEMA_VERSION, request, findings, passed, exitCode: passed ? 0 : 1 };
+}
+
+// src/acceptance-audit-suite.ts
+function auditSuiteIntegrity(entries) {
+  const duplicates = entries.filter((entry, index) => entries.findIndex((other) => other.id === entry.id) !== index).map((entry) => entry.id);
+  const missingSidecar = entries.filter((entry) => !entry.sidecar).map((entry) => entry.id);
+  const missingPartition = entries.filter((entry) => entry.partition.trim() === "").map((entry) => entry.id);
+  const missingRevision = entries.filter((entry) => entry.revision.trim() === "").map((entry) => entry.id);
+  const hasNegativeControl = entries.some((entry) => entry.negativeControl);
+  return [
+    {
+      asset: "suite-sidecar",
+      state: missingSidecar.length === 0 ? "complete" : "missing",
+      ...missingSidecar.length === 0 ? {} : { reason: `missing sidecar: ${missingSidecar.join(", ")}` }
+    },
+    {
+      asset: "negative-control",
+      state: hasNegativeControl ? "complete" : "missing",
+      ...hasNegativeControl ? {} : { reason: "suite has no declared negative control" }
+    },
+    {
+      asset: "partition",
+      state: duplicates.length === 0 && missingPartition.length === 0 ? "complete" : "inconclusive",
+      ...duplicates.length === 0 && missingPartition.length === 0 ? {} : { reason: [...duplicates.length === 0 ? [] : [`duplicate ids: ${duplicates.join(", ")}`], ...missingPartition.length === 0 ? [] : [`unpartitioned: ${missingPartition.join(", ")}`]].join("; ") }
+    },
+    {
+      asset: "exact-revision",
+      state: missingRevision.length === 0 ? "complete" : "stale",
+      ...missingRevision.length === 0 ? {} : { reason: `missing exact revision: ${missingRevision.join(", ")}` }
+    }
+  ];
+}
+
+// src/acceptance-audit-render.ts
+var xml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+function renderAcceptanceAuditMarkdown(result) {
+  return `# Acceptance audit
+
+${result.passed ? "Passed" : "Failed"} (exit ${result.exitCode}).
+
+| asset | state | reason |
+| --- | --- | --- |
+${result.findings.map((f2) => `| ${f2.asset} | ${f2.state} | ${f2.reason ?? ""} |`).join("\n")}
+`;
+}
+function renderAcceptanceAuditJunit(result) {
+  const failures = result.findings.filter((f2) => f2.state !== "complete");
+  return `<?xml version="1.0" encoding="UTF-8"?><testsuite name="jevitate.acceptance-audit" tests="${result.findings.length}" failures="${failures.length}">${result.findings.map((f2) => `<testcase name="${xml(f2.asset)}">${f2.state === "complete" ? "" : `<failure message="${xml(f2.state)}">${xml(f2.reason ?? "")}</failure>`}</testcase>`).join("")}</testsuite>
+`;
+}
+function renderAcceptanceAuditSarif(result) {
+  return `${JSON.stringify({ version: "2.1.0", runs: [{ tool: { driver: { name: "jevitate acceptance audit", rules: result.findings.map((f2) => ({ id: f2.asset })) } }, results: result.findings.filter((f2) => f2.state !== "complete").map((f2) => ({ ruleId: f2.asset, level: "error", message: { text: f2.reason ?? f2.state } })) }] }, null, 2)}
+`;
+}
+
+// src/acceptance-audit-cli.ts
+function registerAcceptanceAuditCommands(program2) {
+  const acceptance = program2.command("acceptance").description("read-only acceptance evidence tools");
+  acceptance.command("audit").description("audit release acceptance evidence and emit CI artifacts").requiredOption("--requirements <file>").requiredOption("--suite <file>").option("--persona <file>").option("--journey <file>").option("--approval <file>").option("--verify <file>").option("--review <file>").option("--out <dir>").option("--json").action(async function() {
+    const o = this.opts();
+    try {
+      const core = await auditCoreAcceptanceAssets({ requirements: o.requirements, persona: o.persona, sourceJourney: o.journey, approvedHash: o.approval, verifyFix: o.verify, strictReview: o.review });
+      const entries = JSON.parse(await readFile45(o.suite, "utf8"));
+      if (!Array.isArray(entries)) throw new Error("suite must be a JSON array of acceptance entries");
+      const result = acceptanceAuditResult({ requirementsFile: o.requirements, suiteFile: o.suite, strict: true }, [...core, ...auditSuiteIntegrity(entries)]);
+      if (o.out !== void 0) {
+        await mkdir39(o.out, { recursive: true });
+        await Promise.all([writeFile46(`${o.out}/acceptance-audit.md`, renderAcceptanceAuditMarkdown(result)), writeFile46(`${o.out}/acceptance-audit.junit.xml`, renderAcceptanceAuditJunit(result)), writeFile46(`${o.out}/acceptance-audit.sarif`, renderAcceptanceAuditSarif(result)), writeFile46(`${o.out}/acceptance-audit.json`, `${JSON.stringify(result, null, 2)}
+`)]);
+      }
+      emitEnvelope(program2, ok(result), { json: o.json === true, exitCode: result.exitCode, command: "acceptance audit", human: (r) => renderAcceptanceAuditMarkdown(r) });
+    } catch (err) {
+      emitEnvelope(program2, fail("E_ACCEPTANCE_AUDIT", err instanceof Error ? err.message : String(err)), { json: o.json === true, command: "acceptance audit" });
+    }
+  });
+}
+
 // src/program.ts
 function versionString() {
   return formatVersion(currentEngineInfo());
@@ -122286,6 +122931,7 @@ function buildProgram(deps) {
   registerMissionCommands(program2, deps);
   registerServeCommands(program2, deps, buildProgram);
   registerInboxCommands(program2, deps);
+  registerAcceptanceAuditCommands(program2);
   registerUxCommands(program2, deps);
   registerAiCommands(program2, deps);
   registerCheckCommand(