@jevitate/cli 0.18.1 → 0.19.0

package/dist/bin.js

@@ -53836,13 +53836,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 +53867,119 @@ function relaxedMutationReplay(journey, m, opts = {}) {
   }
   return { journey: copy };
 }
+var MAX_TARGETED_RELAXATIONS = 4;
+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 };
+}
 function needsRelaxedReplay(plan2, m, result) {
   if (result.outcome !== "failed")
     return false;
@@ -53875,8 +53989,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";
@@ -53902,6 +54026,7 @@ function classifyMutation(site, m, result) {
 }
 var PRECEDENCE = ["sensitive", "insensitive", "cascade", "not-applied", "error"];
 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));
@@ -53912,7 +54037,16 @@ function judgeAssertions(journey, plan2, results) {
       const first = verdicts.find((x) => x.v === v);
       if (first === void 0)
         continue;
-      return v === "sensitive" ? { site: key2, verdict: v, provedBy: first.m.id } : { site: key2, verdict: v };
+      if (v === "sensitive") {
+        const proof = proofFor(first.m, key2);
+        return proof !== void 0 && proof.refused === void 0 ? { site: key2, verdict: v, provedBy: first.m.id, relaxedSites: proof.relaxedSites } : { site: key2, verdict: v, provedBy: first.m.id };
+      }
+      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 +54064,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)" };
 }
 
@@ -55383,7 +55521,13 @@ var ReviewChangeSchema = external_exports.discriminatedUnion("kind", [
     sideEffects: DiffSchema
   }).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(),
@@ -62390,9 +62534,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 = "0a3d2f5";
+var GENERATED_TREE = "963f59f";
+var GENERATED_BUILT_AT = "2026-10-19T17:41:04.191Z";
 
 // src/version.ts
 import { readFileSync as readFileSync5 } from "node:fs";
@@ -62414,13 +62558,13 @@ function readCliVersion() {
 
 // src/engine.ts
 function bundledCommit() {
-  return true ? "ec540dd" : void 0;
+  return true ? "0a3d2f5" : void 0;
 }
 function bundledBuiltAt() {
-  return true ? "2026-10-18T23:04:28.655Z" : void 0;
+  return true ? "2026-10-19T17:41:04.191Z" : void 0;
 }
 function bundledTree() {
-  return true ? "d9818ad" : void 0;
+  return true ? "963f59f" : void 0;
 }
 function currentBuildTree() {
   return bundledTree() ?? GENERATED_TREE;
@@ -80381,7 +80525,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 +80546,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;
@@ -95099,7 +95243,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 +108608,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 +108701,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 +108716,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 +108739,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 +108775,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 +108786,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 +108839,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 },
@@ -109084,12 +109239,12 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
   const mutations = [];
   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 +109272,19 @@ 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;
+        targeted.push(await runTargetedProof(journey, plan2, m, site, initial, (describe6) => runReplay(m, describe6), replayOpts2));
+      }
       mutations.push({
         kind: m.kind,
         step: m.step,
@@ -109127,15 +109292,26 @@ 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 }
+  }));
   const { verdict, reason } = mutationProofVerdict({ basePassed: base.outcome === "ok", mutations, assertions: judged });
   const count = (v) => assertions.filter((a) => a.verdict === v).length;
   const report2 = {
@@ -109152,7 +109328,9 @@ 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
     }
   };
   const redacted = redactSecretParams(report2, journey, opts.params);
@@ -109168,7 +109346,10 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
   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 ? "" : `, 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 +109362,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 +109380,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 +109426,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 +109493,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 +109507,27 @@ 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 } };
+  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 ?? ""), next: `jevitate journey verify ${ctx.id} --mutate` }
+  };
+}
+var TARGETED_REFUSAL_MARKER = "a targeted proof was refused: ";
+function inconclusiveProofGuidance(reason) {
+  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) return `reduce the layered checks between the mutation and the target (relaxation bound ${bound2[1]})`;
+  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 +109613,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 +109664,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 +111033,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 +115280,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,

package/dist/build-info.generated.js

@@ -5,7 +5,7 @@
 // this plain `tsc --build` dist (no bundler substitution), so it needs real committed values
 // here instead. See ./engine.ts, which prefers the esbuild-injected value when present and
 // falls back to these.
-export const GENERATED_COMMIT = "ec540dd";
-export const GENERATED_TREE = "d9818ad";
-export const GENERATED_BUILT_AT = "2026-10-18T23:04:17.587Z";
+export const GENERATED_COMMIT = "0a3d2f5";
+export const GENERATED_TREE = "963f59f";
+export const GENERATED_BUILT_AT = "2026-10-19T17:40:57.283Z";
 //# sourceMappingURL=build-info.generated.js.map

package/dist/journey-api.js

@@ -425,7 +425,11 @@ export async function runJourneyProgrammatically(opts, mutation = {}) {
             // `extract as: "apiKey"`), so the output, failures and artifacts below never carry it.
             let runSecrets = secrets;
             try {
-                const raw = await outcomeChecks.run(actor, () => runner.run({ journey: replayed, params, policy }));
+                // #609: a mutated copy may no longer name a param the stored Journey takes (a targeted proof
+                // relaxed the only check naming an assertion-only `expected_*` param). The supplied set was
+                // validated against the stored Journey above; the copy runs with the subset it still reads.
+                const replayParams = replayed === journey ? params : prefixParams(journey, replayed, params);
+                const raw = await outcomeChecks.run(actor, () => runner.run({ journey: replayed, params: replayParams, policy }));
                 runSecrets = runSecretValues(secrets, raw);
                 result = redactSecretValues(raw, runSecrets);
             }