omp-conductor 0.12.0 → 0.14.0

package/src/store.ts

@@ -14,20 +14,25 @@ import { mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 import { stateDir } from "./config.ts";
-import { DECISION_TTL_MS, DEFAULT_CAPS } from "./types.ts";
+import { DECISION_TTL_MS, DEFAULT_CAPS, DIGEST_BACKLOG_LIMIT } from "./types.ts";
 import { dispatchInfra, neverStarted } from "./failure-class.ts";
 import type {
+  BaseHealth,
   DecisionDraft,
   FailureClass,
   DecisionRecord,
   DecisionState,
+  DigestBacklog,
   DispatchSummary,
   FrictionAdmissionReason,
   FrictionKind,
   FrictionObservation,
   FrictionSignal,
   HeldNotice,
+  InterruptCategory,
   HeldNoticeDraft,
+  MaterialEvent,
+  MaterialEventDraft,
   LabelOp,
   MergeLock,
   ReportDeliveryState,
@@ -41,6 +46,7 @@ import type {
   SessionRole,
   SettlementFlag,
   Store,
+  TurnOverride,
   VerbDecision,
   VerbLedgerDraft,
   VerbLedgerEntry,
@@ -73,6 +79,7 @@ const FRICTION_HOLD_REASONS: ReadonlySet<FrictionAdmissionReason> = new Set([
   "failed-attempts",
   "continuations",
   "parent-lookup-error",
+  "issue-state-lookup-error",
   "open-pr-lookup-error",
   "unroutable:no-repo-label",
   "unroutable:multiple-repo-labels",
@@ -107,6 +114,10 @@ const UPDATABLE_COLUMNS: Record<string, true> = {
   sessionFile: true,
   prUrl: true,
   headSha: true,
+  mergeSha: true,
+  baseRef: true,
+  baseCheck: true,
+  baseCheckAt: true,
   salvageSha: true,
   salvageError: true,
   salvageAckAt: true,
@@ -139,6 +150,10 @@ interface RunRow {
   sessionFile: string | null;
   prUrl: string | null;
   headSha: string | null;
+  mergeSha: string | null;
+  baseRef: string | null;
+  baseCheck: string | null;
+  baseCheckAt: number | null;
   salvageSha: string | null;
   salvageError: string | null;
   salvageAckAt: number | null;
@@ -152,6 +167,31 @@ interface RunRow {
   recoveredAt: number | null;
 }
 
+/** The `base_health` table exactly as SQLite hands it back. */
+interface BaseHealthRow {
+  project: string;
+  repo: string;
+  branch: string;
+  headSha: string;
+  verdict: string;
+  runsCount: number;
+  detail: string | null;
+  checkedAt: number;
+}
+
+function toBaseHealth(row: BaseHealthRow): BaseHealth {
+  const health: BaseHealth = {
+    repo: row.repo,
+    branch: row.branch,
+    headSha: row.headSha,
+    verdict: row.verdict as BaseHealth["verdict"],
+    runsCount: row.runsCount,
+    checkedAt: row.checkedAt,
+  };
+  if (row.detail !== null) health.detail = row.detail;
+  return health;
+}
+
 interface FrictionRollupRow {
   project: string;
   day: string;
@@ -216,6 +256,18 @@ interface ReportRow {
   lastError: string | null;
 }
 
+/** The `material_events` table exactly as SQLite hands it back (#274). */
+interface MaterialEventRow {
+  id: string;
+  project: string;
+  category: string;
+  summary: string;
+  evidence: string;
+  occurredAt: number;
+  recordedAt: number;
+  digestReportId: string | null;
+}
+
 /** The `verb_ledger` table exactly as SQLite hands it back (#126). */
 interface VerbLedgerRow {
   id: string;
@@ -256,6 +308,10 @@ CREATE TABLE IF NOT EXISTS runs (
   sessionFile TEXT,
   prUrl       TEXT,
   headSha     TEXT,
+  mergeSha    TEXT,
+  baseRef     TEXT,
+  baseCheck   TEXT,
+  baseCheckAt INTEGER,
   salvageSha  TEXT,
   salvageError TEXT,
   salvageAckAt INTEGER,
@@ -271,11 +327,45 @@ CREATE TABLE IF NOT EXISTS runs (
 CREATE INDEX IF NOT EXISTS runs_project_issue ON runs (project, issue);
 CREATE INDEX IF NOT EXISTS runs_project_state ON runs (project, state);
 
+CREATE TABLE IF NOT EXISTS base_health (
+  project   TEXT    NOT NULL,
+  repo      TEXT    NOT NULL,
+  branch    TEXT    NOT NULL,
+  headSha   TEXT    NOT NULL,
+  verdict   TEXT    NOT NULL,
+  runsCount INTEGER NOT NULL,
+  detail    TEXT,
+  checkedAt INTEGER NOT NULL,
+  PRIMARY KEY (project, repo)
+);
+
 CREATE TABLE IF NOT EXISTS notifications (
   "key" TEXT    PRIMARY KEY,
   at    INTEGER NOT NULL
 );
 
+-- A one-shot operator-selected ceiling for an issue's next claimed attempt.
+-- The run insert and consumption happen in one transaction.
+CREATE TABLE IF NOT EXISTS turn_overrides (
+  project  TEXT    NOT NULL,
+  issue    INTEGER NOT NULL CHECK (issue > 0),
+  maxTurns INTEGER NOT NULL CHECK (maxTurns > 0),
+  setAt    INTEGER NOT NULL CHECK (setAt >= 0),
+  PRIMARY KEY (project, issue)
+);
+
+-- Append-only audit of every operator-selected ceiling. Consuming or replacing
+-- the pending value never erases what was requested.
+CREATE TABLE IF NOT EXISTS turn_override_ledger (
+  id       TEXT    PRIMARY KEY,
+  project  TEXT    NOT NULL,
+  issue    INTEGER NOT NULL CHECK (issue > 0),
+  maxTurns INTEGER NOT NULL CHECK (maxTurns > 0),
+  setAt    INTEGER NOT NULL CHECK (setAt >= 0)
+);
+CREATE INDEX IF NOT EXISTS turn_override_ledger_project_at
+  ON turn_override_ledger (project, setAt);
+
 CREATE TABLE IF NOT EXISTS dispatch_summaries (
   project   TEXT PRIMARY KEY,
   summary   TEXT NOT NULL
@@ -308,10 +398,10 @@ CREATE TABLE IF NOT EXISTS friction_surfaces (
 -- on the same row. This one is keyed by report id and carries delivery state,
 -- the attempt in flight, and the message id Telegram actually returned.
 --
--- The partial unique index is the digest guard: a digest:<day> key can exist at
--- most once per project, so "has today's digest been handed over?" is a question
--- the ledger answers rather than the model's memory of the last tick. Material
--- reports carry no key and are never suppressed.
+-- The partial unique index is the digest guard: a non-failed digest:<day> key
+-- can exist at most once per project, so "has today's digest been handed over?"
+-- is a question the ledger answers rather than the model's memory of the last
+-- tick. A failed handoff can be replaced; material reports carry no key.
 CREATE TABLE IF NOT EXISTS reports (
   id            TEXT    PRIMARY KEY,
   project       TEXT    NOT NULL,
@@ -330,10 +420,26 @@ CREATE TABLE IF NOT EXISTS reports (
   lastError     TEXT
 );
 CREATE UNIQUE INDEX IF NOT EXISTS reports_dedupe
-  ON reports (project, dedupeKey) WHERE dedupeKey IS NOT NULL;
+  ON reports (project, dedupeKey) WHERE dedupeKey IS NOT NULL AND state <> 'failed';
 CREATE INDEX IF NOT EXISTS reports_project_state
   ON reports (project, state, nextAttemptAt);
 
+-- Ordinary material outcomes awaiting authorship in a deferred digest (#274).
+-- Association happens when a digest is accepted into the outbox, not when the
+-- session happens to remember the event or when Telegram later delivers it.
+CREATE TABLE IF NOT EXISTS material_events (
+  id             TEXT    PRIMARY KEY,
+  project        TEXT    NOT NULL,
+  category       TEXT    NOT NULL,
+  summary        TEXT    NOT NULL,
+  evidence       TEXT    NOT NULL,
+  occurredAt     INTEGER NOT NULL,
+  recordedAt     INTEGER NOT NULL,
+  digestReportId TEXT    REFERENCES reports(id)
+);
+CREATE INDEX IF NOT EXISTS material_events_project_undigested
+  ON material_events (project, occurredAt) WHERE digestReportId IS NULL;
+
 -- Interrupts a project's reporting.interruptOn policy deferred to the digest
 -- (#229): an escalation that must not page the operator's phone now is held
 -- here so the daily rollup can surface it. digestedAt set -> re-surfaced by a
@@ -341,17 +447,33 @@ CREATE INDEX IF NOT EXISTS reports_project_state
 -- are escalations that never reached a send, distinct from reports the model
 -- wrote on purpose.
 CREATE TABLE IF NOT EXISTS held_notices (
-  id         TEXT    PRIMARY KEY,
-  project    TEXT    NOT NULL,
-  category   TEXT    NOT NULL,
-  summary    TEXT    NOT NULL,
-  detail     TEXT    NOT NULL,
-  createdAt  INTEGER NOT NULL,
-  digestedAt INTEGER
+  id                 TEXT    PRIMARY KEY,
+  project            TEXT    NOT NULL,
+  category           TEXT    NOT NULL,
+  summary            TEXT    NOT NULL,
+  detail             TEXT    NOT NULL,
+  createdAt          INTEGER NOT NULL,
+  releaseOnAvailable INTEGER NOT NULL DEFAULT 0,
+  urgent             INTEGER NOT NULL DEFAULT 0,
+  digestedAt         INTEGER,
+  digestReportId     TEXT    REFERENCES reports(id)
 );
 CREATE INDEX IF NOT EXISTS held_notices_project_undigested
   ON held_notices (project, digestedAt) WHERE digestedAt IS NULL;
 
+-- A due digest gets one bounded handoff lease per oldest availability notice
+-- and local day. The lease closes the snapshot-to-CLI race; expiry hands
+-- ownership back to the daemon catch-up instead of starving the notice.
+CREATE TABLE IF NOT EXISTS availability_digest_reservations (
+  project       TEXT    NOT NULL,
+  cycleKey      TEXT    NOT NULL,
+  firstNoticeId TEXT    NOT NULL,
+  expiresAt     INTEGER NOT NULL,
+  PRIMARY KEY (project, cycleKey, firstNoticeId)
+);
+CREATE INDEX IF NOT EXISTS availability_digest_reservations_active
+  ON availability_digest_reservations (project, expiresAt);
+
 -- The action ledger for the conductor-owned mutation verbs (#126). Every
 -- decided call lands here, refusals included: the question an escalation asks
 -- is "what did this run try", and a table that only records what succeeded
@@ -519,6 +641,10 @@ function toRecord(row: RunRow): RunRecord {
   if (row.sessionFile !== null) record.sessionFile = row.sessionFile;
   if (row.prUrl !== null) record.prUrl = row.prUrl;
   if (row.headSha !== null) record.headSha = row.headSha;
+  if (row.mergeSha !== null) record.mergeSha = row.mergeSha;
+  if (row.baseRef !== null) record.baseRef = row.baseRef;
+  if (row.baseCheck !== null) record.baseCheck = row.baseCheck as RunRecord["baseCheck"];
+  if (row.baseCheckAt !== null) record.baseCheckAt = row.baseCheckAt;
   if (row.salvageSha !== null) record.salvageSha = row.salvageSha;
   if (row.salvageError !== null) record.salvageError = row.salvageError;
   if (row.salvageAckAt !== null) record.salvageAckAt = row.salvageAckAt;
@@ -560,6 +686,19 @@ function toReport(row: ReportRow): ReportRecord {
   return record;
 }
 
+function toMaterialEvent(row: MaterialEventRow): MaterialEvent {
+  return {
+    id: row.id,
+    project: row.project,
+    category: row.category,
+    summary: row.summary,
+    evidence: row.evidence,
+    occurredAt: row.occurredAt,
+    recordedAt: row.recordedAt,
+    ...(row.digestReportId === null ? {} : { digestReportId: row.digestReportId }),
+  };
+}
+
 interface DecisionRow {
   id: string;
   project: string;
@@ -731,6 +870,23 @@ export function openStore(dbPath: string): Store {
   db.exec("PRAGMA foreign_keys = ON;");
   db.exec("PRAGMA busy_timeout = 5000;");
   db.exec(SCHEMA);
+  // #274: a terminally failed digest did not count as sent, but the old unique
+  // index still blocked a replacement under the same daily key. Replace that
+  // one-time schema so owed ledger rows can be handed off again.
+  const reportDedupeIndex = db
+    .query<{ sql: string | null }, []>(
+      `SELECT sql FROM sqlite_master WHERE type = 'index' AND name = 'reports_dedupe'`,
+    )
+    .get();
+  if (!(reportDedupeIndex?.sql ?? "").includes("state <> 'failed'")) {
+    db.exec(
+      `BEGIN IMMEDIATE;
+       DROP INDEX IF EXISTS reports_dedupe;
+       CREATE UNIQUE INDEX reports_dedupe
+         ON reports (project, dedupeKey) WHERE dedupeKey IS NOT NULL AND state <> 'failed';
+       COMMIT;`,
+    );
+  }
   // Additive migrations are idempotent and preserve every existing row.
   // Historical rows predate per-run ceilings, so the package default is the
   // only truthful recoverable value; every new run persists its actual cap.
@@ -744,6 +900,18 @@ export function openStore(dbPath: string): Store {
   if (!columns.some((column) => column.name === "headSha")) {
     db.exec("ALTER TABLE runs ADD COLUMN headSha TEXT");
   }
+  // Historical merged rows were never watched after settlement, so NULL is
+  // "not observed", never permission to claim their base branch was green.
+  for (const [name, type] of [
+    ["mergeSha", "TEXT"],
+    ["baseRef", "TEXT"],
+    ["baseCheck", "TEXT"],
+    ["baseCheckAt", "INTEGER"],
+  ] as const) {
+    if (!columns.some((column) => column.name === name)) {
+      db.exec(`ALTER TABLE runs ADD COLUMN ${name} ${type}`);
+    }
+  }
   // v0.3.22 and earlier removed a blocked run's dirty tree without saving it
   // (#118), so no row before this release has anywhere to record where the
   // work went. A NULL `salvageSha` on a historical row therefore means "never
@@ -785,6 +953,24 @@ export function openStore(dbPath: string): Store {
       db.exec(`ALTER TABLE runs ADD COLUMN ${name} ${type}`);
     }
   }
+  // Existing held-notice rows predate exact digest ownership (#274). A NULL
+  // report id is truthful for already-digested history and means "still owed"
+  // only while digestedAt is also NULL.
+  const heldNoticeColumns = db.query<{ name: string }, []>("PRAGMA table_info(held_notices)").all();
+  if (!heldNoticeColumns.some((column) => column.name === "digestReportId")) {
+    db.exec("ALTER TABLE held_notices ADD COLUMN digestReportId TEXT");
+  }
+  // #273 distinguishes category-deferred notices from otherwise-interruptible
+  // notices held only because the operator was outside their working window.
+  // Historical rows were category-deferred, so false is the only safe default.
+  if (!heldNoticeColumns.some((column) => column.name === "releaseOnAvailable")) {
+    db.exec("ALTER TABLE held_notices ADD COLUMN releaseOnAvailable INTEGER NOT NULL DEFAULT 0");
+  }
+  // Urgent recovery notices bypass category batching only; they still wait for
+  // the configured availability window. Historical notices were not urgent.
+  if (!heldNoticeColumns.some((column) => column.name === "urgent")) {
+    db.exec("ALTER TABLE held_notices ADD COLUMN urgent INTEGER NOT NULL DEFAULT 0");
+  }
 
   // One-time repair, and the reason it lives here rather than in the classifier:
   // a turn-0 environment fault that was ALREADY classified `unknown` and
@@ -878,9 +1064,10 @@ export function openStore(dbPath: string): Store {
   const insertRun = db.query<unknown, SqlValue[]>(
     `INSERT INTO runs (
        id, project, issue, repo, branch, worktree, state, attempt, turns,
-       maxTurns, spendUsd, sessionFile, prUrl, headSha, salvageSha, salvageError,
-       salvageAckAt, startedAt, endedAt, lastError, settlementFlags, report
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       maxTurns, spendUsd, sessionFile, prUrl, headSha, mergeSha, baseRef,
+       baseCheck, baseCheckAt, salvageSha, salvageError, salvageAckAt, startedAt,
+       endedAt, lastError, settlementFlags, report
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
   const selectRun = db.query<RunRow, [string]>(`SELECT * FROM runs WHERE id = ?`);
   const selectActive = db.query<RunRow, SqlValue[]>(
@@ -910,6 +1097,33 @@ export function openStore(dbPath: string): Store {
         AND (state <> 'merged' OR COALESCE(endedAt, startedAt) >= ?)
       ORDER BY startedAt DESC`,
   );
+  const selectPendingBaseChecks = db.query<RunRow, [string, number]>(
+    `SELECT * FROM runs
+      WHERE project = ? AND state = 'merged' AND baseCheck = 'pending'
+      ORDER BY COALESCE(endedAt, startedAt) ASC, rowid ASC
+      LIMIT ?`,
+  );
+  const upsertBaseHealthRow = db.query<
+    unknown,
+    [string, string, string, string, string, number, SqlValue, number]
+  >(
+    `INSERT OR REPLACE INTO base_health
+       (project, repo, branch, headSha, verdict, runsCount, detail, checkedAt)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+  const selectBaseHealth = db.query<BaseHealthRow, [string]>(
+    `SELECT * FROM base_health WHERE project = ? ORDER BY repo ASC`,
+  );
+  const selectMergedRepoBranches = db.query<
+    { repo: string; baseRef: string | null },
+    [string, number]
+  >(
+    `SELECT repo, baseRef FROM runs
+      WHERE project = ? AND state = 'merged'
+        AND COALESCE(endedAt, startedAt) >= ?
+      GROUP BY repo, baseRef
+      ORDER BY repo ASC, baseRef ASC`,
+  );
   const countAttempts = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs WHERE project = ? AND issue = ?`,
   );
@@ -922,12 +1136,16 @@ export function openStore(dbPath: string): Store {
   const countFailures = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs
       WHERE project = ? AND issue = ? AND state = 'failed'
-        AND (failureClass IS NULL OR failureClass NOT IN ('ci-infra', 'settlement-stuck', 'env-start-failure', 'dispatch-infra', 'provider-credit', 'provider-transient'))`,
+        AND (failureClass IS NULL OR failureClass NOT IN ('ci-infra', 'settlement-stuck', 'env-start-failure', 'dispatch-infra', 'provider-credit', 'provider-transient', 'returned-for-revision'))`,
   );
   const countContinuations = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs
-      WHERE project = ? AND issue = ? AND state IN ('killed', 'orphaned', 'blocked')
-        AND (failureClass IS NULL OR failureClass NOT IN ('admin-kill', 'settlement-stuck', 'env-start-failure', 'dispatch-infra', 'provider-credit', 'provider-transient'))`,
+      WHERE project = ? AND issue = ?
+        AND (
+          (state IN ('killed', 'orphaned', 'blocked')
+            AND (failureClass IS NULL OR failureClass NOT IN ('admin-kill', 'settlement-stuck', 'env-start-failure', 'dispatch-infra', 'provider-credit', 'provider-transient')))
+          OR (state = 'failed' AND failureClass = 'returned-for-revision')
+        )`,
   );
   // How many times one issue reached a given class. Recovery uses it to bound a
   // retry loop whose cause is persistent (e.g. a mirror that will not refresh):
@@ -993,6 +1211,38 @@ export function openStore(dbPath: string): Store {
       ORDER BY startedAt DESC, rowid DESC
       LIMIT 1`,
   );
+  const upsertTurnOverride = db.query<unknown, [string, number, number, number]>(
+    `INSERT INTO turn_overrides (project, issue, maxTurns, setAt) VALUES (?, ?, ?, ?)
+     ON CONFLICT(project, issue) DO UPDATE SET
+       maxTurns = excluded.maxTurns,
+       setAt = excluded.setAt`,
+  );
+  const insertTurnOverrideLedger = db.query<
+    unknown,
+    [string, string, number, number, number]
+  >(
+    `INSERT INTO turn_override_ledger (id, project, issue, maxTurns, setAt)
+     VALUES (?, ?, ?, ?, ?)`,
+  );
+  const selectTurnOverride = db.query<{ maxTurns: number }, [string, number]>(
+    `SELECT maxTurns FROM turn_overrides WHERE project = ? AND issue = ?`,
+  );
+  const deleteTurnOverride = db.query<unknown, [string, number]>(
+    `DELETE FROM turn_overrides WHERE project = ? AND issue = ?`,
+  );
+  const selectTurnOverrides = db.query<TurnOverride, [string]>(
+    `SELECT project, issue, maxTurns, setAt FROM turn_overrides
+      WHERE project = ? ORDER BY issue ASC`,
+  );
+  const selectTurnOverrideLedger = db.query<
+    TurnOverride,
+    [string, number, number, number]
+  >(
+    `SELECT project, issue, maxTurns, setAt FROM turn_override_ledger
+      WHERE project = ? AND (? = 0 OR issue = ?)
+      ORDER BY setAt DESC, rowid DESC
+      LIMIT ?`,
+  );
   // Every attempt that settled with a report, in attempt order. NULLs are the
   // rows written before #199, or one killed before the worker returned a
   // report — skipping them makes a continuation read exactly today's priors.
@@ -1091,7 +1341,9 @@ export function openStore(dbPath: string): Store {
   );
   const selectReport = db.query<ReportRow, [string]>(`SELECT * FROM reports WHERE id = ?`);
   const selectReportByDedupe = db.query<ReportRow, [string, string]>(
-    `SELECT * FROM reports WHERE project = ? AND dedupeKey = ?`,
+    `SELECT * FROM reports
+      WHERE project = ? AND dedupeKey = ? AND state <> 'failed'
+      ORDER BY createdAt DESC, rowid DESC LIMIT 1`,
   );
   const selectDueReports = db.query<ReportRow, [string, number, number]>(
     `SELECT * FROM reports
@@ -1099,23 +1351,231 @@ export function openStore(dbPath: string): Store {
       ORDER BY createdAt ASC, rowid ASC
       LIMIT ?`,
   );
+  const deletePendingMaterialReport = db.query<unknown, [string, string]>(
+    `DELETE FROM reports
+      WHERE id = ? AND project = ? AND kind = 'material' AND state = 'pending'`,
+  );
+  const deletePendingAvailabilityReport = db.query<unknown, [string, string]>(
+    `DELETE FROM reports
+      WHERE id = ? AND project = ? AND kind = 'digest' AND state = 'pending'
+        AND dedupeKey LIKE 'availability/%'`,
+  );
+  const selectPendingAvailabilityReports = db.query<
+    { id: string; ambiguous: number },
+    [string]
+  >(
+    `SELECT id, ambiguous FROM reports
+      WHERE project = ? AND kind = 'digest' AND state = 'pending'
+        AND dedupeKey LIKE 'availability/%'
+      ORDER BY createdAt ASC, rowid ASC`,
+  );
+  const releaseAvailabilityNotices = db.query<
+    unknown,
+    [number, string, string, string, string, string]
+  >(
+    `UPDATE held_notices
+        SET digestReportId = NULL,
+            digestedAt = NULL,
+            summary = CASE
+              WHEN ? = 1 AND summary NOT LIKE 'POSSIBLE REPEAT%'
+                THEN 'POSSIBLE REPEAT of catch-up ' || ? || ': ' || summary
+              ELSE summary
+            END
+      WHERE project = ? AND digestReportId = ? AND EXISTS (
+        SELECT 1 FROM reports
+          WHERE id = ? AND project = ? AND kind = 'digest' AND state = 'pending'
+            AND dedupeKey LIKE 'availability/%'
+      )`,
+  );
+  const selectAvailabilityReservationCandidate = db.query<{ id: string }, [string]>(
+    `SELECT held_notices.id FROM held_notices
+      WHERE held_notices.project = ? AND held_notices.releaseOnAvailable = 1 AND (
+        (held_notices.digestReportId IS NULL AND held_notices.digestedAt IS NULL)
+        OR EXISTS (
+          SELECT 1 FROM reports
+            WHERE reports.id = held_notices.digestReportId AND (
+              reports.state = 'failed'
+              OR (
+                reports.state = 'pending' AND reports.kind = 'digest'
+                AND reports.dedupeKey LIKE 'availability/%'
+              )
+            )
+        )
+      )
+      ORDER BY held_notices.createdAt ASC, held_notices.rowid ASC
+      LIMIT 1`,
+  );
+  const selectAvailabilityReservation = db.query<
+    { expiresAt: number },
+    [string, string, string]
+  >(
+    `SELECT expiresAt FROM availability_digest_reservations
+      WHERE project = ? AND cycleKey = ? AND firstNoticeId = ?`,
+  );
+  const insertAvailabilityReservation = db.query<
+    unknown,
+    [string, string, string, number]
+  >(
+    `INSERT OR IGNORE INTO availability_digest_reservations
+       (project, cycleKey, firstNoticeId, expiresAt)
+     VALUES (?, ?, ?, ?)`,
+  );
+  const countActiveAvailabilityReservations = db.query<
+    { count: number },
+    [string, number]
+  >(
+    `SELECT COUNT(*) AS count FROM availability_digest_reservations
+      WHERE project = ? AND expiresAt > ?`,
+  );
+  const deleteAvailabilityReservationForNotice = db.query<
+    unknown,
+    [string, string]
+  >(
+    `DELETE FROM availability_digest_reservations
+      WHERE project = ? AND firstNoticeId = ?`,
+  );
 
-  // Held notices (#229): escalations deferred to the digest by the project's
-  // `reporting.interruptOn` policy. `digestedAt` NULL = still owed.
+  // Held notices (#229) and ordinary material events (#274) stay separate
+  // sources. Both are associated with one accepted digest by exact row id.
   const insertHeldNotice = db.query<unknown, SqlValue[]>(
-    `INSERT INTO held_notices (id, project, category, summary, detail, createdAt, digestedAt)
-     VALUES (?, ?, ?, ?, ?, ?, NULL)`,
+    `INSERT INTO held_notices
+       (id, project, category, summary, detail, createdAt, releaseOnAvailable, urgent, digestedAt)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)
+     ON CONFLICT(id) DO NOTHING`,
+  );
+  const insertHeldNoticeDraft = (notice: HeldNoticeDraft): boolean =>
+    insertHeldNotice.run(
+      notice.id ?? crypto.randomUUID(),
+      notice.project,
+      notice.category,
+      notice.summary,
+      notice.detail,
+      notice.createdAt,
+      notice.releaseOnAvailable === true ? 1 : 0,
+      notice.urgent === true ? 1 : 0,
+    ).changes === 1;
+  const deferPendingReportToNoticeTx = db.transaction(
+    (id: string, notice: HeldNoticeDraft): boolean => {
+      if (deletePendingMaterialReport.run(id, notice.project).changes !== 1) return false;
+      if (!insertHeldNoticeDraft(notice)) {
+        throw new Error(`held notice ${notice.id ?? "(generated)"} already exists`);
+      }
+      return true;
+    },
+  );
+  const releasePendingAvailabilityReportRecord = (
+    id: string,
+    project: string,
+    possibleRepeat = false,
+  ): boolean => {
+    if (
+      releaseAvailabilityNotices.run(possibleRepeat ? 1 : 0, id, project, id, id, project)
+        .changes === 0
+    ) {
+      return false;
+    }
+    if (deletePendingAvailabilityReport.run(id, project).changes !== 1) {
+      throw new Error(`availability catch-up ${id} changed during release`);
+    }
+    return true;
+  };
+  const releasePendingAvailabilityReportTx = db.transaction(
+    releasePendingAvailabilityReportRecord,
+  );
+  const reserveAvailabilityDigestTx = db.transaction(
+    (project: string, cycleKey: string, at: number, expiresAt: number): boolean => {
+      const candidate = selectAvailabilityReservationCandidate.get(project);
+      if (candidate === null) return false;
+      if (selectAvailabilityReservation.get(project, cycleKey, candidate.id) !== null) {
+        return false;
+      }
+      if (
+        insertAvailabilityReservation.run(project, cycleKey, candidate.id, expiresAt).changes ===
+        0
+      ) {
+        return false;
+      }
+      for (const row of selectPendingAvailabilityReports.all(project)) {
+        releasePendingAvailabilityReportRecord(row.id, project, row.ambiguous !== 0);
+      }
+      return true;
+    },
+  );
+  type HeldNoticeRow = {
+    id: string;
+    category: string;
+    summary: string;
+    detail: string;
+    createdAt: number;
+    releaseOnAvailable: number;
+    urgent: number;
+  };
+  const undigestedNoticeWhere = `project = ? AND (
+        (digestReportId IS NULL AND digestedAt IS NULL)
+        OR EXISTS (SELECT 1 FROM reports WHERE reports.id = held_notices.digestReportId AND reports.state = 'failed')
+      )`;
+  const selectUndigestedNotices = db.query<HeldNoticeRow, [string, number]>(
+    `SELECT id, category, summary, detail, createdAt, releaseOnAvailable, urgent FROM held_notices
+      WHERE ${undigestedNoticeWhere}
+      ORDER BY createdAt ASC, rowid ASC
+      LIMIT ?`,
   );
-  const selectUndigestedNotices = db.query<
-    { id: string; category: string; summary: string; detail: string; createdAt: number },
+  const selectAvailabilityHeldNotices = db.query<HeldNoticeRow, [string, number]>(
+    `SELECT id, category, summary, detail, createdAt, releaseOnAvailable, urgent FROM held_notices
+      WHERE ${undigestedNoticeWhere} AND releaseOnAvailable = 1
+      ORDER BY createdAt ASC, rowid ASC
+      LIMIT ?`,
+  );
+  const selectHeldNoticeBacklog = db.query<
+    { count: number; availabilityCount: number | null; oldestAt: number | null },
     [string]
   >(
-    `SELECT id, category, summary, detail, createdAt FROM held_notices
-      WHERE project = ? AND digestedAt IS NULL
-      ORDER BY createdAt ASC`,
+    `SELECT COUNT(*) AS count,
+            SUM(CASE WHEN releaseOnAvailable = 1 THEN 1 ELSE 0 END) AS availabilityCount,
+            MIN(createdAt) AS oldestAt
+       FROM held_notices
+      WHERE project = ? AND (
+        (digestReportId IS NULL AND digestedAt IS NULL)
+        OR EXISTS (SELECT 1 FROM reports WHERE reports.id = held_notices.digestReportId AND reports.state = 'failed')
+      )`,
+  );
+  const assignHeldNoticeToDigest = db.query<unknown, [number, string, string, string]>(
+    `UPDATE held_notices SET digestedAt = ?, digestReportId = ?
+      WHERE project = ? AND id = ? AND (
+        (digestReportId IS NULL AND digestedAt IS NULL)
+        OR EXISTS (SELECT 1 FROM reports WHERE reports.id = held_notices.digestReportId AND reports.state = 'failed')
+      )`,
+  );
+  const insertMaterialEvent = db.query<unknown, SqlValue[]>(
+    `INSERT INTO material_events
+       (id, project, category, summary, evidence, occurredAt, recordedAt, digestReportId)
+     VALUES (?, ?, ?, ?, ?, ?, ?, NULL)`,
+  );
+  const selectMaterialEvent = db.query<MaterialEventRow, [string]>(
+    `SELECT * FROM material_events WHERE id = ?`,
+  );
+  const selectUndigestedMaterialEvents = db.query<MaterialEventRow, [string, number]>(
+    `SELECT * FROM material_events
+      WHERE project = ? AND (
+        digestReportId IS NULL
+        OR EXISTS (SELECT 1 FROM reports WHERE reports.id = material_events.digestReportId AND reports.state = 'failed')
+      )
+      ORDER BY occurredAt ASC, recordedAt ASC, rowid ASC
+      LIMIT ?`,
+  );
+  const selectMaterialEventBacklog = db.query<{ count: number; oldestAt: number | null }, [string]>(
+    `SELECT COUNT(*) AS count, MIN(occurredAt) AS oldestAt FROM material_events
+      WHERE project = ? AND (
+        digestReportId IS NULL
+        OR EXISTS (SELECT 1 FROM reports WHERE reports.id = material_events.digestReportId AND reports.state = 'failed')
+      )`,
   );
-  const markNoticesDigestedRow = db.query<unknown, [number, string]>(
-    `UPDATE held_notices SET digestedAt = ? WHERE project = ? AND digestedAt IS NULL`,
+  const assignMaterialEventToDigest = db.query<unknown, [string, string, string]>(
+    `UPDATE material_events SET digestReportId = ?
+      WHERE project = ? AND id = ? AND (
+        digestReportId IS NULL
+        OR EXISTS (SELECT 1 FROM reports WHERE reports.id = material_events.digestReportId AND reports.state = 'failed')
+      )`,
   );
   // The newest digest dedupe key a project has actually run toward — an
   // `updatedAt`-newest row whose key is a digest prefix and that did not end in
@@ -1171,6 +1631,90 @@ export function openStore(dbPath: string): Store {
       ORDER BY createdAt ASC, rowid ASC`,
   );
 
+  const enqueueReportRecord = (draft: ReportDraft): ReportEnqueue => {
+    const report: ReportRecord = {
+      id: newReportId(),
+      project: draft.project,
+      kind: draft.kind,
+      body: draft.body,
+      state: "pending",
+      attempts: 0,
+      ambiguous: false,
+      ...(draft.dedupeKey === undefined ? {} : { dedupeKey: draft.dedupeKey }),
+      createdAt: draft.at,
+      updatedAt: draft.at,
+      // Due immediately. No report has earned a backoff before its first send.
+      nextAttemptAt: draft.at,
+    };
+    const inserted = insertReport.run(
+      report.id,
+      report.project,
+      report.kind,
+      report.body,
+      report.state,
+      report.attempts,
+      null,
+      0,
+      toSql(draft.dedupeKey),
+      report.createdAt,
+      report.updatedAt,
+      report.nextAttemptAt,
+      null,
+      null,
+      null,
+    );
+    if (inserted.changes > 0) return { report, deduped: false };
+    // `INSERT OR IGNORE` swallowed a conflict. A digest-key conflict is the
+    // expected path; a random 48-bit id collision has no matching key and fails
+    // closed below instead of returning an unrelated report.
+    const existing =
+      draft.dedupeKey === undefined ? null : selectReportByDedupe.get(draft.project, draft.dedupeKey);
+    if (existing === null) {
+      throw new Error(`report ${report.id} could not be enqueued for ${draft.project}`);
+    }
+    return { report: toReport(existing), deduped: true };
+  };
+
+  const enqueueDigestReportRecord = (
+    draft: ReportDraft,
+    materialEventIds: readonly string[],
+    heldNoticeIds: readonly string[],
+  ): ReportEnqueue => {
+    if (draft.kind !== "digest") {
+      throw new Error("digest handoff needs kind digest");
+    }
+    const enqueued = enqueueReportRecord(draft);
+    if (enqueued.deduped) return enqueued;
+    for (const id of new Set(materialEventIds)) {
+      if (assignMaterialEventToDigest.run(enqueued.report.id, draft.project, id).changes !== 1) {
+        throw new Error(`material event ${id} is not owed by project ${draft.project}`);
+      }
+    }
+    for (const id of new Set(heldNoticeIds)) {
+      if (assignHeldNoticeToDigest.run(draft.at, enqueued.report.id, draft.project, id).changes !== 1) {
+        throw new Error(`held notice ${id} is not owed by project ${draft.project}`);
+      }
+      if (!draft.dedupeKey?.startsWith("availability/")) {
+        deleteAvailabilityReservationForNotice.run(draft.project, id);
+      }
+    }
+    return enqueued;
+  };
+  const enqueueDigestReportTx = db.transaction(enqueueDigestReportRecord);
+  const enqueueAvailabilityReportTx = db.transaction(
+    (draft: ReportDraft, heldNoticeIds: readonly string[]): ReportEnqueue | undefined => {
+      if (draft.kind !== "digest" || !draft.dedupeKey?.startsWith("availability/")) {
+        throw new Error("availability handoff needs an availability digest key");
+      }
+      if (
+        (countActiveAvailabilityReservations.get(draft.project, draft.at)?.count ?? 0) > 0
+      ) {
+        return undefined;
+      }
+      return enqueueDigestReportRecord(draft, [], heldNoticeIds);
+    },
+  );
+
   const insertDecision = db.query<never, [string, string, string, SqlValue, number, number, SqlValue, string]>(
     `INSERT INTO decisions
        (id, project, question, blocks, askedAt, expiresAt, condition, state)
@@ -1347,34 +1891,58 @@ export function openStore(dbPath: string): Store {
     recordGhRefusalTx(at);
   };
 
+  const insertRunRecord = (r: Omit<RunRecord, "id">): RunRecord => {
+    const record: RunRecord = { ...r, id: crypto.randomUUID() };
+    insertRun.run(
+      record.id,
+      record.project,
+      record.issue,
+      record.repo,
+      record.branch,
+      record.worktree,
+      record.state,
+      record.attempt,
+      record.turns,
+      record.maxTurns,
+      record.spendUsd,
+      toSql(record.sessionFile),
+      toSql(record.prUrl),
+      toSql(record.headSha),
+      toSql(record.mergeSha),
+      toSql(record.baseRef),
+      toSql(record.baseCheck),
+      toSql(record.baseCheckAt),
+      toSql(record.salvageSha),
+      toSql(record.salvageError),
+      toSql(record.salvageAckAt),
+      record.startedAt,
+      toSql(record.endedAt),
+      toSql(record.lastError),
+      toSql(record.settlementFlags),
+      toSql(record.report),
+    );
+    return record;
+  };
+  const createRunTx = db.transaction((r: Omit<RunRecord, "id">): RunRecord => {
+    if (r.state !== "claimed") return insertRunRecord(r);
+    const turnOverride = selectTurnOverride.get(r.project, r.issue)?.maxTurns;
+    const record = insertRunRecord({
+      ...r,
+      maxTurns: Math.max(r.maxTurns, turnOverride ?? r.maxTurns),
+    });
+    if (turnOverride !== undefined) deleteTurnOverride.run(r.project, r.issue);
+    return record;
+  });
+  const setTurnOverrideTx = db.transaction(
+    (project: string, issue: number, maxTurns: number, setAt: number): void => {
+      upsertTurnOverride.run(project, issue, maxTurns, setAt);
+      insertTurnOverrideLedger.run(crypto.randomUUID(), project, issue, maxTurns, setAt);
+    },
+  );
+
   return {
     createRun(r: Omit<RunRecord, "id">): RunRecord {
-      const record: RunRecord = { ...r, id: crypto.randomUUID() };
-      insertRun.run(
-        record.id,
-        record.project,
-        record.issue,
-        record.repo,
-        record.branch,
-        record.worktree,
-        record.state,
-        record.attempt,
-        record.turns,
-        record.maxTurns,
-        record.spendUsd,
-        toSql(record.sessionFile),
-        toSql(record.prUrl),
-        toSql(record.headSha),
-        toSql(record.salvageSha),
-        toSql(record.salvageError),
-        toSql(record.salvageAckAt),
-        record.startedAt,
-        toSql(record.endedAt),
-        toSql(record.lastError),
-        toSql(record.settlementFlags),
-        toSql(record.report),
-      );
-      return record;
+      return createRunTx(r);
     },
 
     updateRun(id: string, patch: Partial<RunRecord>): void {
@@ -1414,6 +1982,36 @@ export function openStore(dbPath: string): Store {
     recentRuns(project: string, mergedSinceEpochMs: number): RunRecord[] {
       return selectRecentRuns.all(project, mergedSinceEpochMs).map(toRecord);
     },
+    runsNeedingBaseCheck(project: string, limit = 20): RunRecord[] {
+      return selectPendingBaseChecks.all(project, limit).map(toRecord);
+    },
+
+    upsertBaseHealth(project: string, row: BaseHealth): void {
+      upsertBaseHealthRow.run(
+        project,
+        row.repo,
+        row.branch,
+        row.headSha,
+        row.verdict,
+        row.runsCount,
+        row.detail ?? null,
+        row.checkedAt,
+      );
+    },
+
+    baseHealth(project: string): BaseHealth[] {
+      return selectBaseHealth.all(project).map(toBaseHealth);
+    },
+
+    mergedRepoBranches(
+      project: string,
+      sinceEpochMs: number,
+    ): { repo: string; baseRef?: string }[] {
+      return selectMergedRepoBranches.all(project, sinceEpochMs).map((row) =>
+        row.baseRef === null ? { repo: row.repo } : { repo: row.repo, baseRef: row.baseRef },
+      );
+    },
+
 
     salvagedRuns(project: string): RunRecord[] {
       return selectSalvaged.all(project).map(toRecord);
@@ -1440,6 +2038,30 @@ export function openStore(dbPath: string): Store {
       return row ? toRecord(row) : undefined;
     },
 
+    setTurnOverride(project: string, issue: number, maxTurns: number, setAt = Date.now()): void {
+      setTurnOverrideTx(project, issue, maxTurns, setAt);
+    },
+
+    turnOverride(project: string, issue: number): number | undefined {
+      return selectTurnOverride.get(project, issue)?.maxTurns;
+    },
+
+    clearTurnOverride(project: string, issue: number): void {
+      deleteTurnOverride.run(project, issue);
+    },
+
+    listTurnOverrides(project: string): TurnOverride[] {
+      return selectTurnOverrides.all(project);
+    },
+
+    turnOverrideLedger(
+      project: string,
+      opts: { issue?: number; limit?: number } = {},
+    ): TurnOverride[] {
+      const issue = opts.issue ?? 0;
+      return selectTurnOverrideLedger.all(project, issue, issue, opts.limit ?? 50);
+    },
+
     attemptReports(project: string, issue: number): { attempt: number; report: string }[] {
       return selectAttemptReports.all(project, issue);
     },
@@ -1498,22 +2120,86 @@ export function openStore(dbPath: string): Store {
     },
 
     addHeldNotice(notice: HeldNoticeDraft): void {
-      insertHeldNotice.run(
-        crypto.randomUUID(),
-        notice.project,
-        notice.category,
-        notice.summary,
-        notice.detail,
-        notice.createdAt,
+      insertHeldNoticeDraft(notice);
+    },
+
+    undigestedNotices(
+      project: string,
+      limit = DIGEST_BACKLOG_LIMIT,
+      availabilityOnly = false,
+      categories?: readonly InterruptCategory[],
+      urgent?: boolean,
+    ): HeldNotice[] {
+      if (categories?.length === 0) return [];
+      const rows =
+        availabilityOnly && categories !== undefined
+          ? db
+              .query<HeldNoticeRow, SqlValue[]>(
+                `SELECT id, category, summary, detail, createdAt, releaseOnAvailable, urgent
+                   FROM held_notices
+                  WHERE ${undigestedNoticeWhere}
+                    AND releaseOnAvailable = 1
+                    AND category IN (${categories.map(() => "?").join(", ")})
+                    ${urgent === undefined ? "" : "AND urgent = ?"}
+                  ORDER BY createdAt ASC, rowid ASC
+                  LIMIT ?`,
+              )
+              .all(project, ...categories, ...(urgent === undefined ? [] : [urgent ? 1 : 0]), limit)
+          : (availabilityOnly ? selectAvailabilityHeldNotices : selectUndigestedNotices).all(
+              project,
+              limit,
+            );
+      return rows.map((row) => ({
+        id: row.id,
+        category: row.category as HeldNotice["category"],
+        summary: row.summary,
+        detail: row.detail,
+        createdAt: row.createdAt,
+        ...(row.releaseOnAvailable === 1 ? { releaseOnAvailable: true as const } : {}),
+        ...(row.urgent === 1 ? { urgent: true as const } : {}),
+      }));
+    },
+
+    recordMaterialEvent(event: MaterialEventDraft): MaterialEvent {
+      const record: MaterialEvent = {
+        id: newReportId(),
+        ...event,
+      };
+      insertMaterialEvent.run(
+        record.id,
+        record.project,
+        record.category,
+        record.summary,
+        record.evidence,
+        record.occurredAt,
+        record.recordedAt,
       );
+      return record;
     },
 
-    undigestedNotices(project: string): HeldNotice[] {
-      return selectUndigestedNotices.all(project).map((row) => ({ ...row }) as HeldNotice);
+    getMaterialEvent(id: string): MaterialEvent | undefined {
+      const row = selectMaterialEvent.get(id);
+      return row === null ? undefined : toMaterialEvent(row);
     },
 
-    markNoticesDigested(project: string, at: number): void {
-      markNoticesDigestedRow.run(at, project);
+    undigestedMaterialEvents(project: string, limit = DIGEST_BACKLOG_LIMIT): MaterialEvent[] {
+      return selectUndigestedMaterialEvents.all(project, limit).map(toMaterialEvent);
+    },
+
+    digestBacklog(project: string): DigestBacklog {
+      const material = selectMaterialEventBacklog.get(project);
+      const held = selectHeldNoticeBacklog.get(project);
+      return {
+        materialCount: material?.count ?? 0,
+        ...(material?.oldestAt === null || material?.oldestAt === undefined
+          ? {}
+          : { materialOldestAt: material.oldestAt }),
+        heldNoticeCount: held?.count ?? 0,
+        availabilityHeldNoticeCount: held?.availabilityCount ?? 0,
+        ...(held?.oldestAt === null || held?.oldestAt === undefined
+          ? {}
+          : { heldNoticeOldestAt: held.oldestAt }),
+      };
     },
 
     recordFriction,
@@ -1591,50 +2277,22 @@ export function openStore(dbPath: string): Store {
     },
 
     enqueueReport(draft: ReportDraft): ReportEnqueue {
-      const report: ReportRecord = {
-        id: newReportId(),
-        project: draft.project,
-        kind: draft.kind,
-        body: draft.body,
-        state: "pending",
-        attempts: 0,
-        ambiguous: false,
-        ...(draft.dedupeKey === undefined ? {} : { dedupeKey: draft.dedupeKey }),
-        createdAt: draft.at,
-        updatedAt: draft.at,
-        // Due immediately. A backoff nobody has earned yet would delay the
-        // first attempt at a report an operator is already waiting for.
-        nextAttemptAt: draft.at,
-      };
-      const inserted = insertReport.run(
-        report.id,
-        report.project,
-        report.kind,
-        report.body,
-        report.state,
-        report.attempts,
-        null,
-        0,
-        toSql(draft.dedupeKey),
-        report.createdAt,
-        report.updatedAt,
-        report.nextAttemptAt,
-        null,
-        null,
-        null,
-      );
-      if (inserted.changes > 0) return { report, deduped: false };
-      // `INSERT OR IGNORE` swallowed a conflict, and the only conflict this
-      // table has is the digest guard — a 48-bit id collision is not a thing
-      // anyone needs to handle. Return the row that won rather than the one
-      // that lost, so whoever handed the digest over is told the truth about
-      // which report their operator will actually receive.
-      const existing =
-        draft.dedupeKey === undefined ? null : selectReportByDedupe.get(draft.project, draft.dedupeKey);
-      if (existing === null) {
-        throw new Error(`report ${report.id} could not be enqueued for ${draft.project}`);
-      }
-      return { report: toReport(existing), deduped: true };
+      return enqueueReportRecord(draft);
+    },
+
+    enqueueDigestReport(
+      draft: ReportDraft,
+      materialEventIds: readonly string[],
+      heldNoticeIds: readonly string[],
+    ): ReportEnqueue {
+      return enqueueDigestReportTx(draft, materialEventIds, heldNoticeIds);
+    },
+
+    enqueueAvailabilityReport(
+      draft: ReportDraft,
+      heldNoticeIds: readonly string[],
+    ): ReportEnqueue | undefined {
+      return enqueueAvailabilityReportTx.immediate(draft, heldNoticeIds);
     },
 
     getReport(id: string): ReportRecord | undefined {
@@ -1642,6 +2300,21 @@ export function openStore(dbPath: string): Store {
       return row === null ? undefined : toReport(row);
     },
 
+    deferPendingReportToNotice(id: string, notice: HeldNoticeDraft): boolean {
+      return deferPendingReportToNoticeTx(id, notice);
+    },
+    releasePendingAvailabilityReport(id: string, project: string, possibleRepeat = false): boolean {
+      return releasePendingAvailabilityReportTx(id, project, possibleRepeat);
+    },
+    reserveAvailabilityDigest(
+      project: string,
+      cycleKey: string,
+      at: number,
+      expiresAt: number,
+    ): boolean {
+      return reserveAvailabilityDigestTx.immediate(project, cycleKey, at, expiresAt);
+    },
+
     dueReports(project: string, now: number, limit: number): ReportRecord[] {
       return selectDueReports.all(project, now, limit).map(toReport);
     },