omp-conductor 0.2.0

package/src/store.ts

@@ -0,0 +1,263 @@
+/**
+ * Run bookkeeping on bun:sqlite.
+ *
+ * The tracker's labels remain the source of truth for *what* the fleet is
+ * doing; this store exists so the dispatcher can answer cap questions ("am I
+ * already at two workers?", "have I spent $25 today?") without a round-trip to
+ * GitHub on every tick, and so a restart can reconcile the runs it left
+ * mid-flight. Losing the file is survivable — it is a cache with a memory, not
+ * a ledger.
+ */
+
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+import type { RunRecord, RunState, Store } from "./types.ts";
+
+/**
+ * States that consume a worker slot. `pushed-green` counts: the branch is
+ * pushed and CI is green but nothing is merged, so the worktree, the branch
+ * and the issue claim are all still held.
+ */
+const ACTIVE_STATES: readonly RunState[] = ["claimed", "running", "pushed-green"];
+
+const ACTIVE_PLACEHOLDERS = ACTIVE_STATES.map(() => "?").join(", ");
+
+/**
+ * Allowlist for `updateRun`'s dynamic SET clause. Column names cannot be bound
+ * as parameters, so they are matched against this table rather than
+ * interpolated from caller input. `id` is deliberately absent: it is the
+ * address of the row, not one of its fields.
+ */
+const UPDATABLE_COLUMNS: Record<string, true> = {
+  project: true,
+  issue: true,
+  repo: true,
+  branch: true,
+  worktree: true,
+  state: true,
+  attempt: true,
+  turns: true,
+  spendUsd: true,
+  sessionFile: true,
+  prUrl: true,
+  startedAt: true,
+  endedAt: true,
+  lastError: true,
+};
+
+/** Everything SQLite will accept from us. */
+type SqlValue = string | number | null;
+
+/** The `runs` table exactly as SQLite hands it back: optional means NULL. */
+interface RunRow {
+  id: string;
+  project: string;
+  issue: number;
+  repo: string;
+  branch: string;
+  worktree: string;
+  state: string;
+  attempt: number;
+  turns: number;
+  spendUsd: number;
+  sessionFile: string | null;
+  prUrl: string | null;
+  startedAt: number;
+  endedAt: number | null;
+  lastError: string | null;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS runs (
+  id          TEXT    PRIMARY KEY,
+  project     TEXT    NOT NULL,
+  issue       INTEGER NOT NULL,
+  repo        TEXT    NOT NULL,
+  branch      TEXT    NOT NULL,
+  worktree    TEXT    NOT NULL,
+  state       TEXT    NOT NULL,
+  attempt     INTEGER NOT NULL,
+  turns       INTEGER NOT NULL,
+  spendUsd    REAL    NOT NULL,
+  sessionFile TEXT,
+  prUrl       TEXT,
+  startedAt   INTEGER NOT NULL,
+  endedAt     INTEGER,
+  lastError   TEXT
+);
+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 notifications (
+  "key" TEXT    PRIMARY KEY,
+  at    INTEGER NOT NULL
+);
+`;
+
+/**
+ * `undefined` is not a legal binding, and a boolean is only accepted by some
+ * bun:sqlite builds, so both are normalised before they reach the driver.
+ */
+function toSql(value: unknown): SqlValue {
+  if (value === undefined || value === null) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  return value as SqlValue;
+}
+
+/**
+ * A NULL column becomes an absent property rather than an `undefined` one, so
+ * a record read back out of the store deep-equals the one that went in.
+ */
+function toRecord(row: RunRow): RunRecord {
+  const record: RunRecord = {
+    id: row.id,
+    project: row.project,
+    issue: row.issue,
+    repo: row.repo,
+    branch: row.branch,
+    worktree: row.worktree,
+    state: row.state as RunState,
+    attempt: row.attempt,
+    turns: row.turns,
+    spendUsd: row.spendUsd,
+    startedAt: row.startedAt,
+  };
+  if (row.sessionFile !== null) record.sessionFile = row.sessionFile;
+  if (row.prUrl !== null) record.prUrl = row.prUrl;
+  if (row.endedAt !== null) record.endedAt = row.endedAt;
+  if (row.lastError !== null) record.lastError = row.lastError;
+  return record;
+}
+
+/**
+ * Open (creating if needed) the run store at `dbPath`; `:memory:` is honoured
+ * for tests. Safe to call on a fresh path — the schema is applied on open, so
+ * there is no separate migration step to forget.
+ */
+export function openStore(dbPath: string): Store {
+  if (dbPath !== ":memory:" && !dbPath.startsWith("file:")) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+  }
+
+  const db = new Database(dbPath, { create: true });
+
+  // WAL lets the plugin read status while the daemon is mid-write; the busy
+  // timeout covers the single writer lock they still contend for.
+  db.exec("PRAGMA journal_mode = WAL;");
+  db.exec("PRAGMA foreign_keys = ON;");
+  db.exec("PRAGMA busy_timeout = 5000;");
+  // ponytail: the schema is created if absent and never migrated — a column
+  // change means hand-editing or deleting the file. Upgrade path for the first
+  // shape change: PRAGMA user_version plus an ordered migration list here.
+  db.exec(SCHEMA);
+
+  const insertRun = db.query<unknown, SqlValue[]>(
+    `INSERT INTO runs (
+       id, project, issue, repo, branch, worktree, state, attempt, turns,
+       spendUsd, sessionFile, prUrl, startedAt, endedAt, lastError
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+  const selectRun = db.query<RunRow, [string]>(`SELECT * FROM runs WHERE id = ?`);
+  const selectActive = db.query<RunRow, SqlValue[]>(
+    `SELECT * FROM runs
+      WHERE project = ? AND state IN (${ACTIVE_PLACEHOLDERS})
+      ORDER BY startedAt ASC`,
+  );
+  const countAttempts = db.query<{ n: number }, [string, number]>(
+    `SELECT COUNT(*) AS n FROM runs WHERE project = ? AND issue = ?`,
+  );
+  const countStartedSince = db.query<{ n: number }, [string, number]>(
+    `SELECT COUNT(*) AS n FROM runs WHERE project = ? AND startedAt >= ?`,
+  );
+  const sumSpendSince = db.query<{ total: number }, [string, number]>(
+    `SELECT COALESCE(SUM(spendUsd), 0) AS total
+       FROM runs WHERE project = ? AND startedAt >= ?`,
+  );
+  const countNotified = db.query<{ n: number }, [string]>(
+    `SELECT COUNT(*) AS n FROM notifications WHERE "key" = ?`,
+  );
+  // First notification wins, so the row records when a human was actually
+  // paged rather than when the newest retry re-reported the same event.
+  const insertNotified = db.query<unknown, [string, number]>(
+    `INSERT OR IGNORE INTO notifications ("key", at) VALUES (?, ?)`,
+  );
+
+  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.spendUsd,
+        toSql(record.sessionFile),
+        toSql(record.prUrl),
+        record.startedAt,
+        toSql(record.endedAt),
+        toSql(record.lastError),
+      );
+      return record;
+    },
+
+    updateRun(id: string, patch: Partial<RunRecord>): void {
+      const assignments: string[] = [];
+      const values: SqlValue[] = [];
+      for (const [column, value] of Object.entries(patch)) {
+        if (!UPDATABLE_COLUMNS[column]) continue;
+        assignments.push(`${column} = ?`);
+        values.push(toSql(value));
+      }
+      if (assignments.length === 0) return;
+      values.push(id);
+      // An unknown id matches no row: zero changes, no error, by design — the
+      // dispatcher patches runs a restart may already have reaped.
+      db.query<unknown, SqlValue[]>(
+        `UPDATE runs SET ${assignments.join(", ")} WHERE id = ?`,
+      ).run(...values);
+    },
+
+    getRun(id: string): RunRecord | undefined {
+      const row = selectRun.get(id);
+      return row ? toRecord(row) : undefined;
+    },
+
+    activeRuns(project: string): RunRecord[] {
+      return selectActive.all(project, ...ACTIVE_STATES).map(toRecord);
+    },
+
+    attemptsFor(project: string, issue: number): number {
+      return countAttempts.get(project, issue)?.n ?? 0;
+    },
+
+    runsStartedSince(project: string, sinceEpochMs: number): number {
+      return countStartedSince.get(project, sinceEpochMs)?.n ?? 0;
+    },
+
+    spendSince(project: string, sinceEpochMs: number): number {
+      return sumSpendSince.get(project, sinceEpochMs)?.total ?? 0;
+    },
+
+    wasNotified(key: string): boolean {
+      return (countNotified.get(key)?.n ?? 0) > 0;
+    },
+
+    markNotified(key: string): void {
+      // ponytail: notifications is append-only and never pruned. It gains one
+      // short row per escalation, so it is decades from mattering; prune by
+      // `at` if it ever does.
+      insertNotified.run(key, Date.now());
+    },
+
+    close(): void {
+      db.close(false);
+    },
+  };
+}

