omp-conductor 0.15.9 → 0.15.11

package/src/store.ts

@@ -31,6 +31,9 @@ import type {
   HeldNotice,
   InterruptCategory,
   HeldNoticeDraft,
+  IntakeDraft,
+  IntakeItem,
+  IntakeState,
   MaterialEvent,
   MaterialEventDraft,
   LabelOp,
@@ -41,6 +44,7 @@ import type {
   ReportKind,
   ReportRecord,
   RecoveryAction,
+  RunPatch,
   RunRecord,
   RunState,
   SessionRole,
@@ -292,6 +296,34 @@ interface MergeLockRow {
   at: number;
 }
 
+/** The `intake_items` table exactly as SQLite hands it back (#299). */
+interface IntakeRow {
+  id: string;
+  project: string;
+  text: string;
+  createdAt: number;
+  state: string;
+  issueUrl: string | null;
+  groomedAt: number | null;
+}
+
+/**
+ * NULL columns become absent properties, matching the other row converters:
+ * a record read back out of the store deep-equals the one that went in.
+ */
+function toIntakeItem(row: IntakeRow): IntakeItem {
+  const item: IntakeItem = {
+    id: row.id,
+    project: row.project,
+    text: row.text,
+    createdAt: row.createdAt,
+    state: row.state as IntakeState,
+    ...(row.issueUrl === null ? {} : { issueUrl: row.issueUrl }),
+    ...(row.groomedAt === null ? {} : { groomedAt: row.groomedAt }),
+  };
+  return item;
+}
+
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS runs (
   id          TEXT    PRIMARY KEY,
@@ -575,6 +607,23 @@ CREATE TABLE IF NOT EXISTS label_ops (
   lastError     TEXT
 );
 CREATE INDEX IF NOT EXISTS label_ops_project_next ON label_ops (project, nextAttemptAt);
+
+-- Raw ideas captured by the intake command (#299), held durably until
+-- #300 resolves them into issues. A thought from 02:00 must survive a restart
+-- and a reinstall, so it lives here rather than in any process's memory. The
+-- state CHECK keeps the three-state vocabulary exact; issueUrl and groomedAt
+-- stay NULL until an idea becomes (or is dropped instead of) an issue.
+CREATE TABLE IF NOT EXISTS intake_items (
+  id        TEXT    PRIMARY KEY,
+  project   TEXT    NOT NULL,
+  text      TEXT    NOT NULL,
+  createdAt INTEGER NOT NULL,
+  state     TEXT    NOT NULL CHECK (state IN ('pending', 'groomed', 'dismissed')),
+  issueUrl  TEXT,
+  groomedAt INTEGER
+);
+CREATE INDEX IF NOT EXISTS intake_items_project_state
+  ON intake_items (project, state, createdAt);
 `;
 
 /**
@@ -937,10 +986,10 @@ export function openStore(dbPath: string): Store {
   if (!columns.some((column) => column.name === "settlementFlags")) {
     db.exec("ALTER TABLE runs ADD COLUMN settlementFlags TEXT");
   }
-  // Rows written before the settlement report was persisted (#199) have no
-  // text to pool across attempts, so a continuation reads empty priors and
-  // audits exactly as it did before this release. No backfill: the bytes only
-  // ever existed in a worker's memory.
+  // The settlement report was first persisted in #199; rows written before it
+  // simply have no report, which is the honest reading of a kill that never
+  // produced one. No backfill: the bytes only ever existed in a worker's
+  // memory.
   if (!columns.some((column) => column.name === "report")) {
     db.exec("ALTER TABLE runs ADD COLUMN report TEXT");
   }
@@ -1101,6 +1150,38 @@ export function openStore(dbPath: string): Store {
         AND (state <> 'merged' OR COALESCE(endedAt, startedAt) >= ?)
       ORDER BY startedAt DESC`,
   );
+  // Every attempt that recorded one PR URL, newest first — deliberately NOT the
+  // `recentRuns` newest-attempt-per-issue view. Mediated PR verbs resolve a
+  // PR's owner through this: a requeued continuation hides its predecessor's
+  // PR from `recentRuns` the moment it is created, so ownership must be able
+  // to read past the issue's newest row (#434). Merged rows keep the same
+  // recent-history bound as `recentRuns`.
+  const selectRunsForPr = db.query<RunRow, [string, string, number]>(
+    `SELECT * FROM runs
+      WHERE project = ? AND prUrl = ?
+        AND (state <> 'merged' OR COALESCE(endedAt, startedAt) >= ?)
+      ORDER BY startedAt DESC, rowid DESC`,
+  );
+  // The stats window (#282): rows settling at or after `since` — merged rows
+  // included, so a chain whose PR merged inside the window is an outcome —
+  // plus, for those merged issues, their WHOLE attempt chain even when it
+  // started before the window. A continuation that began weeks ago and merged
+  // today must report one lead time from its first claim, not from the window
+  // start; ordering by issue/startedAt makes the first row of each chain its
+  // first queue-label claim.
+  const selectStatsRuns = db.query<RunRow, [string, number, string, number]>(
+    `SELECT * FROM runs
+      WHERE project = ?
+        AND (
+          COALESCE(endedAt, startedAt) >= ?
+          OR issue IN (
+            SELECT issue FROM runs
+              WHERE project = ? AND state = 'merged'
+                AND COALESCE(endedAt, startedAt) >= ?
+          )
+        )
+      ORDER BY issue ASC, startedAt ASC, rowid ASC`,
+  );
   const selectPendingBaseChecks = db.query<RunRow, [string, number]>(
     `SELECT * FROM runs
       WHERE project = ? AND state = 'merged' AND baseCheck = 'pending'
@@ -1215,6 +1296,14 @@ export function openStore(dbPath: string): Store {
       ORDER BY startedAt DESC, rowid DESC
       LIMIT 1`,
   );
+  // Every attempt for one issue, oldest first. An exhaustion escalation groups
+  // these by `failureClass` to report how the continuation budget was spent
+  // (#439); the numeric `*For` counters cannot reconstruct that on their own.
+  const selectRunsForIssue = db.query<RunRow, [string, number]>(
+    `SELECT * FROM runs
+      WHERE project = ? AND issue = ?
+      ORDER BY startedAt ASC, rowid ASC`,
+  );
   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
@@ -1247,14 +1336,8 @@ export function openStore(dbPath: string): Store {
       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.
-  const selectAttemptReports = db.query<{ attempt: number; report: string }, [string, number]>(
-    `SELECT attempt, report FROM runs
-      WHERE project = ? AND issue = ? AND report IS NOT NULL
-      ORDER BY attempt`,
-  );
+  // The settlement report row is kept for the audit trail; nothing pools it
+  // across attempts any more (#488).
   const countStartedSince = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs WHERE project = ? AND startedAt >= ?`,
   );
@@ -1331,6 +1414,10 @@ export function openStore(dbPath: string): Store {
   const selectGhCalls = db.query<{ source: string; calls: number }, [string]>(
     `SELECT source, calls FROM gh_calls WHERE day = ? ORDER BY source`,
   );
+  const sumGhCallsBetween = db.query<{ total: number }, [string, string]>(
+    `SELECT COALESCE(SUM(calls), 0) AS total FROM gh_calls
+      WHERE day BETWEEN ? AND ?`,
+  );
 
   // The report outbox (#123). Every terminal transition names the attempt it is
   // settling, because a request can come back *after* the stale-`sending` sweep
@@ -1531,12 +1618,20 @@ export function openStore(dbPath: string): Store {
       LIMIT ?`,
   );
   const selectHeldNoticeBacklog = db.query<
-    { count: number; availabilityCount: number | null; oldestAt: number | null },
+    {
+      count: number;
+      availabilityCount: number | null;
+      oldestAt: number | null;
+      digestOldestAt: number | null;
+      availabilityOldestAt: number | null;
+    },
     [string]
   >(
     `SELECT COUNT(*) AS count,
             SUM(CASE WHEN releaseOnAvailable = 1 THEN 1 ELSE 0 END) AS availabilityCount,
-            MIN(createdAt) AS oldestAt
+            MIN(createdAt) AS oldestAt,
+            MIN(CASE WHEN releaseOnAvailable = 0 THEN createdAt END) AS digestOldestAt,
+            MIN(CASE WHEN releaseOnAvailable = 1 THEN createdAt END) AS availabilityOldestAt
        FROM held_notices
       WHERE project = ? AND (
         (digestReportId IS NULL AND digestedAt IS NULL)
@@ -1581,6 +1676,23 @@ export function openStore(dbPath: string): Store {
         OR EXISTS (SELECT 1 FROM reports WHERE reports.id = material_events.digestReportId AND reports.state = 'failed')
       )`,
   );
+  const insertIntake = db.query<unknown, SqlValue[]>(
+    `INSERT INTO intake_items (id, project, text, createdAt, state)
+     VALUES (?, ?, ?, ?, 'pending')`,
+  );
+  const selectPendingIntake = db.query<IntakeRow, [string]>(
+    `SELECT * FROM intake_items
+      WHERE project = ? AND state = 'pending'
+      ORDER BY createdAt ASC, rowid ASC`,
+  );
+  const groomIntake = db.query<unknown, SqlValue[]>(
+    `UPDATE intake_items SET state = 'groomed', issueUrl = ?, groomedAt = ?
+      WHERE id = ? AND state = 'pending'`,
+  );
+  const dismissIntake = db.query<unknown, [string]>(
+    `UPDATE intake_items SET state = 'dismissed', issueUrl = NULL, groomedAt = NULL
+      WHERE id = ? AND state = 'pending'`,
+  );
   // 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
@@ -1949,11 +2061,15 @@ export function openStore(dbPath: string): Store {
       return createRunTx(r);
     },
 
-    updateRun(id: string, patch: Partial<RunRecord>): void {
+    updateRun(id: string, patch: RunPatch): void {
       const assignments: string[] = [];
       const values: SqlValue[] = [];
       for (const [column, value] of Object.entries(patch)) {
-        if (!UPDATABLE_COLUMNS[column]) continue;
+        // An explicitly-`undefined` key is the same as an absent one: a patch
+        // built by spreading a partial result must not widen into columns the
+        // caller did not mean to write (#468). Clearing a column still works by
+        // naming it with an explicit `null`, which `toSql` maps to SQL NULL.
+        if (!UPDATABLE_COLUMNS[column] || value === undefined) continue;
         assignments.push(`${column} = ?`);
         values.push(toSql(value));
       }
@@ -1986,6 +2102,9 @@ export function openStore(dbPath: string): Store {
     recentRuns(project: string, mergedSinceEpochMs: number): RunRecord[] {
       return selectRecentRuns.all(project, mergedSinceEpochMs).map(toRecord);
     },
+    runsForProjectPr(project: string, prUrl: string, mergedSinceEpochMs: number): RunRecord[] {
+      return selectRunsForPr.all(project, prUrl, mergedSinceEpochMs).map(toRecord);
+    },
     runsNeedingBaseCheck(project: string, limit = 20): RunRecord[] {
       return selectPendingBaseChecks.all(project, limit).map(toRecord);
     },
@@ -2041,6 +2160,9 @@ export function openStore(dbPath: string): Store {
       const row = selectLatestRun.get(project, issue);
       return row ? toRecord(row) : undefined;
     },
+    runsForIssue(project: string, issue: number): RunRecord[] {
+      return selectRunsForIssue.all(project, issue).map(toRecord);
+    },
 
     setTurnOverride(project: string, issue: number, maxTurns: number, setAt = Date.now()): void {
       setTurnOverrideTx(project, issue, maxTurns, setAt);
@@ -2066,11 +2188,6 @@ export function openStore(dbPath: string): Store {
       return selectTurnOverrideLedger.all(project, issue, issue, opts.limit ?? 50);
     },
 
-    attemptReports(project: string, issue: number): { attempt: number; report: string }[] {
-      return selectAttemptReports.all(project, issue);
-    },
-
-
     runsStartedSince(project: string, sinceEpochMs: number): number {
       return countStartedSince.get(project, sinceEpochMs)?.n ?? 0;
     },
@@ -2079,6 +2196,10 @@ export function openStore(dbPath: string): Store {
       return sumSpendSince.get(project, sinceEpochMs)?.total ?? 0;
     },
 
+    statsRuns(project: string, sinceEpochMs: number): RunRecord[] {
+      return selectStatsRuns.all(project, sinceEpochMs, project, sinceEpochMs).map(toRecord);
+    },
+
     wasNotified(key: string): boolean {
       return (countNotified.get(key)?.n ?? 0) > 0;
     },
@@ -2203,6 +2324,12 @@ export function openStore(dbPath: string): Store {
         ...(held?.oldestAt === null || held?.oldestAt === undefined
           ? {}
           : { heldNoticeOldestAt: held.oldestAt }),
+        ...(held?.digestOldestAt === null || held?.digestOldestAt === undefined
+          ? {}
+          : { digestHeldNoticeOldestAt: held.digestOldestAt }),
+        ...(held?.availabilityOldestAt === null || held?.availabilityOldestAt === undefined
+          ? {}
+          : { availabilityHeldNoticeOldestAt: held.availabilityOldestAt }),
       };
     },
 
@@ -2226,6 +2353,10 @@ export function openStore(dbPath: string): Store {
       return selectGhCalls.all(day);
     },
 
+    ghCallsBetween(sinceDay: string, untilDay: string): number {
+      return sumGhCallsBetween.get(sinceDay, untilDay)?.total ?? 0;
+    },
+
     pendingFriction(
       project: string,
       sinceEpochMs: number,
@@ -2375,6 +2506,31 @@ export function openStore(dbPath: string): Store {
         .map(toReport);
     },
 
+    /**
+     * One escalation handoff per event while the first has not landed (#347,
+     * #453). The notifications ledger cannot decide this — its rows are
+     * permanent, so an identical retry would be refused forever once the first
+     * occurrence was marked (#453). The question is instead "is the first
+     * handoff still owed?": an escalation report still in the outbox (the
+     * `openReports` pending/sending/failed set) for the same project, category
+     * and folded text, or a held notice of the same category and text that has
+     * not been digested yet. Once the report is delivered, or the notice
+     * digested, the identical text is a new occurrence, not a double-send.
+     * Material reports describe one ordinary outcome each time and never
+     * dedupe.
+     */
+    hasOpenEscalationHandoff(project: string, category: InterruptCategory, body: string): boolean {
+      const flat = body.replace(/\s+/g, " ").trim();
+      return (
+        selectOpenReports
+          .all(project)
+          .some((row) => row.kind === category && row.body.replace(/\s+/g, " ").trim() === flat) ||
+        selectUndigestedNotices
+          .all(project, DIGEST_BACKLOG_LIMIT)
+          .some((row) => row.category === category && row.detail.replace(/\s+/g, " ").trim() === flat)
+      );
+    },
+
     openReports(project: string): ReportRecord[] {
       return selectOpenReports.all(project).map(toReport);
     },
@@ -2421,6 +2577,11 @@ export function openStore(dbPath: string): Store {
       return selectOpenDecisions.all(project).map(toDecision);
     },
 
+    decision(id: string): DecisionRecord | undefined {
+      const row = selectDecision.get(id);
+      return row === null ? undefined : toDecision(row);
+    },
+
     resolveDecision(id: string, state: "answered" | "withdrawn", resolution: string, at: number): boolean {
       return resolveDecisionRow.run(state, resolution, at, id).changes > 0;
     },
@@ -2532,6 +2693,30 @@ export function openStore(dbPath: string): Store {
       return row === null ? undefined : row.createdAt;
     },
 
+    recordIntake(draft: IntakeDraft): IntakeItem {
+      const item: IntakeItem = {
+        id: newReportId(),
+        project: draft.project,
+        text: draft.text,
+        createdAt: draft.at,
+        state: "pending",
+      };
+      insertIntake.run(item.id, item.project, item.text, item.createdAt);
+      return item;
+    },
+
+    pendingIntake(project: string): IntakeItem[] {
+      return selectPendingIntake.all(project).map(toIntakeItem);
+    },
+
+    resolveIntake(id: string, state: "groomed" | "dismissed", issueUrl?: string): boolean {
+      const result =
+        state === "groomed"
+          ? groomIntake.run(issueUrl ?? null, Date.now(), id)
+          : dismissIntake.run(id);
+      return result.changes > 0;
+    },
+
     close(): void {
       db.close(false);
     },

package/src/tracker/github.ts

@@ -136,7 +136,7 @@ export class GhError extends Error {
  * and closed, which is how bodies containing newlines, backticks or a leading
  * `-` reach `gh` without ever being interpolated into argv.
  */
-async function gh(argv: string[], stdin?: string): Promise<string> {
+export async function gh(argv: string[], stdin?: string): Promise<string> {
   const proc = Bun.spawn(["gh", ...argv], {
     // Always a closed stream: commands that do not read stdin see immediate
     // EOF instead of an open pipe nobody ends.
@@ -392,14 +392,33 @@ function checkVerdict(check: GhCheck): CheckVerdict {
  * Verify one `gh pr view --json state,isDraft,headRefOid,statusCheckRollup`
  * payload, optionally against a caller-observed head. A missing rollup is
  * pending rather than green because GitHub may not have created the checks yet.
+ *
+ * By default this answers the merge gate's question — "may this merge" — and a
+ * non-open PR is a refusal (`expected OPEN`), so a mutating verb never acts on
+ * a merged or closed PR. `opts.read` (the `conductor_pr_status` surface) asks
+ * a different question: *what is this PR's state*, and a merged or closed PR
+ * is reported as a fact rather than a failure — the merge gate paths never
+ * pass `read`, so the `expected OPEN` refusal stays exactly where it gates.
  */
-export function prVerificationFrom(raw: string, expectedHead?: string): PrVerification {
+export function prVerificationFrom(
+  raw: string,
+  expectedHead?: string,
+  opts?: { read?: boolean },
+): PrVerification {
   const pr = JSON.parse(raw) as GhPrVerification;
   if (typeof pr.headRefOid !== "string" || pr.headRefOid === "") {
     throw new Error("PR head is unavailable");
   }
   const headSha = pr.headRefOid;
   if (pr.state !== "OPEN") {
+    if (opts?.read === true) {
+      const stateName = pr.state?.toLowerCase() ?? "unknown";
+      return {
+        status: "failed",
+        reason: `PR is ${stateName}; checks are unavailable for a non-open PR`,
+        headSha,
+      };
+    }
     return { status: "failed", reason: `PR is ${pr.state ?? "unknown"}, expected OPEN`, headSha };
   }
   if (pr.isDraft !== false) {
@@ -1275,7 +1294,11 @@ export function makeTracker(
       }
     },
 
-    async verifyPr(url: string, expectedHead?: string): Promise<PrVerification | undefined> {
+    async verifyPr(
+      url: string,
+      expectedHead?: string,
+      opts?: { read?: boolean },
+    ): Promise<PrVerification | undefined> {
       if (!PR_URL.test(url)) return undefined;
       try {
         const raw = await runGh([
@@ -1285,7 +1308,7 @@ export function makeTracker(
           "--json",
           "state,isDraft,headRefOid,statusCheckRollup",
         ]);
-        const verification = prVerificationFrom(raw, expectedHead);
+        const verification = prVerificationFrom(raw, expectedHead, opts);
         if (verification.status !== "failed") return verification;
 
         const detailsUrl = failedCheck(raw)?.detailsUrl;