@jevitate/cli 0.18.0 → 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 = "60df60f";
-var GENERATED_TREE = "dd8e50a";
-var GENERATED_BUILT_AT = "2026-10-18T20:33:54.995Z";
+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 ? "60df60f" : void 0;
+  return true ? "0a3d2f5" : void 0;
 }
 function bundledBuiltAt() {
-  return true ? "2026-10-18T20:33:54.995Z" : void 0;
+  return true ? "2026-10-19T17:41:04.191Z" : void 0;
 }
 function bundledTree() {
-  return true ? "dd8e50a" : 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;
@@ -94790,7 +94934,9 @@ function handbackFacts(a) {
   const failedKind = at3 === void 0 ? void 0 : /postcondition failed/.test(reason ?? "") ? "postcondition" : "other";
   return {
     outcome: a.result.outcome,
-    ...at3 === void 0 ? {} : { failedAt: at3 },
+    // `at` is the run's 0-based step index; `failedAt` names the step as a person counts it (1-based,
+    // as the run's own "step N failed" reason does).
+    ...at3 === void 0 ? {} : { failedAt: at3 + 1 },
     ...failedKind === void 0 ? {} : { failedKind },
     steps: a.steps,
     checksPassed: a.result.outcome === "ok" ? a.steps : at3 ?? 0,
@@ -95097,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 {
@@ -105344,7 +105491,14 @@ async function whoami(http, origin, key2) {
   }
   const tenant = body.tenant?.name;
   const prefix = typeof body.keyPrefix === "string" && /^jzu_[a-z2-7]{4}$/.test(body.keyPrefix) ? body.keyPrefix : key2.slice(0, 8);
-  return { product: { id: product.id, name: product.name }, tenant: typeof tenant === "string" ? tenant : "", keyPrefix: prefix };
+  const max = body.limits?.maxUploadBytes;
+  const maxUploadBytes = typeof max === "number" && Number.isSafeInteger(max) && max > 0 ? max : void 0;
+  return {
+    product: { id: product.id, name: product.name },
+    tenant: typeof tenant === "string" ? tenant : "",
+    keyPrefix: prefix,
+    ...maxUploadBytes === void 0 ? {} : { maxUploadBytes }
+  };
 }
 function processTerminal() {
   return {
@@ -105464,7 +105618,7 @@ async function resolvePublishKey(req, deps) {
     throw err;
   }
 }
-var MAX_UPLOAD_BYTES = 256 * 1024 * 1024;
+var DEFAULT_MAX_UPLOAD_BYTES = 95e6;
 var MEDIA_PATH_RE = /^media\/(?:[A-Za-z0-9][A-Za-z0-9._-]{0,63}\/(?:step-[0-9]{2,3}\.(?:png|webp)|demo\.webm|demo\.vtt)|findings\/[0-9a-f]{16}\.(?:png|webp))$/u;
 async function filesUnder(dir, base) {
   let entries;
@@ -105504,9 +105658,6 @@ async function zipBundle(outDir, bundleJson, files, key2) {
   const unlisted = (await filesUnder(join57(outDir, "media"), outDir)).filter((p) => !listed2.has(p));
   if (unlisted.length > 0) throw new JourneezeError("E_JOURNEEZE_BUNDLE", `the export wrote media the bundle does not list (${unlisted.slice(0, 3).join(", ")}) \u2014 refusing to send it`);
   const body = zipStore(entries);
-  if (body.byteLength > MAX_UPLOAD_BYTES) {
-    throw new JourneezeError("E_JOURNEEZE_BUNDLE", `the bundle with its media is ${body.byteLength} bytes \u2014 over Journeeze's ${MAX_UPLOAD_BYTES}-byte upload limit`);
-  }
   return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
 }
 async function resolveProductName(req, resolved, deps) {
@@ -105521,9 +105672,20 @@ async function resolveProductName(req, resolved, deps) {
       );
     }
   }
-  if (req.productName !== void 0) return req.productName;
-  if (resolved.fromSaved) return resolved.savedProductName;
-  return verified.product.name;
+  if (req.productName !== void 0) return { productName: req.productName, verified };
+  if (resolved.fromSaved) return { productName: resolved.savedProductName, verified };
+  return { productName: verified.product.name, verified };
+}
+async function uploadLimit(verified, resolved, deps) {
+  const info = verified ?? await whoami(deps.http ?? fetchJourneezeHttp, resolved.origin, resolved.key);
+  return info.maxUploadBytes ?? DEFAULT_MAX_UPLOAD_BYTES;
+}
+function assertUploadSize(bundle, maxUploadBytes) {
+  if (bundle.body.byteLength <= maxUploadBytes) return;
+  throw new JourneezeError(
+    "E_JOURNEEZE_BUNDLE",
+    `the bundle${bundle.contentType === "application/zip" ? " with its media" : ""} is ${bundle.body.byteLength} bytes \u2014 over Journeeze's ${maxUploadBytes}-byte upload limit; nothing was sent (approve fewer demos with media, or publish without them)`
+  );
 }
 async function buildBundle(req, deps, key2, productName) {
   const outDir = await mkdtemp4(join57(tmpdir4(), "jev-journeeze-"));
@@ -105687,8 +105849,9 @@ async function publishToJourneeze(req, deps = {}) {
   try {
     const resolved = await resolvePublishKey(req, deps);
     key2 = resolved.key;
-    const productName = await resolveProductName(req, resolved, deps);
+    const { productName, verified } = await resolveProductName(req, resolved, deps);
     const bundle = await buildBundle(req, deps, key2, productName);
+    assertUploadSize(bundle, await uploadLimit(verified, resolved, deps));
     const result = req.dryRun ? { dryRun: true, baseUrl: resolved.origin, productName, idempotencyKey: bundle.idempotencyKey, status: "dry-run", warnings: [], errors: [] } : await upload(resolved.origin, key2, bundle, productName, deps);
     const text2 = JSON.stringify(result);
     return text2.includes(key2) ? JSON.parse(redactText(text2, [key2])) : result;
@@ -107856,6 +108019,9 @@ function journeyLayout(program2, deps, flags) {
     return null;
   }
 }
+function flaggedCatalogDir(layout) {
+  return layout.from.project === "flag" || layout.from.project === "dir" ? layout.catalogDir ?? void 0 : void 0;
+}
 
 // src/journey-cli/list.ts
 function registerJourneyList(journey, program2, deps) {
@@ -108442,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");
 }
@@ -108532,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 };
@@ -108547,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)`);
@@ -108564,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}`}`
@@ -108600,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 };
@@ -108611,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;
@@ -108664,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 },
@@ -109063,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 }
@@ -109096,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,
@@ -109106,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 = {
@@ -109131,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);
@@ -109147,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
@@ -109160,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(
@@ -109178,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) {
@@ -109220,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("; ") },
@@ -109287,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 {
@@ -109296,7 +109504,31 @@ function proofCheck(ctx, journeysDir, cwd) {
       blocker: { check: "proof", journey: ctx.id, why: verify2.reason ?? "some checks cannot fail", next: `jevitate journey verify ${ctx.id} --mutate` }
     };
   }
-  return { check: { check: "proof", journey: ctx.id, state: "inconclusive", detail: verify2.reason ?? `proof verdict ${verify2.verdict}`, evidence } };
+  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 },
+    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" && 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) {
   const r = relative9(cwd, path2);
@@ -109381,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({
@@ -109415,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 },
@@ -109572,7 +109833,7 @@ function registerJourneyReadiness(journey, program2, deps) {
           ...browser === void 0 ? {} : { browser },
           browserPortFactory: deps.explore?.browserPortFactory,
           journeysDir: layout.journeysDir,
-          catalogDir: resolveCatalogDir(deps.catalogDir, layout.catalogDir ?? void 0),
+          catalogDir: resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)),
           ...deps.explore?.targetsConfigPath === void 0 ? {} : { targetsFile: deps.explore.targetsConfigPath },
           ...layout.projectDir === null ? {} : { projectDir: layout.projectDir },
           ...mode === "report" ? {} : { fixtures }
@@ -109658,21 +109919,20 @@ function inputsLines(inputs) {
   }
   return lines;
 }
-function humanCommands(entry, catalog, draft, ready) {
-  const commands = [];
-  const personaId = entry.review.catalog?.persona?.id;
-  const jobId = entry.review.catalog?.job?.id;
-  if (personaId !== void 0) {
-    const hash3 = catalog.personas.find((p) => p.id === personaId)?.contentHash;
-    commands.push(`jevitate persona approve ${personaId}${hash3 === void 0 ? "" : ` --reviewed-hash ${hash3}`}`);
+function pendingHumanSteps(entry, catalog, draft) {
+  const approvals = [];
+  const persona2 = entry.review.catalog?.persona;
+  const job = entry.review.catalog?.job;
+  if (persona2 !== void 0 && persona2.status !== "approved") {
+    const hash3 = catalog.personas.find((p) => p.id === persona2.id)?.contentHash;
+    approvals.push(`jevitate persona approve ${persona2.id}${hash3 === void 0 ? "" : ` --reviewed-hash ${hash3}`}`);
   }
-  if (jobId !== void 0) {
-    const hash3 = catalog.jobs.find((j) => j.id === jobId)?.contentHash;
-    commands.push(`jevitate job approve ${jobId}${hash3 === void 0 ? "" : ` --reviewed-hash ${hash3}`}`);
+  if (job !== void 0 && job.status !== "approved") {
+    const hash3 = catalog.jobs.find((j) => j.id === job.id)?.contentHash;
+    approvals.push(`jevitate job approve ${job.id}${hash3 === void 0 ? "" : ` --reviewed-hash ${hash3}`}`);
   }
-  if (draft) commands.push(`jevitate journey annotate ${entry.id} --approve`);
-  if (ready) commands.push(`jevitate journey promote ${entry.id} --reviewed-hash ${entry.review.contentHash}`);
-  return commands;
+  if (draft) approvals.push(`jevitate journey annotate ${entry.id} --approve`);
+  return { approvals, promote: journeyApprovalLabel(entry) === "current authorization" ? null : entry.id };
 }
 function journeySection(entry, receipt) {
   const m = entry.journey.metadata;
@@ -109721,14 +109981,21 @@ function renderJourneyBundle(receipt, entries, catalog, drafts) {
     lines.push(...journeySection(entry, receipt), "");
   }
   const ready = receipt.verdict === "technically-ready";
-  lines.push("## Human-only commands", "");
+  const approvals = [];
+  const promotes = [];
   for (const entry of entries) {
-    for (const command of humanCommands(entry, catalog, drafts.has(entry.id), ready)) lines.push(`- ${command}`);
+    const pending = pendingHumanSteps(entry, catalog, drafts.has(entry.id));
+    for (const command of pending.approvals) if (!approvals.includes(command)) approvals.push(command);
+    if (pending.promote !== null) promotes.push(entry);
   }
-  if (!ready) {
+  lines.push("## Human-only commands", "");
+  const now2 = [...approvals, ...ready ? promotes.map((e) => `jevitate journey promote ${e.id} --reviewed-hash ${e.review.contentHash}`) : []];
+  if (now2.length === 0 && (ready || promotes.length === 0)) lines.push("Nothing is waiting for a person: every linked persona and job is approved and every Journey is promoted with a current approval.");
+  for (const command of now2) lines.push(`- ${command}`);
+  if (!ready && promotes.length > 0) {
     lines.push("");
     lines.push("## After the blockers are fixed", "");
-    for (const entry of entries) lines.push(`- jevitate journey promote ${entry.id}`);
+    for (const entry of promotes) lines.push(`- jevitate journey promote ${entry.id}`);
   }
   lines.push("");
   return `${lines.join("\n")}
@@ -109826,7 +110093,7 @@ function registerJourneyBundle(journey, program2, deps) {
     const layout = journeyLayout(program2, deps, { dir: locationFlags.dir, project: locationFlags.project, journeysDir: locationFlags.journeysDir });
     if (layout === null) return;
     const { with: withId, out, check: check3, json: json2 } = this.opts();
-    const catalogDir = resolveCatalogDir(deps.catalogDir, layout.catalogDir ?? void 0);
+    const catalogDir = resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout));
     const location = { journeysDir: layout.journeysDir, catalogDir, ...targetsOpts(deps) };
     const bundleDeps = { cwd: () => process.cwd() };
     if (check3 !== void 0) {
@@ -109946,10 +110213,10 @@ function registerJourneyPromote(journey, program2, deps) {
         }
         reviewedHash = fromSheet;
       }
-      const jev = await jevSetupFor(deps, resolveCatalogDir(deps.catalogDir), { real, jevProvider });
+      const jev = await jevSetupFor(deps, resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)), { real, jevProvider });
       let attention;
       if (!json2) {
-        const { review } = await reviewJourneyById(journeysDir, id, { ...targetsOpts(deps), catalogDir: resolveCatalogDir(deps.catalogDir), readiness: true, jev, action: "journey promote" });
+        const { review } = await reviewJourneyById(journeysDir, id, { ...targetsOpts(deps), catalogDir: resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)), readiness: true, jev, action: "journey promote" });
         program2.configureOutput().writeOut?.(`${renderReviewText(review, reviewRenderOptions({ full: full === true }))}
 `);
         attention = review.attention;
