omp-conductor 0.13.0 → 0.15.0

package/src/diff-flags.ts

@@ -290,9 +290,19 @@ function expandBraces(token: string): string[] {
   return alternatives.map((alt) => prefix + alt + suffix);
 }
 
+/** A trailing slash-separated extension list:
+ *  `scripts/a.sh/.py` → [`scripts/a.sh`, `scripts/a.py`]. */
+function expandExtensionAlternation(token: string): string[] {
+  const match = /^(.+?)\.([A-Za-z][A-Za-z0-9]{1,7})((?:\/\.[A-Za-z][A-Za-z0-9]{1,7})+)$/.exec(token);
+  if (match === null) return [token];
+  const [, base, first, rest] = match;
+  if (base === undefined || first === undefined || rest === undefined) return [token];
+  return [first, ...rest.split("/.").filter(Boolean)].map((extension) => `${base}.${extension}`);
+}
+
 /** Every path-shaped token on the report's `changed:` line. An absent line and
  *  a line naming nothing are the same answer: nothing was disclosed. */
-export function claimedPaths(report: string): string[] {
+function parseClaimedPaths(report: string, extensionAlternatives?: Set<string>): string[] {
   const line = CHANGED_LINE.exec(report)?.[1] ?? "";
   const seen = new Set<string>();
   // Split on whitespace and semicolons, and on commas *outside* a brace group:
@@ -306,13 +316,21 @@ export function claimedPaths(report: string): string[] {
     // directions — sees plain paths: a brace token dies earlier at the
     // CLAIMED_PATH filter if it is never opened up (#224).
     for (const expanded of expandBraces(normalised)) {
-      if (!CLAIMED_PATH.test(expanded) && !DOTTED_MODULE.test(expanded)) continue;
-      seen.add(expanded);
+      const alternatives = expandExtensionAlternation(expanded);
+      for (const path of alternatives) {
+        if (!CLAIMED_PATH.test(path) && !DOTTED_MODULE.test(path)) continue;
+        seen.add(path);
+        if (alternatives.length > 1) extensionAlternatives?.add(path);
+      }
     }
   }
   return [...seen];
 }
 
+export function claimedPaths(report: string): string[] {
+  return parseClaimedPaths(report);
+}
+
 /**
  * Whether one claim covers one path. Every rule here is deliberately generous,
  * because each one that fails produces an omission flag on an honest report:
@@ -505,7 +523,8 @@ export function analyseSettlement(audit: SettlementAudit): SettlementFlag[] {
 
 function reconcileChanged(audit: SettlementAudit, flags: SettlementFlag[]): void {
   const touched = audit.diff.files.filter((f) => DERIVED_FILE[basename(f.path)] !== true);
-  const claims = claimedPaths(audit.report);
+  const extensionAlternatives = new Set<string>();
+  const claims = parseClaimedPaths(audit.report, extensionAlternatives);
   const priorClaims = claimedPaths((audit.priorReports ?? []).join("\n"));
   // Coverage pools the current report with every prior attempt's disclosures:
   // a file the final report no longer names was disclosed while the work was
@@ -553,12 +572,62 @@ function reconcileChanged(audit: SettlementAudit, flags: SettlementFlag[]): void
     if (audit.diff.files.some((f) => covers(claim, f.path) || covers(claim, f.previousPath ?? ""))) {
       continue;
     }
+    if (extensionAlternatives.has(claim)) {
+      const stem = claim.slice(0, claim.lastIndexOf("."));
+      const matchedAlternative = claims.some(
+        (other) =>
+          other !== claim &&
+          extensionAlternatives.has(other) &&
+          other.slice(0, other.lastIndexOf(".")) === stem &&
+          audit.diff.files.some((f) => covers(other, f.path) || covers(other, f.previousPath ?? "")),
+      );
+      if (matchedAlternative) continue;
+    }
     flags.push({
       kind: "unmatched-claim",
       file: claim,
       detail: "named by the report's `changed:` line but not touched by the PR",
     });
   }
+
+  // A parser failure can otherwise accuse the report in both directions for
+  // the same file. Collapse only that self-refuting pair; unrelated findings
+  // remain intact.
+  const unmatched = flags.filter((flag) => flag.kind === "unmatched-claim");
+  const removed = new Set<SettlementFlag>();
+  let exampleClaim = "";
+  let examplePath = "";
+  for (const undisclosed of flags.filter((flag) => flag.kind === "undisclosed-file")) {
+    const name = basename(undisclosed.file);
+    const extension = name.lastIndexOf(".");
+    const stem = extension > 0 ? name.slice(0, extension) : name;
+    if (stem.length < 3) continue;
+    for (const claim of unmatched) {
+      if (!claim.file.includes(stem)) continue;
+      removed.add(undisclosed);
+      removed.add(claim);
+      if (exampleClaim === "") {
+        exampleClaim = claim.file;
+        examplePath = undisclosed.file;
+      }
+    }
+  }
+  if (removed.size === 0) return;
+
+  const kept = flags.filter((flag) => !removed.has(flag));
+  const removedClaims = unmatched.filter((flag) => removed.has(flag)).length;
+  flags.splice(
+    0,
+    flags.length,
+    ...kept,
+    {
+      kind: "report-format-unparsed",
+      file: "(report)",
+      detail:
+        `${removedClaims} claim(s) on the \`changed:\` line could not be parsed as paths yet name the same ` +
+        `file(s) the PR touched (e.g. ${exampleClaim} vs ${examplePath}) — read the diff directly`,
+    },
+  );
 }
 
 function detectWeakening(audit: SettlementAudit, flags: SettlementFlag[]): void {

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
@@ -242,7 +269,7 @@ export function createEscalator(
           // the tick re-raises it. A *report* has no such source — it exists
           // once, in the model's head, and nothing regenerates it — which is
           // why that one needed a ledger and this one does not.
-          await sendTelegram(token, chatId, text);
+          await sendTelegram(token, chatId, text, { topicId: p.escalation.telegramTopicId });
           store.markNotified(key);
           return;
         }
@@ -330,14 +357,52 @@ export function readTelegramToken(): string | undefined {
  * Telegram's own message id when it returns one, and throws on every *known*
  * failure — connection refused, HTTP error, `{"ok":false}` — which is what lets
  * a caller treat a throw as "nobody has this" and a crash as "nobody knows".
+ *
+ * Optional `topicId` pins the message to a forum topic (`message_thread_id`).
+ * A definitive missing-thread reject retries once as a flat chat and warns, so a
+ * deleted topic degrades instead of silently losing the page (#318).
  */
 export async function sendTelegram(
   token: string,
   chatId: string,
   text: string,
+  opts?: { topicId?: number },
+): Promise<number | undefined> {
+  const topicId =
+    opts?.topicId !== undefined && Number.isFinite(opts.topicId) && Number.isSafeInteger(opts.topicId)
+      ? opts.topicId
+      : undefined;
+  try {
+    return await postTelegramMessage(token, chatId, text, topicId);
+  } catch (err) {
+    if (
+      topicId === undefined ||
+      !(err instanceof TelegramSendError) ||
+      err.outcome !== "definitive" ||
+      !isMissingTelegramThread(err.message)
+    ) {
+      throw err;
+    }
+    warn(
+      `escalation.telegramTopicId=${topicId} is stale (${err.message}); retrying flat chat`,
+    );
+    return await postTelegramMessage(token, chatId, text, undefined);
+  }
+}
+
+/** Telegram's definitive "that forum topic is gone" answers. */
+function isMissingTelegramThread(diagnostic: string): boolean {
+  return /message thread not found|topic_id_invalid/i.test(diagnostic);
+}
+
+async function postTelegramMessage(
+  token: string,
+  chatId: string,
+  text: string,
+  topicId: number | undefined,
 ): Promise<number | undefined> {
   const url = `https://api.telegram.org/bot${token}/sendMessage`;
-  const body = JSON.stringify({
+  const payload: Record<string, unknown> = {
     chat_id: chatId,
     // ponytail: hard truncation rather than splitting across messages — the
     // tail of a stack trace is rarely the interesting part. Upgrade path is to
@@ -345,7 +410,9 @@ export async function sendTelegram(
     text:
       text.length > TELEGRAM_TEXT_LIMIT ? `${text.slice(0, TELEGRAM_TEXT_LIMIT)}\n[truncated]` : text,
     disable_web_page_preview: true,
-  });
+  };
+  if (topicId !== undefined) payload.message_thread_id = topicId;
+  const body = JSON.stringify(payload);
 
   let res: Response;
   try {