@jevitate/cli 0.18.1 → 0.20.0

package/dist/bin.js

@@ -39690,15 +39690,23 @@ var INSTRUMENT = `(() => {
 })();`;
 var MAX_CAPTURED = 2e4;
 var RequestCapture = class {
+  /**
+   * #617: every request that finished during the capture (its whole completion history), each
+   * tagged with whether THIS capture saw it begin. A request already in flight when the capture
+   * started still finishes into it, but was not sent by the run the capture covers.
+   */
   #requests = [];
   /** #283: requests sent since the capture started that have not finished (keyed by the request). */
   #inflight = /* @__PURE__ */ new Map();
   /** #283: requests sent that never reported an end (their document went away first). */
   #unfinished = [];
   #truncated = false;
-  /** @internal — fed by the page's monitor. */
-  add(r) {
-    this.#requests.push(r);
+  /**
+   * @internal — fed by the page's monitor. `sent` is false for a completion the capture never saw
+   * begin (#617); it stays in the completion history but is not counted as sent by the capture.
+   */
+  add(r, sent = true) {
+    this.#requests.push({ r, sent });
     if (this.#requests.length > MAX_CAPTURED) {
       this.#requests.shift();
       this.#truncated = true;
@@ -39716,22 +39724,27 @@ var RequestCapture = class {
     const sent = this.#inflight.get(key2);
     this.#inflight.delete(key2);
     if (finished !== null)
-      this.add(finished);
+      this.add(finished, sent !== void 0);
     else if (sent !== void 0 && this.#unfinished.length < MAX_CAPTURED)
       this.#unfinished.push(sent);
   }
-  /** The requests captured so far, in the order they finished. */
+  /** The requests captured so far, in the order they finished, including ones the capture never saw begin. */
   requests() {
-    return [...this.#requests];
+    return this.#requests.map((e) => e.r);
   }
   /**
-   * Every request SENT since the capture started (#283): the finished ones (`requests()`), then the
-   * ones still in flight or abandoned without an end event (`pending: true`, `status: null`). A
-   * `requestMade` check is judged over these — a request counts once it was sent, whether or not
-   * its response has arrived.
+   * Every request SENT since the capture started (#283): the finished ones this capture saw begin,
+   * then the ones still in flight or abandoned without an end event (`pending: true`, `status: null`).
+   * A `requestMade` check is judged over these — a request counts once it was sent, whether or not
+   * its response has arrived. A request that began before the capture started is never among them
+   * (#617): only its completion shows up, in `requests()`.
    */
   sent() {
-    return [...this.#requests, ...this.#unfinished, ...this.#inflight.values()];
+    return [
+      ...this.#requests.filter((e) => e.sent).map((e) => e.r),
+      ...this.#unfinished,
+      ...this.#inflight.values()
+    ];
   }
   /** True when more requests finished than the capture keeps (the oldest were dropped). */
   get truncated() {
@@ -53640,6 +53653,72 @@ function mutationPairIssues(journey) {
   });
   return out;
 }
+function targetedProofPlanIssues(journey) {
+  const plans = journey.metadata.targetedProofs ?? [];
+  if (plans.length === 0)
+    return [];
+  const sites = new Set(journeyAssertions(journey).map(assertionSiteKey));
+  const steps = flat(journey);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  plans.forEach((plan2, index) => {
+    const key2 = `${plan2.check}\0${plan2.mustFailWhen}`;
+    if (seen.has(key2))
+      out.push({ index, field: "check", message: `targetedProofs: duplicate plan for ${plan2.check} and ${plan2.mustFailWhen}` });
+    seen.add(key2);
+    if (!SITE_RE.test(plan2.check)) {
+      out.push({ index, field: "check", message: `targetedProofs: ${JSON.stringify(plan2.check)} is not an assertion site \u2014 expected step:<n>, step-request:<n>:<i> or end-state:<i>` });
+    } else if (!sites.has(plan2.check)) {
+      out.push({ index, field: "check", message: `targetedProofs: the Journey has no assertion at ${plan2.check}` });
+    }
+    let mutated;
+    try {
+      mutated = resolveMutationRef(journey, plan2.mustFailWhen);
+    } catch (err) {
+      out.push({ index, field: "mustFailWhen", message: `targetedProofs: ${err instanceof Error ? err.message : String(err)}` });
+    }
+    const check3 = /^step:([1-9][0-9]*)$/.exec(plan2.check);
+    const targetStep = check3 === null ? null : Number(check3[1]);
+    const relaxed2 = /* @__PURE__ */ new Set();
+    for (const entry of plan2.relax) {
+      if (!/^step:[1-9][0-9]*$/.test(entry)) {
+        out.push({ index, field: "relax", message: `targetedProofs: ${JSON.stringify(entry)} is not a step assertion site \u2014 expected step:<n>` });
+        continue;
+      }
+      if (relaxed2.has(entry)) {
+        out.push({ index, field: "relax", message: `targetedProofs: ${entry} is relaxed twice` });
+        continue;
+      }
+      relaxed2.add(entry);
+      const n3 = Number(entry.slice("step:".length));
+      const recorded = steps[n3 - 1];
+      if (recorded === void 0) {
+        out.push({ index, field: "relax", message: `targetedProofs: the Journey has no step ${n3}` });
+        continue;
+      }
+      if (targetStep === n3) {
+        out.push({ index, field: "relax", message: `targetedProofs: ${entry} is the target assertion \u2014 a declared proof never relaxes it` });
+        continue;
+      }
+      if (targetStep !== null && n3 > targetStep) {
+        out.push({ index, field: "relax", message: `targetedProofs: ${entry} is not before the target step:${targetStep}` });
+        continue;
+      }
+      if (recorded.step.kind === "handback") {
+        out.push({ index, field: "relax", message: `targetedProofs: ${entry} is a resume assertion \u2014 a declared proof never relaxes it` });
+        continue;
+      }
+      if (recorded.step.kind !== "assert" && !("expect" in recorded.step)) {
+        out.push({ index, field: "relax", message: `targetedProofs: ${entry} has no page postcondition to relax` });
+        continue;
+      }
+      if (mutated !== void 0 && n3 < mutated.step) {
+        out.push({ index, field: "relax", message: `targetedProofs: ${entry} is before the mutated step ${mutated.step} (${plan2.mustFailWhen})` });
+      }
+    }
+  });
+  return out;
+}
 function expectedText(a) {
   if (a.kind === "valueEquals")
     return typeof a.value === "string" ? { kind: a.kind, text: a.value } : null;
@@ -53836,13 +53915,14 @@ function relaxedMutationReplay(journey, m, opts = {}) {
     return { journey, skipIndex: index };
   if (m.kind === "swap-param" || m.kind === "truncate-param" || m.kind === "guard-param") {
     const how = paramReplay(journey, m, opts.params ?? {});
-    const target2 = flat(how.journey)[index];
+    const copy2 = how.journey === journey ? structuredClone(journey) : how.journey;
+    const target2 = flat(copy2)[index];
     if (target2 !== void 0 && "expect" in target2.step) {
       const step = { ...target2.step, expect: relaxedExpect(target2.step) };
       delete step.waitFor;
       target2.step = step;
     }
-    return how;
+    return { ...how, journey: copy2 };
   }
   if (m.kind === "block-write") {
     const requests = journeyWriteSteps(journey, opts).find((w) => w.step === m.step)?.requests ?? [];
@@ -53866,6 +53946,174 @@ function relaxedMutationReplay(journey, m, opts = {}) {
   }
   return { journey: copy };
 }
+var MAX_TARGETED_RELAXATIONS = 4;
+var MAX_DECLARED_RELAXATIONS = 8;
+function failedSiteKey(f2) {
+  if (f2.where === "step")
+    return `step:${f2.step}`;
+  if (f2.where === "step-request")
+    return `step-request:${f2.step}:${f2.checkIndex}`;
+  if (f2.where === "end-state")
+    return `end-state:${f2.index}`;
+  return "unevaluable";
+}
+function targetedMutationReplay(journey, m, targetSiteKey, relaxedSiteKeys, opts = {}) {
+  if (relaxedSiteKeys.includes(targetSiteKey))
+    throw new Error(`${targetSiteKey} is the target assertion \u2014 a targeted proof never relaxes it`);
+  const base = relaxedMutationReplay(journey, m, opts);
+  if (relaxedSiteKeys.length === 0)
+    return base;
+  return { ...base, journey: relaxStepSites(journey, base.journey, relaxedSiteKeys) };
+}
+function targetedControlReplay(journey, m, relaxedSiteKeys) {
+  const own2 = flat(journey)[m.step - 1]?.step;
+  const ownKey = own2 !== void 0 && (own2.kind === "assert" || "expect" in own2) ? [`step:${m.step}`] : [];
+  return { journey: relaxStepSites(journey, journey, [.../* @__PURE__ */ new Set([...ownKey, ...relaxedSiteKeys])]) };
+}
+function relaxStepSites(journey, from, keys) {
+  const byKey = new Map(journeyAssertions(journey).map((s3) => [assertionSiteKey(s3), s3]));
+  const copy = structuredClone(from);
+  const steps = flat(copy);
+  for (const key2 of keys) {
+    const match2 = /^step:([1-9][0-9]*)$/.exec(key2);
+    if (match2 === null)
+      throw new Error(`${key2} is not a step assertion site \u2014 a targeted proof only relaxes step:<n>`);
+    const site = byKey.get(key2);
+    if (site !== void 0 && site.where === "step" && site.field === "resume")
+      throw new Error(`${key2} is a resume assertion \u2014 a targeted proof never relaxes it`);
+    const recorded = steps[Number(match2[1]) - 1];
+    if (recorded === void 0)
+      throw new Error(`journey '${journey.metadata.id}' has no step ${match2[1]} to relax`);
+    const step = { ...recorded.step };
+    if (recorded.step.kind === "assert")
+      step.check = { kind: "urlIncludes", text: "" };
+    else if ("expect" in recorded.step)
+      step.expect = relaxedExpect(recorded.step);
+    else
+      throw new Error(`${key2} has no page postcondition to relax`);
+    delete step.waitFor;
+    recorded.step = step;
+  }
+  return copy;
+}
+function nextTargetedRelaxation(journey, plan2, m, targetSiteKey, result, relaxedSoFar) {
+  const target = journeyAssertions(journey).find((s3) => assertionSiteKey(s3) === targetSiteKey);
+  if (target === void 0)
+    return { refuse: `${targetSiteKey} is not an assertion site of this Journey` };
+  if (classifyMutation(target, m, result) !== "cascade")
+    return null;
+  const first = result.failedSites[0];
+  if (first === void 0)
+    return { refuse: "no failed site to relax" };
+  if (first.where === "unevaluable")
+    return { refuse: "unevaluable end state" };
+  if (first.where !== "step")
+    return { refuse: `${failedSiteKey(first)} is not a step postcondition` };
+  const key2 = `step:${first.step}`;
+  if (!first.postcondition)
+    return { refuse: `${key2} action failed (not a postcondition)` };
+  if (first.step < m.step)
+    return { refuse: "failure before the mutated step" };
+  const step = flat(journey)[first.step - 1]?.step;
+  if (step === void 0)
+    return { refuse: `${key2} does not exist` };
+  if (step.kind === "handback")
+    return { refuse: `${key2} is a resume assertion (not a relaxable page postcondition)` };
+  if (target.where === "step" && target.step <= first.step)
+    return { refuse: `${key2} is not before the target ${targetSiteKey}` };
+  if (!plan2.pairs.some((p) => p.site === key2 && p.mutation === m.id))
+    return { refuse: `${key2} is not paired with ${m.id}` };
+  if (relaxedSoFar.includes(key2))
+    return { refuse: `${key2} is already relaxed` };
+  if (relaxedSoFar.length >= MAX_TARGETED_RELAXATIONS)
+    return { refuse: `relaxation bound ${MAX_TARGETED_RELAXATIONS} reached` };
+  return { relax: key2 };
+}
+async function runTargetedProof(journey, plan2, m, target, initial, replay, opts = {}) {
+  const site = assertionSiteKey(target);
+  const relaxedSites = [];
+  const relaxedFirst = initial.relaxed !== void 0 && initial.failedSites.some((f2) => f2.where === "step" && f2.step === m.step && f2.postcondition) && !(target.where === "step" && target.step === m.step);
+  let run = relaxedFirst ? { outcome: initial.relaxed.outcome, failedSites: initial.relaxed.failedSites } : { outcome: initial.outcome, failedSites: initial.failedSites };
+  for (; ; ) {
+    const next = nextTargetedRelaxation(journey, plan2, m, site, run, relaxedSites);
+    if (next === null)
+      break;
+    if ("refuse" in next)
+      return { site, relaxedSites, outcome: run.outcome, failedSites: run.failedSites, refused: next.refuse };
+    relaxedSites.push(next.relax);
+    const relaxedNow = [...relaxedSites];
+    run = await replay((j) => targetedMutationReplay(j, m, site, relaxedNow, opts), "targeted");
+  }
+  if (relaxedSites.length > 0 && classifyMutationPlain(target, m, run) === "sensitive") {
+    const control = await replay((j) => targetedControlReplay(j, m, relaxedSites), "control");
+    if (control.outcome !== "passed") {
+      return {
+        site,
+        relaxedSites,
+        outcome: run.outcome,
+        failedSites: run.failedSites,
+        control: control.outcome,
+        refused: `the unmutated control replay with ${relaxedSites.join(", ")} relaxed did not pass (${control.outcome})`
+      };
+    }
+    return { site, relaxedSites, outcome: run.outcome, failedSites: run.failedSites, control: control.outcome };
+  }
+  return { site, relaxedSites, outcome: run.outcome, failedSites: run.failedSites };
+}
+async function runDeclaredTargetedProof(journey, plan2, m, target, declared, replay, opts = {}) {
+  const site = assertionSiteKey(target);
+  const relax = declared.relax;
+  const unpaired = relax.find((key2) => !plan2.pairs.some((p) => p.site === key2 && p.mutation === m.id));
+  if (unpaired !== void 0) {
+    return { site, relaxedSites: relax, outcome: "error", failedSites: [], declared: true, refused: `${unpaired} is not paired with ${m.id}` };
+  }
+  const relaxedNow = [...relax];
+  const run = await replay((j) => targetedMutationReplay(j, m, site, relaxedNow, opts), "targeted");
+  const first = run.failedSites[0];
+  if (first !== void 0 && first.where === "step" && first.postcondition && !relax.includes(`step:${first.step}`) && (target.where !== "step" || first.step < target.step)) {
+    const key2 = `step:${first.step}`;
+    return { site, relaxedSites: relax, outcome: run.outcome, failedSites: run.failedSites, declared: true, refused: `${key2} blocked the declared proof (not in relax)` };
+  }
+  if (classifyMutationPlain(target, m, run) === "sensitive") {
+    const control = await replay((j) => targetedControlReplay(j, m, relaxedNow), "control");
+    if (control.outcome !== "passed") {
+      return {
+        site,
+        relaxedSites: relax,
+        outcome: run.outcome,
+        failedSites: run.failedSites,
+        declared: true,
+        control: control.outcome,
+        refused: `the unmutated control replay with ${relax.join(", ")} relaxed did not pass (${control.outcome})`
+      };
+    }
+    return { site, relaxedSites: relax, outcome: run.outcome, failedSites: run.failedSites, declared: true, control: control.outcome };
+  }
+  return { site, relaxedSites: relax, outcome: run.outcome, failedSites: run.failedSites, declared: true };
+}
+function suggestTargetedProofPlan(proof, m) {
+  if (proof.refused !== `relaxation bound ${MAX_TARGETED_RELAXATIONS} reached`)
+    return null;
+  const first = proof.failedSites[0];
+  if (first === void 0 || first.where !== "step")
+    return null;
+  const relax = [...proof.relaxedSites, `step:${first.step}`];
+  if (relax.length > MAX_DECLARED_RELAXATIONS)
+    return null;
+  return { check: proof.site, mustFailWhen: m.id, relax };
+}
+function declaredTargetedProofFor(journey, m, siteKey) {
+  for (const plan2 of journey.metadata.targetedProofs ?? []) {
+    if (plan2.check !== siteKey)
+      continue;
+    try {
+      if (resolveMutationRef(journey, plan2.mustFailWhen).id === m.id)
+        return plan2;
+    } catch {
+    }
+  }
+  return void 0;
+}
 function needsRelaxedReplay(plan2, m, result) {
   if (result.outcome !== "failed")
     return false;
@@ -53875,8 +54123,18 @@ function needsRelaxedReplay(plan2, m, result) {
   return plan2.pairs.some((p) => p.mutation === m.id && p.site !== own2);
 }
 function classifyMutation(site, m, result) {
+  const verdict = classifyMutationPlain(site, m, result);
+  if (verdict !== "cascade")
+    return verdict;
+  const proof = result.targeted?.find((t) => t.site === assertionSiteKey(site));
+  if (proof === void 0 || proof.refused !== void 0)
+    return "cascade";
+  const targeted = classifyMutationPlain(site, m, { outcome: proof.outcome, failedSites: proof.failedSites });
+  return targeted === "sensitive" || targeted === "insensitive" ? targeted : "cascade";
+}
+function classifyMutationPlain(site, m, result) {
   if (result.relaxed !== void 0 && result.failedSites.some((f2) => f2.where === "step" && f2.step === m.step && f2.postcondition) && !(site.where === "step" && site.step === m.step)) {
-    return classifyMutation(site, m, { outcome: result.relaxed.outcome, failedSites: result.relaxed.failedSites });
+    return classifyMutationPlain(site, m, { outcome: result.relaxed.outcome, failedSites: result.relaxed.failedSites });
   }
   if (result.outcome === "passed")
     return "insensitive";
@@ -53901,18 +54159,52 @@ function classifyMutation(site, m, result) {
   return fs.some((f2) => f2.where === "end-state" && f2.index === site.index) ? "sensitive" : "cascade";
 }
 var PRECEDENCE = ["sensitive", "insensitive", "cascade", "not-applied", "error"];
+function provenSensitive(journey, m, results, key2, visiting) {
+  if (visiting.has(key2))
+    return false;
+  const site = journeyAssertions(journey).find((s3) => assertionSiteKey(s3) === key2);
+  const result = results.get(m.id) ?? { outcome: "error", failedSites: [] };
+  if (site === void 0 || classifyMutation(site, m, result) !== "sensitive")
+    return false;
+  const proof = result.targeted?.find((t) => t.site === key2);
+  if (proof === void 0 || proof.refused !== void 0)
+    return true;
+  const next = /* @__PURE__ */ new Set([...visiting, key2]);
+  return proof.relaxedSites.every((relaxed2) => provenSensitive(journey, m, results, relaxed2, next));
+}
 function judgeAssertions(journey, plan2, results) {
+  const proofFor = (m, key2) => results.get(m.id)?.targeted?.find((t) => t.site === key2);
   return journeyAssertions(journey).map((site) => {
     const key2 = assertionSiteKey(site);
     const paired = plan2.mutations.filter((m) => plan2.pairs.some((p) => p.site === key2 && p.mutation === m.id));
     if (paired.length === 0)
       return { site: key2, verdict: "unpaired" };
     const verdicts = paired.map((m) => ({ m, v: classifyMutation(site, m, results.get(m.id) ?? { outcome: "error", failedSites: [] }) }));
+    let unsound;
     for (const v of PRECEDENCE) {
       const first = verdicts.find((x) => x.v === v);
-      if (first === void 0)
+      if (first === void 0 && !(v === "cascade" && unsound !== void 0))
         continue;
-      return v === "sensitive" ? { site: key2, verdict: v, provedBy: first.m.id } : { site: key2, verdict: v };
+      if (v === "sensitive") {
+        for (const { m } of verdicts.filter((x) => x.v === "sensitive")) {
+          const proof = proofFor(m, key2);
+          if (proof === void 0 || proof.refused !== void 0)
+            return { site: key2, verdict: v, provedBy: m.id };
+          const bad = proof.relaxedSites.find((relaxed2) => !provenSensitive(journey, m, results, relaxed2, /* @__PURE__ */ new Set([key2])));
+          if (bad === void 0)
+            return { site: key2, verdict: v, provedBy: m.id, relaxedSites: proof.relaxedSites };
+          unsound ??= `relaxed site ${bad} is not itself proven sensitive to ${m.id}`;
+        }
+        continue;
+      }
+      if (v === "cascade" && unsound !== void 0)
+        return { site: key2, verdict: v, targetedRefusal: unsound };
+      if (v === "cascade") {
+        const refusal = paired.map((m) => proofFor(m, key2)).find((t) => t !== void 0 && t.refused !== void 0);
+        if (refusal !== void 0)
+          return { site: key2, verdict: v, targetedRefusal: refusal.refused };
+      }
+      return { site: key2, verdict: v };
     }
     return { site: key2, verdict: "error" };
   });
@@ -53930,6 +54222,10 @@ function mutationProofVerdict(input2) {
     return { verdict: "insensitive" };
   if (paired.every((a) => a.verdict === "sensitive"))
     return { verdict: "proven" };
+  const refusals = input2.assertions.map((a) => a.targetedRefusal).filter((r) => r !== void 0);
+  if (refusals.length > 0) {
+    return { verdict: "inconclusive", reason: `some paired assertions were neither proven nor shown vacuous (cascade, not-applied or error); a targeted proof was refused: ${refusals[0]}` };
+  }
   return { verdict: "inconclusive", reason: "some paired assertions were neither proven nor shown vacuous (cascade, not-applied or error)" };
 }
 
@@ -54496,6 +54792,12 @@ var JourneySchema = external_exports.object({
     endState: external_exports.array(OutcomeCheckSchema).max(50).optional(),
     acceptedWeak: external_exports.object({ reason: external_exports.string().min(1), rules: external_exports.array(external_exports.string()) }).strict().optional(),
     mutationPairs: external_exports.array(external_exports.object({ check: external_exports.string().min(1).max(100), mustFailWhen: external_exports.string().min(1).max(200) }).strict()).max(100).optional(),
+    // #616: a declared targeted-proof plan; the relax list is bounded tighter than the automatic proof.
+    targetedProofs: external_exports.array(external_exports.object({
+      check: external_exports.string().min(1).max(100),
+      mustFailWhen: external_exports.string().min(1).max(200),
+      relax: external_exports.array(external_exports.string().min(1).max(60)).min(1).max(MAX_DECLARED_RELAXATIONS)
+    }).strict()).max(20).optional(),
     approval: external_exports.object({
       contentHash: external_exports.string().regex(/^[0-9a-f]{64}$/, "approval.contentHash: a sha256 hex digest"),
       at: external_exports.string().min(1),
@@ -54521,6 +54823,9 @@ var JourneySchema = external_exports.object({
   for (const issue3 of mutationPairIssues(j)) {
     ctx.addIssue({ code: "custom", path: ["metadata", "mutationPairs", issue3.index, issue3.field], message: issue3.message });
   }
+  for (const issue3 of targetedProofPlanIssues(j)) {
+    ctx.addIssue({ code: "custom", path: ["metadata", "targetedProofs", issue3.index, issue3.field], message: issue3.message });
+  }
   const declared = /* @__PURE__ */ new Set([...j.metadata.params, ...(j.metadata.parameters ?? []).map((p) => p.name)]);
   j.recording.pages.forEach((page, pi) => page.steps.forEach((rs, si) => {
     if (rs.step.kind !== "navigate")
@@ -55360,7 +55665,9 @@ var ReviewVerifySchema = external_exports.discriminatedUnion("status", [
     /** True when the Journey changed after this proof ran (the verdict is for other content). */
     stale: external_exports.boolean(),
     reason: external_exports.string().optional(),
-    summary: external_exports.record(external_exports.string(), external_exports.number())
+    summary: external_exports.record(external_exports.string(), external_exports.number()),
+    /** #616: a reviewable declared targeted-proof plan the automatic bound refused (names only). */
+    suggestedTargetedProofs: external_exports.array(external_exports.object({ check: external_exports.string(), mustFailWhen: external_exports.string(), relax: external_exports.array(external_exports.string()) }).strict()).optional()
   }).strict()
 ]);
 var DiffSchema = external_exports.object({ added: external_exports.array(external_exports.string()), removed: external_exports.array(external_exports.string()) }).strict();
@@ -55380,10 +55687,18 @@ var ReviewChangeSchema = external_exports.discriminatedUnion("kind", [
     stepIdOnly: external_exports.boolean().optional(),
     steps: DiffSchema,
     assertions: DiffSchema,
-    sideEffects: DiffSchema
+    sideEffects: DiffSchema,
+    /** #616: proof-plan changes (`metadata.mutationPairs` / `metadata.targetedProofs`); omitted when neither side declares any. */
+    proofPlans: DiffSchema.optional()
   }).strict()
 ]);
-var ReviewAttentionSchema = external_exports.object({ severity: external_exports.enum(["warn", "info"]), text: external_exports.string(), hint: external_exports.string().optional() }).strict();
+var ReviewAttentionSchema = external_exports.object({
+  severity: external_exports.enum(["warn", "info"]),
+  text: external_exports.string(),
+  hint: external_exports.string().optional(),
+  /** #608: a person's catalog approval settles this item — readiness lists it as awaiting-human, never as a failure. */
+  settledBy: external_exports.enum(["catalog-approval"]).optional()
+}).strict();
 var JourneyReviewSchema = external_exports.object({
   id: external_exports.string(),
   name: external_exports.string(),
@@ -55419,6 +55734,8 @@ var JourneyReviewSchema = external_exports.object({
     endStateText: external_exports.array(external_exports.string()).optional(),
     lint: external_exports.object({ errors: external_exports.number().int(), warnings: external_exports.number().int(), findings: external_exports.array(ReviewLintFindingSchema) }).strict(),
     acceptedWeak: external_exports.object({ reason: external_exports.string(), rules: external_exports.array(external_exports.string()) }).strict().optional(),
+    /** #616: the declared targeted-proof plans (`metadata.targetedProofs`) a reviewer approves with the Journey. Additive. */
+    targetedProofs: external_exports.array(external_exports.object({ check: external_exports.string(), mustFailWhen: external_exports.string(), relax: external_exports.array(external_exports.string()) }).strict()).optional(),
     verify: ReviewVerifySchema
   }).strict(),
   changeSinceApproval: ReviewChangeSchema,
@@ -62390,9 +62707,9 @@ function hostStarvedFailure(failure3, health) {
 }
 
 // src/build-info.generated.ts
-var GENERATED_COMMIT = "ec540dd";
-var GENERATED_TREE = "d9818ad";
-var GENERATED_BUILT_AT = "2026-10-18T23:04:28.655Z";
+var GENERATED_COMMIT = "c9b33ab";
+var GENERATED_TREE = "35c694a";
+var GENERATED_BUILT_AT = "2026-10-19T23:00:10.969Z";
 
 // src/version.ts
 import { readFileSync as readFileSync5 } from "node:fs";
@@ -62414,13 +62731,13 @@ function readCliVersion() {
 
 // src/engine.ts
 function bundledCommit() {
-  return true ? "ec540dd" : void 0;
+  return true ? "c9b33ab" : void 0;
 }
 function bundledBuiltAt() {
-  return true ? "2026-10-18T23:04:28.655Z" : void 0;
+  return true ? "2026-10-19T23:00:10.969Z" : void 0;
 }
 function bundledTree() {
-  return true ? "d9818ad" : void 0;
+  return true ? "35c694a" : void 0;
 }
 function currentBuildTree() {
   return bundledTree() ?? GENERATED_TREE;
@@ -79842,9 +80159,11 @@ function renderSteps(r, w, opts) {
 function renderProvesAtTheEnd(r, w, opts) {
   void opts;
   const endState = r.proof.endStateText ?? r.proof.endState;
-  if (endState.length > 0) {
+  const plans = r.proof.targetedProofs ?? [];
+  if (endState.length > 0 || plans.length > 0) {
     w.head("PROVES AT THE END", "Proves at the end");
     for (const e of endState) w.put(`${w.bullet}\u2713 `, e, w.bullet.length + 2);
+    for (const p of plans) w.put(`${w.bullet}\u21BA `, `declared targeted proof: ${p.check} against ${p.mustFailWhen} may relax ${p.relax.join(", ")}`, w.bullet.length + 2);
     w.gap();
   }
 }
@@ -79935,7 +80254,13 @@ function renderFullDetail(r, w, opts) {
     w.put(w.bullet, `Approved${c.approvedAt === void 0 ? "" : ` ${humanTime(c.approvedAt)}`} as ${nb(w.code(c.approvedHash))}${c.kind === "snapshot-missing" ? "; its snapshot is missing" : ""} \u2014 ${c.changed ? "CHANGED since" : "unchanged since"}`);
     if (c.stepIdOnly === true) w.put(w.bullet, STEP_ID_ONLY_LABEL);
     if (c.kind === "diff") {
-      for (const [label2, d] of [["Steps", c.steps], ["Assertions", c.assertions], ["Side effects", c.sideEffects]]) {
+      const blocks = [
+        ["Steps", c.steps],
+        ["Assertions", c.assertions],
+        ["Side effects", c.sideEffects]
+      ];
+      if (c.proofPlans !== void 0) blocks.push(["Proof plans", c.proofPlans]);
+      for (const [label2, d] of blocks) {
         if (d.added.length === 0 && d.removed.length === 0) continue;
         w.put(w.bullet, `${label2}:`);
         for (const l2 of d.removed) w.put(`${w.bullet}  `, `\u2212 ${l2}`, w.bullet.length + 4);
@@ -80216,6 +80541,8 @@ function buildChange(journey, hash3, snapshot2, stepIdOnly) {
   }
   const approvedHash = journeyReviewHash(snapshot2);
   const approvedAt = approval?.at ?? snapshot2.metadata.approval?.at;
+  const beforePlans = proofPlanLines(snapshot2);
+  const afterPlans = proofPlanLines(journey);
   return {
     kind: "diff",
     approvedHash,
@@ -80224,7 +80551,9 @@ function buildChange(journey, hash3, snapshot2, stepIdOnly) {
     ...idOnly,
     steps: multisetDiff(stepLines(snapshot2), stepLines(journey)),
     assertions: multisetDiff(assertionLines(snapshot2), assertionLines(journey)),
-    sideEffects: multisetDiff(sideEffectLines(snapshot2), sideEffectLines(journey))
+    sideEffects: multisetDiff(sideEffectLines(snapshot2), sideEffectLines(journey)),
+    // #616: only present when a side declares a proof plan, so an unrelated diff stays as before.
+    ...beforePlans.length === 0 && afterPlans.length === 0 ? {} : { proofPlans: multisetDiff(beforePlans, afterPlans) }
   };
 }
 function stepLines(j) {
@@ -80236,6 +80565,12 @@ function assertionLines(j) {
     ...journeyAssertions(j).filter((s3) => s3.where === "step-request").map((s3) => `step request: ${describeCheck(s3.check)}`)
   ];
 }
+function proofPlanLines(j) {
+  return [
+    ...(j.metadata.mutationPairs ?? []).map((p) => `mutation pair: ${p.check} must fail when ${p.mustFailWhen}`),
+    ...(j.metadata.targetedProofs ?? []).map((p) => `targeted proof: ${p.check} against ${p.mustFailWhen} may relax ${p.relax.join(", ")}`)
+  ];
+}
 function sideEffectLines(j) {
   return [
     ...[...new Set(buildWriteRequests(j).map((w) => `write ${w.method} ${w.endpoint}`))],
@@ -80273,7 +80608,8 @@ function buildVerify(journey, hash3, rec) {
     // #523: an executable-content change stales the proof; an old record without it compares the full hash.
     stale: rec.proofHash === void 0 ? rec.contentHash !== hash3 : rec.proofHash !== journeyProofHash(journey),
     ...rec.reason === void 0 ? {} : { reason: rec.reason },
-    summary: { ...rec.summary }
+    summary: { ...rec.summary },
+    ...rec.suggestedTargetedProofs === void 0 ? {} : { suggestedTargetedProofs: rec.suggestedTargetedProofs.map((p) => ({ ...p, relax: [...p.relax] })) }
   };
 }
 function buildJourneyReview(journey, ctx = {}) {
@@ -80351,6 +80687,8 @@ function buildJourneyReview(journey, ctx = {}) {
         findings: findings.map((f2) => ({ rule: f2.rule, level: f2.level, ...f2.step === void 0 ? {} : { step: f2.step }, message: f2.message }))
       },
       ...m.acceptedWeak === void 0 ? {} : { acceptedWeak: { reason: m.acceptedWeak.reason, rules: [...m.acceptedWeak.rules] } },
+      // #616: the declared targeted-proof plans, copied out of the metadata for review.
+      ...m.targetedProofs === void 0 || m.targetedProofs.length === 0 ? {} : { targetedProofs: m.targetedProofs.map((p) => ({ check: p.check, mustFailWhen: p.mustFailWhen, relax: [...p.relax] })) },
       verify: buildVerify(journey, hash3, ctx.lastVerify)
     },
     changeSinceApproval: buildChange(journey, hash3, ctx.approvedSnapshot, ctx.stepIdOnly === true),
@@ -80381,7 +80719,7 @@ function describeFile(step) {
 }
 function buildAttention(r, weakEndState, goal) {
   const out = [];
-  const warn = (text2, hint2) => void out.push({ severity: "warn", text: text2, ...hint2 === void 0 ? {} : { hint: hint2 } });
+  const warn = (text2, hint2, settledBy) => void out.push({ severity: "warn", text: text2, ...hint2 === void 0 ? {} : { hint: hint2 }, ...settledBy === void 0 ? {} : { settledBy } });
   const info = (text2, hint2) => void out.push({ severity: "info", text: text2, ...hint2 === void 0 ? {} : { hint: hint2 } });
   const weakSteps = [...new Set(r.proof.stepAssertions.filter((a) => a.weak).map((a) => a.step))];
   if (weakSteps.length === 1) warn(`Step ${stepRanges(weakSteps)} proves nothing: its check passes even if the step fails`);
@@ -80402,12 +80740,12 @@ function buildAttention(r, weakEndState, goal) {
     else info(`${text2}, exempted by allowControl`);
   }
   if (r.catalog !== void 0) {
-    if (r.catalog.unvetted.length > 0) warn(`Unvetted catalog links: ${r.catalog.unvetted.join(", ")}`, `approve them, or promote with --accept-unvetted "<reason>"`);
+    if (r.catalog.unvetted.length > 0) warn(`Unvetted catalog links: ${r.catalog.unvetted.join(", ")}`, `approve them, or promote with --accept-unvetted "<reason>"`, "catalog-approval");
     if (r.catalog.needsReReview.length > 0) warn(`Catalog links need re-review: ${r.catalog.needsReReview.join("; ")}`);
   }
   for (const f2 of r.findings ?? []) {
     if (f2.analyzer === "catalog-analysis") continue;
-    if (f2.severity !== "info") warn(f2.message, f2.fix);
+    if (f2.severity !== "info") warn(f2.message, f2.fix, f2.analyzer === "catalog-links" && f2.code === "journey.unvetted" ? "catalog-approval" : void 0);
     else if (f2.analyzer === "readiness" || f2.analyzer === "readiness-jev") info(f2.message, f2.fix);
   }
   const c = r.changeSinceApproval;
@@ -94594,6 +94932,7 @@ var JourneyOutcomeChecks = class {
   async #judge(s3, fallback) {
     const window2 = s3.capture ?? fallback;
     if (window2 === void 0) return [];
+    const ownCapture = s3.capture !== void 0;
     const since = s3.startedAt;
     const until = s3.until;
     const out = [];
@@ -94602,7 +94941,7 @@ var JourneyOutcomeChecks = class {
         await evaluateNetworkCheckAwaiting(
           c,
           () => ({
-            requests: window2.sent().filter((q) => (since === void 0 || q.startedAt !== void 0 && q.startedAt >= since) && (until === void 0 || q.startedAt !== void 0 && q.startedAt <= until)),
+            requests: window2.sent().filter((q) => (ownCapture || since === void 0 || q.startedAt !== void 0 && q.startedAt >= since) && (until === void 0 || q.startedAt !== void 0 && q.startedAt <= until)),
             truncated: window2.truncated
           }),
           s3.responseTimeoutMs ?? this.#responseTimeoutMs
@@ -95099,7 +95438,8 @@ async function runJourneyProgrammatically(opts, mutation2 = {}) {
       let result;
       let runSecrets2 = secrets;
       try {
-        const raw = await outcomeChecks.run(actor, () => runner.run({ journey: replayed, params, policy }));
+        const replayParams = replayed === journey ? params : prefixParams(journey, replayed, params);
+        const raw = await outcomeChecks.run(actor, () => runner.run({ journey: replayed, params: replayParams, policy }));
         runSecrets2 = runSecretValues(secrets, raw);
         result = redactSecretValues(raw, runSecrets2);
       } finally {
@@ -108463,6 +108803,9 @@ function redactReason(reason, params, names = TEXT_PARAMS) {
   }
   return out;
 }
+function redactProducerParams(reason, params) {
+  return params === void 0 ? reason : redactReason(reason, params, Object.keys(params));
+}
 function chainSucceeded(result) {
   return result.unmatched.length === 0 && result.runs.every((run) => run.outcome === "ok");
 }
@@ -108553,10 +108896,10 @@ async function runHandoffChain(inputs, outputs, fromJourney, fromOutput, request
         ...identity,
         outcome: result.outcome,
         ...stamp,
-        ..."reason" in result ? { reason: redactReason(result.reason, params, redactors) } : {}
+        ..."reason" in result ? { reason: redactProducerParams(redactReason(result.reason, params, redactors), opts.params) } : {}
       });
     } catch (err) {
-      runs.push({ ...identity, outcome: "error", ...stamp, reason: redactReason(err instanceof Error ? err.message : String(err), params, redactors) });
+      runs.push({ ...identity, outcome: "error", ...stamp, reason: redactProducerParams(redactReason(err instanceof Error ? err.message : String(err), params, redactors), opts.params) });
     }
   }
   return { from: { journey: opts.from, outcome: "ok", records: records.length }, runs, unmatched, rejected };
@@ -108568,9 +108911,15 @@ async function runJourneyChain(opts, deps = {}) {
   const toJourney = await registry3.get(opts.to);
   if (toJourney === null) throw new UnknownJourneyError(`unknown journey '${opts.to}'`);
   const inputs = toJourney.metadata.inputs;
-  const needsFrom = inputs !== void 0 || opts.requirePromoted === true;
-  const fromJourney = needsFrom ? await registry3.get(opts.from) : null;
-  if (needsFrom && fromJourney === null) throw new UnknownJourneyError(`unknown journey '${opts.from}'`);
+  const fromJourney = await registry3.get(opts.from);
+  if (fromJourney === null) throw new UnknownJourneyError(`unknown journey '${opts.from}'`);
+  const producerParams = { ...opts.params ?? {} };
+  try {
+    validateParams(journeyParamSchema(fromJourney), producerParams);
+  } catch (err) {
+    if (err instanceof ParamValidationError) throw new JourneyChainError("E_CHAIN_PARAMS", err.message);
+    throw err;
+  }
   if (opts.requirePromoted === true) {
     for (const j of [fromJourney, toJourney]) {
       if (!j.metadata.promoted) throw new JourneyChainError("E_CHAIN_NOT_PROMOTED", `journey '${j.metadata.id}' is not promoted \u2014 a chain runs promoted Journeys (journey chain --allow-draft runs drafts on the CLI)`);
@@ -108585,9 +108934,9 @@ async function runJourneyChain(opts, deps = {}) {
     handoff2 = { inputs, outputs };
   }
   const requests = handoff2 === void 0 ? parseChainRequests(opts.requests) : void 0;
-  const fromResult = await runner({ ...shared3, id: opts.from, params: {} });
+  const fromResult = await runner({ ...shared3, id: opts.from, params: producerParams });
   if (fromResult.outcome !== "ok") {
-    const reason = "reason" in fromResult ? fromResult.reason : void 0;
+    const reason = "reason" in fromResult ? redactProducerParams(fromResult.reason, opts.params) : void 0;
     throw new JourneyChainError(
       "E_CHAIN_FROM_FAILED",
       `discover Journey '${opts.from}' did not run ok (${fromResult.outcome})${reason === void 0 ? "" : `: ${reason}`}`
@@ -108621,10 +108970,10 @@ async function runJourneyChain(opts, deps = {}) {
         commentId: request.commentId,
         account: request.account,
         outcome: result.outcome,
-        ..."reason" in result ? { reason: redactReason(result.reason, mapped.params) } : {}
+        ..."reason" in result ? { reason: redactProducerParams(redactReason(result.reason, mapped.params), opts.params) } : {}
       });
     } catch (err) {
-      runs.push({ commentId: request.commentId, account: request.account, outcome: "error", reason: redactReason(err instanceof Error ? err.message : String(err), mapped.params) });
+      runs.push({ commentId: request.commentId, account: request.account, outcome: "error", reason: redactProducerParams(redactReason(err instanceof Error ? err.message : String(err), mapped.params), opts.params) });
     }
   }
   return { from: { journey: opts.from, outcome: "ok", records: count }, runs, unmatched };
@@ -108632,12 +108981,12 @@ async function runJourneyChain(opts, deps = {}) {
 
 // src/journey-cli/chain.ts
 function registerJourneyChain(journey, program2, deps) {
-  withReplayAllowFlag(withEnvironmentFlags(withBrowserLaunchFlags(withEmulationFlags(withProjectFlags(journey.command("chain")))))).requiredOption("--from <id>", "the discover Journey, run once to produce the records").requiredOption("--to <id>", "the prepare-only reply Journey, run once per matched request").requiredOption("--requests <file>", "JSON Lines file of approved requests ({commentId, account, replyText})").option("--dir <path>", DEPRECATED_DIR_HELP).option("--storage-state <file>", "Playwright storageState JSON to start each run authenticated; must exist").option("--allow-draft", "also run Journeys that are not promoted (authoring); without it both must be promoted").option("--json", "emit a JSON envelope").action(async function() {
+  withReplayAllowFlag(withEnvironmentFlags(withBrowserLaunchFlags(withEmulationFlags(withProjectFlags(journey.command("chain")))))).requiredOption("--from <id>", "the discover Journey, run once to produce the records").requiredOption("--to <id>", "the prepare-only reply Journey, run once per matched request").requiredOption("--requests <file>", "JSON Lines file of approved requests ({commentId, account, replyText})").option("--param <kv>", "param as key=value (repeatable)", collectParam, {}).option("--dir <path>", DEPRECATED_DIR_HELP).option("--storage-state <file>", "Playwright storageState JSON to start each run authenticated; must exist").option("--allow-draft", "also run Journeys that are not promoted (authoring); without it both must be promoted").option("--json", "emit a JSON envelope").action(async function() {
     const locationFlags = this.opts();
     const layout = journeyLayout(program2, deps, { dir: locationFlags.dir, project: locationFlags.project, journeysDir: locationFlags.journeysDir });
     if (layout === null) return;
     const chainJourneysDir = layout.journeysDir;
-    const { from, to, requests: requestsFile, storageState: storageStateFlag, json: json2, allowDraft } = this.opts();
+    const { from, to, requests: requestsFile, storageState: storageStateFlag, json: json2, allowDraft, param } = this.opts();
     const { env: envName, baseUrl } = this.opts();
     let environment;
     let allow;
@@ -108685,6 +109034,7 @@ function registerJourneyChain(journey, program2, deps) {
           from,
           to,
           requests,
+          ...Object.keys(param).length === 0 ? {} : { params: param },
           dir: chainJourneysDir,
           requirePromoted: allowDraft !== true,
           ...siteGate === void 0 ? {} : { siteGate },
@@ -109082,14 +109432,16 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
   const checkOf = new Map(sites.map((s3) => [assertionSiteKey(s3), describeCheck(s3.check)]));
   const plan2 = planJourneyMutations(journey, { ...lintOpts, params: opts.params });
   const mutations = [];
+  const suggested = [];
+  const seenSuggestions = /* @__PURE__ */ new Set();
   if (base.outcome === "ok") {
     const replayOpts2 = { ...lintOpts, params: opts.params };
-    const replay = async (m, describe6) => {
+    const runReplay = async (m, describe6) => {
       try {
-        const how = describe6(journey, m, replayOpts2);
+        const how = describe6(journey);
         const r = await run(how.params === void 0 ? runOpts : { ...runOpts, params: { ...how.params } }, {
           structuredFailures: true,
-          ...how.journey === journey ? {} : { mutateJourney: (j) => describe6(j, m, replayOpts2).journey },
+          ...how.journey === journey ? {} : { mutateJourney: (j) => describe6(j).journey },
           ...how.skipIndex === void 0 ? {} : { skipStep: (i) => i === how.skipIndex },
           ...how.swapSelectAtStep === void 0 ? {} : { selectAlternativeAtStep: how.swapSelectAtStep },
           ...how.blockIndex === void 0 ? {} : { blockWritesAtStep: how.blockIndex }
@@ -109117,9 +109469,30 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
         return { outcome: "error", failedSites: [], reason: err instanceof Error ? err.message : String(err) };
       }
     };
+    const replay = (m, describe6) => runReplay(m, (j) => describe6(j, m, replayOpts2));
+    const siteByKey = new Map(sites.map((s3) => [assertionSiteKey(s3), s3]));
     for (const m of plan2.mutations) {
       const first = await replay(m, mutationReplay);
       const relaxed2 = needsRelaxedReplay(plan2, m, first) ? await replay(m, relaxedMutationReplay) : void 0;
+      const initial = { outcome: first.outcome, failedSites: first.failedSites, ...relaxed2 === void 0 ? {} : { relaxed: relaxed2 } };
+      const targeted = [];
+      for (const pair of plan2.pairs) {
+        if (pair.mutation !== m.id) continue;
+        const site = siteByKey.get(pair.site);
+        if (site === void 0 || classifyMutation(site, m, initial) !== "cascade") continue;
+        const declared = declaredTargetedProofFor(journey, m, pair.site);
+        targeted.push(
+          declared === void 0 ? await runTargetedProof(journey, plan2, m, site, initial, (describe6) => runReplay(m, describe6), replayOpts2) : await runDeclaredTargetedProof(journey, plan2, m, site, declared, (describe6) => runReplay(m, describe6), replayOpts2)
+        );
+        const suggestion = suggestTargetedProofPlan(targeted[targeted.length - 1], m);
+        if (suggestion !== null) {
+          const key2 = `${suggestion.check}\0${suggestion.mustFailWhen}\0${suggestion.relax.join(",")}`;
+          if (!seenSuggestions.has(key2)) {
+            seenSuggestions.add(key2);
+            suggested.push(suggestion);
+          }
+        }
+      }
       mutations.push({
         kind: m.kind,
         step: m.step,
@@ -109127,15 +109500,30 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
         ...m.param === void 0 ? {} : { param: m.param },
         ...m.source === void 0 ? {} : { source: m.source },
         ...first,
-        ...relaxed2 === void 0 ? {} : { relaxed: relaxed2 }
+        ...relaxed2 === void 0 ? {} : { relaxed: relaxed2 },
+        ...targeted.length === 0 ? {} : { targeted }
       });
     }
   }
   const results = new Map(
-    mutations.map((m) => [m.id, { outcome: m.outcome, failedSites: m.failedSites, ...m.relaxed === void 0 ? {} : { relaxed: m.relaxed } }])
+    mutations.map((m) => [
+      m.id,
+      { outcome: m.outcome, failedSites: m.failedSites, ...m.relaxed === void 0 ? {} : { relaxed: m.relaxed }, ...m.targeted === void 0 ? {} : { targeted: m.targeted } }
+    ])
   );
   const judged = judgeAssertions(journey, plan2, results);
-  const assertions = judged.map((a) => ({ site: a.site, check: checkOf.get(a.site) ?? a.site, verdict: a.verdict, ...a.provedBy === void 0 ? {} : { provedBy: a.provedBy } }));
+  const assertions = judged.map((a) => ({
+    site: a.site,
+    check: checkOf.get(a.site) ?? a.site,
+    verdict: a.verdict,
+    ...a.provedBy === void 0 ? {} : { provedBy: a.provedBy },
+    ...a.relaxedSites === void 0 ? {} : { relaxedSites: a.relaxedSites },
+    ...a.targetedRefusal === void 0 ? {} : { targetedRefusal: a.targetedRefusal },
+    // #616: the proving proof was a declared plan, not the automatic relaxation search.
+    ...a.provedBy !== void 0 && results.get(a.provedBy)?.targeted?.some((t) => t.site === a.site && t.declared === true) === true ? { declaredProof: true } : {}
+  }));
+  const order = new Map(journeyAssertions(journey).map((s3, i) => [assertionSiteKey(s3), i]));
+  const siteOrder = (key2) => order.get(key2) ?? Number.MAX_SAFE_INTEGER;
   const { verdict, reason } = mutationProofVerdict({ basePassed: base.outcome === "ok", mutations, assertions: judged });
   const count = (v) => assertions.filter((a) => a.verdict === v).length;
   const report2 = {
@@ -109152,8 +109540,12 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
       cascade: count("cascade"),
       notApplied: count("not-applied"),
       error: count("error"),
-      unpaired: count("unpaired")
-    }
+      unpaired: count("unpaired"),
+      // #609: assertions proven sensitive through a targeted proof that relaxed earlier sites.
+      targeted: assertions.filter((a) => (a.relaxedSites?.length ?? 0) > 0).length
+    },
+    // #616: in assertion order, so the first suggestion is the one for the refusal the verdict quotes.
+    ...suggested.length === 0 ? {} : { suggestedTargetedProofs: [...suggested].sort((a, b2) => siteOrder(a.check) - siteOrder(b2.check)) }
   };
   const redacted = redactSecretParams(report2, journey, opts.params);
   await writeVerifyRecord(opts.dir, {
@@ -109163,12 +109555,16 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
     verdict: redacted.verdict,
     ...redacted.reason === void 0 ? {} : { reason: redacted.reason },
     summary: { ...redacted.summary },
+    ...redacted.suggestedTargetedProofs === void 0 ? {} : { suggestedTargetedProofs: redacted.suggestedTargetedProofs },
     at: clock.nowIso()
   });
   return redacted;
 }
 function verifyAssertionLine(a) {
-  return `${a.verdict.padEnd(11)}  ${a.site.padEnd(18)}  ${a.check}${a.provedBy === void 0 ? "" : `  (proved by ${a.provedBy})`}`;
+  const relaxed2 = a.relaxedSites === void 0 || a.relaxedSites.length === 0 ? "" : a.declaredProof === true ? `, declared plan relaxed ${a.relaxedSites.join(", ")}` : `, relaxed ${a.relaxedSites.join(", ")}`;
+  const proved = a.provedBy === void 0 ? "" : `  (proved by ${a.provedBy}${relaxed2})`;
+  const refused = a.targetedRefusal === void 0 ? "" : `  (targeted proof refused: ${a.targetedRefusal})`;
+  return `${a.verdict.padEnd(11)}  ${a.site.padEnd(18)}  ${a.check}${proved}${refused}`;
 }
 
 // src/journey-readiness.ts
@@ -109181,7 +109577,7 @@ var ReadinessError = class extends Error {
   }
 };
 var REQUIRED_PROOF_CHECK = "proof";
-function resolveTarget2(opts, deps, required2) {
+function resolveTarget2(opts, deps, required2, declared) {
   let environment;
   if (opts.env !== void 0 || opts.baseUrl !== void 0) {
     environment = environmentFromFlags(
@@ -109199,6 +109595,10 @@ function resolveTarget2(opts, deps, required2) {
   if (missing.length > 0) {
     throw new ReadinessError("E_READINESS_PARAMS", `missing required param(s): ${missing.join(", ")}`);
   }
+  const unknown2 = Object.keys(opts.params ?? {}).filter((name) => !declared.includes(name));
+  if (unknown2.length > 0) {
+    throw new ReadinessError("E_READINESS_PARAMS", `unknown param(s): ${unknown2.join(", ")}`);
+  }
   return environment;
 }
 function requiredParams(journey, pair, hasRequests) {
@@ -109241,7 +109641,7 @@ function boundaryCheck(ctx) {
   return ctx.journey.metadata.boundary === void 0 ? { check: "boundary", journey: ctx.id, state: "not-run", detail: "no prepare-only boundary declared" } : { check: "boundary", journey: ctx.id, state: "pass", detail: "a prepare-only boundary is declared" };
 }
 function reviewStrictCheck(ctx) {
-  const warns = (ctx.review.attention ?? []).filter((a) => a.severity === "warn");
+  const warns = (ctx.review.attention ?? []).filter((a) => a.severity === "warn" && !(a.settledBy === "catalog-approval" && ctx.review.catalog !== void 0));
   if (warns.length > 0) {
     return {
       check: { check: "review-strict", journey: ctx.id, state: "fail", detail: warns.map((a) => a.text).join("; ") },
@@ -109308,8 +109708,10 @@ function proofCheck(ctx, journeysDir, cwd) {
     };
   }
   if (verify2.verdict === "proven") {
-    const passed = Object.values(verify2.summary).reduce((a, b2) => a + b2, 0);
-    return { check: { check: "proof", journey: ctx.id, state: "pass", detail: `proven ${passed}/${passed}`, evidence } };
+    const targeted = verify2.summary.targeted ?? 0;
+    const passed = Object.entries(verify2.summary).filter(([k]) => k !== "targeted").reduce((a, [, b2]) => a + b2, 0);
+    const detail = targeted === 0 ? `proven ${passed}/${passed}` : `proven ${passed}/${passed}, ${targeted} through a targeted proof (earlier defenses relaxed one at a time; see the verify report)`;
+    return { check: { check: "proof", journey: ctx.id, state: "pass", detail, evidence } };
   }
   if (verify2.verdict === "insensitive") {
     return {
@@ -109320,10 +109722,36 @@ function proofCheck(ctx, journeysDir, cwd) {
   if (nothingToMutate(ctx.journey, verify2.summary)) {
     return { check: { check: "proof", journey: ctx.id, state: "pass", detail: "read-only with no inputs: nothing a mutation could break", evidence } };
   }
-  return { check: { check: "proof", journey: ctx.id, state: "inconclusive", detail: verify2.reason ?? `proof verdict ${verify2.verdict}`, evidence } };
+  const suggested = verify2.status === "recorded" ? verify2.suggestedTargetedProofs : void 0;
+  return {
+    check: { check: "proof", journey: ctx.id, state: "inconclusive", detail: verify2.reason ?? `proof verdict ${verify2.verdict}`, evidence },
+    blocker: { check: "proof", journey: ctx.id, why: inconclusiveProofGuidance(verify2.reason ?? "", suggested), next: `jevitate journey verify ${ctx.id} --mutate` }
+  };
+}
+var TARGETED_REFUSAL_MARKER = "a targeted proof was refused: ";
+function inconclusiveProofGuidance(reason, suggested) {
+  const at3 = reason.indexOf(TARGETED_REFUSAL_MARKER);
+  if (at3 < 0) return "inspect the cascade assertions in the verify report";
+  const refusal = reason.slice(at3 + TARGETED_REFUSAL_MARKER.length).trim();
+  const unpaired = /^(\S+) is not paired with (\S+)$/.exec(refusal);
+  if (unpaired !== null) {
+    return `declare the earlier check ${unpaired[1]} as a defense of ${unpaired[2]} with a metadata.mutationPairs entry {check:'${unpaired[1]}', mustFailWhen:'${unpaired[2]}'}, then re-run verify`;
+  }
+  const bound2 = /relaxation bound (\d+)/.exec(refusal);
+  if (bound2 !== null) {
+    const first = suggested?.[0];
+    const plan2 = first === void 0 ? `declare a metadata.targetedProofs plan (at most ${MAX_DECLARED_RELAXATIONS} earlier postconditions)` : `declare exactly this metadata.targetedProofs entry: ${JSON.stringify(first)} \u2014 a human reviews it like any other proof change (the review hash changes, so the Journey needs re-approval)`;
+    return `${plan2}, then re-run verify (relaxation bound ${bound2[1]})`;
+  }
+  const blocked = /^(\S+) blocked the declared proof \(not in relax\)$/.exec(refusal);
+  if (blocked !== null) return `add ${blocked[1]} to that plan's relax list (metadata.targetedProofs), then re-run verify`;
+  const unsound = /^relaxed site (\S+) is not itself proven sensitive to (\S+)$/.exec(refusal);
+  if (unsound !== null) return `pair ${unsound[1]} with ${unsound[2]} (metadata.mutationPairs) or make it a real defense, then re-run verify`;
+  if (refusal.includes("action failed")) return "the mutated value makes an earlier action impossible, so that target cannot be proven independently \u2014 keep the check; it stays inconclusive by design";
+  return "inspect the cascade assertions in the verify report";
 }
 function nothingToMutate(journey, summary2) {
-  const paired = Object.entries(summary2).filter(([k]) => k !== "unpaired").reduce((n3, [, v]) => n3 + v, 0);
+  const paired = Object.entries(summary2).filter(([k]) => k !== "unpaired" && k !== "targeted").reduce((n3, [, v]) => n3 + v, 0);
   return (summary2.unpaired ?? 0) > 0 && paired === 0 && journeyWriteSteps(journey).length === 0 && journeyParamSchema(journey).required.length === 0;
 }
 function relativeEvidence(cwd, path2) {
@@ -109409,21 +109837,38 @@ async function runJourneyReadiness(opts, deps = {}) {
   const pair = opts.with !== void 0;
   let environment;
   let replay;
+  let boundConsumerParams;
   if (mode !== "report") {
-    environment = resolveTarget2(opts, deps, requiredParams(contexts[0].journey, pair, opts.requests !== void 0));
+    const producerSchema = journeyParamSchema(contexts[0].journey).required;
+    environment = resolveTarget2(opts, deps, requiredParams(contexts[0].journey, pair, opts.requests !== void 0), producerSchema);
     const params = { ...opts.params ?? {} };
     try {
       if (pair) {
-        const chained = await chain({
-          from: opts.id,
-          to: opts.with,
-          requests: opts.requests ?? "",
-          dir: opts.journeysDir,
-          environment,
-          ...opts.storageState === void 0 ? {} : { storageState: opts.storageState },
-          ...opts.browser === void 0 ? {} : { browser: opts.browser },
-          ...opts.browserPortFactory === void 0 ? {} : { browserPortFactory: opts.browserPortFactory }
-        });
+        const chained = await chain(
+          {
+            from: opts.id,
+            to: opts.with,
+            requests: opts.requests ?? "",
+            params: { ...opts.params ?? {} },
+            dir: opts.journeysDir,
+            environment,
+            ...opts.storageState === void 0 ? {} : { storageState: opts.storageState },
+            ...opts.browser === void 0 ? {} : { browser: opts.browser },
+            ...opts.browserPortFactory === void 0 ? {} : { browserPortFactory: opts.browserPortFactory }
+          },
+          {
+            // #608: the consumer's proof must run with the params the chain actually bound for it
+            // (record fields + request), captured from the first consumer run; names and outcomes
+            // are all the chain itself returns.
+            runJourney: async (chainOpts) => {
+              const result = await run(chainOpts);
+              if (chainOpts.id === opts.with && boundConsumerParams === void 0) {
+                boundConsumerParams = { ...chainOpts.params };
+              }
+              return result;
+            }
+          }
+        );
         replay = pairReplay(chained);
       } else {
         const result = await run({
@@ -109443,11 +109888,23 @@ async function runJourneyReadiness(opts, deps = {}) {
     }
     if (mode === "prove") {
       for (const ctx of contexts) {
+        const consumer = pair && ctx.id === opts.with;
+        if (consumer && boundConsumerParams === void 0) {
+          ctx.review = {
+            ...ctx.review,
+            proof: {
+              ...ctx.review.proof,
+              verify: { status: "not-verified", hint: `the chain bound no request for '${ctx.id}' \u2014 supply a --requests line that matches a discovered record` }
+            }
+          };
+          continue;
+        }
+        const proofParams = consumer ? boundConsumerParams : params;
         try {
           await verify2({
             dir: opts.journeysDir,
             id: ctx.id,
-            params,
+            params: proofParams,
             environment,
             ...opts.storageState === void 0 ? {} : { storageState: opts.storageState },
             ...opts.browser === void 0 ? {} : { browser: opts.browser },
@@ -110800,8 +111257,9 @@ function registerJourneyVerify(journey, program2, deps) {
         for (const a of report2.assertions) out?.(`${verifyAssertionLine(a)}
 `);
         const s3 = report2.summary;
+        const targeted = s3.targeted > 0 ? `, ${s3.targeted} targeted` : "";
         out?.(
-          `${report2.verdict} \u2014 journey '${report2.journeyId}': ${s3.sensitive} sensitive, ${s3.insensitive} insensitive, ${s3.cascade} cascade, ${s3.notApplied} not applied, ${s3.error} error, ${s3.unpaired} unpaired${report2.reason === void 0 ? "" : ` (${report2.reason})`}
+          `${report2.verdict} \u2014 journey '${report2.journeyId}': ${s3.sensitive} sensitive, ${s3.insensitive} insensitive, ${s3.cascade} cascade, ${s3.notApplied} not applied, ${s3.error} error, ${s3.unpaired} unpaired${targeted}${report2.reason === void 0 ? "" : ` (${report2.reason})`}
 `
         );
       }
@@ -115046,13 +115504,14 @@ var CLI_TOOL_SPECS = [
   },
   {
     name: "chain_journeys",
-    description: "`jevitate journey chain --from <discover> --to <reply> --requests <file>` (#580): run a discover Journey once, then a prepare-only reply Journey once per approved request in the JSON Lines file ({commentId, account, replyText}) matched to a discovered record by commentId AND account. Both Journeys must be promoted. Unmatched requests never run; an empty discovery stops the chain (no target is guessed). The result names ids and outcomes only, never record or reply text. Exit 0 only when every request matched and its run was ok.",
+    description: "`jevitate journey chain --from <discover> --to <reply> --requests <file>` (#580): run a discover Journey once, then a prepare-only reply Journey once per approved request in the JSON Lines file ({commentId, account, replyText}) matched to a discovered record by commentId AND account. Both Journeys must be promoted. #608: params supplies explicit producer (discover) params, validated against the producer's schema before anything runs. Unmatched requests never run; an empty discovery stops the chain (no target is guessed). The result names ids and outcomes only, never record or reply text. Exit 0 only when every request matched and its run was ok.",
     command: {
       path: "journey chain",
       params: {
         from: s2("--from", { required: true }),
         to: s2("--to", { required: true }),
         requests: path("--requests", { required: true }),
+        params: { kind: "params", flag: "--param" },
         storageState: session("--storage-state"),
         ...EXTENSION,
         ...EMULATION,