@@ -109962,7 +110229,7 @@ function registerJourneyPromote(journey, program2, deps) {
         ...reviewedHash === void 0 ? {} : { reviewedHash },
         ...acceptUnvetted === void 0 ? {} : { acceptUnvetted },
         ...acceptFindings === void 0 ? {} : { acceptFindings },
-        catalogDir: resolveCatalogDir(deps.catalogDir),
+        catalogDir: resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)),
         // #437: a typed confirmation on a TTY (or the escape hatch, or the MCP channel), recorded as provenance.
         confirm: /* @__PURE__ */ ((confirm2) => (request) => confirm2(attention === void 0 ? request : { ...request, attention }))(
           makeApprovalConfirm(deps.approval, nonInteractiveApproval === void 0 ? {} : { nonInteractiveReason: nonInteractiveApproval })
@@ -110031,7 +110298,7 @@ function registerJourneyReview(journey, program2, deps) {
         return;
       }
       try {
-        const result = await listStaleJourneys({ journeysDir: reviewJourneysDir, catalogDir: resolveCatalogDir(deps.catalogDir) });
+        const result = await listStaleJourneys({ journeysDir: reviewJourneysDir, catalogDir: resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)) });
         if (json2) emitJson(program2, ok(result));
         else program2.configureOutput().writeOut?.(renderStaleJourneys(result));
         process.exitCode = 0;
