omp-conductor 0.12.0 → 0.13.0

package/src/store.ts

@@ -41,6 +41,7 @@ import type {
   SessionRole,
   SettlementFlag,
   Store,
+  TurnOverride,
   VerbDecision,
   VerbLedgerDraft,
   VerbLedgerEntry,
@@ -73,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",
@@ -107,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,
@@ -139,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;
@@ -256,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,
@@ -276,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
@@ -519,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;
@@ -744,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
@@ -878,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[]>(
@@ -910,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 = ?`,
   );
@@ -993,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.
@@ -1347,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 {
@@ -1414,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);
@@ -1440,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);
     },