omp-conductor 0.10.0 → 0.13.0

package/src/config.ts

@@ -24,6 +24,7 @@ import {
   DEFAULT_AUTHORITY,
   DEFAULT_CAPS,
   DEFAULT_PROJECT_POLICY,
+  DEFAULT_REPORT_POLICY,
   DEFAULT_REPORT_SCOPE,
   DENIED_RELEASE_GRANTS,
   DRAFT_POLICIES,
@@ -34,8 +35,12 @@ import {
   RELEASE_REQUIREMENTS,
   RELEASE_SHAPES,
   REPORT_SCOPES,
+  INTERRUPT_CATEGORIES,
+  DIGEST_CADENCES,
   type Caps,
   type ConductorConfig,
+  type DigestCadence,
+  type InterruptCategory,
   type MergePreconditions,
   type PlanUsageCap,
   type ProjectConfig,
@@ -43,6 +48,7 @@ import {
   type ReleasePreconditions,
   type ReleaseRequirement,
   type ReportScope,
+  type ReportingPolicy,
   type RepoTarget,
   type ResolvedGrants,
 } from "./types.ts";
@@ -64,6 +70,8 @@ const CAP_KEYS = Object.keys(DEFAULT_CAPS) as (keyof Caps)[];
 
 /** Quoted for error messages, from the same data the guards below read. */
 const REPORT_SCOPE_LIST = quoteList(REPORT_SCOPES);
+const INTERRUPT_CATEGORY_LIST = quoteList(INTERRUPT_CATEGORIES);
+const DIGEST_CADENCE_LIST = quoteList(DIGEST_CADENCES);
 const AUTHORITY_HOLDER_LIST = quoteList(AUTHORITY_HOLDERS);
 const ORCHESTRATOR_MODE_LIST = quoteList(ORCHESTRATOR_MODES);
 const RELEASE_SHAPE_LIST = quoteList(RELEASE_SHAPES);
@@ -219,12 +227,16 @@ export function writeConfigRaw(text: string): void {
  */
 export function resolveCaps(p: ProjectConfig, defaults: Caps): Caps {
   const o: Partial<Caps> = p.caps ?? {};
+  const workerMaxTurns = o.workerMaxTurns ?? defaults.workerMaxTurns;
   return {
     maxConcurrentWorkers: o.maxConcurrentWorkers ?? defaults.maxConcurrentWorkers,
     maxConcurrentWorkersPerRepo: o.maxConcurrentWorkersPerRepo ?? defaults.maxConcurrentWorkersPerRepo,
     dailySpendUsd: o.dailySpendUsd !== undefined ? o.dailySpendUsd : defaults.dailySpendUsd,
     planUsage: o.planUsage !== undefined ? o.planUsage : defaults.planUsage,
-    workerMaxTurns: o.workerMaxTurns ?? defaults.workerMaxTurns,
+    workerMaxTurns,
+    workerMaxTurnsCeiling:
+      o.workerMaxTurnsCeiling ??
+      (o.workerMaxTurns === undefined ? defaults.workerMaxTurnsCeiling : workerMaxTurns * 2),
     workerWallClockMs: o.workerWallClockMs ?? defaults.workerWallClockMs,
     maxAttemptsPerIssue: o.maxAttemptsPerIssue ?? defaults.maxAttemptsPerIssue,
     maxContinuationsPerIssue:
@@ -358,9 +370,13 @@ function validate(parsed: unknown, path: string): ConductorConfig {
     );
   }
 
+  const configuredDefaults = coerceCaps(root["defaults"], `"defaults"`, problems, legacyCaps);
+  const defaultWorkerMaxTurns = configuredDefaults.workerMaxTurns ?? DEFAULT_CAPS.workerMaxTurns;
   const defaults: Caps = {
     ...DEFAULT_CAPS,
-    ...coerceCaps(root["defaults"], `"defaults"`, problems, legacyCaps),
+    ...configuredDefaults,
+    workerMaxTurnsCeiling:
+      configuredDefaults.workerMaxTurnsCeiling ?? defaultWorkerMaxTurns * 2,
   };
 
   const rawProjects = root["projects"];
@@ -482,34 +498,173 @@ function normalizeProject(
  * that silently resolved to `"material"` would read as configured on the day the
  * operator meant to turn the volume down, and the config would keep lying.
  */
-function normalizeReporting(parsed: unknown, label: string, problems: string[]): ProjectConfig["reporting"] {
-  if (parsed === undefined) return { scope: DEFAULT_REPORT_SCOPE };
+/** The legacy `reporting.scope` presets, materialised as explicit policies.
+ *  Kept separate from {@link DEFAULT_REPORT_POLICY} (the "no key on disk"
+ *  default, which must stay `material`): each preset records `scopePreset` so
+ *  the tick prompt can keep saying the exact legacy words (#229). Exported so
+ *  the setup wizard and the config validator agree on one mapping. */
+export const SCOPE_PRESETS: Record<ReportScope, ReportingPolicy> = {
+  material: {
+    interruptOn: [...INTERRUPT_CATEGORIES],
+    digest: { cadence: "per-tick" },
+    scopePreset: "material",
+  },
+  decisions: {
+    interruptOn: ["tier2", "decision-needed", "fleet-stopped"],
+    digest: { cadence: "per-tick" },
+    scopePreset: "decisions",
+  },
+  escalations: {
+    interruptOn: ["tier2", "fleet-stopped"],
+    digest: { cadence: "daily" },
+    scopePreset: "escalations",
+  },
+};
+
+function defaultReporting(): ReportingPolicy {
+  return { ...DEFAULT_REPORT_POLICY, interruptOn: [...DEFAULT_REPORT_POLICY.interruptOn] };
+}
+
+/** The 24-hour `HH:MM` shape `digest.at` must take. */
+const DIGEST_AT = /^([01]\d|2[0-3]):[0-5]\d$/;
+
+/**
+ * The reporting policy: a legacy `scope` preset, or the explicit
+ * `interruptOn` + `digest` form. The two forms are mutually exclusive — a
+ * preset IS a policy, so configuring alongside it says one thing and means
+ * another (#229).
+ */
+function normalizeReporting(parsed: unknown, label: string, problems: string[]): ReportingPolicy {
+  if (parsed === undefined) return defaultReporting();
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    problems.push(`${label}: reporting must be an object with a "scope" of ${REPORT_SCOPE_LIST}`);
-    return { scope: DEFAULT_REPORT_SCOPE };
+    problems.push(`${label}: reporting must be an object with a "scope" preset or explicit "interruptOn"/"digest"`);
+    return defaultReporting();
   }
   const raw = parsed as Raw;
-
-  const unknownKeys = Object.keys(raw).filter((k) => k !== "scope");
+  const keys = Object.keys(raw);
+  // `scopePreset` is written by a fully-normalised policy (the setup wizard
+  // saves presets materialised); `scope` is the legacy form. Both are known.
+  const known = ["scope", "interruptOn", "digest", "scopePreset"];
+  const unknownKeys = keys.filter((k) => !known.includes(k));
   if (unknownKeys.length > 0) {
-    // Stricter than caps, which tolerate a retired key: `reporting` has exactly
-    // one member, so an unrecognised key here is a typo every time, and the
-    // block that ignores it looks configured either way.
     problems.push(`${label}: reporting has unknown key(s): ${unknownKeys.join(", ")}`);
   }
-
-  return {
-    scope: pickLiteral(
+  const hasScope = raw["scope"] !== undefined;
+  const hasExplicit = keys.includes("interruptOn") || keys.includes("digest");
+  if (hasScope && hasExplicit) {
+    problems.push(`${label}: reporting.scope is a preset — remove it when configuring interruptOn/digest explicitly`);
+    return defaultReporting();
+  }
+  if (hasScope || (!hasExplicit && keys.length === 0)) {
+    const scope = pickLiteral(
       raw["scope"],
       REPORT_SCOPES,
       DEFAULT_REPORT_SCOPE,
       `${label}: reporting.scope`,
       REPORT_SCOPE_LIST,
       problems,
-    ),
+    );
+    const preset = SCOPE_PRESETS[scope] ?? SCOPE_PRESETS[DEFAULT_REPORT_SCOPE];
+    return {
+      interruptOn: [...preset.interruptOn],
+      digest: { ...preset.digest },
+      scopePreset: preset.scopePreset,
+    };
+  }
+
+  // A fully-normalised policy (what the setup wizard writes and saveConfig
+  // round-trips) has interruptOn/digest and may carry scopePreset; keep that
+  // back-annotation so the tick prompt can still speak the legacy words.
+  const storedPreset = raw["scopePreset"];
+  const scopePreset =
+    typeof storedPreset === "string" && (REPORT_SCOPES as readonly string[]).includes(storedPreset)
+      ? (storedPreset as ReportScope)
+      : undefined;
+
+  return {
+    interruptOn: normalizeInterruptOn(raw["interruptOn"], label, problems),
+    digest: normalizeDigest(raw["digest"], label, problems),
+    ...(scopePreset === undefined ? {} : { scopePreset }),
   };
 }
 
+function normalizeInterruptOn(parsed: unknown, label: string, problems: string[]): InterruptCategory[] {
+  const fallback = [...INTERRUPT_CATEGORIES];
+  if (parsed === undefined) {
+    problems.push(`${label}: reporting.interruptOn is required in the explicit form (or use reporting.scope)`);
+    return fallback;
+  }
+  if (!Array.isArray(parsed)) {
+    problems.push(`${label}: reporting.interruptOn must be an array of ${INTERRUPT_CATEGORY_LIST}`);
+    return fallback;
+  }
+  const out: InterruptCategory[] = [];
+  for (const item of parsed) {
+    if (typeof item !== "string" || !(INTERRUPT_CATEGORIES as readonly string[]).includes(item)) {
+      problems.push(`${label}: reporting.interruptOn has unknown category ${JSON.stringify(item)} — one of ${INTERRUPT_CATEGORY_LIST}`);
+      continue;
+    }
+    const category = item as InterruptCategory;
+    if (!out.includes(category)) out.push(category);
+  }
+  if (out.length === 0) {
+    problems.push(`${label}: reporting.interruptOn must name at least one category`);
+    return fallback;
+  }
+  return out;
+}
+
+function normalizeDigest(parsed: unknown, label: string, problems: string[]): ReportingPolicy["digest"] {
+  const fallback: ReportingPolicy["digest"] = { cadence: "per-tick" };
+  if (parsed === undefined) {
+    problems.push(`${label}: reporting.digest is required in the explicit form (or use reporting.scope)`);
+    return fallback;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    problems.push(`${label}: reporting.digest must be an object with a "cadence" of ${DIGEST_CADENCE_LIST}`);
+    return fallback;
+  }
+  const raw = parsed as Raw;
+  const unknownKeys = Object.keys(raw).filter((k) => !["cadence", "at", "timezone"].includes(k));
+  if (unknownKeys.length > 0) {
+    problems.push(`${label}: reporting.digest has unknown key(s): ${unknownKeys.join(", ")}`);
+  }
+  const cadence = pickLiteral(
+    raw["cadence"],
+    DIGEST_CADENCES,
+    "per-tick",
+    `${label}: reporting.digest.cadence`,
+    DIGEST_CADENCE_LIST,
+    problems,
+  );
+  const digest: ReportingPolicy["digest"] = { cadence };
+  if (cadence !== "daily") {
+    if (raw["at"] !== undefined) problems.push(`${label}: reporting.digest.at is only valid with cadence "daily"`);
+    if (raw["timezone"] !== undefined) problems.push(`${label}: reporting.digest.timezone is only valid with cadence "daily"`);
+    return digest;
+  }
+  if (raw["at"] !== undefined) {
+    if (typeof raw["at"] !== "string" || !DIGEST_AT.test(raw["at"])) {
+      problems.push(`${label}: reporting.digest.at must be a 24h HH:MM time`);
+    } else {
+      digest.at = raw["at"];
+    }
+  }
+  if (raw["timezone"] !== undefined) {
+    if (typeof raw["timezone"] !== "string") {
+      problems.push(`${label}: reporting.digest.timezone must be a string`);
+    } else {
+      try {
+        new Intl.DateTimeFormat("en-GB", { timeZone: raw["timezone"] });
+        digest.timezone = raw["timezone"];
+      } catch {
+        problems.push(`${label}: reporting.digest.timezone is not a known IANA timezone`);
+      }
+    }
+  }
+  return digest;
+}
+
 /**
  * Who triages escalations, and how they are delivered when nobody answers.
  *
@@ -853,12 +1008,37 @@ function normalizeRepos(parsed: unknown, label: string, problems: string[]): Rec
     };
     const graph = normalizeGraphProject(value?.["graphProject"], `${label}: routing.repos.${key}`, problems);
     if (graph !== undefined) target.graphProject = graph;
+    const migrations = normalizeMigrationsDir(value?.["migrations"], `${label}: routing.repos.${key}`, problems);
+    if (migrations !== undefined) target.migrations = { dir: migrations };
     repos[key] = target;
   }
 
   return repos;
 }
 
+/**
+ * The ordered-migration-chain directory (#227), or `undefined` when the repo
+ * opts out of the chain check.
+ *
+ * Repo-relative, no leading `/`, and no `..` segment — the value is read in one
+ * process and used in another against the base branch's tree, so anything that
+ * is not plainly a directory name is a guess the guard must not make.
+ */
+function normalizeMigrationsDir(parsed: unknown, label: string, problems: string[]): string | undefined {
+  if (parsed === undefined) return undefined;
+  const raw = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? (parsed as Raw) : undefined;
+  const dir = raw?.["dir"];
+  if (!nonEmptyString(dir)) {
+    problems.push(`${label}.migrations.dir must be a non-empty string`);
+    return undefined;
+  }
+  if (dir.startsWith("/") || dir.split("/").includes("..")) {
+    problems.push(`${label}.migrations.dir must be a repo-relative directory`);
+    return undefined;
+  }
+  return dir;
+}
+
 /**
  * The path of the index-only clone whose code graph this repo's workers query,
  * or `undefined` when the repo has none.