@jevitate/cli 0.16.0 → 0.17.0

package/dist/bin.js

@@ -31320,6 +31320,8 @@ var USAGE_ERROR_PATTERNS = [
 var USAGE_ERROR_CODES = /* @__PURE__ */ new Set([
   "E_CHECK_SUITE",
   // the suite (or its preflight) was refused
+  "E_CHAIN_REQUEST",
+  // #580: an approved-requests line is malformed or carries an unknown key — nothing ran
   "E_CAMPAIGN_PREFLIGHT",
   // #485: a campaign's preconditions failed (start URL, session, allow list) — no mission ran
   "E_AI_SETUP_REQUIRED",
@@ -35996,11 +35998,31 @@ async function waitForOutcome(actor, expect, wait, step) {
 }
 
 // ../interpreter/dist/run-step.js
+var SelectAlternativeUnavailableError = class extends Error {
+  constructor() {
+    super("no-alternative: the select has no enabled option other than the one this proof avoids");
+    this.name = "SelectAlternativeUnavailableError";
+  }
+};
 async function strictTarget(actor, d, opts) {
   const page = actor.ability(BrowseTheWebToken).session.page;
   const locator = await resolveTarget(page, d, opts);
   return Target.named(descriptorToTarget(d).description).locatedBy(() => locator);
 }
+async function selectAlternativeValue(locator, avoid) {
+  const value = await locator.evaluate((el, avoided) => {
+    const options = el.options ?? [];
+    for (let i = 0; i < options.length; i += 1) {
+      const option = options[i];
+      if (!option.disabled && option.value !== "" && option.value !== avoided)
+        return option.value;
+    }
+    return null;
+  }, avoid);
+  if (value === null)
+    throw new SelectAlternativeUnavailableError();
+  return value;
+}
 function resolveValue(value, vars) {
   if ("var" in value) {
     const v = vars.get(value.var);
@@ -36101,9 +36123,12 @@ async function runStep(actor, rec, vars, index = 0, targetOpts = {}) {
       return { kind: "done" };
     }
     case "select": {
-      const value = resolveValue(step.value, vars);
+      const alternative = targetOpts.selectAlternative?.(index);
+      const chosen = alternative === void 0 ? resolveValue(step.value, vars) : void 0;
       const page = actor.ability(BrowseTheWebToken).session.page;
-      await (await resolveTarget(page, step.target, targetOpts)).selectOption(value);
+      const locator = await resolveTarget(page, step.target, targetOpts);
+      const value = chosen ?? await selectAlternativeValue(locator, alternative.avoid);
+      await locator.selectOption(value);
       await postcondition(actor, expected(step.expect), step.waitFor, "select", index, targetOpts);
       return { kind: "done" };
     }
@@ -36150,8 +36175,14 @@ async function runStep(actor, rec, vars, index = 0, targetOpts = {}) {
         vars.set(`${step.as}.__index`, String(i));
         for (const childStep of step.steps) {
           await runRowScopedChildStep(actor, childStep, rowLocator, vars, expected);
+          if (childStep.kind === "extract") {
+            const value = vars.get(childStep.as);
+            if (value !== void 0)
+              vars.set(`${step.as}.${i}.${childStep.as}`, value);
+          }
         }
       }
+      vars.set(`${step.as}.count`, String(count));
       return { kind: "done" };
     }
     case "handback": {
@@ -36266,6 +36297,7 @@ var RecordingInterpreter = class {
       ...this.options.targetTimeoutMs === void 0 ? {} : { timeoutMs: this.options.targetTimeoutMs },
       ...this.options.observer === void 0 ? {} : { observer: this.options.observer },
       ...this.options.skipStep === void 0 ? {} : { skipStep: this.options.skipStep },
+      ...this.options.selectAlternative === void 0 ? {} : { selectAlternative: this.options.selectAlternative },
       ...this.options.fixtureBaseDir === void 0 ? {} : { fixtureBaseDir: this.options.fixtureBaseDir },
       ...this.options.refLookup === void 0 ? {} : { refLookup: this.options.refLookup }
     };
@@ -53506,7 +53538,7 @@ function assertionSiteKey(site) {
     return `step-request:${site.step}:${site.checkIndex}`;
   return `end-state:${site.index}`;
 }
-var MUTATION_RE = /^(skip|block-write|stale-value|swap-param|truncate-param):(.+)$/;
+var MUTATION_RE = /^(skip|block-write|stale-value|swap-param|truncate-param|guard-param):(.+)$/;
 var SITE_RE = /^(?:step:[1-9][0-9]*|step-request:[1-9][0-9]*:(?:0|[1-9][0-9]*)|end-state:(?:0|[1-9][0-9]*))$/;
 function flat(journey) {
   return journey.recording.pages.flatMap((p) => p.steps);
@@ -53518,15 +53550,36 @@ function firstActionStep(journey, name) {
   const i = flat(journey).findIndex((r) => actionRefs(r.step).includes(name));
   return i < 0 ? null : i + 1;
 }
+function allActionReadsAreSelect(journey, name) {
+  const reads2 = flat(journey).filter((r) => actionRefs(r.step).includes(name));
+  return reads2.length > 0 && reads2.every((r) => r.step.kind === "select");
+}
+function reviewedValue(journey, name, supplied) {
+  const declared = (journey.metadata.parameters ?? []).find((p) => p.name === name);
+  return declared?.mutationValues?.find((v) => v !== supplied) ?? null;
+}
+function selectsVar(step, name) {
+  return step.kind === "select" && "var" in step.value && step.value.var === name;
+}
 function paramMutation(kind, step, param) {
   return { kind, step, id: `${kind}:${param}`, param };
 }
+function guardSites(journey, sites, name) {
+  const action = firstActionStep(journey, name);
+  return sites.filter((s3) => s3.where === "step" && siteRefs(s3).includes(name) && (action === null || s3.step < action));
+}
 function paramMutationRef(journey, kind, name, value) {
   const declared = [...journey.metadata.params, ...(journey.metadata.parameters ?? []).map((p) => p.name)];
   if (!declared.includes(name))
     throw new Error(`${JSON.stringify(value)}: ${JSON.stringify(name)} is not a declared parameter`);
   if (secretParamNames(journey).includes(name))
     throw new Error(`${JSON.stringify(value)}: ${name} is a secret parameter \u2014 a secret is never mutated`);
+  if (kind === "guard-param") {
+    const first = guardSites(journey, journeyAssertions(journey), name)[0];
+    if (first === void 0)
+      throw new Error(`${JSON.stringify(value)}: no step assertion checks ${name} before an action reads it`);
+    return paramMutation(kind, first.step, name);
+  }
   const step = firstActionStep(journey, name);
   if (step === null)
     throw new Error(`${JSON.stringify(value)}: no step's action reads ${name} (a fill or a navigate URL)`);
@@ -53535,9 +53588,9 @@ function paramMutationRef(journey, kind, name, value) {
 function resolveMutationRef(journey, value) {
   const m = MUTATION_RE.exec(value.trim());
   if (m === null)
-    throw new Error(`${JSON.stringify(value)} is not a mutation \u2014 expected skip:<step>, block-write:<step> or stale-value:<step> (a step number or an anchor name), or swap-param:<param> / truncate-param:<param>`);
+    throw new Error(`${JSON.stringify(value)} is not a mutation \u2014 expected skip:<step>, block-write:<step> or stale-value:<step> (a step number or an anchor name), or swap-param:<param> / truncate-param:<param> / guard-param:<param>`);
   const ref = m[2];
-  if (m[1] === "swap-param" || m[1] === "truncate-param")
+  if (m[1] === "swap-param" || m[1] === "truncate-param" || m[1] === "guard-param")
     return paramMutationRef(journey, m[1], ref, value);
   let step;
   try {
@@ -53653,17 +53706,30 @@ function planJourneyMutations(journey, opts = {}) {
   const params = opts.params ?? {};
   const names = [...new Set(sites.flatMap(siteRefs))];
   for (const name of names) {
+    const supplied = mutableParamValue(journey, name, params);
+    const guards = guardSites(journey, sites, name);
+    const guardValue = supplied === null ? null : reviewedValue(journey, name, supplied) ?? swappedValue(journey, name, params);
+    if (guards.length > 0 && guardValue !== null) {
+      const g = { ...paramMutation("guard-param", guards[0].step, name), source: reviewedValue(journey, name, supplied) === null ? "generated" : "reviewed" };
+      mutations.push(g);
+      for (const s3 of guards)
+        pair(s3, g);
+    }
     const at3 = firstActionStep(journey, name);
     if (at3 === null)
       continue;
-    const naming = sites.filter((s3) => siteRefs(s3).includes(name));
-    for (const [kind, value] of [
+    const naming = sites.filter((s3) => siteRefs(s3).includes(name) && !guards.includes(s3));
+    if (naming.length === 0)
+      continue;
+    const candidates = [
       ["swap-param", swappedValue(journey, name, params)],
-      ["truncate-param", truncatedValue(journey, name, params)]
-    ]) {
+      ...allActionReadsAreSelect(journey, name) ? [] : [["truncate-param", truncatedValue(journey, name, params)]]
+    ];
+    const source = supplied !== null && reviewedValue(journey, name, supplied) !== null ? "reviewed" : allActionReadsAreSelect(journey, name) ? "option" : "generated";
+    for (const [kind, value] of candidates) {
       if (value === null)
         continue;
-      const m = paramMutation(kind, at3, name);
+      const m = kind === "swap-param" ? { ...paramMutation(kind, at3, name), source } : paramMutation(kind, at3, name);
       mutations.push(m);
       for (const s3 of naming)
         pair(s3, m);
@@ -53686,7 +53752,7 @@ function mutationWait(wait) {
 var MUTATION_WAIT_MARGIN_MS = 5e3;
 function mutationReplay(journey, m, opts = {}) {
   const index = m.step - 1;
-  if (m.kind === "swap-param" || m.kind === "truncate-param")
+  if (m.kind === "swap-param" || m.kind === "truncate-param" || m.kind === "guard-param")
     return paramReplay(journey, m, opts.params ?? {});
   if (m.kind === "block-write") {
     const requests = journeyWriteSteps(journey, opts).find((w) => w.step === m.step)?.requests ?? [];
@@ -53719,6 +53785,25 @@ function mutationReplay(journey, m, opts = {}) {
 }
 function paramReplay(journey, m, params) {
   const name = m.param ?? "";
+  const index = m.step - 1;
+  const target = flat(journey)[index]?.step;
+  if (m.kind === "guard-param") {
+    const supplied2 = mutableParamValue(journey, name, params);
+    const wrong = supplied2 === null ? null : reviewedValue(journey, name, supplied2) ?? swappedValue(journey, name, params);
+    if (wrong === null)
+      throw new Error(`${m.id}: parameter ${name} has no value this proof may alter (not supplied, blank, too short, or secret)`);
+    return { journey, params: { ...params, [name]: wrong } };
+  }
+  const reviewedFrom = m.kind === "swap-param" ? mutableParamValue(journey, name, params) : null;
+  const reviewed = reviewedFrom === null ? null : reviewedValue(journey, name, reviewedFrom);
+  if (reviewedFrom !== null && reviewed !== null)
+    return { journey: pinAssertionRefs(journey, name, reviewedFrom), params: { ...params, [name]: reviewed } };
+  if (m.kind === "swap-param" && target !== void 0 && selectsVar(target, name)) {
+    const supplied2 = mutableParamValue(journey, name, params);
+    if (supplied2 === null)
+      throw new Error(`${m.id}: parameter ${name} has no value this proof may alter (not supplied, blank, too short, or secret)`);
+    return { journey: structuredClone(journey), swapSelectAtStep: { index, avoid: supplied2 } };
+  }
   const supplied = mutableParamValue(journey, name, params);
   const altered = m.kind === "swap-param" ? swappedValue(journey, name, params) : truncatedValue(journey, name, params);
   if (supplied === null || altered === null)
@@ -53734,7 +53819,7 @@ function relaxedMutationReplay(journey, m, opts = {}) {
   const index = m.step - 1;
   if (m.kind === "skip")
     return { journey, skipIndex: index };
-  if (m.kind === "swap-param" || m.kind === "truncate-param") {
+  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];
     if (target2 !== void 0 && "expect" in target2.step) {
@@ -53987,7 +54072,9 @@ var JourneySuccessCriterionSchema = external_exports.object({
 var JourneyParameterSchema = external_exports.object({
   name: external_exports.string().min(1).max(200),
   description: external_exports.string().max(2e3).optional(),
-  secret: external_exports.boolean().optional()
+  secret: external_exports.boolean().optional(),
+  // #579: reviewed, non-secret alternative values — at most 20 distinct 1..2000-char strings.
+  mutationValues: external_exports.array(TEXT).min(1).max(20).refine((vs) => new Set(vs).size === vs.length, { message: "mutationValues: duplicate value" }).optional()
 }).strict();
 var CATALOG_REF_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 var CatalogRefSchema = external_exports.string().regex(CATALOG_REF_RE, "a catalog id: 1-64 of [A-Za-z0-9._-], starting alphanumeric");
@@ -54072,6 +54159,17 @@ var JourneySchema = external_exports.object({
   }));
   for (const issue3 of assertionRefIssues(j))
     ctx.addIssue({ code: "custom", path: [...issue3.path], message: issue3.message });
+  (j.metadata.parameters ?? []).forEach((p, i) => {
+    if (p.mutationValues === void 0)
+      return;
+    if (p.secret === true || SECRET_PARAM_NAME_RE2.test(p.name)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["metadata", "parameters", i, "mutationValues"],
+        message: `E_MUTATION_VALUES_SECRET: parameter "${p.name}" is a secret (secret: true or a credential-like name) \u2014 mutationValues are reviewed, non-secret values and may never carry a credential`
+      });
+    }
+  });
 });
 function ownAssertions(step) {
   if (step.kind === "assert")
@@ -54293,6 +54391,40 @@ function deriveParamSchema(rec) {
   }
   return { required: required2 };
 }
+function journeyParamSchema(journey) {
+  const { required: required2 } = deriveParamSchema(journey.recording);
+  const declared = /* @__PURE__ */ new Set([...journey.metadata.params, ...(journey.metadata.parameters ?? []).map((p) => p.name)]);
+  const extracted = /* @__PURE__ */ new Set();
+  const add = (a) => {
+    for (const name of assertionRefs(a)) {
+      if (declared.has(name) && !extracted.has(name) && !required2.includes(name))
+        required2.push(name);
+    }
+  };
+  for (const page of journey.recording.pages) {
+    for (const { step } of page.steps) {
+      for (const name of actionRefs(step))
+        if (declared.has(name) && !extracted.has(name) && !required2.includes(name))
+          required2.push(name);
+      if (step.kind === "extract")
+        extracted.add(step.as);
+      for (const { assertion } of ownAssertions(step))
+        add(assertion);
+      if (step.kind === "forEach") {
+        for (const child of step.steps) {
+          if (child.kind === "extract")
+            extracted.add(child.as);
+          for (const { assertion } of ownAssertions(child))
+            add(assertion);
+        }
+      }
+    }
+  }
+  for (const c of journey.metadata.endState ?? [])
+    if (c.kind === "page" || c.kind === "reloadThen")
+      add(c.assertion);
+  return { required: required2 };
+}
 function validateParams(schema, params) {
   const provided = Object.keys(params);
   const missing = schema.required.filter((v) => !(v in params));
@@ -54303,7 +54435,7 @@ function validateParams(schema, params) {
 }
 function journeyRunParams(journey) {
   const out = [...journey.metadata.params];
-  for (const p of deriveParamSchema(journey.recording).required)
+  for (const p of journeyParamSchema(journey).required)
     if (!out.includes(p))
       out.push(p);
   return out;
@@ -61856,9 +61988,9 @@ function hostStarvedFailure(failure3, health) {
 }
 
 // src/build-info.generated.ts
-var GENERATED_COMMIT = "2b37f8e";
-var GENERATED_TREE = "c3b34ef";
-var GENERATED_BUILT_AT = "2026-10-18T00:47:21.290Z";
+var GENERATED_COMMIT = "89237bd";
+var GENERATED_TREE = "b6b4c8d";
+var GENERATED_BUILT_AT = "2026-10-18T16:47:05.375Z";
 
 // src/version.ts
 import { readFileSync as readFileSync5 } from "node:fs";
@@ -61880,13 +62012,13 @@ function readCliVersion() {
 
 // src/engine.ts
 function bundledCommit() {
-  return true ? "2b37f8e" : void 0;
+  return true ? "89237bd" : void 0;
 }
 function bundledBuiltAt() {
-  return true ? "2026-10-18T00:47:21.290Z" : void 0;
+  return true ? "2026-10-18T16:47:05.375Z" : void 0;
 }
 function bundledTree() {
-  return true ? "c3b34ef" : void 0;
+  return true ? "b6b4c8d" : void 0;
 }
 function currentBuildTree() {
   return bundledTree() ?? GENERATED_TREE;
@@ -80224,13 +80356,13 @@ import { readFile as readFile9, writeFile as writeFile8, mkdir as mkdir8, rm as
 import { homedir as realHomedir } from "node:os";
 import { join as join19, dirname as dirname6 } from "node:path";
 function detectRuntimes(deps = {}) {
-  const existsSync46 = deps.existsSync ?? realExistsSync;
+  const existsSync47 = deps.existsSync ?? realExistsSync;
   const homedir6 = deps.homedir ?? realHomedir;
   const cwd = deps.cwd ?? process.cwd;
   const detected = [];
-  if (existsSync46(join19(homedir6(), ".claude"))) detected.push("claude-code");
-  if (existsSync46(join19(homedir6(), ".codex"))) detected.push("codex");
-  if (existsSync46(join19(cwd(), ".cursor"))) detected.push("cursor");
+  if (existsSync47(join19(homedir6(), ".claude"))) detected.push("claude-code");
+  if (existsSync47(join19(homedir6(), ".codex"))) detected.push("codex");
+  if (existsSync47(join19(cwd(), ".cursor"))) detected.push("cursor");
   detected.push("generic");
   return detected;
 }
@@ -82119,7 +82251,7 @@ var JourneyRunner = class {
   }
   async #run(req, collect9) {
     assertCompletePolicy(req?.policy);
-    validateParams(deriveParamSchema(req.journey.recording), req.params);
+    validateParams(journeyParamSchema(req.journey), req.params);
     if (req.policy.secret.secretMode === "vault-autofill") {
       await this.preflightSecretRefs(req.journey.metadata.secretRefs ?? []);
     }
@@ -90742,7 +90874,7 @@ async function resolveJourneyPrefix(opts) {
   }
   const prefix = journeyPrefix(full, resolved.step);
   const used = prefixParams(full, prefix, opts.params);
-  validateParams(deriveParamSchema(prefix.recording), used);
+  validateParams(journeyParamSchema(prefix), used);
   const branch = journeyBranchPoint(full, resolved);
   const site = full.recording.site;
   let startUrl;
@@ -94050,10 +94182,10 @@ function redactSecretValues(result, secrets) {
   return scrub3(result);
 }
 function prefixParams(full, prefix, params) {
-  const known = deriveParamSchema(full.recording).required;
+  const known = journeyParamSchema(full).required;
   const unknown2 = Object.keys(params).filter((k) => !known.includes(k));
   if (unknown2.length > 0) throw new ParamValidationError(`param mismatch \u2014 missing: [], unknown: [${unknown2.join(", ")}]`);
-  const needed = deriveParamSchema(prefix.recording).required;
+  const needed = journeyParamSchema(prefix).required;
   return Object.fromEntries(Object.entries(params).filter(([k]) => needed.includes(k)));
 }
 function journeyFixtureBaseDir(deps = {}) {
@@ -94211,7 +94343,7 @@ async function runJourneyProgrammatically(opts, mutation2 = {}) {
     );
   }
   const inputParams = journey === full ? opts.params : prefixParams(full, journey, opts.params);
-  validateParams(deriveParamSchema(journey.recording), inputParams);
+  validateParams(journeyParamSchema(journey), inputParams);
   const replayed = mutation2.mutateJourney === void 0 || journey !== full ? journey : mutation2.mutateJourney(journey);
   const policy = opts.policy ?? safeRunPolicy();
   const gate2 = await gateJourney(opts.siteGate, journey.recording, { ...opts.account === void 0 ? {} : { account: opts.account }, enforceLimits: true });
@@ -94282,8 +94414,15 @@ async function runJourneyProgrammatically(opts, mutation2 = {}) {
         shots === void 0 ? void 0 : screenshotObserver(shots, (a) => a.ability(BrowseTheWebToken).session.page, whatOf)
       );
       const skipStep = mutation2.skipStep;
+      const selectAlternative = mutation2.selectAlternativeAtStep;
       const fixtureBaseDir = opts.fixtureBaseDir ?? journeyFixtureBaseDir();
-      const interpreter = opts.interpreter ?? (opts.observer === void 0 && shots === void 0 && replayDeltas === void 0 && outcomeChecks.observer() === void 0 && blocker === void 0 && healGuard === void 0 && skipStep === void 0 ? new RecordingInterpreter({ fixtureBaseDir, refLookup: refs }) : new RecordingInterpreter({ observer, fixtureBaseDir, refLookup: refs, ...skipStep === void 0 ? {} : { skipStep: (i) => skipStep(i) } }));
+      const interpreter = opts.interpreter ?? (opts.observer === void 0 && shots === void 0 && replayDeltas === void 0 && outcomeChecks.observer() === void 0 && blocker === void 0 && healGuard === void 0 && skipStep === void 0 && selectAlternative === void 0 ? new RecordingInterpreter({ fixtureBaseDir, refLookup: refs }) : new RecordingInterpreter({
+        observer,
+        fixtureBaseDir,
+        refLookup: refs,
+        ...skipStep === void 0 ? {} : { skipStep: (i) => skipStep(i) },
+        ...selectAlternative === void 0 ? {} : { selectAlternative: (i) => i === selectAlternative.index ? { avoid: selectAlternative.avoid } : void 0 }
+      }));
       const heal = opts.heal === void 0 || healGuard === void 0 ? void 0 : { scope: opts.heal.scope, riskOf: journeyStepRisk(), writeGuard: healGuard.guard, allowedOrigins, observe: healObserver(healDir, mask) };
       const runner = new JourneyRunner(actor, interpreter, void 0, void 0, opts.selfHealer, heal);
       let result;
@@ -107473,6 +107612,249 @@ function registerJourneyRun(journey, program2, deps) {
   }));
 }
 
+// src/journey-cli/chain.ts
+import { existsSync as existsSync27, readFileSync as readFileSync33 } from "node:fs";
+
+// src/journey-chain.ts
+var JourneyChainError = class extends Error {
+  code;
+  constructor(code, message2) {
+    super(message2);
+    this.name = "JourneyChainError";
+    this.code = code;
+  }
+};
+var E_CHAIN_FIELD = "E_CHAIN_FIELD";
+var REQUEST_KEYS = ["commentId", "account", "replyText"];
+function parseChainRequests(text2) {
+  const requests = [];
+  const lines = text2.split(/\r?\n/);
+  for (let n3 = 0; n3 < lines.length; n3++) {
+    const line2 = lines[n3]?.trim() ?? "";
+    if (line2 === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line2);
+    } catch {
+      throw new JourneyChainError("E_CHAIN_REQUEST", `request line ${n3 + 1} is not valid JSON`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new JourneyChainError("E_CHAIN_REQUEST", `request line ${n3 + 1} must be a JSON object`);
+    }
+    const bag = parsed;
+    const keys = Object.keys(bag);
+    const missing = REQUEST_KEYS.filter((k) => !keys.includes(k));
+    const extra = keys.filter((k) => !REQUEST_KEYS.includes(k));
+    if (missing.length > 0 || extra.length > 0) {
+      throw new JourneyChainError("E_CHAIN_REQUEST", `request line ${n3 + 1} \u2014 missing: [${missing.join(", ")}], unknown: [${extra.join(", ")}]`);
+    }
+    for (const k of REQUEST_KEYS) {
+      if (typeof bag[k] !== "string") {
+        throw new JourneyChainError("E_CHAIN_REQUEST", `request line ${n3 + 1} \u2014 ${k} must be a string`);
+      }
+    }
+    requests.push({ commentId: bag.commentId, account: bag.account, replyText: bag.replyText });
+  }
+  return requests;
+}
+var recordKey2 = (commentId, account) => `${commentId}\0${account}`;
+var asString = (v) => typeof v === "string" && v !== "" ? v : void 0;
+function readRecords(output3) {
+  const bag = output3 !== null && typeof output3 === "object" ? output3 : {};
+  const raw = bag["records.count"];
+  const count = typeof raw === "string" ? Number.parseInt(raw, 10) : Number.NaN;
+  if (!Number.isInteger(count) || count <= 0) {
+    throw new JourneyChainError("E_CHAIN_EMPTY", `the discover Journey returned no records (records.count = ${raw === void 0 ? "missing" : JSON.stringify(raw)})`);
+  }
+  const field3 = (i, name) => asString(bag[`records.${i}.${name}`]);
+  const records = Array.from({ length: count }, (_, i) => ({
+    commentId: field3(i, "commentId"),
+    account: field3(i, "account"),
+    threadId: field3(i, "threadId"),
+    sourceText: field3(i, "sourceText"),
+    parentId: field3(i, "parentId")
+  }));
+  return { count, records };
+}
+function chainParams(record2, request, declared) {
+  const sources = {
+    commentId: record2.commentId,
+    replyIdentity: record2.account,
+    threadId: record2.threadId,
+    expected_commentid: record2.commentId,
+    expected_account: record2.account,
+    expected_sourcetext: record2.sourceText,
+    expected_parentid: record2.parentId
+  };
+  const params = { replyText: request.replyText };
+  for (const [name, value] of Object.entries(sources)) {
+    if (!declared.has(name)) continue;
+    if (value === void 0) return { ok: false, detail: `E_CHAIN_FIELD: the record has no value for ${name}` };
+    params[name] = value;
+  }
+  return { ok: true, params };
+}
+var TEXT_PARAMS = ["replyText", "expected_sourcetext"];
+function redactReason(reason, params) {
+  let out = reason;
+  for (const name of TEXT_PARAMS) {
+    const value = params[name];
+    if (value === void 0 || value === "") continue;
+    for (const form of /* @__PURE__ */ new Set([value, JSON.stringify(value).slice(1, -1)])) out = out.split(form).join(`<param ${name}>`);
+  }
+  return out;
+}
+function chainSucceeded(result) {
+  return result.unmatched.length === 0 && result.runs.every((run) => run.outcome === "ok");
+}
+function sharedRunOptions(opts) {
+  return {
+    dir: opts.dir,
+    ...opts.environment === void 0 ? {} : { environment: opts.environment },
+    ...opts.storageState === void 0 ? {} : { storageState: opts.storageState },
+    ...opts.browser === void 0 ? {} : { browser: opts.browser },
+    ...opts.emulation === void 0 ? {} : { emulation: opts.emulation },
+    ...opts.browserPortFactory === void 0 ? {} : { browserPortFactory: opts.browserPortFactory },
+    ...opts.allow === void 0 ? {} : { allow: opts.allow },
+    ...opts.siteGate === void 0 ? {} : { siteGate: opts.siteGate }
+  };
+}
+async function runJourneyChain(opts, deps = {}) {
+  const requests = parseChainRequests(opts.requests);
+  const runner = deps.runJourney ?? runJourneyProgrammatically;
+  const shared3 = sharedRunOptions(opts);
+  const registry3 = new JourneyRegistry(new FsJourneyStore(opts.dir));
+  const toJourney = await registry3.get(opts.to);
+  if (toJourney === null) throw new UnknownJourneyError(`unknown journey '${opts.to}'`);
+  if (opts.requirePromoted === true) {
+    const fromJourney = await registry3.get(opts.from);
+    if (fromJourney === null) throw new UnknownJourneyError(`unknown journey '${opts.from}'`);
+    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)`);
+    }
+  }
+  const fromResult = await runner({ ...shared3, id: opts.from, params: {} });
+  if (fromResult.outcome !== "ok") {
+    const reason = "reason" in fromResult ? fromResult.reason : void 0;
+    throw new JourneyChainError(
+      "E_CHAIN_FROM_FAILED",
+      `discover Journey '${opts.from}' did not run ok (${fromResult.outcome})${reason === void 0 ? "" : `: ${reason}`}`
+    );
+  }
+  const { count, records } = readRecords(fromResult.output);
+  const declared = new Set(journeyParamSchema(toJourney).required);
+  const byKey = /* @__PURE__ */ new Map();
+  for (const record2 of records) {
+    if (record2.commentId !== void 0 && record2.account !== void 0) byKey.set(recordKey2(record2.commentId, record2.account), record2);
+  }
+  const runs = [];
+  const unmatched = [];
+  for (const request of requests) {
+    const record2 = byKey.get(recordKey2(request.commentId, request.account));
+    if (record2 === void 0) {
+      unmatched.push({ commentId: request.commentId, account: request.account });
+      continue;
+    }
+    const mapped = chainParams(record2, request, declared);
+    if (!mapped.ok) {
+      runs.push({ commentId: request.commentId, account: request.account, outcome: E_CHAIN_FIELD, reason: mapped.detail });
+      continue;
+    }
+    try {
+      const result = await runner({ ...shared3, id: opts.to, params: mapped.params });
+      runs.push({
+        commentId: request.commentId,
+        account: request.account,
+        outcome: result.outcome,
+        ..."reason" in result ? { reason: redactReason(result.reason, mapped.params) } : {}
+      });
+    } catch (err) {
+      runs.push({ commentId: request.commentId, account: request.account, outcome: "error", reason: redactReason(err instanceof Error ? err.message : String(err), mapped.params) });
+    }
+  }
+  return { from: { journey: opts.from, outcome: "ok", records: count }, runs, unmatched };
+}
+
+// src/journey-cli/chain.ts
+function registerJourneyChain(journey, program2, deps) {
+  withReplayAllowFlag(withEnvironmentFlags(withBrowserLaunchFlags(withEmulationFlags(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>", "journeys directory (default: the repo's .jevitate/journeys; outside a repo ~/.jevitate/journeys)").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 { from, to, requests: requestsFile, dir, storageState: storageStateFlag, json: json2, allowDraft } = this.opts();
+    const { env: envName, baseUrl } = this.opts();
+    let environment;
+    let allow;
+    try {
+      allow = replayAllowFromFlags(this.opts().allow);
+      environment = environmentFromFlags(
+        { ...envName === void 0 ? {} : { env: envName }, ...baseUrl === void 0 ? {} : { baseUrl } },
+        environmentSeams(deps)
+      );
+    } catch (err) {
+      if (!isEnvironmentError(err)) throw err;
+      emitJson(program2, fail(err.code, err.message));
+      return;
+    }
+    const storageState = storageStateFlag ?? environment?.storageState;
+    if (storageState !== void 0 && !existsSync27(storageState)) {
+      emitJson(program2, fail("E_CHAIN_ARGS", `storage state not found: ${storageState}`));
+      return;
+    }
+    let requests;
+    try {
+      requests = readFileSync33(requestsFile, "utf8");
+    } catch (err) {
+      emitJson(program2, fail("E_CHAIN_ARGS", `could not read requests file ${requestsFile}: ${err instanceof Error ? err.message : String(err)}`));
+      return;
+    }
+    let browser;
+    try {
+      browser = browserRunFromFlags(this.opts(), deps.explore?.env ?? process.env);
+    } catch (err) {
+      emitJson(program2, fail("E_CHAIN_ARGS", err instanceof Error ? err.message : String(err)));
+      return;
+    }
+    let emulation;
+    try {
+      emulation = emulationFromFlags(this.opts());
+    } catch (err) {
+      emitJson(program2, fail("E_CHAIN_ARGS", err instanceof Error ? err.message : String(err)));
+      return;
+    }
+    try {
+      const result = await withSiteGate(
+        resolveDbPath(deps),
+        (siteGate) => runJourneyChain({
+          from,
+          to,
+          requests,
+          dir: resolveJourneysDir(deps, dir),
+          requirePromoted: allowDraft !== true,
+          ...siteGate === void 0 ? {} : { siteGate },
+          browserPortFactory: deps.explore?.browserPortFactory,
+          ...browser === void 0 ? {} : { browser },
+          ...emulation === void 0 ? {} : { emulation },
+          ...storageState !== void 0 ? { storageState } : {},
+          ...environment === void 0 ? {} : { environment },
+          ...allow.length === 0 ? {} : { allow }
+        })
+      );
+      const envelope = ok(result);
+      if (json2) emitJson(program2, envelope);
+      else writeRawResult(program2, result);
+      process.exitCode = chainSucceeded(result) ? 0 : 1;
+    } catch (err) {
+      if (err instanceof JourneyChainError) {
+        emitJson(program2, fail(err.code, err.message));
+      } else if (err instanceof UnknownJourneyError) {
+        emitJson(program2, fail("E_UNKNOWN_JOURNEY", String(err.message)));
+      } else if (isEnvironmentError(err)) {
+        emitJson(program2, fail(err.code, err.message));
+      } else {
+        emitJson(program2, fail("E_CHAIN", String(err instanceof Error ? err.message : err)));
+      }
+    }
+  });
+}
+
 // src/journey-cli/promote.ts
 import { readFile as readFile31 } from "node:fs/promises";
 
@@ -108021,7 +108403,7 @@ function registerJourneyReview(journey, program2, deps) {
 }
 
 // src/journey-cli/migrate.ts
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 
 // src/journey-migrate-api.ts
 import { readdir as readdir11, readFile as readFile32, writeFile as writeFile37 } from "node:fs/promises";
@@ -108277,7 +108659,7 @@ function registerJourneyMigrate(journey, program2, deps) {
       return;
     }
     const storageState = storageStateFlag ?? environment?.storageState;
-    if (storageState !== void 0 && !existsSync27(storageState)) {
+    if (storageState !== void 0 && !existsSync28(storageState)) {
       emitJson(program2, fail("E_JOURNEY_MIGRATE_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -108610,7 +108992,7 @@ function registerJourneyLint(journey, program2, deps) {
 }
 
 // src/journey-cli/verify.ts
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 
 // src/journey-verify.ts
 function verifyExitCode(verdict) {
@@ -108660,10 +109042,14 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
           structuredFailures: true,
           ...how.journey === journey ? {} : { mutateJourney: (j) => describe6(j, m, replayOpts2).journey },
           ...how.skipIndex === void 0 ? {} : { skipStep: (i) => i === how.skipIndex },
+          ...how.swapSelectAtStep === void 0 ? {} : { selectAlternativeAtStep: how.swapSelectAtStep },
           ...how.blockIndex === void 0 ? {} : { blockWritesAtStep: how.blockIndex }
         });
         const blocked = r.blockedWrites ?? [];
         const blockedFields = how.blockIndex === void 0 ? {} : { blockedWrites: blocked.map((b2) => `${b2.method} ${b2.path}`) };
+        if (r.outcome === "quarantined" && /no-alternative/.test(r.reason)) {
+          return { outcome: "not-applied", failedSites: [], ...blockedFields, reason: r.reason };
+        }
         if (how.blockIndex !== void 0 && !blockedOwnWrite(how.blockRequests ?? [], blocked)) {
           return {
             outcome: "not-applied",
@@ -108685,7 +109071,15 @@ async function verifyJourneyMutations(opts, run = runJourneyProgrammatically) {
     for (const m of plan2.mutations) {
       const first = await replay(m, mutationReplay);
       const relaxed2 = needsRelaxedReplay(plan2, m, first) ? await replay(m, relaxedMutationReplay) : void 0;
-      mutations.push({ kind: m.kind, step: m.step, id: m.id, ...m.param === void 0 ? {} : { param: m.param }, ...first, ...relaxed2 === void 0 ? {} : { relaxed: relaxed2 } });
+      mutations.push({
+        kind: m.kind,
+        step: m.step,
+        id: m.id,
+        ...m.param === void 0 ? {} : { param: m.param },
+        ...m.source === void 0 ? {} : { source: m.source },
+        ...first,
+        ...relaxed2 === void 0 ? {} : { relaxed: relaxed2 }
+      });
     }
   }
   const results = new Map(
@@ -108753,7 +109147,7 @@ function registerJourneyVerify(journey, program2, deps) {
       ...ownFixtureFlags.after === void 0 && environment?.hooks?.after !== void 0 ? { after: environment.hooks.after } : {}
     };
     const storageState = storageStateFlag ?? environment?.storageState;
-    if (storageState !== void 0 && !existsSync28(storageState)) {
+    if (storageState !== void 0 && !existsSync29(storageState)) {
       emitJson(program2, fail("E_JOURNEY_VERIFY_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -109180,7 +109574,7 @@ function registerJourneyLinkCommand(journey, program2, deps) {
 }
 
 // src/journey-annotate-cli.ts
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 function registerJourneyAnnotateCommand(journey, program2, deps) {
   withScreenshotsFlag(withEnvironmentFlags(withBrowserLaunchFlags(withEmulationFlags(withFixtureFlags(journey.command("annotate <id>")))))).description(
     "draft each step's objective/expected result (and the goal/success criteria when missing) by replaying the Journey; writes a reviewable draft, never the Journey \u2014 `--approve` applies a reviewed draft (human gate)"
@@ -109229,7 +109623,7 @@ function registerJourneyAnnotateCommand(journey, program2, deps) {
       ...ownFixtureFlags.after === void 0 && environment?.hooks?.after !== void 0 ? { after: environment.hooks.after } : {}
     };
     const storageState = storageStateFlag ?? environment?.storageState;
-    if (storageState !== void 0 && !existsSync29(storageState)) {
+    if (storageState !== void 0 && !existsSync30(storageState)) {
       emitJson(program2, fail("E_JOURNEY_ANNOTATE_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -109317,7 +109711,7 @@ review or edit it, then apply it: jevitate journey annotate ${id} --approve
 }
 
 // src/journey-demo-cli.ts
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync31 } from "node:fs";
 import { join as join64, resolve as resolvePath15 } from "node:path";
 function registerJourneyDemoCommand(journey, program2, deps) {
   withScreenshotsFlag(withEnvironmentFlags(withDemoFlags(withBrowserLaunchFlags(withEmulationFlags(withFixtureFlags(journey.command("demo <id>"))))))).description(
@@ -109341,7 +109735,7 @@ function registerJourneyDemoCommand(journey, program2, deps) {
       ...ownFixtureFlags.after === void 0 && environment?.hooks?.after !== void 0 ? { after: environment.hooks.after } : {}
     };
     const storageState = storageStateFlag ?? environment?.storageState;
-    if (storageState !== void 0 && !existsSync30(storageState)) {
+    if (storageState !== void 0 && !existsSync31(storageState)) {
       emitJson(program2, fail("E_JOURNEY_DEMO_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -109437,6 +109831,7 @@ function registerJourneyCommands(program2, deps) {
   registerJourneyList(journey, program2, deps);
   registerJourneyFind(journey, program2, deps);
   registerJourneyRun(journey, program2, deps);
+  registerJourneyChain(journey, program2, deps);
   registerJourneyPromote(journey, program2, deps);
   registerJourneyReview(journey, program2, deps);
   registerJourneyMigrate(journey, program2, deps);
@@ -109461,7 +109856,7 @@ function registerBuiltinAnalyzers() {
 }
 
 // src/source-cli.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 
 // src/source-run-api.ts
 var realResolvedJourneyRunner = async (file2, params, policy, storageState, emulation, browser, siteGate) => {
@@ -109470,7 +109865,7 @@ var realResolvedJourneyRunner = async (file2, params, policy, storageState, emul
       `journey '${file2.metadata.id}' requires auth (metadata.requiresAuth) \u2014 run with --storage-state <file>`
     );
   }
-  validateParams(deriveParamSchema(file2.recording), params);
+  validateParams(journeyParamSchema(file2), params);
   const allowedOrigins = [.../* @__PURE__ */ new Set([file2.recording.site, ...file2.declaredOrigins])];
   const gate2 = await gateJourney(siteGate, file2.recording, { enforceLimits: true });
   const port = new PlaywrightBrowserPort();
@@ -109679,7 +110074,7 @@ function registerSourceCommands(program2, deps) {
     "Playwright storageState JSON to start the session authenticated (#118: required when the journey declares metadata.requiresAuth); must exist"
   ).option("--json", "emit a JSON envelope").option(TAG_FLAG, TAG_HELP, collectTag, []).action(taggedAction(program2, "source run", async function(name, journeyId) {
     const { param, storageState, json: json2, ...emulationFlags } = this.opts();
-    if (storageState !== void 0 && !existsSync31(storageState)) {
+    if (storageState !== void 0 && !existsSync32(storageState)) {
       emitJson(program2, fail("E_SOURCE_RUN_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -109742,7 +110137,7 @@ function registerSourceCommands(program2, deps) {
 }
 
 // src/load-cli.ts
-import { existsSync as existsSync32 } from "node:fs";
+import { existsSync as existsSync33 } from "node:fs";
 
 // ../load/dist/percentiles.js
 function percentile(sorted2, p) {
@@ -109870,7 +110265,7 @@ async function runJourneyLoadTest(opts) {
       `journey '${opts.id}' requires auth (metadata.requiresAuth) \u2014 run with --storage-state <file>`
     );
   }
-  validateParams(deriveParamSchema(journey.recording), opts.params);
+  validateParams(journeyParamSchema(journey), opts.params);
   const policy = opts.policy ?? safeRunPolicy();
   const browserPortFactory = opts.browserPortFactory ?? (() => new PlaywrightBrowserPort());
   const fixtureBaseDir = journeyFixtureBaseDir();
@@ -109950,7 +110345,7 @@ function registerLoadCommands(program2, deps) {
       return;
     }
     const storageState = storageStateFlag ?? environment?.storageState;
-    if (storageState !== void 0 && !existsSync32(storageState)) {
+    if (storageState !== void 0 && !existsSync33(storageState)) {
       emitJson(program2, fail("E_LOAD_RUN_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -110000,10 +110395,10 @@ function registerLoadCommands(program2, deps) {
 }
 
 // src/explore-cli/run.ts
-import { existsSync as existsSync34 } from "node:fs";
+import { existsSync as existsSync35 } from "node:fs";
 
 // src/type-fixture-file.ts
-import { readFileSync as readFileSync33, statSync as statSync10 } from "node:fs";
+import { readFileSync as readFileSync34, statSync as statSync10 } from "node:fs";
 import { basename as basename15, resolve as resolve18 } from "node:path";
 var TYPE_FIXTURE_MAX_BYTES = 256 * 1024;
 function loadTypeFixtures(specs, cwd = process.cwd()) {
@@ -110022,7 +110417,7 @@ function loadTypeFixtures(specs, cwd = process.cwd()) {
     if (size > TYPE_FIXTURE_MAX_BYTES) {
       throw new TypeFixtureSpecError(`--type-fixture ${descriptor}: ${path2} is ${size} bytes (at most ${TYPE_FIXTURE_MAX_BYTES})`);
     }
-    const bytes = readFileSync33(abs);
+    const bytes = readFileSync34(abs);
     let text2;
     try {
       text2 = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
@@ -110343,7 +110738,7 @@ async function runExploreMultiRun(args) {
 import { resolve as resolvePath16 } from "node:path";
 
 // src/campaign-api.ts
-import { existsSync as existsSync33, readFileSync as readFileSync34 } from "node:fs";
+import { existsSync as existsSync34, readFileSync as readFileSync35 } from "node:fs";
 import { mkdir as mkdir31, writeFile as writeFile39 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname28, isAbsolute as isAbsolute11, join as join66, resolve as resolve19 } from "node:path";
@@ -110460,7 +110855,7 @@ var at2 = (path2) => path2.length === 0 ? "spec" : path2.map((p) => typeof p ===
 async function validateCampaign(specPath, opts) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync34(specPath, "utf8"));
+    raw = JSON.parse(readFileSync35(specPath, "utf8"));
   } catch (e) {
     throw new CampaignSpecError([`cannot read ${specPath}: ${e instanceof SyntaxError ? "not valid JSON" : e instanceof Error ? e.message : String(e)}`]);
   }
@@ -110484,8 +110879,8 @@ async function validateCampaignSpec(raw, specPath, opts) {
     problems.push(`env: ${err.message}`);
   }
   const defaultSession = spec.storageState === void 0 ? environment?.storageState : abs(spec.storageState);
-  if (spec.storageState !== void 0 && !existsSync33(abs(spec.storageState))) problems.push(`storageState: not found: ${abs(spec.storageState)}`);
-  if (spec.fixtures !== void 0 && !existsSync33(abs(spec.fixtures))) problems.push(`fixtures: not found: ${abs(spec.fixtures)}`);
+  if (spec.storageState !== void 0 && !existsSync34(abs(spec.storageState))) problems.push(`storageState: not found: ${abs(spec.storageState)}`);
+  if (spec.fixtures !== void 0 && !existsSync34(abs(spec.fixtures))) problems.push(`fixtures: not found: ${abs(spec.fixtures)}`);
   if ((spec.before !== void 0 || spec.after !== void 0) && opts.allowShellHooks !== true) {
     problems.push("before/after: operator shell hooks run only with --allow-shell-hooks");
   }
@@ -110510,7 +110905,7 @@ async function validateCampaignSpec(raw, specPath, opts) {
     }
     if (new Set(job.strategies).size !== job.strategies.length) problems.push(`${where}.strategies: duplicate strategy`);
     const session2 = job.storageState === void 0 ? defaultSession : abs(job.storageState);
-    if (job.storageState !== void 0 && !existsSync33(abs(job.storageState))) problems.push(`${where}.storageState: not found: ${abs(job.storageState)}`);
+    if (job.storageState !== void 0 && !existsSync34(abs(job.storageState))) problems.push(`${where}.storageState: not found: ${abs(job.storageState)}`);
     let stored = null;
     try {
       stored = await registry3.get(job.journey);
@@ -110555,7 +110950,7 @@ async function validateCampaignSpec(raw, specPath, opts) {
     if (deepest > 0) {
       try {
         const prefix = journeyPrefix(full, deepest);
-        validateParams(deriveParamSchema(prefix.recording), prefixParams(full, prefix, job.params ?? {}));
+        validateParams(journeyParamSchema(prefix), prefixParams(full, prefix, job.params ?? {}));
       } catch (err) {
         problems.push(`${where}.params: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -112278,7 +112673,7 @@ function registerExploreRun(program2, deps, buildProgram2) {
       emitExplore(fail(err.code, err.message));
       return;
     }
-    if (o.storageState !== void 0 && !existsSync34(o.storageState) && (authCheck.mode === "off" || projectPersona?.login === void 0)) {
+    if (o.storageState !== void 0 && !existsSync35(o.storageState) && (authCheck.mode === "off" || projectPersona?.login === void 0)) {
       emitExplore(fail("E_EXPLORE_ARGS", `storage state not found: ${o.storageState}`));
       return;
     }
@@ -112570,11 +112965,11 @@ function pick3(k, v) {
 import { resolve as resolve22 } from "node:path";
 
 // src/sweep-api.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync11, readFileSync as readFileSync35, realpathSync as realpathSync5, statSync as statSync11, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync11, readFileSync as readFileSync36, realpathSync as realpathSync5, statSync as statSync11, writeFileSync as writeFileSync13 } from "node:fs";
 import { basename as basename18, dirname as dirname30, extname as extname2, join as join68, resolve as resolve21 } from "node:path";
 
 // src/mcp-paths.ts
-import { existsSync as existsSync35, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync36, realpathSync as realpathSync4 } from "node:fs";
 import { basename as basename17, dirname as dirname29, isAbsolute as isAbsolute12, join as join67, relative as relative9, resolve as resolve20, sep as sep9 } from "node:path";
 var McpPathError = class extends Error {
   error = "invalid_args";
@@ -112592,7 +112987,7 @@ function realish(p) {
   let head2 = p;
   const tail = [];
   for (; ; ) {
-    if (existsSync35(head2)) {
+    if (existsSync36(head2)) {
       try {
         return join67(realpathSync4(head2), ...tail);
       } catch {
@@ -112968,6 +113363,29 @@ var CLI_TOOL_SPECS = [
       omitted: { "--dir": OMIT.storeDir, "--allow": OMIT.mcpOrigins, ...HOOK_FLAGS, ...BROWSER_FLAGS, ...JSON_FLAG }
     }
   },
+  {
+    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.",
+    command: {
+      path: "journey chain",
+      params: {
+        from: s2("--from", { required: true }),
+        to: s2("--to", { required: true }),
+        requests: path("--requests", { required: true }),
+        storageState: session("--storage-state"),
+        ...EXTENSION,
+        ...EMULATION,
+        ...ENVIRONMENT
+      },
+      omitted: {
+        "--allow-draft": "#580: over MCP a chain runs promoted Journeys only, as run_journey does; running drafts is the operator's CLI call",
+        "--dir": OMIT.storeDir,
+        "--allow": OMIT.mcpOrigins,
+        ...BROWSER_FLAGS,
+        ...JSON_FLAG
+      }
+    }
+  },
   {
     name: "publish_journey",
     description: "`jevitate journey publish <id> --to <source>`: publish a promoted Journey into a registered source on a new publish/<id> branch (a PR when gh is available). Secret references only; declared origins must cover its steps.",
@@ -113994,7 +114412,7 @@ function personaOf(value, base, roots, where, problems) {
   }
   try {
     const confined = confineMcpPath(abs, `persona of ${where}`, roots, { session: true });
-    if (!existsSync36(confined)) {
+    if (!existsSync37(confined)) {
       problems.push(`${where}: persona storage state not found: ${confined}`);
       return void 0;
     }
@@ -114063,8 +114481,8 @@ function validateRunShaping(options, strategy, where, problems) {
 }
 function loadSweepTargets(path2, opts = {}) {
   const abs = resolve21(path2);
-  if (!existsSync36(abs)) throw new SweepSpecError(`targets file not found: ${abs}`);
-  const text2 = readFileSync35(abs, "utf8");
+  if (!existsSync37(abs)) throw new SweepSpecError(`targets file not found: ${abs}`);
+  const text2 = readFileSync36(abs, "utf8");
   const isTsv = /\.(tsv|txt)$/i.test(abs);
   const parsed = isTsv ? parseTsv(text2, path2) : parseJson(text2, path2);
   const problems = [...parsed.problems];
@@ -114311,9 +114729,9 @@ function targetArgv(plan2, target, runDir) {
   ];
 }
 function finishedEnvelope(envelopePath) {
-  if (!existsSync36(envelopePath)) return void 0;
+  if (!existsSync37(envelopePath)) return void 0;
   try {
-    const env = JSON.parse(readFileSync35(envelopePath, "utf8"));
+    const env = JSON.parse(readFileSync36(envelopePath, "utf8"));
     if (!isRecord(env) || env.ok !== true || !isRecord(env.data)) return void 0;
     if (env.data.interrupted !== void 0) return void 0;
     return env;
@@ -114687,7 +115105,7 @@ function registerVerifyFixCommands(program2, deps) {
 }
 
 // src/author-journey-cli.ts
-import { existsSync as existsSync37 } from "node:fs";
+import { existsSync as existsSync38 } from "node:fs";
 var AUTHOR_GOAL_RUN_FLAGS = [
   "successWhen",
   "allowVacuousChecks",
@@ -114783,7 +115201,7 @@ function registerAuthorJourneyCommands(program2, deps) {
     ].join("\n")
   ).action(async function() {
     const o = this.opts();
-    if (o.storageState !== void 0 && !existsSync37(o.storageState)) {
+    if (o.storageState !== void 0 && !existsSync38(o.storageState)) {
       emitJson(program2, fail("E_EXPLORE_ARGS", `storage state not found: ${o.storageState}`));
       return;
     }
@@ -114905,11 +115323,11 @@ function registerAuthorJourneyCommands(program2, deps) {
 }
 
 // src/demo-aspect-cli.ts
-import { existsSync as existsSync39 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 import { join as join71, resolve as resolvePath18 } from "node:path";
 
 // src/demo-aspect-api.ts
-import { existsSync as existsSync38 } from "node:fs";
+import { existsSync as existsSync39 } from "node:fs";
 import { mkdir as mkdir33, mkdtemp as mkdtemp5, readFile as readFile33, rm as rm13, writeFile as writeFile41 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
 import { dirname as dirname31, join as join70 } from "node:path";
@@ -115246,7 +115664,7 @@ async function demoAspect(opts) {
   const store = new FsJourneyStore(opts.journeysDir);
   if (await store.get(id) !== null) throw new DemoExistsError(`journey '${id}' already exists \u2014 pick another --id (nothing was changed)`);
   const recordPath = demoDraftPath(opts.journeysDir, id);
-  if (existsSync38(recordPath)) {
+  if (existsSync39(recordPath)) {
     throw new DemoExistsError(`a demo draft '${id}' is waiting for approval (${recordPath}) \u2014 approve it with \`jevitate demo approve ${id}\`, or pick another --id`);
   }
   const maxReplays = opts.maxReplays ?? DEMO_MINIMIZE_MAX_REPLAYS;
@@ -115493,7 +115911,7 @@ function replayOptionsFrom(cmd, deps, o, environment) {
     fixtureIdentity: o.fixtureIdentity
   };
   const storageState = o.storageState ?? environment.storageState;
-  if (storageState !== void 0 && !existsSync39(storageState)) throw new DemoAspectArgsError(`storage state not found: ${storageState}`);
+  if (storageState !== void 0 && !existsSync40(storageState)) throw new DemoAspectArgsError(`storage state not found: ${storageState}`);
   let browser;
   let emulation;
   try {
@@ -115846,12 +116264,12 @@ function registerRecordCommands(program2, deps) {
 }
 
 // src/regression-cli.ts
-import { existsSync as existsSync41 } from "node:fs";
+import { existsSync as existsSync42 } from "node:fs";
 import { readFile as readFile35, writeFile as writeFile43 } from "node:fs/promises";
 import { join as join73 } from "node:path";
 
 // src/regression-api.ts
-import { existsSync as existsSync40 } from "node:fs";
+import { existsSync as existsSync41 } from "node:fs";
 import { readFile as readFile34 } from "node:fs/promises";
 var RegressionExistsError = class extends Error {
   code = "E_REGRESSION_EXISTS";
@@ -115939,7 +116357,7 @@ function describeNoOracle(missionResult) {
 }
 async function runRegressionCapture(opts) {
   const recordingPath = safeChildPath(opts.regressionsDir, opts.id, { what: "regression id", suffix: ".recording.json" });
-  if (opts.force !== true && existsSync40(recordingPath)) {
+  if (opts.force !== true && existsSync41(recordingPath)) {
     throw new RegressionExistsError(opts.id, opts.regressionsDir);
   }
   const raw = JSON.parse(await readFile34(opts.failingRecordingPath, "utf8"));
@@ -116181,12 +116599,12 @@ function registerRegressionCommands(program2, deps) {
     const { from, id, dir, attempts, summary: summary2, result: resultPath, fingerprint: fingerprint2, storageState, force, json: json2, param } = flags;
     if (refuseUnsafeName(program2, id, "regression id")) return;
     for (const [flag, path2] of [["--from", from], ["--result", resultPath]]) {
-      if (path2 !== void 0 && !existsSync41(path2)) {
+      if (path2 !== void 0 && !existsSync42(path2)) {
         emitJson(program2, fail("E_REGRESSION_ARGS", `${flag} file not found: ${path2}`));
         return;
       }
     }
-    if (storageState !== void 0 && !existsSync41(storageState)) {
+    if (storageState !== void 0 && !existsSync42(storageState)) {
       emitJson(program2, fail("E_REGRESSION_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -116283,7 +116701,7 @@ function registerRegressionCommands(program2, deps) {
       return;
     }
     const storageState = storageStateFlag ?? environment?.storageState;
-    if (storageState !== void 0 && !existsSync41(storageState)) {
+    if (storageState !== void 0 && !existsSync42(storageState)) {
       emitJson(program2, fail("E_REGRESSION_ARGS", `storage state not found: ${storageState}`));
       return;
     }
@@ -116296,7 +116714,7 @@ function registerRegressionCommands(program2, deps) {
     }
     if (refuseUnsafeName(program2, id, "regression id")) return;
     const regressionsDir = resolveRegressionsDir(dir);
-    if (!existsSync41(join73(regressionsDir, `${id}.recording.json`))) {
+    if (!existsSync42(join73(regressionsDir, `${id}.recording.json`))) {
       const notFound = new RegressionNotFoundError(id, regressionsDir);
       emitJson(program2, fail(notFound.code, notFound.message));
       return;
@@ -116354,7 +116772,7 @@ function registerRegressionCommands(program2, deps) {
 }
 
 // src/mission-api.ts
-import { existsSync as existsSync42 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import { resolve as resolvePath19 } from "node:path";
 var UnknownMissionTargetError = class extends Error {
 };
@@ -116392,7 +116810,7 @@ function applyAuth(target, auth) {
   }
   if (auth.storageState !== void 0) {
     const abs = resolvePath19(auth.storageState);
-    if (!existsSync42(abs)) throw new MissionTargetAuthError(`storage state not found: ${abs}`);
+    if (!existsSync43(abs)) throw new MissionTargetAuthError(`storage state not found: ${abs}`);
     base.storageState = abs;
   }
   if (auth.saveStorageState !== void 0) base.saveStorageState = auth.saveStorageState === true ? true : resolvePath19(auth.saveStorageState);
@@ -116437,7 +116855,7 @@ async function promoteMissionTarget(ctx, id) {
 }
 
 // src/mission-queue-cli.ts
-import { readFileSync as readFileSync36 } from "node:fs";
+import { readFileSync as readFileSync37 } from "node:fs";
 import { Option as Option2 } from "commander";
 
 // src/mcp-api.ts
@@ -116496,6 +116914,9 @@ var ALLOWED_TOOLS = [
   // #401 — the assertion-strength lint promote_journey applies; #402 — its mutation proof.
   "lint_journey",
   "verify_journey",
+  // #580 — the two-journey chain: discover once, prepare-only reply per approved request. Promoted
+  // Journeys only (--allow-draft is CLI-only); ids and outcomes only, never record or reply text.
+  "chain_journeys",
   // #425 — a sweep: many explore missions over a targets file, one aggregated result.
   "run_sweep",
   // #432 — the read-only review sheet a person reads before promote_journey (bound by its content hash).
@@ -117265,7 +117686,7 @@ var tagsArg = (args) => {
 };
 
 // src/mcp-tools/findings.ts
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 import { access, readFile as readFile37 } from "node:fs/promises";
 import { join as join77 } from "node:path";
 function findingTools(ctx) {
@@ -117355,7 +117776,7 @@ function findingTools(ctx) {
   };
   const verifyFixOptions = (args) => {
     const storageState = optPath(args, "storageState", pathRoots, { session: true });
-    if (storageState !== void 0 && !existsSync43(storageState)) throw new McpArgError(`storage state not found: ${storageState}`);
+    if (storageState !== void 0 && !existsSync44(storageState)) throw new McpArgError(`storage state not found: ${storageState}`);
     const replays = optInt(args, "replays", 1);
     const invariantFiles = (optStringArray(args, "invariants") ?? []).map((f2, i) => optPath({ [`invariants[${i}]`]: f2 }, `invariants[${i}]`, pathRoots));
     const fixtures = optPath(args, "fixtures", pathRoots);
@@ -117484,7 +117905,7 @@ function findingTools(ctx) {
 }
 
 // src/mcp-tools/journey.ts
-import { existsSync as existsSync44 } from "node:fs";
+import { existsSync as existsSync45 } from "node:fs";
 function journeyTools(ctx) {
   const { deps, pathRoots, credentialStore, runJourney } = ctx;
   const findCaps = deps.findCapabilities ?? ((query) => findCapabilities(new JourneyRegistry(new FsJourneyStore(deps.journeysDir)), query));
@@ -117497,7 +117918,7 @@ function journeyTools(ctx) {
       { ...deps.environmentsFile === void 0 ? {} : { environmentsFile: deps.environmentsFile }, ...deps.targetsConfigPath === void 0 ? {} : { targetsFile: deps.targetsConfigPath } }
     );
     const storageState = optPath(args, "storageState", pathRoots, { session: true }) ?? environment?.storageState;
-    if (args.storageState !== void 0 && storageState !== void 0 && !existsSync44(storageState)) throw new McpArgError(`storage state not found: ${storageState}`);
+    if (args.storageState !== void 0 && storageState !== void 0 && !existsSync45(storageState)) throw new McpArgError(`storage state not found: ${storageState}`);
     const headed = optBool(args, "headed");
     const slowMo = optInt(args, "slowMo", 0);
     const recordVideo = optRecordVideo(args, pathRoots);
@@ -118111,7 +118532,7 @@ function registerMissionQueueCommands(program2, mission, deps) {
     let invariants;
     if (o.invariants !== void 0) {
       try {
-        invariants = JSON.parse(readFileSync36(o.invariants, "utf8"));
+        invariants = JSON.parse(readFileSync37(o.invariants, "utf8"));
       } catch (e) {
         refuse4("E_MISSION_QUEUE_INVARIANTS", `cannot read invariants file ${o.invariants}: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`);
         return;
@@ -118868,7 +119289,7 @@ function registerUxCommands(program2, deps) {
 }
 
 // src/logs-retention.ts
-import { readFileSync as readFileSync37, readdirSync as readdirSync11, rmSync as rmSync2, rmdirSync as rmdirSync2, statSync as statSync12 } from "node:fs";
+import { readFileSync as readFileSync38, readdirSync as readdirSync11, rmSync as rmSync2, rmdirSync as rmdirSync2, statSync as statSync12 } from "node:fs";
 import { join as join79 } from "node:path";
 var DEFAULT_LOGS_RETENTION = { ttlDays: 14, keepLatest: 50 };
 var LogsConfigError = class extends Error {
@@ -118877,7 +119298,7 @@ var LogsConfigError = class extends Error {
 function loadLogsRetention(path2 = resolveDataDir(["config.json"])) {
   let raw;
   try {
-    raw = readFileSync37(path2, "utf8");
+    raw = readFileSync38(path2, "utf8");
   } catch (e) {
     if (typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT") return DEFAULT_LOGS_RETENTION;
     throw new LogsConfigError(`cannot read ${path2}: ${e instanceof Error ? e.message : String(e)}`);
@@ -118938,8 +119359,8 @@ function pruneLogs(root2, retention, opts = {}) {
 }
 
 // src/logs-cli.ts
-import { readFileSync as readFileSync38 } from "node:fs";
-import { existsSync as existsSync45 } from "node:fs";
+import { readFileSync as readFileSync39 } from "node:fs";
+import { existsSync as existsSync46 } from "node:fs";
 var LOG_WRITING_COMMANDS = /* @__PURE__ */ new Set(["explore", "explore-author-journey", "record", "ux", "check", "run", "verify-fix", "capture"]);
 function registerLogsCommands(program2, deps) {
   const configPath = deps.logs?.configPath ?? resolveDataDir(["config.json"]);
@@ -118977,7 +119398,7 @@ function registerLogsCommands(program2, deps) {
     const emit5 = (envelope) => emitJson(program2, envelope);
     if (o.real === true && o.fakeAi === true) return emit5(fail("E_LOGS_ARGS", "--real and --fake-ai are mutually exclusive \u2014 pass one, not both"));
     if (o.threshold !== void 0 && !(o.threshold >= 0 && o.threshold <= 1)) return emit5(fail("E_LOGS_ARGS", "--threshold must be a probability in 0..1"));
-    if (!existsSync45(signalsPathFor(o.result))) {
+    if (!existsSync46(signalsPathFor(o.result))) {
       return emit5(fail("E_LOGS_ARGS", `no signals next to ${o.result} (${signalsPathFor(o.result)}): run explore with --log-source and --log-triage first`));
     }
     let secrets;
@@ -118990,7 +119411,7 @@ function registerLogsCommands(program2, deps) {
       throw err;
     }
     try {
-      const file2 = JSON.parse(readFileSync38(o.result, "utf8"));
+      const file2 = JSON.parse(readFileSync39(o.result, "utf8"));
       if (typeof file2.result !== "object" || file2.result === null) return emit5(fail("E_LOGS_ARGS", `${o.result} is not a jevitate run result`));
       const judge = o.real === true ? (await buildExploreGateways(deps, { real: true, fakeAi: false, jevProvider: o.jevProvider })).judge : void 0;
       const updated = await triageRunResult(file2.result, o.result, {
@@ -119014,7 +119435,7 @@ result   ${o.result}
 }
 
 // src/inbox-cli.ts
-import { readFileSync as readFileSync39 } from "node:fs";
+import { readFileSync as readFileSync40 } from "node:fs";
 import { Option as Option3 } from "commander";
 var INBOX_DIR_HELP = "inbox store directory (default: ~/.jevitate/inbox \u2014 the dir `jevitate mcp` and `jevitate ui` use)";
 var REDACTED = "***REDACTED***";
@@ -119122,7 +119543,7 @@ function registerInboxCommands(program2, deps) {
     let findings;
     if (o.findings !== void 0) {
       try {
-        findings = JSON.parse(readFileSync39(o.findings, "utf8"));
+        findings = JSON.parse(readFileSync40(o.findings, "utf8"));
       } catch (e) {
         const code = `E_${commandPath(cmd).toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_INPUT`;
         emitJsonOrRefusal(program2, fail(code, `cannot read --findings ${o.findings}: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`));