omp-conductor 0.13.0 → 0.14.0

package/src/digest-schedule.ts

@@ -9,27 +9,53 @@
 
 import type { ReportingPolicy } from "./types.ts";
 
-/** `YYYY-MM-DD` in an IANA timezone (host zone when `timezone` is absent). */
-export function localDayKey(at: number, timezone?: string): string {
-  const parts = new Intl.DateTimeFormat("en-CA", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-  }).formatToParts(new Date(at));
-  const get = (type: "year" | "month" | "day"): string =>
-    parts.find((p) => p.type === type)?.value ?? "00";
-  return `${get("year")}-${get("month")}-${get("day")}`;
+const MINUTE_MS = 60_000;
+const NEXT_DIGEST_HORIZON_MS = 3 * 24 * 60 * MINUTE_MS;
+
+export type DigestScheduleState =
+  | { mode: "disabled" }
+  | { mode: "per-tick" }
+  | { mode: "due"; timezone: string }
+  | { mode: "scheduled"; timezone: string; nextAt?: number };
+
+const localMinuteFormatters = new Map<string, Intl.DateTimeFormat>();
+interface CachedDigestSchedule {
+  lastDigestDayKey: string | undefined;
+  from: number;
+  until: number;
+  state: Extract<DigestScheduleState, { mode: "scheduled" }>;
+}
+
+const schedules = new WeakMap<ReportingPolicy["digest"], CachedDigestSchedule>();
+
+
+function localDigestMinute(at: number, timezone?: string): { day: string; clock: string } {
+  const key = timezone ?? "";
+  let formatter = localMinuteFormatters.get(key);
+  if (formatter === undefined) {
+    formatter = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23",
+    });
+    localMinuteFormatters.set(key, formatter);
+  }
+  const parts = formatter.formatToParts(new Date(at));
+  const get = (type: Intl.DateTimeFormatPartTypes): string =>
+    parts.find((part) => part.type === type)?.value ?? "00";
+  return {
+    day: `${get("year")}-${get("month")}-${get("day")}`,
+    clock: `${get("hour")}:${get("minute")}`,
+  };
 }
 
-/** `HH:MM` wall-clock in the zone, 24h and zero-padded. */
-function localClockAt(at: number, timezone?: string): string {
-  return new Intl.DateTimeFormat("en-GB", {
-    timeZone: timezone,
-    hour: "2-digit",
-    minute: "2-digit",
-    hourCycle: "h23",
-  }).format(new Date(at));
+/** `YYYY-MM-DD` in an IANA timezone (host zone when `timezone` is absent). */
+export function localDayKey(at: number, timezone?: string): string {
+  return localDigestMinute(at, timezone).day;
 }
 
 /**
@@ -51,9 +77,51 @@ export function digestDue(
   if (cadence === "none") return false;
   if (cadence === "per-tick") return true;
   // daily
-  if (at === undefined) {
-    return lastDigestDayKey !== localDayKey(now, timezone);
+  const local = localDigestMinute(now, timezone);
+  if (at === undefined) return lastDigestDayKey !== local.day;
+  if (lastDigestDayKey === local.day) return false;
+  return local.clock >= at;
+}
+
+/** Mechanical status for the next digest opportunity, using the same
+ * predicate that gates report submission. Minute scanning deliberately keeps
+ * skipped/repeated DST wall-clock times on the runtime's real timeline. */
+export function digestScheduleState(
+  policy: Pick<ReportingPolicy, "digest">,
+  lastDigestDayKey: string | undefined,
+  now: number,
+): DigestScheduleState {
+  if (policy.digest.cadence === "none") return { mode: "disabled" };
+  if (policy.digest.cadence === "per-tick") return { mode: "per-tick" };
+
+  const timezone =
+    policy.digest.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+  if (digestDue(policy, lastDigestDayKey, now)) return { mode: "due", timezone };
+
+  const from = Math.floor(now / MINUTE_MS) * MINUTE_MS;
+  const cached = schedules.get(policy.digest);
+  if (
+    cached !== undefined &&
+    cached.lastDigestDayKey === lastDigestDayKey &&
+    from >= cached.from &&
+    from < cached.until
+  ) {
+    return cached.state;
   }
-  if (lastDigestDayKey === localDayKey(now, timezone)) return false;
-  return localClockAt(now, timezone) >= at;
-}
+
+  const end = now + NEXT_DIGEST_HORIZON_MS;
+  let cursor = from + MINUTE_MS;
+  while (cursor <= end && !digestDue(policy, lastDigestDayKey, cursor)) cursor += MINUTE_MS;
+  const state: Extract<DigestScheduleState, { mode: "scheduled" }> = {
+    mode: "scheduled",
+    timezone,
+    ...(cursor > end ? {} : { nextAt: cursor }),
+  };
+  schedules.set(policy.digest, {
+    lastDigestDayKey,
+    from,
+    until: cursor,
+    state,
+  });
+  return state;
+}

