omp-conductor 0.12.0 → 0.14.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 {
@@ -745,6 +814,10 @@ export function formatSettlementFlags(
       pooledHeading(diff.attempts),
   ];
   for (const flag of flags.slice(0, RENDERED_FLAGS)) {
+    if (flag.kind === "pr-adopted") {
+      lines.push(`  ${flag.kind} — ${flag.detail}`);
+      continue;
+    }
     lines.push(
       `  ${flag.kind}  ${flag.file}${flag.line === undefined ? "" : `:${flag.line}`} — ${flag.detail}` +
         (flag.unattributed === true ? "  [unattributed: the dispatching issue never names this file]" : ""),

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) {
-          // A category this policy defers does not page now: it is held here so
-          // the digest is the delivery authority for it (#229). A missing
-          // `reporting` block means the default (page everything); an explicit
-          // list decides each escalation by its category, defaulting `tier2`.
-          const category = e.category ?? "tier2";
-          const interruptOn = p.reporting?.interruptOn;
-          if (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/failure-class.ts

@@ -22,6 +22,9 @@ export interface ClassifyFacts {
   pr?: "open" | "merged" | "closed";
   mergeable?: "conflicting" | "clean" | "unknown";
   checks?: { name: string; state: string; link?: string }[];
+  /** Full session error recovered from the transcript. Kept as a fact so a
+   *  classification retry does not lose an HTTP status the run row cannot store. */
+  sessionError?: { status?: number; message: string };
   /** Tail (ANSI-stripped) of the first failed check's log, when one was
    *  reachable. Lets the table tell an infrastructure outage (#177) from a
    *  deterministic test failure by the log's own words. */
@@ -221,6 +224,8 @@ const DISPATCH_GIT_ERROR = /^(?:Error: )?git .+ exited \d+/s;
 
 export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classification {
   const hasArtifacts = run.prUrl !== undefined || run.headSha !== undefined || run.salvageSha !== undefined;
+  const providerError =
+    facts.sessionError ?? (run.lastError === undefined ? undefined : { message: run.lastError });
 
   // The PR landed while the row says otherwise. Whatever else is true about this
   // run, it succeeded, and the recovery is bookkeeping.
@@ -249,10 +254,7 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
   // first request produces a turn-0 row with no artifacts, which
   // `env-start-failure` would otherwise absorb and lose the cause.
   if (run.state === "failed" || run.state === "killed") {
-    const credit =
-      run.lastError === undefined
-        ? undefined
-        : providerCreditRefusal({ message: run.lastError });
+    const credit = providerError === undefined ? undefined : providerCreditRefusal(providerError);
     if (credit !== undefined) {
       return { cls: "provider-credit", recovery: "requeue", evidence: credit };
     }
@@ -267,7 +269,7 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
   // the same reason as the credit branch: a turn-0 stall would otherwise be
   // absorbed by `env-start-failure` and lose its cause.
   if (run.state === "failed" || run.state === "killed") {
-    const transient = run.lastError === undefined ? undefined : providerTransientFault({ message: run.lastError });
+    const transient = providerError === undefined ? undefined : providerTransientFault(providerError);
     if (transient !== undefined) {
       return { cls: "provider-transient", recovery: "requeue", evidence: transient };
     }

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,8 +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 {
+  formatBaseHealth,
   formatDispatchSummary,
   formatReleaseGrants,
   formatSalvagedRuns,
@@ -1026,7 +1028,7 @@ export function formatFleetStatus(
   // a halt) answers "who stopped the fleet" without opening a file (#185). An
   // unparseable sentinel — paused but with no datable line 1 — is itself news:
   // it means a run admitted before an *unknown* pause cannot prove innocence
-  // (#174), so every mutation is refused.
+  // (#174), so completion mutations fail closed while release gates remain usable.
   const dispatchLine =
     layers.dispatch === "paused"
       ? (() => {
@@ -1036,7 +1038,7 @@ export function formatFleetStatus(
             return `dispatch  paused (source: ${prov.source}${reason})`;
           }
           return isPaused() && pausedAt() === undefined
-            ? "dispatch  paused (unparseable sentinel — all mutations refused)"
+            ? "dispatch  paused (unparseable sentinel — new work and completion mutations refused; release gates remain available)"
             : "dispatch  paused";
         })()
       : `dispatch  ${layers.dispatch}`;
@@ -1059,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}`,
@@ -1110,6 +1141,9 @@ function formatProjectBody(s: StatusSnapshot): string {
           })`,
         ]),
     `  new worker turns   ${s.caps.workerMaxTurns}`,
+    ...s.turnOverrides.map(
+      ({ issue, maxTurns }) => `  turn override      #${issue} → ${maxTurns} (next attempt)`,
+    ),
     `  worker wall clock  ${Math.round(s.caps.workerWallClockMs / 60_000)}m`,
     `  failed attempts    ${s.caps.maxAttemptsPerIssue}`,
     `  continuations      ${s.caps.maxContinuationsPerIssue}`,
@@ -1136,8 +1170,10 @@ function formatProjectBody(s: StatusSnapshot): string {
       if (flagged !== undefined) lines.push(`      ${flagged}`);
     }
   }
+  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(
       "",

package/src/omp.ts

@@ -19,7 +19,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
 import { worktreeConfinement } from "./confinement.ts";
-import { releasePolicyTripwire } from "./release-policy.ts";
+import { releasePolicyTripwire, type ReleaseBlockContext } from "./release-policy.ts";
 import type {
   HostToParent,
   ParentToHost,
@@ -158,7 +158,7 @@ export async function createLocalSession(opts: {
   /** Install the release/deploy tool-call gate with these per-shape grants. */
   releaseGrants?: ResolvedGrants;
   /** Durable audit callback invoked only when that gate rejects a call. */
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   /**
    * The conductor verb socket this session's mutation tools call (#126).
    *
@@ -393,7 +393,7 @@ export interface CreateSessionOptions {
   resume?: boolean;
   role: SessionRole;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
 
   /**
    * Where the control socket is bound. The daemon puts it beside the run's own
@@ -681,7 +681,11 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
           break;
         }
         case "release-blocked":
-          opts.onReleaseBlocked?.(message.shape);
+          opts.onReleaseBlocked?.(message.shape, {
+            tool: message.tool,
+            reason: message.reason,
+            args: message.args,
+          });
           break;
       }
     }