@loopover/miner 0.1.0

package/lib/governor-ledger.js

@@ -0,0 +1,203 @@
+import { chmodSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { normalizeGovernorLedgerEvent } from "@loopover/engine";
+import { applySchemaMigrations } from "./schema-version.js";
+import {
+  GOVERNOR_LEDGER_PURGE_SPEC,
+  GOVERNOR_LEDGER_RETENTION_SPEC,
+  purgeStoreByRepo,
+  pruneLedgerByRetention,
+  resolveLedgerRetentionPolicy,
+} from "./store-maintenance.js";
+
+// Append-only governor decision ledger (#2328): every allowed/denied/throttled/kill-switch outcome lands in a
+// local SQLite table for contributor audit. IMMUTABILITY INVARIANT: `appendGovernorEvent`/`readGovernorEvents`
+// only ever issue INSERT and SELECT — never UPDATE/DELETE. Two documented exceptions, both separate maintenance
+// operations rather than part of normal ledger operation: opt-in retention pruning (#4834, automatic) and
+// `purgeByRepo` (#5564, always explicit and operator-invoked, never automatic).
+// This module does not enforce governor policy; it only persists structured events other phases will emit.
+
+const defaultDbFileName = "governor-ledger.sqlite3";
+let defaultGovernorLedger = null;
+
+export function resolveGovernorLedgerDbPath(env = process.env) {
+  const explicitPath = typeof env.GITTENSORY_MINER_GOVERNOR_LEDGER_DB === "string"
+    ? env.GITTENSORY_MINER_GOVERNOR_LEDGER_DB.trim()
+    : "";
+  if (explicitPath) return explicitPath;
+
+  const explicitConfigDir = typeof env.GITTENSORY_MINER_CONFIG_DIR === "string"
+    ? env.GITTENSORY_MINER_CONFIG_DIR.trim()
+    : "";
+  if (explicitConfigDir) return join(explicitConfigDir, defaultDbFileName);
+
+  const configHome = typeof env.XDG_CONFIG_HOME === "string" && env.XDG_CONFIG_HOME.trim()
+    ? env.XDG_CONFIG_HOME.trim()
+    : join(homedir(), ".config");
+  return join(configHome, "gittensory-miner", defaultDbFileName);
+}
+
+function normalizeDbPath(dbPath) {
+  const path = (dbPath ?? resolveGovernorLedgerDbPath()).trim();
+  if (!path) throw new Error("invalid_governor_ledger_db_path");
+  return path;
+}
+
+function normalizeOptionalRepoFullName(repoFullName) {
+  if (repoFullName === undefined || repoFullName === null) return undefined;
+  if (typeof repoFullName !== "string") throw new Error("invalid_repo_full_name");
+  const [owner, repo, extra] = repoFullName.trim().split("/");
+  if (!owner || !repo || extra !== undefined) throw new Error("invalid_repo_full_name");
+  return `${owner}/${repo}`;
+}
+
+function rowToEntry(row) {
+  let payload;
+  try {
+    payload = JSON.parse(row.payload_json);
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+      throw new Error("corrupted_governor_row");
+    }
+  } catch {
+    throw new Error("corrupted_governor_row");
+  }
+  return {
+    id: row.id,
+    ts: row.ts,
+    eventType: row.event_type,
+    repoFullName: row.repo_full_name,
+    actionClass: row.action_class,
+    decision: row.decision,
+    reason: row.reason,
+    payload,
+  };
+}
+
+// Decision-log projection (#5159): the public, MCP-exposed shape. Deliberately omits payload_json (which #5134
+// is expanding with reputation/self-plagiarism/budget state). Kept honest by an explicit named-column SELECT
+// below — never SELECT * — so the sensitive column cannot leak even by accident.
+function rowToDecision(row) {
+  return {
+    id: row.id,
+    ts: row.ts,
+    eventType: row.event_type,
+    repoFullName: row.repo_full_name,
+    actionClass: row.action_class,
+    decision: row.decision,
+    reason: row.reason,
+  };
+}
+
+/**
+ * Opens the append-only governor ledger, creating the table on first use. Rows are returned in ascending `id`
+ * order (insertion order). (#2328)
+ */
+export function initGovernorLedger(dbPath = resolveGovernorLedgerDbPath()) {
+  const resolvedPath = normalizeDbPath(dbPath);
+  mkdirSync(dirname(resolvedPath), { recursive: true, mode: 0o700 });
+  const db = new DatabaseSync(resolvedPath);
+  chmodSync(resolvedPath, 0o600);
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS governor_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      ts TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      repo_full_name TEXT,
+      action_class TEXT NOT NULL,
+      decision TEXT NOT NULL,
+      reason TEXT NOT NULL,
+      payload_json TEXT NOT NULL
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_governor_events_repo ON governor_events (repo_full_name, id)");
+  // Schema-version convention (#4832): stamp the baseline and run any post-baseline migrations (none yet).
+  applySchemaMigrations(db, []);
+  // Opt-in retention (#4834): prune aged/excess rows when an operator has enabled it; a no-op by default.
+  pruneLedgerByRetention(db, GOVERNOR_LEDGER_RETENTION_SPEC, resolveLedgerRetentionPolicy(), Date.now());
+
+  const appendStatement = db.prepare(`
+    INSERT INTO governor_events (ts, event_type, repo_full_name, action_class, decision, reason, payload_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const getByIdStatement = db.prepare("SELECT * FROM governor_events WHERE id = ?");
+  const readAllStatement = db.prepare("SELECT * FROM governor_events ORDER BY id ASC");
+  const readByRepoStatement = db.prepare(
+    "SELECT * FROM governor_events WHERE repo_full_name = ? ORDER BY id ASC",
+  );
+  // Explicit named-column projection for the read-only decision log (#5159) — payload_json is intentionally
+  // NOT in this list, so widening it would be a deliberate edit that the redaction test guards against.
+  const decisionColumns = "id, ts, event_type, repo_full_name, action_class, decision, reason";
+  const readDecisionsAllStatement = db.prepare(
+    `SELECT ${decisionColumns} FROM governor_events ORDER BY id ASC`,
+  );
+  const readDecisionsByRepoStatement = db.prepare(
+    `SELECT ${decisionColumns} FROM governor_events WHERE repo_full_name = ? ORDER BY id ASC`,
+  );
+
+  return {
+    dbPath: resolvedPath,
+    appendGovernorEvent(event) {
+      const normalized = normalizeGovernorLedgerEvent(event);
+      const ts = new Date().toISOString();
+      const result = appendStatement.run(
+        ts,
+        normalized.eventType,
+        normalized.repoFullName,
+        normalized.actionClass,
+        normalized.decision,
+        normalized.reason,
+        normalized.payloadJson,
+      );
+      return rowToEntry(getByIdStatement.get(Number(result.lastInsertRowid)));
+    },
+    readGovernorEvents(filter = {}) {
+      const repoFullName = normalizeOptionalRepoFullName(filter.repoFullName);
+      const rows =
+        repoFullName === undefined
+          ? readAllStatement.all()
+          : readByRepoStatement.all(repoFullName);
+      return rows.map(rowToEntry);
+    },
+    readGovernorDecisions(filter = {}) {
+      const repoFullName = normalizeOptionalRepoFullName(filter.repoFullName);
+      const rows =
+        repoFullName === undefined
+          ? readDecisionsAllStatement.all()
+          : readDecisionsByRepoStatement.all(repoFullName);
+      return rows.map(rowToDecision);
+    },
+    // Explicit, operator-invoked right-to-be-forgotten purge (#5564) — never runs automatically. See the
+    // IMMUTABILITY INVARIANT note above: this is a deliberate, separate exception, not a normal ledger write.
+    // Requires a real repoFullName (unlike the optional filters above): a purge must never silently no-op.
+    purgeByRepo(repoFullName) {
+      const normalized = normalizeOptionalRepoFullName(repoFullName);
+      if (normalized === undefined) throw new Error("invalid_repo_full_name");
+      return purgeStoreByRepo(db, GOVERNOR_LEDGER_PURGE_SPEC, normalized);
+    },
+    close() {
+      db.close();
+    },
+  };
+}
+
+function getDefaultGovernorLedger() {
+  defaultGovernorLedger ??= initGovernorLedger();
+  return defaultGovernorLedger;
+}
+
+export function appendGovernorEvent(event) {
+  return getDefaultGovernorLedger().appendGovernorEvent(event);
+}
+
+export function readGovernorEvents(filter) {
+  return getDefaultGovernorLedger().readGovernorEvents(filter);
+}
+
+export function closeDefaultGovernorLedger() {
+  if (!defaultGovernorLedger) return;
+  defaultGovernorLedger.close();
+  defaultGovernorLedger = null;
+}

package/lib/governor-open-pr.d.ts

@@ -0,0 +1,21 @@
+import type {
+  OwnSubmissionRecord,
+  SelfPlagiarismCandidate,
+  SelfPlagiarismVerdict,
+} from "@loopover/engine";
+import type { AppendGovernorEventInput, GovernorLedgerEntry } from "./governor-ledger.js";
+
+export type EvaluateOpenPrSelfPlagiarismInput = {
+  candidate: SelfPlagiarismCandidate;
+  recentOwnSubmissions?: readonly OwnSubmissionRecord[];
+  selfPlagiarismConfig?: unknown;
+};
+
+export type EvaluateOpenPrSelfPlagiarismOptions = {
+  append?: (event: AppendGovernorEventInput) => GovernorLedgerEntry;
+};
+
+export function evaluateOpenPrSelfPlagiarism(
+  input: EvaluateOpenPrSelfPlagiarismInput,
+  options?: EvaluateOpenPrSelfPlagiarismOptions,
+): { verdict: SelfPlagiarismVerdict; recorded: GovernorLedgerEntry };

package/lib/governor-open-pr.js

@@ -0,0 +1,27 @@
+// Governor open_pr self-plagiarism gate (#2345). Consults the engine's pure selfPlagiarismCheck before an open_pr
+// write is allowed and records throttled/denied outcomes to the append-only governor ledger.
+
+import {
+  buildSelfPlagiarismGovernorLedgerEvent,
+  resolveSelfPlagiarismConfig,
+  selfPlagiarismCheck,
+} from "@loopover/engine";
+import { appendGovernorEvent } from "./governor-ledger.js";
+
+/**
+ * Run the self-plagiarism throttle for a prospective open_pr and persist the governor decision.
+ *
+ * @param {object} input
+ * @param {import("@loopover/engine").SelfPlagiarismCandidate} input.candidate
+ * @param {readonly import("@loopover/engine").OwnSubmissionRecord[]} input.recentOwnSubmissions
+ * @param {unknown} [input.selfPlagiarismConfig] parsed `.gittensory-miner.yml` selfPlagiarism block
+ * @param {{ append?: typeof appendGovernorEvent }} [options]
+ */
+export function evaluateOpenPrSelfPlagiarism(input, options = {}) {
+  const append = options.append ?? appendGovernorEvent;
+  const config = resolveSelfPlagiarismConfig(input.selfPlagiarismConfig);
+  const verdict = selfPlagiarismCheck(input.candidate, input.recentOwnSubmissions ?? [], config);
+  const ledgerEvent = buildSelfPlagiarismGovernorLedgerEvent(input.candidate.repoFullName, verdict);
+  const recorded = append(ledgerEvent);
+  return { verdict, recorded };
+}

package/lib/governor-pause-cli.d.ts

@@ -0,0 +1,23 @@
+import type { GovernorState } from "./governor-state.js";
+
+export type ParsedGovernorPauseArgs =
+  | { json: boolean; dryRun: boolean; reason: string | null }
+  | { error: string };
+
+export type ParsedGovernorResumeArgs = { json: boolean; dryRun: boolean } | { error: string };
+
+export type ParsedGovernorNoArgsSubcommand = { json: boolean } | { error: string };
+
+export type GovernorPauseCliOptions = {
+  openGovernorState?: () => GovernorState;
+};
+
+export function parseGovernorPauseArgs(args: string[]): ParsedGovernorPauseArgs;
+
+export function parseGovernorResumeArgs(args: string[]): ParsedGovernorResumeArgs;
+
+export function runGovernorPause(args: string[], options?: GovernorPauseCliOptions): Promise<number>;
+
+export function runGovernorResume(args: string[], options?: GovernorPauseCliOptions): Promise<number>;
+
+export function runGovernorStatus(args: string[], options?: GovernorPauseCliOptions): Promise<number>;

package/lib/governor-pause-cli.js

@@ -0,0 +1,171 @@
+// The governor pause/resume control surface (#4851): a real, persisted pause flag an operator (or, in a future
+// wave, the governor itself) can toggle via this CLI, that loop-cli.js's iteration loop actually checks before
+// each cycle. Distinct from governor-kill-switch.js (a read-only resolver over pre-existing env/YAML inputs this
+// package never itself writes) and governor-run-halt.js (a one-way, run-scoped terminal breaker with no resume
+// path) -- this is the first genuinely operator/governor-writable stop/go control. Persisted on governor-state.js's
+// existing single-row scalar-state table, not a new store: a pause flag has no relational key of its own, the
+// same reasoning that table's other scalar fields (rate-limit buckets, cap usage) already rely on.
+
+import { openGovernorState } from "./governor-state.js";
+
+const GOVERNOR_PAUSE_USAGE = "Usage: gittensory-miner governor pause [--reason <text>] [--dry-run] [--json]";
+const GOVERNOR_RESUME_USAGE = "Usage: gittensory-miner governor resume [--dry-run] [--json]";
+const GOVERNOR_STATUS_USAGE = "Usage: gittensory-miner governor status [--json]";
+
+export function parseGovernorPauseArgs(args) {
+  const options = { json: false, dryRun: false, reason: null };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === "--json") {
+      options.json = true;
+      continue;
+    }
+    // #4847: reports what pausing would do and returns before writing to governor-state.
+    if (token === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    if (token === "--reason") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("-")) return { error: GOVERNOR_PAUSE_USAGE };
+      options.reason = value;
+      index += 1;
+      continue;
+    }
+    return { error: `Unknown option: ${token}` };
+  }
+
+  return options;
+}
+
+export function parseGovernorResumeArgs(args) {
+  const options = { json: false, dryRun: false };
+
+  for (const token of args) {
+    if (token === "--json") {
+      options.json = true;
+      continue;
+    }
+    // #4847: reports what resuming would do and returns before writing to governor-state.
+    if (token === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    return { error: GOVERNOR_RESUME_USAGE };
+  }
+
+  return options;
+}
+
+function parseNoArgsSubcommand(args, usage) {
+  if (args.length === 0) return { json: false };
+  if (args.length === 1 && args[0] === "--json") return { json: true };
+  return { error: usage };
+}
+
+async function withGovernorState(options, run) {
+  const ownsGovernorState = options.openGovernorState === undefined;
+  const governorState = (options.openGovernorState ?? openGovernorState)();
+  try {
+    return run(governorState);
+  } finally {
+    if (ownsGovernorState) governorState.close();
+  }
+}
+
+function renderPauseState(pauseState) {
+  if (!pauseState.paused) return "governor is not paused";
+  const reason = pauseState.reason ? ` (${pauseState.reason})` : "";
+  return `governor is PAUSED since ${pauseState.pausedAt}${reason}`;
+}
+
+export async function runGovernorPause(args, options = {}) {
+  const parsed = parseGovernorPauseArgs(args);
+  if ("error" in parsed) {
+    console.error(parsed.error);
+    return 2;
+  }
+
+  if (parsed.dryRun) {
+    const dryRunResult = { outcome: "dry_run", paused: true, reason: parsed.reason };
+    if (parsed.json) {
+      console.log(JSON.stringify(dryRunResult));
+    } else {
+      const reason = parsed.reason ? ` (${parsed.reason})` : "";
+      console.log(`DRY RUN: would pause the governor${reason}. No governor-state write was made.`);
+    }
+    return 0;
+  }
+
+  try {
+    return await withGovernorState(options, (governorState) => {
+      const pauseState = governorState.savePauseState({ paused: true, reason: parsed.reason });
+      if (parsed.json) {
+        console.log(JSON.stringify(pauseState));
+      } else {
+        console.log(renderPauseState(pauseState));
+      }
+      return 0;
+    });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+}
+
+export async function runGovernorResume(args, options = {}) {
+  const parsed = parseGovernorResumeArgs(args);
+  if ("error" in parsed) {
+    console.error(parsed.error);
+    return 2;
+  }
+
+  if (parsed.dryRun) {
+    const dryRunResult = { outcome: "dry_run", paused: false };
+    if (parsed.json) {
+      console.log(JSON.stringify(dryRunResult));
+    } else {
+      console.log("DRY RUN: would resume the governor. No governor-state write was made.");
+    }
+    return 0;
+  }
+
+  try {
+    return await withGovernorState(options, (governorState) => {
+      const pauseState = governorState.savePauseState({ paused: false });
+      if (parsed.json) {
+        console.log(JSON.stringify(pauseState));
+      } else {
+        console.log(renderPauseState(pauseState));
+      }
+      return 0;
+    });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+}
+
+export async function runGovernorStatus(args, options = {}) {
+  const parsed = parseNoArgsSubcommand(args, GOVERNOR_STATUS_USAGE);
+  if ("error" in parsed) {
+    console.error(parsed.error);
+    return 2;
+  }
+
+  try {
+    return await withGovernorState(options, (governorState) => {
+      const pauseState = governorState.loadPauseState();
+      if (parsed.json) {
+        console.log(JSON.stringify(pauseState));
+      } else {
+        console.log(renderPauseState(pauseState));
+      }
+      return 0;
+    });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+}

package/lib/governor-run-halt.d.ts

@@ -0,0 +1,37 @@
+import type {
+  GovernorCapLimits,
+  GovernorCapUsage,
+  PortfolioConvergenceInput,
+  PortfolioConvergenceThresholds,
+  RunLoopHaltVerdict,
+} from "@loopover/engine";
+import type { AppendGovernorEventInput, GovernorLedgerEntry } from "./governor-ledger.js";
+import type { QueueEntry } from "./portfolio-queue.js";
+
+export type RunLoopInFlightItem = {
+  repoFullName: string;
+  identifier: string;
+};
+
+export type EvaluateRunLoopBoundaryGateInput = {
+  runHalted?: boolean;
+  usage: GovernorCapUsage;
+  limits: GovernorCapLimits;
+  convergence: PortfolioConvergenceInput;
+  convergenceThresholds?: PortfolioConvergenceThresholds;
+  inFlightItem?: RunLoopInFlightItem | null;
+  markFailed?: (repoFullName: string, identifier: string) => QueueEntry | null;
+};
+
+export type EvaluateRunLoopBoundaryGateResult = {
+  verdict: RunLoopHaltVerdict;
+  recorded: GovernorLedgerEntry | null;
+  runHalted: boolean;
+  canClaimNext: boolean;
+  releasedItem: QueueEntry | null;
+};
+
+export function evaluateRunLoopBoundaryGate(
+  input: EvaluateRunLoopBoundaryGateInput,
+  options?: { append?: (event: AppendGovernorEventInput) => GovernorLedgerEntry },
+): EvaluateRunLoopBoundaryGateResult;

package/lib/governor-run-halt.js

@@ -0,0 +1,58 @@
+// Governor run-loop halt gate (#2347). Consults non-convergence + budget caps at each iteration boundary,
+// releases in-flight portfolio items on a fresh halt, and records the decision to the governor ledger.
+
+import {
+  buildRunLoopHaltGovernorLedgerEvent,
+  evaluateRunLoopHalt,
+} from "@loopover/engine";
+import { appendGovernorEvent } from "./governor-ledger.js";
+
+/**
+ * Evaluate run-loop halt signals before claiming the next portfolio item.
+ *
+ * @param {object} input
+ * @param {boolean} [input.runHalted] whether the run is already halted
+ * @param {import("@loopover/engine").GovernorCapUsage} input.usage cumulative run usage
+ * @param {import("@loopover/engine").GovernorCapLimits} input.limits run ceilings
+ * @param {import("@loopover/engine").PortfolioConvergenceInput} input.convergence in-flight item history
+ * @param {import("@loopover/engine").PortfolioConvergenceThresholds} [input.convergenceThresholds]
+ * @param {{ repoFullName: string, identifier: string } | null | undefined} [input.inFlightItem]
+ * @param {(repoFullName: string, identifier: string) => import("./portfolio-queue.js").QueueEntry | null} [input.markFailed]
+ * @param {{ append?: typeof appendGovernorEvent }} [options]
+ */
+export function evaluateRunLoopBoundaryGate(input, options = {}) {
+  const append = options.append ?? appendGovernorEvent;
+  const wasHalted = Boolean(input.runHalted);
+  const verdict = evaluateRunLoopHalt({
+    runHalted: wasHalted,
+    usage: input.usage,
+    limits: input.limits,
+    convergence: input.convergence,
+    convergenceThresholds: input.convergenceThresholds,
+  });
+
+  const newlyHalted = !wasHalted && verdict.shouldHalt;
+  let releasedItem = null;
+  if (newlyHalted && input.inFlightItem && typeof input.markFailed === "function") {
+    releasedItem = input.markFailed(input.inFlightItem.repoFullName, input.inFlightItem.identifier);
+  }
+
+  const recorded =
+    newlyHalted || (!wasHalted && !verdict.shouldHalt)
+      ? append(
+          buildRunLoopHaltGovernorLedgerEvent(
+            input.inFlightItem?.repoFullName ?? null,
+            input.inFlightItem?.identifier ?? null,
+            verdict,
+          ),
+        )
+      : null;
+
+  return {
+    verdict,
+    recorded,
+    runHalted: verdict.shouldHalt,
+    canClaimNext: verdict.canClaimNext,
+    releasedItem,
+  };
+}

package/lib/governor-state.d.ts

@@ -0,0 +1,63 @@
+import type { GovernorCapUsage, OwnSubmissionRecord, RepoOutcomeHistory, WriteRateLimitBackoffStore, WriteRateLimitBucketStore } from "@loopover/engine";
+
+export type GovernorRateLimitState = {
+  buckets: WriteRateLimitBucketStore;
+  backoffAttempts: WriteRateLimitBackoffStore;
+};
+
+export type ListRecentOwnSubmissionsFilter = {
+  repoFullName?: string;
+  limit?: number;
+};
+
+export type GovernorPauseState = {
+  paused: boolean;
+  reason: string | null;
+  pausedAt: string | null;
+};
+
+export type GovernorPauseInput = {
+  paused: boolean;
+  reason?: string | null;
+};
+
+export type GovernorState = {
+  dbPath: string;
+  loadRateLimitState(): GovernorRateLimitState;
+  saveRateLimitState(rateLimitState: GovernorRateLimitState): void;
+  loadCapUsage(): GovernorCapUsage;
+  saveCapUsage(capUsage: GovernorCapUsage): void;
+  loadPauseState(): GovernorPauseState;
+  savePauseState(pauseState: GovernorPauseInput): GovernorPauseState;
+  loadReputationHistory(repoFullName: string, apiBaseUrl?: string): RepoOutcomeHistory;
+  saveReputationHistory(repoFullName: string, history: RepoOutcomeHistory, apiBaseUrl?: string): RepoOutcomeHistory;
+  recordOwnSubmission(record: OwnSubmissionRecord): OwnSubmissionRecord;
+  listRecentOwnSubmissions(filter?: ListRecentOwnSubmissionsFilter): OwnSubmissionRecord[];
+  close(): void;
+};
+
+export function resolveGovernorStateDbPath(env?: Record<string, string | undefined>): string;
+
+export function openGovernorState(dbPath?: string): GovernorState;
+
+export function loadRateLimitState(): GovernorRateLimitState;
+
+export function saveRateLimitState(rateLimitState: GovernorRateLimitState): void;
+
+export function loadCapUsage(): GovernorCapUsage;
+
+export function saveCapUsage(capUsage: GovernorCapUsage): void;
+
+export function loadPauseState(): GovernorPauseState;
+
+export function savePauseState(pauseState: GovernorPauseInput): GovernorPauseState;
+
+export function loadReputationHistory(repoFullName: string, apiBaseUrl?: string): RepoOutcomeHistory;
+
+export function saveReputationHistory(repoFullName: string, history: RepoOutcomeHistory, apiBaseUrl?: string): RepoOutcomeHistory;
+
+export function recordOwnSubmission(record: OwnSubmissionRecord): OwnSubmissionRecord;
+
+export function listRecentOwnSubmissions(filter?: ListRecentOwnSubmissionsFilter): OwnSubmissionRecord[];
+
+export function closeDefaultGovernorState(): void;