omp-conductor 0.15.6 → 0.15.7

package/src/setup-discover.ts

@@ -0,0 +1,425 @@
+/** Deterministic, fail-open facts used to pre-fill the setup interview. */
+
+export const DISCOVERY_TIMEOUT_MS = 5_000;
+
+export interface DiscoveryRunResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  timedOut?: boolean;
+}
+
+export type DiscoveryRunner = (
+  argv: readonly string[],
+  opts?: { cwd?: string },
+) => Promise<DiscoveryRunResult>;
+
+export interface DiscoveredRepoFacts {
+  defaultBranch?: string;
+  labels?: string[];
+  environments?: string[];
+  requiredChecks?: string[];
+}
+
+export interface DiscoveredFacts extends DiscoveredRepoFacts {
+  trackerRepo?: string;
+  routingKey?: string;
+  cloneUrl?: string;
+  artefacts?: string[];
+  roadmaps?: string[];
+  evidence?: string[];
+  skipped?: string[];
+}
+
+export interface DiscoveryTarget {
+  cwd: string;
+}
+
+function jsonObject(raw: string): Record<string, unknown> | undefined {
+  try {
+    const value: unknown = JSON.parse(raw);
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Parse `gh repo view --json defaultBranchRef`. */
+export function defaultBranchFrom(raw: string): string | undefined {
+  const ref = jsonObject(raw)?.defaultBranchRef;
+  if (typeof ref !== "object" || ref === null || Array.isArray(ref)) return undefined;
+  const name = (ref as Record<string, unknown>).name;
+  return typeof name === "string" && name.trim() !== "" ? name.trim() : undefined;
+}
+
+/** Parse `gh label list --json name`. */
+export function labelsFrom(raw: string): string[] | undefined {
+  try {
+    const value: unknown = JSON.parse(raw);
+    if (!Array.isArray(value)) return undefined;
+    const names: string[] = [];
+    for (const row of value) {
+      if (typeof row !== "object" || row === null || Array.isArray(row)) return undefined;
+      const name = (row as Record<string, unknown>).name;
+      if (typeof name !== "string" || name.trim() === "") return undefined;
+      names.push(name.trim());
+    }
+    return names;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Parse GitHub's environments REST response. */
+export function environmentsFrom(raw: string): string[] | undefined {
+  const rows = jsonObject(raw)?.environments;
+  if (!Array.isArray(rows)) return undefined;
+  const names: string[] = [];
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) return undefined;
+    const name = (row as Record<string, unknown>).name;
+    if (typeof name !== "string" || name.trim() === "") return undefined;
+    names.push(name.trim());
+  }
+  return names;
+}
+
+/** Parse branch protection, or the branch's latest check-runs fallback. */
+export function requiredChecksFrom(raw: string): string[] | undefined {
+  const parsed = jsonObject(raw);
+  if (parsed === undefined) return undefined;
+  const names: string[] = [];
+  const protection = parsed.required_status_checks;
+  if (protection === null) return [];
+  if (typeof protection === "object" && protection !== null && !Array.isArray(protection)) {
+    const status = protection as Record<string, unknown>;
+    if (!Array.isArray(status.contexts) && !Array.isArray(status.checks)) return undefined;
+    if (Array.isArray(status.contexts)) {
+      for (const context of status.contexts) {
+        if (typeof context !== "string" || context.trim() === "") return undefined;
+        names.push(context.trim());
+      }
+    }
+    if (Array.isArray(status.checks)) {
+      for (const check of status.checks) {
+        if (typeof check !== "object" || check === null || Array.isArray(check)) return undefined;
+        const context = (check as Record<string, unknown>).context;
+        if (typeof context !== "string" || context.trim() === "") return undefined;
+        names.push(context.trim());
+      }
+    }
+    return [...new Set(names)];
+  }
+
+  const runs = parsed.check_runs;
+  if (!Array.isArray(runs)) return undefined;
+  for (const run of runs) {
+    if (typeof run !== "object" || run === null || Array.isArray(run)) return undefined;
+    const name = (run as Record<string, unknown>).name;
+    if (typeof name !== "string" || name.trim() === "") return undefined;
+    names.push(name.trim());
+  }
+  return [...new Set(names)];
+}
+
+/** Parse a package manifest into the npm artefact it publishes. */
+export function artefactsFromPackage(raw: string): string[] | undefined {
+  const manifest = jsonObject(raw);
+  const name = manifest?.name;
+  if (manifest?.private === true) return undefined;
+  return typeof name === "string" && name.trim() !== "" ? [name.trim()] : undefined;
+}
+
+/** Parse a recursive Git tree into repository package-manifest paths. */
+export function packagePathsFrom(raw: string): string[] | undefined {
+  // A truncated recursive tree is a partial view of a large repository: a
+  // single visible manifest cannot be trusted as "the" artefact, so the whole
+  // field is unavailable rather than guessed from the slice GitHub returned.
+  if (jsonObject(raw)?.truncated === true) return undefined;
+  const tree = jsonObject(raw)?.tree;
+  if (!Array.isArray(tree)) return undefined;
+  const paths: string[] = [];
+  for (const row of tree) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) return undefined;
+    const path = (row as Record<string, unknown>).path;
+    if (typeof path !== "string") return undefined;
+    if ((path === "package.json" || path.endsWith("/package.json")) && !path.includes("node_modules/")) {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+
+/** Parse open milestones into operator-facing roadmap choices. */
+export function milestonesFrom(raw: string): string[] | undefined {
+  try {
+    const value: unknown = JSON.parse(raw);
+    if (!Array.isArray(value)) return undefined;
+    const choices: string[] = [];
+    for (const row of value) {
+      if (typeof row !== "object" || row === null || Array.isArray(row)) return undefined;
+      const milestone = row as Record<string, unknown>;
+      if (typeof milestone.title !== "string" || milestone.title.trim() === "") return undefined;
+      choices.push(
+        typeof milestone.html_url === "string" && milestone.html_url.trim() !== ""
+          ? `${milestone.title.trim()} — ${milestone.html_url.trim()}`
+          : milestone.title.trim(),
+      );
+    }
+    return choices;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Parse `gh project list --format json` into operator-facing roadmap choices. */
+export function projectsFrom(raw: string): string[] | undefined {
+  const projects = jsonObject(raw)?.projects;
+  if (!Array.isArray(projects)) return undefined;
+  const choices: string[] = [];
+  for (const row of projects) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) return undefined;
+    const project = row as Record<string, unknown>;
+    if (project.closed === true) continue;
+    if (typeof project.title !== "string" || project.title.trim() === "") return undefined;
+    choices.push(
+      typeof project.url === "string" && project.url.trim() !== ""
+        ? `${project.title.trim()} — ${project.url.trim()}`
+        : project.title.trim(),
+    );
+  }
+  return choices;
+}
+
+/** Parse a Git remote URL into the `owner/repo` spelling setup accepts. */
+export function trackerRepoFrom(raw: string): string | undefined {
+  const remote = raw.trim().replace(/\/$/, "").replace(/\.git$/, "");
+  if (remote === "") return undefined;
+  let path: string;
+  try {
+    path = new URL(remote).pathname;
+  } catch {
+    const colon = remote.indexOf(":");
+    if (colon === -1) return undefined;
+    path = remote.slice(colon + 1);
+  }
+  const parts = path.split("/").filter(Boolean);
+  if (parts.length !== 2 || parts.some((part) => !/^[A-Za-z0-9._-]+$/.test(part))) return undefined;
+  return `${parts[0]}/${parts[1]}`;
+}
+
+/** The routing key of a single repository is its clone URL's repository name. */
+export function routingKeyFromCloneUrl(raw: string): string | undefined {
+  return trackerRepoFrom(raw)?.split("/")[1];
+}
+
+/** A bounded subprocess runner. Missing executables and every other fault are data. */
+export const runDiscovery: DiscoveryRunner = async (argv, opts = {}) => {
+  try {
+    const proc = Bun.spawn([...argv], {
+      ...(opts.cwd === undefined ? {} : { cwd: opts.cwd }),
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+        // The child won the race and already exited.
+      }
+    }, DISCOVERY_TIMEOUT_MS);
+    try {
+      const [exitCode, stdout, stderr] = await Promise.all([
+        proc.exited,
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ]);
+      return { exitCode, stdout, stderr, ...(timedOut ? { timedOut: true } : {}) };
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch (err) {
+    return { exitCode: -1, stdout: "", stderr: err instanceof Error ? err.message : String(err) };
+  }
+};
+
+async function attempted(
+  run: DiscoveryRunner,
+  argv: readonly string[],
+  opts?: { cwd?: string },
+): Promise<DiscoveryRunResult> {
+  try {
+    return await run(argv, opts);
+  } catch (err) {
+    return { exitCode: -1, stdout: "", stderr: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+function failure(result: DiscoveryRunResult): string {
+  if (result.timedOut === true) return `timed out after ${DISCOVERY_TIMEOUT_MS / 1_000}s`;
+  const lines = result.stderr.trim().split("\n").filter(Boolean);
+  return lines.slice(-2).join(" ") || `command exited ${result.exitCode}`;
+}
+
+function parsed<T>(
+  label: string,
+  result: DiscoveryRunResult,
+  parse: (raw: string) => T | undefined,
+  skipped: string[],
+): T | undefined {
+  if (result.exitCode !== 0) {
+    skipped.push(`${label}: ${failure(result)}`);
+    return undefined;
+  }
+  const value = parse(result.stdout);
+  if (value === undefined) skipped.push(`${label}: gh returned a malformed reply`);
+  return value;
+}
+
+/** Detailed facts and diagnostics consumed by the wizard's discovery hook. */
+async function discoverRepoFactsDetailed(
+  repo: string,
+  run: DiscoveryRunner,
+): Promise<DiscoveredFacts> {
+  const evidence: string[] = [];
+  const skipped: string[] = [];
+  try {
+    const owner = repo.split("/")[0] ?? repo;
+    const [branchReply, labelsReply, environmentsReply, milestonesReply, projectsReply] = await Promise.all([
+      attempted(run, ["gh", "repo", "view", repo, "--json", "defaultBranchRef"]),
+      attempted(run, ["gh", "label", "list", "--repo", repo, "--limit", "1000", "--json", "name"]),
+      attempted(run, ["gh", "api", `repos/${repo}/environments?per_page=100`]),
+      attempted(run, ["gh", "api", `repos/${repo}/milestones?state=open&per_page=100`]),
+      attempted(run, ["gh", "project", "list", "--owner", owner, "--limit", "100", "--format", "json"]),
+    ]);
+
+    const defaultBranch = parsed("default branch", branchReply, defaultBranchFrom, skipped);
+    const labels = parsed("labels", labelsReply, labelsFrom, skipped);
+    const environments = parsed("release environments", environmentsReply, environmentsFrom, skipped);
+    const milestones = parsed("open milestones", milestonesReply, milestonesFrom, skipped);
+    const projects = parsed("Projects boards", projectsReply, projectsFrom, skipped);
+
+    if (defaultBranch !== undefined) evidence.push(`default branch "${defaultBranch}" — gh repo view ${repo}`);
+    if (labels !== undefined) evidence.push(`labels (${labels.join(", ") || "none"}) — gh label list --repo ${repo}`);
+    if (environments !== undefined) {
+      evidence.push(`release environments (${environments.join(", ") || "none"}) — GitHub environments for ${repo}`);
+    }
+
+    let requiredChecks: string[] | undefined;
+    let artefacts: string[] | undefined;
+    if (defaultBranch !== undefined) {
+      const branch = encodeURIComponent(defaultBranch);
+      const [protectionReply, treeReply] = await Promise.all([
+        attempted(run, ["gh", "api", `repos/${repo}/branches/${branch}/protection`]),
+        attempted(run, ["gh", "api", `repos/${repo}/git/trees/${branch}?recursive=1`]),
+      ]);
+      requiredChecks = parsed("required checks", protectionReply, requiredChecksFrom, []);
+      let checkEvidence = `branch protection for ${repo}@${defaultBranch}`;
+      if (requiredChecks === undefined) {
+        const runsReply = await attempted(run, ["gh", "api", `repos/${repo}/commits/${branch}/check-runs?per_page=100`]);
+        requiredChecks = parsed("required checks", runsReply, requiredChecksFrom, skipped);
+        checkEvidence = `latest check runs for ${repo}@${defaultBranch}`;
+      }
+      if (requiredChecks !== undefined) {
+        evidence.push(`merge checks (${requiredChecks.join(", ") || "none"}) — ${checkEvidence}`);
+      }
+
+      let packagePaths: string[] | undefined;
+      if (jsonObject(treeReply.stdout)?.truncated === true) {
+        skipped.push(
+          "release artefacts: the repository's recursive Git tree was truncated, so the visible manifests may be a partial view; the published artefact is left for you to type",
+        );
+      } else {
+        packagePaths = parsed("release artefacts", treeReply, packagePathsFrom, skipped);
+      }
+      if (packagePaths?.length === 1) {
+        const manifest = await attempted(run, [
+          "gh",
+          "api",
+          "-H",
+          "Accept: application/vnd.github.raw+json",
+          `repos/${repo}/contents/${packagePaths[0]}`,
+        ]);
+        artefacts = parsed("release artefacts", manifest, artefactsFromPackage, skipped);
+        if (artefacts !== undefined) {
+          evidence.push(`release artefact "${artefacts[0]}" — ${packagePaths[0]} package name`);
+        }
+      }
+    }
+
+    const roadmaps = projects === undefined && milestones === undefined
+      ? undefined
+      : [...new Set([...(projects ?? []), ...(milestones ?? [])])];
+    if (roadmaps !== undefined && roadmaps.length > 0) {
+      evidence.push(`roadmap candidates — GitHub Projects and open milestones for ${repo}`);
+    }
+
+    return {
+      ...(defaultBranch === undefined ? {} : { defaultBranch }),
+      ...(labels === undefined ? {} : { labels }),
+      ...(environments === undefined ? {} : { environments }),
+      ...(requiredChecks === undefined ? {} : { requiredChecks }),
+      ...(artefacts === undefined ? {} : { artefacts }),
+      ...(roadmaps === undefined ? {} : { roadmaps }),
+      evidence,
+      skipped,
+    };
+  } catch (err) {
+    return {
+      evidence,
+      skipped: [...skipped, `repo discovery: ${err instanceof Error ? err.message : String(err)}`],
+    };
+  }
+}
+
+/** Discover the four exact repository facts exposed as the module's pure API. */
+export async function discoverRepoFacts(
+  repo: string,
+  run: DiscoveryRunner = runDiscovery,
+): Promise<DiscoveredRepoFacts> {
+  const found = await discoverRepoFactsDetailed(repo, run);
+  return {
+    ...(found.defaultBranch === undefined ? {} : { defaultBranch: found.defaultBranch }),
+    ...(found.labels === undefined ? {} : { labels: found.labels }),
+    ...(found.environments === undefined ? {} : { environments: found.environments }),
+    ...(found.requiredChecks === undefined ? {} : { requiredChecks: found.requiredChecks }),
+  };
+}
+
+/** Discover `owner/repo` from the checkout's origin, or return no value. */
+export async function discoverTrackerRepo(
+  cwd: string,
+  run: DiscoveryRunner = runDiscovery,
+): Promise<string | undefined> {
+  const result = await attempted(run, ["git", "remote", "get-url", "origin"], { cwd });
+  return result.exitCode === 0 ? trackerRepoFrom(result.stdout) : undefined;
+}
+
+/** Compose checkout and GitHub facts for the wizard's single discovery hook. */
+export async function discoverFacts(
+  target: DiscoveryTarget,
+  run: DiscoveryRunner = runDiscovery,
+): Promise<DiscoveredFacts> {
+  const origin = await attempted(run, ["git", "remote", "get-url", "origin"], { cwd: target.cwd });
+  if (origin.exitCode !== 0) {
+    return { evidence: [], skipped: [`tracker repo: ${failure(origin)}`] };
+  }
+  const trackerRepo = trackerRepoFrom(origin.stdout);
+  if (trackerRepo === undefined) {
+    return { evidence: [], skipped: ["tracker repo: origin is not an owner/repo Git remote"] };
+  }
+  const cloneUrl = origin.stdout.trim();
+  const repo = await discoverRepoFactsDetailed(trackerRepo, run);
+  return {
+    ...repo,
+    trackerRepo,
+    cloneUrl,
+    routingKey: routingKeyFromCloneUrl(cloneUrl),
+    evidence: [`tracker repo "${trackerRepo}" — git remote get-url origin`, ...(repo.evidence ?? [])],
+  };
+}

package/src/setup-wizard.ts

@@ -42,6 +42,11 @@ import {
 } from "./setup-host.ts";
 import { runGraphInstall, runHostInstall } from "./setup-install.ts";
 import { probeGates, probeProse, probeRepoMap, type ProbedGate, type ProbeTarget } from "./setup-probe.ts";
+import {
+  discoverFacts,
+  type DiscoveredFacts,
+  type DiscoveryTarget,
+} from "./setup-discover.ts";
 import {
   AMEND_AREAS,
   BASE_FRESHNESS_CHOICES,
@@ -459,10 +464,12 @@ async function askAuthority(
  * shape cannot be added without a question to ask about it — an unasked shape
  * would silently take the deny default and read as a decision afterwards.
  *
- * No fleet vocabulary here on purpose (#122): every one of these is an act the
- * package can recognise anywhere, not a step in one project's release topology.
+ * No fleet-specific vocabulary here (#122): these are generic release acts.
+ * Version preparation becomes executable only when a repo declares its version
+ * file; package names, suite pins and deployment topology still stay in policy.
  */
 const RELEASE_SHAPE_QUESTIONS: { readonly [K in (typeof RELEASE_SHAPES)[number]]: string } = {
+  "version-bump-pr": "open and land an exact version-only pull request before tagging",
   "git-tag": "create git tags (`git tag v1.2.3`)",
   "git-push-tags": "push tags to the remote (`git push --follow-tags`)",
   "package-publish": "publish packages (`npm publish` and equivalents)",
@@ -489,14 +496,26 @@ async function askJudgment(
   ui: WizardUi,
   grants: ResolvedGrants,
   prior: OperatorJudgment,
+  roadmapChoices: readonly string[] = [],
 ): Promise<OperatorJudgment> {
   // Always asked. A tracker shows what is open, never what matters, and an
   // orchestrator that cannot rank work grooms by recency — which is how a stale
   // issue outranks the thing being shipped this month.
+  let roadmapSeed = prior.roadmap ?? "";
+  if (roadmapSeed === "" && roadmapChoices.length > 0) {
+    const other = "Type a different roadmap or priority";
+    const picked = await ui.select(
+      "Roadmap candidates found in GitHub",
+      [...roadmapChoices.map((label) => ({ label })), { label: other }],
+      { initialIndex: 0 },
+    );
+    if (picked === undefined) throw new Cancelled();
+    roadmapSeed = picked === other ? "" : picked;
+  }
   const roadmap = await ask(
     ui,
     "Where does the roadmap live, and what is the current priority?",
-    prior.roadmap ?? "",
+    roadmapSeed,
   );
   const judgment: OperatorJudgment = { ...prior, ...(roadmap.length === 0 ? {} : { roadmap }) };
 
@@ -735,7 +754,12 @@ function priorProject(existing: ConductorConfig | undefined, name: string | unde
  * prompts or the defaults they pre-fill from: the value shown is always the value
  * that would otherwise be carried through.
  */
-type AreaAsker = (ui: WizardUi, a: SetupAnswers, probes: SetupProbes) => Promise<SetupAnswers>;
+type AreaAsker = (
+  ui: WizardUi,
+  a: SetupAnswers,
+  probes: SetupProbes,
+  discovered?: DiscoveredFacts,
+) => Promise<SetupAnswers>;
 
 /**
  * The repo-reading half of onboarding, injected rather than called directly.
@@ -747,6 +771,8 @@ type AreaAsker = (ui: WizardUi, a: SetupAnswers, probes: SetupProbes) => Promise
  * peer, a private repo, or a model that answered in prose.
  */
 export interface SetupProbes {
+  /** Finds exact checkout/GitHub facts. `{}` seeds nothing. */
+  discover(target: DiscoveryTarget): Promise<DiscoveredFacts>;
   /** Proposes a repo's pre-push gates by reading its CI. `[]` seeds nothing. */
   gates(ui: WizardUi, target: ProbeTarget): Promise<ProbedGate[]>;
   /**
@@ -758,12 +784,77 @@ export interface SetupProbes {
 
 /** Reads each repo to propose answers. */
 export const DEFAULT_PROBES: SetupProbes = {
+  discover: (target) => discoverFacts(target),
   gates: (ui, target) => probeGates(ui, target),
   prose: (ui, a) => proseFromRepos(ui, a),
 };
 
 /** `--no-ai`, and every wizard test: nothing is read, nothing is proposed. */
-export const NO_PROBES: SetupProbes = { gates: async () => [], prose: async () => ({}) };
+export const NO_PROBES: SetupProbes = {
+  discover: async () => ({}),
+  gates: async () => [],
+  prose: async () => ({}),
+};
+
+/** Exact facts replace only fresh defaults; saved operator answers always win. */
+function seedFromDiscovery(seed: SetupAnswers, found: DiscoveredFacts): SetupAnswers {
+  const labels = new Map((found.labels ?? []).map((name) => [name.toLowerCase(), name]));
+  const trackerRepo = seed.trackerRepo || found.trackerRepo || "";
+  const targetRepos =
+    seed.targetRepos.length > 0 ||
+    found.routingKey === undefined ||
+    found.cloneUrl === undefined
+      ? seed.targetRepos
+      : [
+          {
+            name: found.routingKey,
+            cloneUrl: found.cloneUrl,
+            defaultBranch: found.defaultBranch ?? SETUP_DEFAULTS.defaultBranch,
+            gates: [],
+          },
+        ];
+  return {
+    ...seed,
+    trackerRepo,
+    queueLabel: labels.get(seed.queueLabel.toLowerCase()) ?? seed.queueLabel,
+    stateLabels: {
+      inProgress: labels.get(seed.stateLabels.inProgress.toLowerCase()) ?? seed.stateLabels.inProgress,
+      blocked: labels.get(seed.stateLabels.blocked.toLowerCase()) ?? seed.stateLabels.blocked,
+      failed: labels.get(seed.stateLabels.failed.toLowerCase()) ?? seed.stateLabels.failed,
+    },
+    targetRepos,
+    policy: {
+      merge: {
+        ...seed.policy.merge,
+        requiredChecks: found.requiredChecks ?? seed.policy.merge.requiredChecks,
+      },
+      release: {
+        ...seed.policy.release,
+        artefacts: found.artefacts ?? seed.policy.release.artefacts,
+        environments: found.environments ?? seed.policy.release.environments,
+      },
+    },
+  };
+}
+
+function showDiscovery(ui: WizardUi, found: DiscoveredFacts): void {
+  if ((found.evidence?.length ?? 0) > 0) {
+    ui.notify(
+      [
+        "Discovered setup defaults:",
+        ...(found.evidence ?? []).map((line) => `  ${line}`),
+        "Every value remains editable at its prompt.",
+      ].join("\n"),
+      "info",
+    );
+  }
+  if ((found.skipped?.length ?? 0) > 0) {
+    ui.notify(
+      ["Some setup discovery was skipped; today's typed defaults remain:", ...(found.skipped ?? []).map((line) => `  ${line}`)].join("\n"),
+      "warning",
+    );
+  }
+}
 
 /**
  * The brief's two prose halves, drafted against **every** configured repo.
@@ -1047,14 +1138,14 @@ const askWorkerModel: AreaAsker = async (ui, a) => {
 
 /** The two ownership questions, then the mechanical gate one shape at a time:
  *  together they are what decides what an unattended fleet may do unasked. */
-const askAuthorityArea: AreaAsker = async (ui, a) => {
+const askAuthorityArea: AreaAsker = async (ui, a, _probes, discovered) => {
   const authority = await askAuthority(ui, a.authority);
   const releaseGrants = await askReleaseGrants(ui, a.releaseGrants);
   // Asked here because it is the same decision one layer down: the grants say
   // who may act, and these say where that permission stops. Amending authority
   // therefore re-asks the boundary, which is the point — a grant widened without
   // restating the boundary is how a delegated release loses its end.
-  const judgment = await askJudgment(ui, releaseGrants, a.judgment ?? {});
+  const judgment = await askJudgment(ui, releaseGrants, a.judgment ?? {}, discovered?.roadmaps);
   return { ...a, authority, releaseGrants, judgment };
 };
 
@@ -1432,12 +1523,17 @@ async function collectAnswers(
   probes: SetupProbes,
   opts: { added?: boolean } = {},
 ): Promise<SetupAnswers> {
+  // Discovery is a fresh-interview default only. Re-runs start from the saved
+  // project, so an operator-edited value is never re-guessed.
+  const discovered = prior === undefined ? await probes.discover({ cwd: process.cwd() }) : {};
+  showDiscovery(ui, discovered);
   // Added projects seed under projects/<name>/; a first install and a re-interview
   // of an existing project keep the flat (or already-on-disk) roots.
-  const seed =
+  const baseSeed =
     prior === undefined
       ? defaultAnswers(projectArg ?? "", { added: opts.added === true })
       : answersFromProject(prior);
+  const seed = prior === undefined ? seedFromDiscovery(baseSeed, discovered) : baseSeed;
 
   const projectName = await askValid(
     ui,
@@ -1462,8 +1558,8 @@ async function collectAnswers(
   // routed repo, under one root.
   a = await askGraph(ui, a, probes);
   a = await askCaps(ui, a, probes);
-  a = await askAuthorityArea(ui, a, probes);
-  a = await askPolicy(ui, a, probes);
+  a = await askAuthorityArea(ui, a, probes, discovered);
+  a = await askPolicy(ui, a, probes, discovered);
   a = await askWorkerModel(ui, a, probes);
   a = await askEscalation(ui, a, probes);
   a = await askReporting(ui, a, probes);

package/src/setup.ts

@@ -131,7 +131,14 @@ export interface SetupAnswers {
   queueLabel: string;
   stateLabels: { inProgress: string; blocked: string; failed: string };
   routingLabelPrefix: string;
-  targetRepos: { name: string; cloneUrl: string; defaultBranch: string; gates: { cmd: string; cwd: string }[] }[];
+  targetRepos: {
+    name: string;
+    cloneUrl: string;
+    defaultBranch: string;
+    gates: { cmd: string; cwd: string }[];
+    migrations?: { dir: string };
+    release?: { versionFile: string };
+  }[];
   caps: Partial<Caps>;
   /**
    * Model pattern for worker sessions, in omp's model/role syntax. Absent means
@@ -170,6 +177,13 @@ export interface SetupAnswers {
    * leave one to be defaulted by whichever reader gets there first.
    */
   policy: ProjectPolicy;
+  /**
+   * Hand-edited recovery merge authorizations carried through setup unchanged.
+   * The wizard never grants one; forgetting them during an unrelated amend
+   * would strand an in-progress recovery, while inventing one would weaken the
+   * merge provenance gate.
+   */
+  recoveryMerges?: ProjectConfig["recoveryMerges"];
   /**
    * Whether to render `ORCHESTRATOR.md` into the project's workspace root. Not
    * part of the config — the brief is the operator's file, and the conductor
@@ -702,6 +716,8 @@ export function buildProject(a: SetupAnswers): ProjectConfig {
       ...(graphRoot === undefined || graphRoot.length === 0
         ? {}
         : { graphProject: graphProjectPath(graphRoot, r.name) }),
+      ...(r.migrations === undefined ? {} : { migrations: { ...r.migrations } }),
+      ...(r.release === undefined ? {} : { release: { ...r.release } }),
     };
   }
 
@@ -749,6 +765,9 @@ export function buildProject(a: SetupAnswers): ProjectConfig {
     // Written out in full for the same reason: the file then says what a merge
     // and a release require without anyone having to know a default (#129).
     policy: clonePolicy(a.policy),
+    ...(a.recoveryMerges === undefined
+      ? {}
+      : { recoveryMerges: a.recoveryMerges.map((entry) => ({ ...entry })) }),
     // Written out even when it is the default, so an operator amending the
     // volume has a line in the file to point at. Opting into availability makes
     // the schedule explicit and daily; omitting it preserves the preset's
@@ -918,6 +937,8 @@ export function answersFromProject(p: ProjectConfig): SetupAnswers {
       cloneUrl: r.cloneUrl,
       defaultBranch: r.defaultBranch,
       gates: r.gates.map((g) => ({ cmd: g.cmd, cwd: g.cwd })),
+      ...(r.migrations === undefined ? {} : { migrations: { ...r.migrations } }),
+      ...(r.release === undefined ? {} : { release: { ...r.release } }),
     })),
     caps: { ...p.caps },
     fallbackToIssueComment: p.escalation.fallbackToIssueComment,
@@ -938,6 +959,9 @@ export function answersFromProject(p: ProjectConfig): SetupAnswers {
   if (p.workerModel !== undefined) answers.workerModel = p.workerModel;
   if (p.escalation.telegramChatId !== undefined) answers.telegramChatId = p.escalation.telegramChatId;
   if (p.escalation.telegramTopicId !== undefined) answers.telegramTopicId = p.escalation.telegramTopicId;
+  if (p.recoveryMerges !== undefined) {
+    answers.recoveryMerges = p.recoveryMerges.map((entry) => ({ ...entry }));
+  }
   if (p.reporting?.digest.at !== undefined) answers.dailyDigestAt = p.reporting.digest.at;
   if (p.reporting?.digest.timezone !== undefined) {
     answers.reportingTimezone = p.reporting.digest.timezone;