package/src/tracker/github.ts

@@ -0,0 +1,160 @@
+/**
+ * GitHub adapter for the tracker port.
+ *
+ * Every operation goes through the already-authenticated `gh` CLI, so the
+ * daemon never handles a token itself: credentials stay in the user's keychain
+ * or `gh` config and are never passed as argv, written to a file, or logged.
+ *
+ * ponytail: shelling out to `gh` is the deliberate simplification. The ceiling
+ * is per-call cost (one process spawn plus one TLS handshake per operation,
+ * ~200-400ms) and failure classification by matching human-readable stderr
+ * instead of reading a status code. Upgrade path when either bites: replace the
+ * body of `gh()` with `fetch("https://api.github.com/...")` using a token from
+ * `gh auth token`; the six Tracker methods above it stay untouched.
+ */
+
+import type { ProjectConfig, ReadyIssue, Tracker } from "../types.ts";
+
+/** The subset of `gh issue list --json` output this adapter reads. Fields the
+ *  API can return as null are typed as such so the mapping has to handle it. */
+interface GhIssue {
+  number: number;
+  title: string | null;
+  body: string | null;
+  labels: { name: string }[] | null;
+  url: string;
+  updatedAt: string;
+}
+
+/** Carries the captured stderr so callers can classify a failure without
+ *  re-running the command or parsing the message text of a plain Error. */
+class GhError extends Error {
+  readonly argv: string[];
+  readonly code: number;
+  readonly stderr: string;
+
+  constructor(argv: string[], code: number, stderr: string) {
+    const detail = stderr.trim() || "(no stderr)";
+    super(`\`gh ${argv.join(" ")}\` exited ${code}: ${detail}`);
+    this.name = "GhError";
+    this.argv = argv;
+    this.code = code;
+    this.stderr = stderr;
+  }
+}
+
+/**
+ * The single execution path for this adapter. `stdin` is written to the child
+ * 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> {
+  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.
+    stdin: new Blob([stdin ?? ""]),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, code] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  const signal = proc.signalCode;
+  if (code !== 0 || signal) {
+    throw new GhError(argv, code, signal ? `${stderr}\nterminated by ${signal}` : stderr);
+  }
+  return stdout;
+}
+
+/**
+ * True when a label edit failed only because the requested end state already
+ * holds. Adding a label is idempotent server-side, but removing one that is not
+ * present is a 404, and a concurrent daemon restart can easily race into both.
+ */
+function isLabelNoop(err: unknown, op: "add" | "remove"): boolean {
+  if (!(err instanceof GhError)) return false;
+  const stderr = err.stderr;
+  return op === "add"
+    ? /already (?:has|had|exists|applied|added)|label .* already/i.test(stderr)
+    : /label does not exist|not labeled|does not have (?:that|the|this) label|label .* not found|not found on (?:this )?issue/i.test(
+        stderr,
+      );
+}
+
+export function makeTracker(p: ProjectConfig): Tracker {
+  const repo = p.tracker.repo;
+
+  return {
+    async listReady(): Promise<ReadyIssue[]> {
+      const raw = await gh([
+        "issue",
+        "list",
+        "--repo",
+        repo,
+        "--state",
+        "open",
+        "--label",
+        p.queueLabel,
+        // ponytail: one page is the cap. A queue deeper than 100 ready issues
+        // truncates silently; upgrade path is `--paginate` via the API, but a
+        // backlog that size is a staffing problem before it is a paging one.
+        "--limit",
+        "100",
+        "--json",
+        "number,title,body,labels,url,updatedAt",
+      ]);
+
+      const text = raw.trim();
+      // `gh` prints nothing at all in some no-match paths; an empty queue is
+      // the normal steady state, not an error.
+      if (!text) return [];
+
+      const issues = JSON.parse(text) as GhIssue[];
+      return issues.map((issue) => ({
+        number: issue.number,
+        title: issue.title ?? "",
+        body: issue.body ?? "",
+        labels: (issue.labels ?? []).map((label) => label.name),
+        url: issue.url,
+        updatedAt: issue.updatedAt,
+      }));
+    },
+
+    async addLabel(issue: number, label: string): Promise<void> {
+      try {
+        await gh(["issue", "edit", String(issue), "--repo", repo, "--add-label", label]);
+      } catch (err) {
+        if (!isLabelNoop(err, "add")) throw err;
+      }
+    },
+
+    async removeLabel(issue: number, label: string): Promise<void> {
+      try {
+        await gh(["issue", "edit", String(issue), "--repo", repo, "--remove-label", label]);
+      } catch (err) {
+        if (!isLabelNoop(err, "remove")) throw err;
+      }
+    },
+
+    async comment(issue: number, body: string): Promise<void> {
+      // `--body-file -` reads stdin, so the body is never shell- or argv-
+      // mangled and has no length limit worth worrying about.
+      await gh(["issue", "comment", String(issue), "--repo", repo, "--body-file", "-"], body);
+    },
+
+    async close(issue: number): Promise<void> {
+      await gh(["issue", "close", String(issue), "--repo", repo]);
+    },
+
+    async linkParent(child: number, parent: number): Promise<void> {
+      // Native sub-issue linkage rather than a body mention: it is what the
+      // repo's own epic rollups read, so a human sees the split without us
+      // maintaining a second index of it.
+      await gh(["issue", "edit", String(parent), "--repo", repo, "--add-sub-issue", String(child)]);
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,250 @@
+/**
+ * Shared contract for omp-conductor.
+ *
+ * Every later slice (tracker adapters, the store, the dispatcher loop, the
+ * worker driver, the plugin and the CLI) imports from here and nothing else,
+ * so this file stays free of imports and runtime code — the single exception
+ * is `DEFAULT_CAPS`, which is data, not behaviour.
+ */
+
+/**
+ * Hard limits enforced in code, never by the model. A worker that is asked to
+ * respect a budget will eventually talk itself out of it, so the dispatcher
+ * counts turns, wall clock and dollars itself and kills anything over the line.
+ */
+export interface Caps {
+  /** Parallel omp sessions. Two, because the homelab only has 3 CI runners and
+   *  a third worker would starve its own PR checks. */
+  maxConcurrentWorkers: number;
+  /** Rolling-day spend ceiling; the loop stops claiming work once it is hit. */
+  dailySpendUsd: number;
+  /** Turn ceiling for one worker — catches loops that are burning tokens
+   *  without converging. */
+  workerMaxTurns: number;
+  /** Wall-clock ceiling for one worker (90 min): a session that is merely
+   *  stuck spends no turns, so turns alone cannot detect it. */
+  workerWallClockMs: number;
+  /** Retries per issue before it escalates (2): one clean retry recovers from
+   *  flaky CI, a third almost always means the issue itself is underspecified. */
+  maxAttemptsPerIssue: number;
+}
+
+/**
+ * One module checkout a routed issue can target. A project is usually several
+ * repos (module images, shared packages), and the dispatcher must know how to
+ * clone and validate each one without asking the model.
+ */
+export interface RepoTarget {
+  /** Short routing key that appears in the issue label, e.g. "api". */
+  name: string;
+  cloneUrl: string;
+  /** Branch worktrees are cut from and PRs target. */
+  defaultBranch: string;
+  /**
+   * Exact cheap pre-push commands CI also runs, with the cwd each runs from.
+   * Running the real gate locally is what makes an unattended push safe — a
+   * subset lets lint errors outside the source dir reach the runners.
+   */
+  gates: { cmd: string; cwd: string }[];
+}
+
+/**
+ * How much the orchestrator says out loud without being asked. Declared as data
+ * so the validator, the wizard and the brief all enumerate the same two values:
+ * a third scope cannot be added while one of them still knows only two.
+ */
+export const REPORT_SCOPES = ["escalations", "material"] as const;
+
+export type ReportScope = (typeof REPORT_SCOPES)[number];
+
+/**
+ * What a project that never answered the question gets. `material` rather than
+ * `escalations` because a config written before this key existed was serviced by
+ * a brief that reported material events, and quietly muting an existing fleet is
+ * the kind of change nobody notices until the week it mattered.
+ */
+export const DEFAULT_REPORT_SCOPE: ReportScope = "material";
+
+/**
+ * Everything the dispatcher needs to service one product: where work comes
+ * from, where code goes, and what it may spend doing it. Config is per project
+ * so unrelated products cannot consume each other's budget.
+ */
+export interface ProjectConfig {
+  name: string;
+  /** Issue source. Kind is pinned to "github" today but kept explicit so a
+   *  second tracker is a config change rather than a schema change. */
+  tracker: { kind: "github"; repo: string };
+  /** The one label that means "a human has signed this off as agent-ready". */
+  queueLabel: string;
+  /** Labels the dispatcher writes back so the tracker alone shows live state
+   *  to a human who never opens the daemon's logs. */
+  stateLabels: { inProgress: string; blocked: string; failed: string };
+  /** Maps a `${labelPrefix}${name}` label on an issue to the checkout it
+   *  belongs in, so routing is declared by humans, not guessed. */
+  routing: { labelPrefix: string; repos: Record<string, RepoTarget> };
+  /** Per-project overrides layered on the global defaults. */
+  caps: Partial<Caps>;
+  /**
+   * Model pattern for worker sessions, in omp's model/role syntax. Omitted
+   * leaves the harness default in place, which is what a project that never
+   * answered the question wants.
+   */
+  workerModel?: string;
+  /** How a stuck run reaches a human, and what to do when it cannot. */
+  escalation: { telegramChatId?: string; fallbackToIssueComment: boolean };
+  /**
+   * How loud the orchestrator is. Optional on disk — a config written before
+   * this key existed loads as {@link DEFAULT_REPORT_SCOPE} — so read it through
+   * `resolveReportScope` rather than reaching for `.scope` directly.
+   */
+  reporting?: { scope: ReportScope };
+  /** Parent directory for per-run worktrees. */
+  workspaceRoot: string;
+  /** Cache of bare clones, so N runs share one fetch instead of N. */
+  mirrorRoot: string;
+}
+
+/**
+ * The config format this conductor writes. Bumped from 1 when a daily-volume cap
+ * was retired: a v1 file may still carry cap keys this version no longer
+ * enforces, so it is read leniently and normalised up, while a v2 file is held
+ * to the current key set exactly.
+ */
+export const CONFIG_VERSION = 2;
+
+/**
+ * Versions this conductor can read. A v1 file loads, drops the caps that no
+ * longer exist, and is rewritten as v2 the next time anything saves.
+ */
+export const READABLE_CONFIG_VERSIONS = [1, CONFIG_VERSION] as const;
+
+/**
+ * On-disk root config. `version` is present from day one so a format change
+ * can be migrated instead of silently misread by an older daemon.
+ */
+export interface ConductorConfig {
+  version: typeof CONFIG_VERSION;
+  defaults: Caps;
+  projects: ProjectConfig[];
+}
+
+/**
+ * The tracker-agnostic view of a queued issue: only the fields the dispatcher
+ * actually reads, so adapters never have to fabricate provider metadata.
+ */
+export interface ReadyIssue {
+  number: number;
+  title: string;
+  body: string;
+  labels: string[];
+  url: string;
+  /** Used to detect an issue edited mid-run, which invalidates the claim. */
+  updatedAt: string;
+}
+
+/**
+ * Deliberately narrow so a Gitea or local-file tracker can drop in later.
+ * Nothing here is GitHub-shaped; the GitHub adapter owns `gh` entirely.
+ */
+export interface Tracker {
+  listReady(): Promise<ReadyIssue[]>;
+  addLabel(issue: number, label: string): Promise<void>;
+  removeLabel(issue: number, label: string): Promise<void>;
+  comment(issue: number, body: string): Promise<void>;
+  close(issue: number): Promise<void>;
+  /** Records that a worker split its issue, so follow-up work stays traceable
+   *  to the request that spawned it. */
+  linkParent(child: number, parent: number): Promise<void>;
+}
+
+/**
+ * Execution state is separate from the tracker's own labels on purpose: labels
+ * are coarse and human-editable, while the loop needs to distinguish "pushed
+ * and green, waiting on merge" from "merged" to decide what to do on restart.
+ */
+export type RunState =
+  | "claimed"
+  | "running"
+  | "pushed-green"
+  | "merged"
+  | "blocked"
+  | "failed"
+  | "killed";
+
+/**
+ * One attempt at one issue. Persisted so a daemon restart can reconcile
+ * orphaned worktrees and branches instead of leaking them.
+ */
+export interface RunRecord {
+  id: string;
+  project: string;
+  issue: number;
+  /** `RepoTarget.name` this attempt was routed to. */
+  repo: string;
+  branch: string;
+  worktree: string;
+  state: RunState;
+  /** 1-based attempt number, checked against `Caps.maxAttemptsPerIssue`. */
+  attempt: number;
+  turns: number;
+  spendUsd: number;
+  /** omp session transcript, so a human can read what the worker actually did. */
+  sessionFile?: string;
+  prUrl?: string;
+  startedAt: number;
+  endedAt?: number;
+  /** Last failure text, surfaced verbatim in escalations. */
+  lastError?: string;
+}
+
+/**
+ * Bookkeeping only — GitHub labels remain the source of truth. The store
+ * exists to answer cap questions cheaply and to survive a restart; if it is
+ * ever lost, the tracker can rebuild the world.
+ */
+export interface Store {
+  createRun(r: Omit<RunRecord, "id">): RunRecord;
+  updateRun(id: string, patch: Partial<RunRecord>): void;
+  getRun(id: string): RunRecord | undefined;
+  activeRuns(project: string): RunRecord[];
+  attemptsFor(project: string, issue: number): number;
+  runsStartedSince(project: string, sinceEpochMs: number): number;
+  spendSince(project: string, sinceEpochMs: number): number;
+  /** Idempotence guard so a retry loop cannot page a human repeatedly for the
+   *  same event. */
+  wasNotified(key: string): boolean;
+  markNotified(key: string): void;
+  close(): void;
+}
+
+/**
+ * How loudly to interrupt: tier 1 is "answer when you can" (the run is parked
+ * and safe), tier 2 is "the fleet is stopped until you look".
+ */
+export type EscalationTier = 1 | 2;
+
+/**
+ * A message to a human, carrying enough identity to find the run without
+ * pasting logs into a chat window.
+ */
+export interface Escalation {
+  tier: EscalationTier;
+  project: string;
+  issue: number;
+  summary: string;
+  detail?: string;
+  runId?: string;
+}
+
+/**
+ * Baseline limits used when a project omits `caps`. Data, not behaviour: kept
+ * beside the type so the defaults cannot drift out of shape with it.
+ */
+export const DEFAULT_CAPS: Caps = {
+  maxConcurrentWorkers: 2,
+  dailySpendUsd: 25,
+  workerMaxTurns: 120,
+  workerWallClockMs: 90 * 60 * 1000,
+  maxAttemptsPerIssue: 2,
+};