@@ -110045,8 +110312,8 @@ function registerJourneyReview(journey, program2, deps) {
       return;
     }
     try {
-      const jev = await jevSetupFor(deps, resolveCatalogDir(deps.catalogDir), { real, jevProvider });
-      const { review } = await reviewJourneyById(reviewJourneysDir, id, { ...targetsOpts(deps), catalogDir: resolveCatalogDir(deps.catalogDir), readiness: readiness === true, strict: strict === true, jev });
+      const jev = await jevSetupFor(deps, resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)), { real, jevProvider });
+      const { review } = await reviewJourneyById(reviewJourneysDir, id, { ...targetsOpts(deps), catalogDir: resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)), readiness: readiness === true, strict: strict === true, jev });
       const warnings = (review.attention ?? []).filter((a) => a.severity === "warn").length;
       const strictVerdict = { passed: warnings === 0, warnings };
       const renderOpts = reviewRenderOptions({ full: full === true, toFile: outFile !== void 0 });
@@ -110323,7 +110590,7 @@ function registerJourneyMigrate(journey, program2, deps) {
         return;
       }
       try {
-        const result = await migrateStepIds({ journeysDir: migrateJourneysDir, projectDir: resolveCatalogDir(deps.catalogDir), dryRun: dryRun === true });
+        const result = await migrateStepIds({ journeysDir: migrateJourneysDir, projectDir: resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout)), dryRun: dryRun === true });
         if (json2) emitJson(program2, ok(result));
         else program2.configureOutput().writeOut?.(renderMigrateStepIds(result));
         process.exitCode = 0;
@@ -110643,7 +110910,7 @@ function registerJourneyLint(journey, program2, deps) {
       }
       const fixed = fixResult?.stamped ?? [];
       const reapproval = fixResult?.needsReapproval === true ? { needsReapproval: true, reapproveCommand: fixResult.reapproveCommand } : {};
-      const catalogDir = resolveCatalogDir(deps.catalogDir);
+      const catalogDir = resolveCatalogDir(deps.catalogDir, flaggedCatalogDir(layout));
       const linted = await lintJourneyById(resolvedJourneysDir, id, { catalogDir });
       const stored = await new FsJourneyStore(resolvedJourneysDir).get(id);
       const linkFindings = stored === null ? [] : await journeyLinkWarnings(catalogDir, stored);
@@ -110766,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})`}
 `
         );
       }
@@ -115012,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,