omp-conductor 0.10.0 → 0.13.0

package/src/store.ts

@@ -26,6 +26,8 @@ import type {
   FrictionKind,
   FrictionObservation,
   FrictionSignal,
+  HeldNotice,
+  HeldNoticeDraft,
   LabelOp,
   MergeLock,
   ReportDeliveryState,
@@ -39,6 +41,7 @@ import type {
   SessionRole,
   SettlementFlag,
   Store,
+  TurnOverride,
   VerbDecision,
   VerbLedgerDraft,
   VerbLedgerEntry,
@@ -71,6 +74,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",
@@ -105,6 +109,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,
@@ -137,6 +145,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;
@@ -254,6 +266,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,
@@ -274,6 +290,28 @@ CREATE TABLE IF NOT EXISTS notifications (
   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
@@ -332,6 +370,24 @@ CREATE UNIQUE INDEX IF NOT EXISTS reports_dedupe
 CREATE INDEX IF NOT EXISTS reports_project_state
   ON reports (project, state, nextAttemptAt);
 
+-- 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
+-- digest pass and no longer owed. A table rather than a flag on reports: these
+-- 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
+);
+CREATE INDEX IF NOT EXISTS held_notices_project_undigested
+  ON held_notices (project, digestedAt) WHERE digestedAt IS NULL;
+
 -- 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
@@ -499,6 +555,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;
@@ -724,6 +784,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
@@ -858,9 +930,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[]>(
@@ -890,6 +963,26 @@ 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 selectLatestBaseChecks = db.query<RunRow & { rank: number }, [string, number]>(
+    `SELECT * FROM (
+       SELECT runs.*,
+         ROW_NUMBER() OVER (
+           PARTITION BY repo
+           ORDER BY COALESCE(endedAt, startedAt) DESC, runs.rowid DESC
+         ) AS rank
+       FROM runs
+       WHERE project = ? AND state = 'merged' AND baseCheck IS NOT NULL
+         AND COALESCE(baseCheckAt, endedAt, startedAt) >= ?
+     )
+     WHERE rank = 1
+     ORDER BY repo ASC`,
+  );
   const countAttempts = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs WHERE project = ? AND issue = ?`,
   );
@@ -902,12 +995,12 @@ 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'))`,
+        AND (failureClass IS NULL OR failureClass NOT IN ('ci-infra', 'settlement-stuck', 'env-start-failure', 'dispatch-infra', 'provider-credit', 'provider-transient'))`,
   );
   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'))`,
+        AND (failureClass IS NULL OR failureClass NOT IN ('admin-kill', 'settlement-stuck', 'env-start-failure', 'dispatch-infra', 'provider-credit', 'provider-transient'))`,
   );
   // 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):
@@ -973,6 +1066,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.
@@ -1079,6 +1204,33 @@ export function openStore(dbPath: string): Store {
       ORDER BY createdAt ASC, rowid ASC
       LIMIT ?`,
   );
+
+  // Held notices (#229): escalations deferred to the digest by the project's
+  // `reporting.interruptOn` policy. `digestedAt` NULL = still owed.
+  const insertHeldNotice = db.query<unknown, SqlValue[]>(
+    `INSERT INTO held_notices (id, project, category, summary, detail, createdAt, digestedAt)
+     VALUES (?, ?, ?, ?, ?, ?, NULL)`,
+  );
+  const selectUndigestedNotices = db.query<
+    { id: string; category: string; summary: string; detail: string; createdAt: number },
+    [string]
+  >(
+    `SELECT id, category, summary, detail, createdAt FROM held_notices
+      WHERE project = ? AND digestedAt IS NULL
+      ORDER BY createdAt ASC`,
+  );
+  const markNoticesDigestedRow = db.query<unknown, [number, string]>(
+    `UPDATE held_notices SET digestedAt = ? WHERE project = ? AND digestedAt IS NULL`,
+  );
+  // 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
+  // failure. The CLI refuses an off-schedule digest by comparing this against
+  // today's key under `digestDue` (#229).
+  const selectLastDigestKey = db.query<{ key: string | null }, [string]>(
+    `SELECT dedupeKey AS key FROM reports
+      WHERE project = ? AND dedupeKey LIKE 'digest:%' AND state <> 'failed'
+      ORDER BY createdAt DESC LIMIT 1`,
+  );
   const claimReportRow = db.query<unknown, [string, number, string, number]>(
     `UPDATE reports
         SET state = 'sending', attemptId = ?, attempts = attempts + 1, updatedAt = ?
@@ -1300,34 +1452,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 {
@@ -1367,6 +1543,14 @@ 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);
+    },
+
+    latestBaseChecks(project: string, sinceEpochMs: number): RunRecord[] {
+      return selectLatestBaseChecks.all(project, sinceEpochMs).map(toRecord);
+    },
+
 
     salvagedRuns(project: string): RunRecord[] {
       return selectSalvaged.all(project).map(toRecord);
@@ -1393,6 +1577,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);
     },
@@ -1445,6 +1653,30 @@ export function openStore(dbPath: string): Store {
       return row === null ? undefined : toDispatchSummary(row.summary);
     },
 
+    lastDigestDedupeKey(project: string): string | undefined {
+      const row = selectLastDigestKey.get(project);
+      return row?.key ?? undefined;
+    },
+
+    addHeldNotice(notice: HeldNoticeDraft): void {
+      insertHeldNotice.run(
+        crypto.randomUUID(),
+        notice.project,
+        notice.category,
+        notice.summary,
+        notice.detail,
+        notice.createdAt,
+      );
+    },
+
+    undigestedNotices(project: string): HeldNotice[] {
+      return selectUndigestedNotices.all(project).map((row) => ({ ...row }) as HeldNotice);
+    },
+
+    markNoticesDigested(project: string, at: number): void {
+      markNoticesDigestedRow.run(at, project);
+    },
+
     recordFriction,
 
     recordGhRefusal,