package/src/escalate.ts

@@ -20,11 +20,12 @@
  * those strings end up in daemon logs and, on the fallback path, in a public
  * issue comment.
  */
-
+import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
+import { availabilityOpen, interruptDisposition, type InterruptDisposition } from "./availability.ts";
 import type { OrchestratorHandle } from "./orchestrator.ts";
 import type { Escalation, ProjectConfig, Store, Tracker } from "./types.ts";
 
@@ -137,13 +138,20 @@ export function formatEscalation(e: Escalation, project: string): string {
  * still escalate, just to an issue comment.
  */
 export function createEscalator(
-  p: ProjectConfig,
+  source: ProjectConfig | (() => ProjectConfig),
   tracker: Tracker,
   store: Store,
   orchestrator?: OrchestratorHandle,
+  now: () => number = Date.now,
+  deliveryAllowed: () => boolean = () => true,
 ): Escalator {
+  const currentProject = typeof source === "function" ? source : (): ProjectConfig => source;
   return {
     async escalate(e: Escalation): Promise<void> {
+      // The daemon's provider resolves the config reloaded at the latest tick
+      // boundary. Capture one snapshot for this delivery, including late
+      // settlement callbacks, so a mid-call edit cannot split its policy.
+      const p = currentProject();
       // Stable across daemon restarts: same project, issue, tier and summary is
       // the same event, however many times the loop rediscovers it.
       const key = `${p.name}:${e.issue}:${e.tier}:${e.summary}`;
@@ -210,26 +218,45 @@ export function createEscalator(
         }
       }
 
+      if (e.tier === 2) {
+        const category = e.category ?? "tier2";
+        const at = now();
+        let disposition: InterruptDisposition;
+        if (!deliveryAllowed()) {
+          disposition = "availability";
+        } else if (e.urgent) {
+          // Urgency may bypass category batching when the digest loop itself is
+          // broken (#246), but it cannot invent an out-of-hours bypass the
+          // operator did not configure (#273).
+          const window = p.reporting?.availability;
+          disposition =
+            window !== undefined &&
+            !availabilityOpen(window, at) &&
+            !window.bypass.includes(category)
+              ? "availability"
+              : "interrupt";
+        } else {
+          disposition = interruptDisposition(p.reporting, category, at);
+        }
+        if (disposition !== "interrupt") {
+          store.addHeldNotice({
+            id: createHash("sha256").update(`held-notice\0${key}`).digest("hex"),
+            project: p.name,
+            category,
+            summary: e.summary,
+            detail: text,
+            createdAt: at,
+            ...(disposition === "availability" ? { releaseOnAvailable: true } : {}),
+            ...(e.urgent === true ? { urgent: true } : {}),
+          });
+          store.markNotified(key);
+          return;
+        }
+      }
+
       if (e.tier === 2 && chatId) {
         const token = readTelegramToken();
         if (token) {
-          // The digest can own deferred delivery only while its orchestrator
-          // loop is alive. An urgent escalation says that loop is the failed
-          // component, so waiting for its digest would park the only warning
-          // behind the failure it reports (#246).
-          const category = e.category ?? "tier2";
-          const interruptOn = p.reporting?.interruptOn;
-          if (!e.urgent && interruptOn !== undefined && !interruptOn.includes(category)) {
-            store.addHeldNotice({
-              project: p.name,
-              category,
-              summary: e.summary,
-              detail: text,
-              createdAt: Date.now(),
-            });
-            store.markNotified(key);
-            return;
-          }
           // A send failure throws: `markNotified` stays uncalled so the next
           // poll retries instead of writing the event off as delivered. No
           // backoff in here — the dispatcher tick *is* the retry, and an

package/src/fleet.ts

@@ -27,6 +27,7 @@ import {
 import { createInterface } from "node:readline";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { formatZonedMinute } from "./availability.ts";
 import { findProject, loadConfig, stateDir } from "./config.ts";
 import { planUsageLine, readPlanUsage, sharedUsageSource } from "./usage.ts";
 import { readApprovalSurface, readDaemonProfile } from "./approval-surface.ts";
@@ -36,9 +37,9 @@ import { renderBriefForProject } from "./setup.ts";
 import type { ProjectConfig, Store } from "./types.ts";
 import { settlementFlagSummary } from "./diff-flags.ts";
 import { probeCodeGraph, type CodeGraphHealth } from "./graph-health.ts";
-import { formatOpenReports } from "./reports.ts";
+import { formatDigestBacklog, formatOpenReports } from "./reports.ts";
 import {
-  formatBaseChecks,
+  formatBaseHealth,
   formatDispatchSummary,
   formatReleaseGrants,
   formatSalvagedRuns,
@@ -1060,12 +1061,41 @@ export function formatFleetStatus(
   ].join("\n");
 }
 
+function formatAvailabilityStatus(s: StatusSnapshot): string[] {
+  const availability = s.availability;
+  if (availability === undefined) return [];
+  if (availability.mode === "always") {
+    return ["availability 24-hour interrupts (no weekly window)"];
+  }
+  const mode =
+    availability.nextTransitionAt === undefined || availability.timezone === undefined
+      ? `${availability.mode}; next transition could not be calculated`
+      : `${availability.mode} until ${formatZonedMinute(availability.nextTransitionAt, availability.timezone)}`;
+  const bypass = availability.bypass.length === 0 ? "none" : availability.bypass.join(", ");
+  return [`availability ${mode}; quiet-hours bypass ${bypass}`];
+}
+
+function formatDigestScheduleStatus(s: StatusSnapshot): string[] {
+  const schedule = s.digestSchedule;
+  if (schedule === undefined) return [];
+  if (schedule.mode === "disabled") return ["next digest disabled"];
+  if (schedule.mode === "per-tick") return ["next digest every tick"];
+  if (schedule.mode === "due") return ["next digest due now"];
+  return [
+    schedule.nextAt === undefined
+      ? "next digest could not be calculated"
+      : `next digest ${formatZonedMinute(schedule.nextAt, schedule.timezone)}`,
+  ];
+}
+
 function formatProjectBody(s: StatusSnapshot): string {
   const lines = [
     `project   ${s.project}${s.paused ? "  (PAUSED)" : ""}`,
     ...(s.pauseReason === undefined ? [] : [`paused    ${s.pauseReason}`]),
     `config    ${s.configPath}`,
     `state     ${s.stateDir}`,
+    ...formatAvailabilityStatus(s),
+    ...formatDigestScheduleStatus(s),
     "",
     "caps",
     `  workers            ${s.liveWorkers} / ${s.caps.maxConcurrentWorkers}`,
@@ -1140,9 +1170,10 @@ function formatProjectBody(s: StatusSnapshot): string {
       if (flagged !== undefined) lines.push(`      ${flagged}`);
     }
   }
-  lines.push(...formatBaseChecks(s.baseChecks));
+  lines.push(...formatBaseHealth(s.baseHealth));
   lines.push(...formatSalvagedRuns(s.salvagedRuns));
   lines.push(...formatOpenReports(s.openReports));
+  lines.push(...formatDigestBacklog(s.digestBacklog));
   if (s.liveWorkers > 0) {
     lines.push(
       "",