@loopover/miner 0.1.0

package/lib/opportunity-ranker.js

@@ -0,0 +1,118 @@
+import {
+  DEFAULT_MINER_GOAL_SPEC,
+  parseMinerGoalSpecContent,
+  rankMetadataOpportunities,
+} from "@loopover/engine";
+
+function finiteEpochMs(value) {
+  return Number.isFinite(value) ? value : Date.now();
+}
+
+function finiteNonNegativeInt(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+
+function normalizeCandidate(candidate) {
+  if (!candidate || typeof candidate !== "object") return null;
+  const repoFullName =
+    typeof candidate.repoFullName === "string" ? candidate.repoFullName.trim() : "";
+  const issueNumber = candidate.issueNumber;
+  const title = typeof candidate.title === "string" ? candidate.title.trim() : "";
+  const [owner, repo, extra] = repoFullName.split("/");
+  if (!owner || !repo || extra !== undefined) return null;
+  if (!Number.isInteger(issueNumber) || issueNumber <= 0 || !title) return null;
+  const canonicalRepoFullName = `${owner}/${repo}`;
+  const labels = Array.isArray(candidate.labels)
+    ? candidate.labels
+        .filter((label) => typeof label === "string" && label.trim())
+        .map((label) => label.trim())
+    : [];
+  return {
+    owner,
+    repo,
+    repoFullName: canonicalRepoFullName,
+    issueNumber,
+    title,
+    labels,
+    commentsCount: Number.isFinite(candidate.commentsCount) ? candidate.commentsCount : 0,
+    createdAt: typeof candidate.createdAt === "string" ? candidate.createdAt : null,
+    updatedAt: typeof candidate.updatedAt === "string" ? candidate.updatedAt : null,
+    htmlUrl: typeof candidate.htmlUrl === "string" ? candidate.htmlUrl : null,
+    aiPolicyAllowed: candidate.aiPolicyAllowed !== false,
+    aiPolicySource:
+      candidate.aiPolicySource === "AI-USAGE.md" ||
+      candidate.aiPolicySource === "CONTRIBUTING.md" ||
+      candidate.aiPolicySource === "none"
+        ? candidate.aiPolicySource
+        : "none",
+  };
+}
+
+function buildGoalSpecsByRepo(options = {}) {
+  const goalSpecsByRepo = { ...(options.goalSpecsByRepo ?? {}) };
+  const rawContentByRepo = options.goalSpecContentByRepo ?? {};
+  for (const [repoFullName, content] of Object.entries(rawContentByRepo)) {
+    if (typeof content !== "string" || !content.trim()) continue;
+    goalSpecsByRepo[repoFullName] = parseMinerGoalSpecContent(content).spec;
+  }
+  return goalSpecsByRepo;
+}
+
+function buildRankContext(options = {}) {
+  return {
+    nowMs: finiteEpochMs(options.nowMs),
+    highRiskDuplicateClusters: finiteNonNegativeInt(options.highRiskDuplicateClusters),
+    openPullRequests: finiteNonNegativeInt(options.openPullRequests),
+    goalSpecsByRepo: buildGoalSpecsByRepo(options),
+  };
+}
+
+function collectCandidates(candidates) {
+  const input = Array.isArray(candidates) ? candidates : [];
+  let skippedInvalid = 0;
+  const normalized = [];
+  const seen = new Set();
+  for (const candidate of input) {
+    const entry = normalizeCandidate(candidate);
+    if (!entry) {
+      skippedInvalid += 1;
+      continue;
+    }
+    const key = `${entry.repoFullName.toLowerCase()}#${entry.issueNumber}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    normalized.push(entry);
+  }
+  return { normalized, skippedInvalid };
+}
+
+function rankedUsesDefaultGoalSpec(ranked, options = {}) {
+  const goalSpecsByRepo = buildGoalSpecsByRepo(options);
+  const specRepos = Object.keys(goalSpecsByRepo);
+  if (ranked.length === 0) return specRepos.length === 0;
+  return ranked.some((issue) => {
+    const target = issue.repoFullName.trim().toLowerCase();
+    return !specRepos.some((repo) => repo.trim().toLowerCase() === target);
+  });
+}
+
+/**
+ * Rank metadata-only fan-out candidates locally. Never clones source, never uploads metadata, and never writes to
+ * GitHub — it only composes deterministic engine signals and returns the sorted list.
+ */
+export function rankCandidateIssues(candidates, options = {}) {
+  const { normalized } = collectCandidates(candidates);
+  return rankMetadataOpportunities(normalized, buildRankContext(options));
+}
+
+export function rankCandidateIssuesWithSummary(candidates, options = {}) {
+  const { normalized, skippedInvalid } = collectCandidates(candidates);
+  const ranked = rankMetadataOpportunities(normalized, buildRankContext(options));
+  return {
+    issues: ranked,
+    skippedInvalid,
+    usedDefaultGoalSpec: rankedUsesDefaultGoalSpec(ranked, options),
+    defaultGoalSpec: DEFAULT_MINER_GOAL_SPEC,
+  };
+}

package/lib/orb-export.d.ts

@@ -0,0 +1,54 @@
+import type { NormalizedPrOutcomePayload, PrOutcomeLedgerReader } from "./pr-outcome.js";
+
+/** OPT-IN default: a laptop miner exports nothing unless a contributor turns it on. */
+export const ORB_EXPORT_ENABLED_BY_DEFAULT: false;
+
+/** One anonymized outcome in an export batch — no raw repo name, PR number, or free-text reason. */
+export interface OrbExportRow {
+  repoHash: string;
+  prHash: string;
+  decision: string;
+  reasonBucket: string;
+  closedAt: string | null;
+}
+
+/** The local orb-export store: the per-instance anonymization secret + export cursor, in local SQLite. */
+export interface OrbExportStore {
+  dbPath: string;
+  getOrCreateAnonSecret(): string;
+  getCursor(): string | null;
+  setCursor(cursor: string): void;
+  close(): void;
+}
+
+/** A pr_outcome record as produced by `readPrOutcomes` (the local ledger's latest-per-PR reduction). */
+export type OrbExportOutcome = NormalizedPrOutcomePayload & { repoFullName: string };
+
+export function resolveOrbExportDbPath(env?: Record<string, string | undefined>): string;
+
+export function hmacAnonymize(value: string | number, secret: string): string;
+
+export function buildAnonymizedOrbBatch(
+  outcomes: Iterable<OrbExportOutcome> | Map<string, OrbExportOutcome>,
+  secret: string,
+): OrbExportRow[];
+
+export function openOrbExportStore(dbPath?: string): OrbExportStore;
+
+export function collectOrbExportBatch(options?: {
+  store: OrbExportStore;
+  eventLedger: PrOutcomeLedgerReader;
+  enabled?: boolean;
+}): OrbExportRow[] | null;
+
+export type ParsedOrbExportArgs = { json: boolean; enable: boolean; dryRun: boolean } | { error: string };
+
+export function parseOrbExportArgs(args: string[]): ParsedOrbExportArgs;
+
+export function runOrbExportCli(
+  args: string[],
+  options?: {
+    openOrbExportStore?: () => OrbExportStore;
+    initEventLedger?: () => PrOutcomeLedgerReader;
+  },
+): number;

package/lib/orb-export.js

@@ -0,0 +1,206 @@
+import { chmodSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { createHmac, randomBytes } from "node:crypto";
+import { readPrOutcomes } from "./pr-outcome.js";
+import { initEventLedger } from "./event-ledger.js";
+import { argsWantJson, describeCliError, reportCliFailure } from "./cli-error.js";
+
+// Optional anonymized Orb telemetry export (#4277). The self-host Orb collector (src/selfhost/orb-collector.ts,
+// #1255) is ALWAYS-ON for a maintainer's own instance; a miner runs on a third-party contributor's laptop with a
+// much lower consent bar, so this export is OPT-IN (default OFF) — hence "optional". It mirrors the collector's
+// privacy posture: repo/PR identifiers are HMAC-anonymized with a per-instance DEDICATED secret (generated once,
+// persisted locally, single-purpose), and only a fixed low-cardinality reason bucket + the decision leave — never
+// raw repo names or free text. The data source is the local pr_outcome ledger (pr-outcome.js), not a hosted D1.
+// This module builds the anonymized batch and manages the local secret + cursor; performing the network POST is the
+// caller's job, so this stays pure over its inputs + local store and needs no network to test.
+
+/** OPT-IN: a laptop miner exports nothing unless a contributor explicitly turns it on. */
+export const ORB_EXPORT_ENABLED_BY_DEFAULT = false;
+
+const ANON_SECRET_KEY = "anon_secret";
+const CURSOR_KEY = "export_cursor";
+const defaultDbFileName = "orb-export.sqlite3";
+
+export function resolveOrbExportDbPath(env = process.env) {
+  const explicitPath =
+    typeof env.GITTENSORY_MINER_ORB_EXPORT_DB === "string" ? env.GITTENSORY_MINER_ORB_EXPORT_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 ?? resolveOrbExportDbPath()).trim();
+  if (!path) throw new Error("invalid_orb_export_db_path");
+  return path;
+}
+
+/** HMAC a value with the per-instance secret — mirrors orb-collector.ts's hmacField (sha256, first 24 hex). */
+export function hmacAnonymize(value, secret) {
+  if (typeof secret !== "string" || !secret) throw new Error("invalid_anon_secret");
+  return createHmac("sha256", secret).update(String(value)).digest("hex").slice(0, 24);
+}
+
+/**
+ * Turn the local pr_outcome map (pr-outcome.js `readPrOutcomes`) into an anonymized export batch: repo and PR
+ * identifiers are HMAC-hashed, and only the `decision` + a low-cardinality `reasonBucket` (already one of the
+ * miner's `REJECTION_REASONS`, else `"none"`) + `closedAt` leave. Pure and deterministic (rows sorted by prHash).
+ * Accepts either the Map `readPrOutcomes` returns or any iterable of outcome records.
+ */
+export function buildAnonymizedOrbBatch(outcomes, secret) {
+  const iterable = outcomes && typeof outcomes.values === "function" ? outcomes.values() : outcomes;
+  const rows = [];
+  for (const outcome of iterable ?? []) {
+    if (!outcome || typeof outcome.repoFullName !== "string" || !outcome.repoFullName.trim()) continue;
+    if (!Number.isInteger(outcome.prNumber) || outcome.prNumber <= 0) continue;
+    rows.push({
+      repoHash: hmacAnonymize(outcome.repoFullName, secret),
+      prHash: hmacAnonymize(`${outcome.repoFullName}:${outcome.prNumber}`, secret),
+      decision: outcome.decision,
+      reasonBucket: typeof outcome.reason === "string" && outcome.reason ? outcome.reason : "none",
+      closedAt: typeof outcome.closedAt === "string" && outcome.closedAt ? outcome.closedAt : null,
+    });
+  }
+  rows.sort((a, b) => a.prHash.localeCompare(b.prHash));
+  return rows;
+}
+
+/**
+ * Open/create the local orb-export store: a small key/value SQLite table holding the per-instance anonymization
+ * secret and the export cursor. Mirrors the other miner ledgers' node:sqlite pattern — a `0o700` config dir and a
+ * `0o600` file, since the secret must never leave this machine.
+ */
+export function openOrbExportStore(dbPath = resolveOrbExportDbPath()) {
+  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 orb_export_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+
+  const getStatement = db.prepare("SELECT value FROM orb_export_meta WHERE key = ?");
+  const setStatement = db.prepare(
+    "INSERT INTO orb_export_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+  );
+  const readValue = (key) => {
+    const row = getStatement.get(key);
+    return row && typeof row.value === "string" ? row.value : null;
+  };
+
+  return {
+    dbPath: resolvedPath,
+    /** The per-instance DEDICATED anonymization secret — generated once (256-bit) and persisted, then reused
+     *  forever so a repo/PR always hashes the same way. Single-purpose: only this export uses it. */
+    getOrCreateAnonSecret() {
+      const existing = readValue(ANON_SECRET_KEY);
+      if (existing) return existing;
+      const generated = randomBytes(32).toString("hex");
+      setStatement.run(ANON_SECRET_KEY, generated);
+      return generated;
+    },
+    /** The export watermark (opaque string), or null before the first export. */
+    getCursor() {
+      return readValue(CURSOR_KEY);
+    },
+    setCursor(cursor) {
+      setStatement.run(CURSOR_KEY, String(cursor));
+    },
+    close() {
+      db.close();
+    },
+  };
+}
+
+/**
+ * Collect the anonymized Orb export batch from the local pr_outcome ledger. OPT-IN: returns null (exports nothing)
+ * unless `enabled` is true — a third-party contributor's laptop must explicitly turn this on. Never performs the
+ * network POST itself; the caller sends the returned batch to the Orb ingest endpoint and then advances the store
+ * cursor, so this function stays pure over its inputs and the local store.
+ */
+export function collectOrbExportBatch({ store, eventLedger, enabled = ORB_EXPORT_ENABLED_BY_DEFAULT } = {}) {
+  if (!enabled) return null;
+  if (!store || typeof store.getOrCreateAnonSecret !== "function") throw new Error("invalid_orb_export_store");
+  const outcomes = readPrOutcomes(eventLedger);
+  return buildAnonymizedOrbBatch(outcomes, store.getOrCreateAnonSecret());
+}
+
+const ORB_EXPORT_USAGE = "Usage: gittensory-miner orb export [--enable] [--dry-run] [--json]";
+
+export function parseOrbExportArgs(args) {
+  const options = { json: false, enable: false, dryRun: false };
+  for (const token of args) {
+    if (token === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (token === "--enable") {
+      options.enable = true;
+      continue;
+    }
+    // #4847: openOrbExportStore() itself creates the local SQLite file (a real write) even before any secret is
+    // generated, so a dry run reports what would happen and returns before opening any store at all.
+    if (token === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    return { error: ORB_EXPORT_USAGE };
+  }
+  return options;
+}
+
+/** CLI entry for the anonymized Orb telemetry batch-builder (#4833 wires the previously caller-less exporter).
+ *  OPT-IN: prints nothing to export unless `--enable` is passed. Only builds the anonymized batch (repo/PR
+ *  identifiers HMAC-hashed) — never performs the network POST. */
+export function runOrbExportCli(args, options = {}) {
+  const parsed = parseOrbExportArgs(args);
+  if ("error" in parsed) {
+    return reportCliFailure(argsWantJson(args), parsed.error);
+  }
+
+  if (parsed.dryRun) {
+    const dryRunResult = { outcome: "dry_run", enabled: parsed.enable };
+    if (parsed.json) {
+      console.log(JSON.stringify(dryRunResult, null, 2));
+    } else if (parsed.enable) {
+      console.log("DRY RUN: would build and report an anonymized Orb export batch. No local writes were made.");
+    } else {
+      console.log("DRY RUN: orb export is opt-in and disabled — pass --enable to build an anonymized batch. No local writes were made.");
+    }
+    return 0;
+  }
+
+  // Open the stores INSIDE the try so a bad config path / SQLite open failure returns 2 instead of crashing the
+  // process; the finally guards each close with `?.` since either initializer may have thrown before assigning.
+  const ownsStore = options.openOrbExportStore === undefined;
+  const ownsLedger = options.initEventLedger === undefined;
+  let store;
+  let eventLedger;
+  try {
+    store = (options.openOrbExportStore ?? openOrbExportStore)();
+    eventLedger = (options.initEventLedger ?? initEventLedger)();
+    const batch = collectOrbExportBatch({ store, eventLedger, enabled: parsed.enable });
+    if (batch === null) {
+      if (parsed.json) console.log(JSON.stringify({ enabled: false, batch: null }, null, 2));
+      else console.log("orb export is opt-in and disabled — pass --enable to build an anonymized batch");
+      return 0;
+    }
+    if (parsed.json) console.log(JSON.stringify({ enabled: true, batch }, null, 2));
+    else console.log(`${batch.length} anonymized event(s)`);
+    return 0;
+  } catch (error) {
+    return reportCliFailure(parsed.json, describeCliError(error));
+  } finally {
+    if (ownsStore) store?.close();
+    if (ownsLedger) eventLedger?.close();
+  }
+}

package/lib/plan-store-cli.d.ts

@@ -0,0 +1,37 @@
+import type { PlanRecord, PlanStatus, PlanStore } from "./plan-store.js";
+
+export type ParsedPlanListArgs =
+  | {
+      json: boolean;
+      status: PlanStatus | null;
+    }
+  | { error: string };
+
+export type ParsedPlanShowArgs =
+  | {
+      planId: string;
+      json: boolean;
+    }
+  | { error: string };
+
+export function parsePlanListArgs(args: string[]): ParsedPlanListArgs;
+
+export function parsePlanShowArgs(args: string[]): ParsedPlanShowArgs;
+
+export function renderPlanTable(plans: PlanRecord[]): string;
+
+export function runPlanList(
+  args: string[],
+  options?: { openPlanStore?: () => PlanStore },
+): number;
+
+export function runPlanShow(
+  args: string[],
+  options?: { openPlanStore?: () => PlanStore },
+): number;
+
+export function runPlanCli(
+  subcommand: string | undefined,
+  args: string[],
+  options?: { openPlanStore?: () => PlanStore },
+): number;

package/lib/plan-store-cli.js

@@ -0,0 +1,151 @@
+import { PLAN_STATUSES, openPlanStore } from "./plan-store.js";
+import { argsWantJson, describeCliError, reportCliFailure } from "./cli-error.js";
+
+const PLAN_LIST_USAGE =
+  "Usage: gittensory-miner plan list [--status pending|running|completed|failed] [--json]";
+const PLAN_SHOW_USAGE = "Usage: gittensory-miner plan show <planId> [--json]";
+
+function parseJsonFlag(args) {
+  const options = { json: false };
+  const positional = [];
+
+  for (const token of args) {
+    if (token === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      return { error: `Unknown option: ${token}` };
+    }
+    positional.push(token);
+  }
+
+  return { positional, ...options };
+}
+
+export function parsePlanListArgs(args) {
+  const options = { json: false, status: null };
+  const positional = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (token === "--status") {
+      const status = args[index + 1];
+      if (!status || status.startsWith("-")) return { error: PLAN_LIST_USAGE };
+      if (!PLAN_STATUSES.includes(status)) {
+        return { error: `Invalid status: ${status}. Expected one of ${PLAN_STATUSES.join(", ")}.` };
+      }
+      options.status = status;
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) return { error: `Unknown option: ${token}` };
+    positional.push(token);
+  }
+
+  if (positional.length > 0) return { error: PLAN_LIST_USAGE };
+  return options;
+}
+
+export function parsePlanShowArgs(args) {
+  const parsed = parseJsonFlag(args);
+  if ("error" in parsed) return parsed;
+  if (parsed.positional.length !== 1) return { error: PLAN_SHOW_USAGE };
+
+  const planId = parsed.positional[0]?.trim();
+  if (!planId) return { error: PLAN_SHOW_USAGE };
+
+  return {
+    planId,
+    json: parsed.json,
+  };
+}
+
+function display(value) {
+  if (value === null || value === undefined) return "-";
+  return String(value);
+}
+
+export function renderPlanTable(plans) {
+  if (!Array.isArray(plans) || plans.length === 0) return "no saved plans";
+  const header = [
+    "plan-id".padEnd(20),
+    "status".padEnd(10),
+    "steps".padStart(5),
+    "updated-at".padEnd(24),
+  ].join(" ");
+  const lines = plans.map((record) =>
+    [
+      record.planId.padEnd(20),
+      record.status.padEnd(10),
+      String(record.plan.steps.length).padStart(5),
+      display(record.updatedAt).padEnd(24),
+    ].join(" "),
+  );
+  return [header, ...lines].join("\n");
+}
+
+function withPlanStore(options, run) {
+  const ownsStore = options.openPlanStore === undefined;
+  const planStore = (options.openPlanStore ?? openPlanStore)();
+  try {
+    return run(planStore);
+  } finally {
+    if (ownsStore) planStore.close();
+  }
+}
+
+export function runPlanList(args, options = {}) {
+  const parsed = parsePlanListArgs(args);
+  if ("error" in parsed) {
+    return reportCliFailure(argsWantJson(args), parsed.error);
+  }
+
+  try {
+    return withPlanStore(options, (planStore) => {
+      const plans = planStore.listPlans({ status: parsed.status });
+      if (parsed.json) {
+        console.log(JSON.stringify({ plans }, null, 2));
+      } else {
+        console.log(renderPlanTable(plans));
+      }
+      return 0;
+    });
+  } catch (error) {
+    return reportCliFailure(parsed.json, describeCliError(error));
+  }
+}
+
+export function runPlanShow(args, options = {}) {
+  const parsed = parsePlanShowArgs(args);
+  if ("error" in parsed) {
+    return reportCliFailure(argsWantJson(args), parsed.error);
+  }
+
+  try {
+    return withPlanStore(options, (planStore) => {
+      const plan = planStore.loadPlan(parsed.planId);
+      if (!plan) {
+        return reportCliFailure(parsed.json, "plan_not_found");
+      }
+      if (parsed.json) {
+        console.log(JSON.stringify({ plan }, null, 2));
+      } else {
+        console.log(`${plan.status} (${plan.plan.steps.length} steps)`);
+      }
+      return 0;
+    });
+  } catch (error) {
+    return reportCliFailure(parsed.json, describeCliError(error));
+  }
+}
+
+export function runPlanCli(subcommand, args, options = {}) {
+  if (subcommand === "list") return runPlanList(args, options);
+  if (subcommand === "show") return runPlanShow(args, options);
+  return reportCliFailure(argsWantJson(args), `Unknown plan subcommand: ${subcommand ?? ""}. ${PLAN_LIST_USAGE}`);
+}

package/lib/plan-store.d.ts

@@ -0,0 +1,51 @@
+export type PlanStepStatus = "pending" | "running" | "completed" | "failed" | "skipped";
+
+export type PlanStep = {
+  id: string;
+  title: string;
+  actionClass?: string;
+  dependsOn: string[];
+  status: PlanStepStatus;
+  attempts: number;
+  maxAttempts: number;
+  lastError?: string | null;
+};
+
+export type PlanDag = {
+  steps: PlanStep[];
+};
+
+export type PlanStatus = "pending" | "running" | "completed" | "failed";
+
+export type PlanRecord = {
+  planId: string;
+  plan: PlanDag;
+  status: PlanStatus;
+  updatedAt: string;
+};
+
+export type ListPlansFilter = {
+  status?: PlanStatus | null;
+};
+
+export type PlanStore = {
+  dbPath: string;
+  savePlan(planId: string, plan: PlanDag): PlanRecord;
+  loadPlan(planId: string): PlanRecord | null;
+  listPlans(filter?: ListPlansFilter): PlanRecord[];
+  close(): void;
+};
+
+export const PLAN_STATUSES: readonly PlanStatus[];
+
+export function resolvePlanStoreDbPath(env?: Record<string, string | undefined>): string;
+
+export function openPlanStore(dbPath?: string): PlanStore;
+
+export function savePlan(planId: string, plan: PlanDag): PlanRecord;
+
+export function loadPlan(planId: string): PlanRecord | null;
+
+export function listPlans(filter?: ListPlansFilter): PlanRecord[];
+
+export function closeDefaultPlanStore(): void;