issue-flow 0.18.0 → 0.19.1

package/dist/chunk-7MJGYPHF.js

@@ -0,0 +1,1571 @@
+#!/usr/bin/env node
+import {
+  taskPlanSchema
+} from "./chunk-XNK5UN2D.js";
+import {
+  getGlobalRoot
+} from "./chunk-MAJ6QDRL.js";
+import {
+  writeFileAtomic
+} from "./chunk-PFWHHYEO.js";
+
+// src/storage/db/repository.ts
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile } from "node:fs/promises";
+import { basename, dirname as dirname2 } from "node:path";
+
+// src/storage/db/index.ts
+import { join } from "node:path";
+
+// src/storage/db/driver.ts
+import { mkdirSync, statfsSync } from "node:fs";
+import { dirname } from "node:path";
+var NETWORK_FILESYSTEM_TYPES = /* @__PURE__ */ new Set([26985, 20859, 4283649346]);
+function isNetworkFilesystem(path) {
+  try {
+    return NETWORK_FILESYSTEM_TYPES.has(Number(statfsSync(dirname(path)).type));
+  } catch {
+    return false;
+  }
+}
+function isSqliteExperimentalWarning(warning) {
+  if (!(warning instanceof Error) || warning.name !== "ExperimentalWarning") return false;
+  return warning.message.includes("SQLite is an experimental feature");
+}
+async function loadDatabaseSync() {
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const normalized = typeof warning === "string" ? Object.assign(new Error(warning), {
+      name: typeof args[0] === "string" ? args[0] : "Warning"
+    }) : warning;
+    if (isSqliteExperimentalWarning(normalized)) return;
+    return originalEmitWarning(warning, ...args);
+  });
+  try {
+    const sqlite = await import("node:sqlite");
+    return sqlite.DatabaseSync;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `SQLite storage requires Node.js >= 22.13.0 with the built-in node:sqlite module. ${detail}`,
+      { cause: error }
+    );
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+var NodeSqliteDriver = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  exec(sql) {
+    this.database.exec(sql);
+  }
+  prepare(sql) {
+    return this.database.prepare(sql);
+  }
+  transaction(work) {
+    this.exec("BEGIN IMMEDIATE");
+    try {
+      const value = work();
+      this.exec("COMMIT");
+      return value;
+    } catch (error) {
+      try {
+        this.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
+  integrityCheck() {
+    return this.prepare("PRAGMA integrity_check").get()?.integrity_check ?? "unknown";
+  }
+  backup(destination) {
+    mkdirSync(dirname(destination), { recursive: true });
+    this.prepare("VACUUM INTO ?").run(destination);
+  }
+  vacuum() {
+    this.exec("VACUUM");
+  }
+  close() {
+    this.database.close();
+  }
+};
+async function openDatabase(path, options = {}) {
+  mkdirSync(dirname(path), { recursive: true });
+  const DatabaseSync = await loadDatabaseSync();
+  const driver = new NodeSqliteDriver(new DatabaseSync(path));
+  try {
+    driver.exec("PRAGMA foreign_keys = ON");
+    driver.exec("PRAGMA busy_timeout = 5000");
+    driver.exec("PRAGMA synchronous = NORMAL");
+    const networkFilesystem = (options.isNetworkFilesystem ?? isNetworkFilesystem)(path);
+    driver.exec(`PRAGMA journal_mode = ${networkFilesystem ? "DELETE" : "WAL"}`);
+    if (networkFilesystem) {
+      options.onWarning?.(
+        `SQLite database is on a network filesystem; using journal_mode=DELETE instead of WAL: ${path}`
+      );
+    }
+    return driver;
+  } catch (error) {
+    driver.close();
+    throw error;
+  }
+}
+
+// src/storage/db/migrations.ts
+var INITIAL_SCHEMA = `
+CREATE TABLE projects (
+  id TEXT PRIMARY KEY,
+  root TEXT NOT NULL,
+  remote_url TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE TABLE issues (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  id TEXT NOT NULL,
+  title TEXT,
+  status TEXT NOT NULL,
+  branch_name TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, id)
+);
+CREATE TABLE pipelines (
+  project_id TEXT NOT NULL,
+  issue_id TEXT NOT NULL,
+  state_json TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, issue_id),
+  FOREIGN KEY (project_id, issue_id) REFERENCES issues(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE stories (
+  project_id TEXT NOT NULL,
+  issue_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  priority INTEGER NOT NULL,
+  passes INTEGER NOT NULL CHECK (passes IN (0, 1)),
+  notes TEXT NOT NULL DEFAULT '',
+  PRIMARY KEY (project_id, issue_id, id),
+  FOREIGN KEY (project_id, issue_id) REFERENCES issues(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE story_dependencies (
+  project_id TEXT NOT NULL,
+  issue_id TEXT NOT NULL,
+  story_id TEXT NOT NULL,
+  depends_on_story_id TEXT NOT NULL,
+  PRIMARY KEY (project_id, issue_id, story_id, depends_on_story_id),
+  FOREIGN KEY (project_id, issue_id, story_id) REFERENCES stories(project_id, issue_id, id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, issue_id, depends_on_story_id) REFERENCES stories(project_id, issue_id, id) ON DELETE CASCADE,
+  CHECK (story_id <> depends_on_story_id)
+);
+CREATE TABLE runs (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  issue_id TEXT,
+  status TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  FOREIGN KEY (project_id, issue_id) REFERENCES issues(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE phases (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  status TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT
+);
+CREATE TABLE executions (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  issue_id TEXT,
+  run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+  phase_id TEXT REFERENCES phases(id) ON DELETE SET NULL,
+  status TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  duration_ms INTEGER,
+  cost_status TEXT NOT NULL CHECK (cost_status IN ('reported', 'estimated', 'unknown')),
+  cost_amount REAL,
+  CHECK ((cost_status = 'unknown' AND cost_amount IS NULL) OR (cost_status IN ('reported', 'estimated') AND cost_amount IS NOT NULL AND cost_amount >= 0)),
+  FOREIGN KEY (project_id, issue_id) REFERENCES issues(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE events (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  run_id TEXT REFERENCES runs(id) ON DELETE CASCADE,
+  occurred_at TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  payload_json TEXT NOT NULL
+);
+CREATE TABLE snapshots (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  run_id TEXT REFERENCES runs(id) ON DELETE CASCADE,
+  created_at TEXT NOT NULL,
+  payload_json TEXT NOT NULL
+);
+CREATE TABLE pull_requests (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  issue_id TEXT,
+  number INTEGER,
+  url TEXT,
+  status TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (project_id, issue_id) REFERENCES issues(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE reviews (
+  id TEXT PRIMARY KEY,
+  pull_request_id TEXT NOT NULL REFERENCES pull_requests(id) ON DELETE CASCADE,
+  status TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  payload_json TEXT NOT NULL
+);
+CREATE TABLE verifications (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  issue_id TEXT,
+  status TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  FOREIGN KEY (project_id, issue_id) REFERENCES issues(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE provider_health (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  provider TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, provider)
+);
+CREATE TABLE queues (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  status TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE TABLE queue_issues (
+  queue_id TEXT NOT NULL REFERENCES queues(id) ON DELETE CASCADE,
+  project_id TEXT NOT NULL,
+  issue_id TEXT NOT NULL,
+  position INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  PRIMARY KEY (queue_id, project_id, issue_id),
+  UNIQUE (queue_id, position),
+  FOREIGN KEY (project_id, issue_id) REFERENCES issues(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE migrated_artifacts (
+  source_path TEXT PRIMARY KEY,
+  sha256 TEXT NOT NULL,
+  migrated_at TEXT NOT NULL,
+  table_counts_json TEXT NOT NULL
+);
+CREATE TABLE audit_log (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  occurred_at TEXT NOT NULL,
+  action TEXT NOT NULL,
+  payload_json TEXT NOT NULL
+);
+CREATE INDEX executions_project_issue_started_idx ON executions(project_id, issue_id, started_at);
+CREATE INDEX runs_project_status_started_idx ON runs(project_id, status, started_at);
+CREATE INDEX stories_project_issue_priority_idx ON stories(project_id, issue_id, priority);
+CREATE INDEX phases_run_name_idx ON phases(run_id, name);
+CREATE INDEX events_project_run_occurred_idx ON events(project_id, run_id, occurred_at);
+`;
+var migrations = [
+  {
+    version: 1,
+    name: "initial relational storage",
+    up: (database) => database.exec(INITIAL_SCHEMA)
+  },
+  {
+    version: 2,
+    name: "preserve imported execution details",
+    up: (database) => database.exec("ALTER TABLE executions ADD COLUMN payload_json TEXT NOT NULL DEFAULT '{}'")
+  },
+  {
+    version: 3,
+    name: "index numeric user story identifiers",
+    up: (database) => database.exec(`
+        ALTER TABLE stories ADD COLUMN story_number INTEGER;
+        CREATE INDEX stories_project_number_idx ON stories(project_id, story_number DESC);
+      `)
+  },
+  {
+    version: 4,
+    name: "complete relational state and history indexes",
+    up: (database) => database.exec(`
+        ALTER TABLE pipelines ADD COLUMN project TEXT;
+        ALTER TABLE pipelines ADD COLUMN issue_number TEXT;
+        ALTER TABLE pipelines ADD COLUMN issue_url TEXT;
+        ALTER TABLE pipelines ADD COLUMN branch_name TEXT;
+        ALTER TABLE pipelines ADD COLUMN no_branch INTEGER NOT NULL DEFAULT 0 CHECK (no_branch IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN description TEXT;
+        ALTER TABLE pipelines ADD COLUMN issue_status TEXT;
+        ALTER TABLE pipelines ADD COLUMN completed_at TEXT;
+        ALTER TABLE pipelines ADD COLUMN last_attempt_at TEXT;
+        ALTER TABLE pipelines ADD COLUMN last_error_category TEXT;
+        ALTER TABLE pipelines ADD COLUMN last_error_message TEXT;
+        ALTER TABLE pipelines ADD COLUMN last_error_at TEXT;
+        ALTER TABLE pipelines ADD COLUMN correction_cycle INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE pipelines ADD COLUMN max_correction_cycles INTEGER NOT NULL DEFAULT 3;
+        ALTER TABLE pipelines ADD COLUMN last_review_findings TEXT;
+        ALTER TABLE pipelines ADD COLUMN analyze_completed INTEGER CHECK (analyze_completed IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN prd_completed INTEGER CHECK (prd_completed IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN json_completed INTEGER CHECK (json_completed IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN execution_completed INTEGER CHECK (execution_completed IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN review_completed INTEGER CHECK (review_completed IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN pr_created INTEGER CHECK (pr_created IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN pr_review_completed INTEGER CHECK (pr_review_completed IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN run_status TEXT;
+        ALTER TABLE pipelines ADD COLUMN run_phase TEXT;
+        ALTER TABLE pipelines ADD COLUMN run_attempt INTEGER;
+        ALTER TABLE pipelines ADD COLUMN run_heartbeat_at TEXT;
+        ALTER TABLE pipelines ADD COLUMN run_blocked_reason TEXT;
+        ALTER TABLE pipelines ADD COLUMN run_owner_pid INTEGER;
+        ALTER TABLE pipelines ADD COLUMN run_owner_host TEXT;
+        ALTER TABLE pipelines ADD COLUMN run_owner_started_at TEXT;
+        ALTER TABLE pipelines ADD COLUMN pr_number INTEGER;
+        ALTER TABLE pipelines ADD COLUMN pr_url TEXT;
+        ALTER TABLE pipelines ADD COLUMN pr_head_branch TEXT;
+        ALTER TABLE pipelines ADD COLUMN pr_created_at TEXT;
+        ALTER TABLE pipelines ADD COLUMN pr_review_enabled INTEGER CHECK (pr_review_enabled IN (0, 1));
+        ALTER TABLE pipelines ADD COLUMN pr_review_rounds INTEGER;
+        ALTER TABLE pipelines ADD COLUMN pr_review_recommendation TEXT;
+        ALTER TABLE pipelines ADD COLUMN pr_reviewed_at TEXT;
+
+        ALTER TABLE stories ADD COLUMN description TEXT;
+        ALTER TABLE stories ADD COLUMN acceptance_criteria_json TEXT NOT NULL DEFAULT '[]';
+        ALTER TABLE stories ADD COLUMN duration_seconds REAL;
+        ALTER TABLE stories ADD COLUMN status TEXT;
+        ALTER TABLE stories ADD COLUMN stage TEXT;
+        ALTER TABLE stories ADD COLUMN stage_since TEXT;
+        ALTER TABLE stories ADD COLUMN stage_detail TEXT;
+        ALTER TABLE stories ADD COLUMN input_tokens INTEGER;
+        ALTER TABLE stories ADD COLUMN output_tokens INTEGER;
+        ALTER TABLE stories ADD COLUMN cache_read_tokens INTEGER;
+        ALTER TABLE stories ADD COLUMN cache_creation_tokens INTEGER;
+
+        ALTER TABLE runs ADD COLUMN session_id TEXT;
+        ALTER TABLE runs ADD COLUMN heartbeat_at TEXT;
+        ALTER TABLE runs ADD COLUMN pid INTEGER;
+        ALTER TABLE runs ADD COLUMN host TEXT;
+        ALTER TABLE events ADD COLUMN session_id TEXT;
+        ALTER TABLE events ADD COLUMN sequence INTEGER;
+        ALTER TABLE snapshots ADD COLUMN issue_id TEXT;
+        ALTER TABLE snapshots ADD COLUMN session_id TEXT;
+        ALTER TABLE snapshots ADD COLUMN updated_at TEXT;
+        ALTER TABLE executions ADD COLUMN session_id TEXT;
+        ALTER TABLE executions ADD COLUMN purpose TEXT;
+        ALTER TABLE executions ADD COLUMN attempt INTEGER;
+        ALTER TABLE executions ADD COLUMN trigger TEXT;
+        ALTER TABLE executions ADD COLUMN trigger_reason TEXT;
+        ALTER TABLE executions ADD COLUMN input_tokens INTEGER;
+        ALTER TABLE executions ADD COLUMN output_tokens INTEGER;
+        ALTER TABLE executions ADD COLUMN cache_read_tokens INTEGER;
+        ALTER TABLE executions ADD COLUMN cache_creation_tokens INTEGER;
+        ALTER TABLE executions ADD COLUMN reasoning_tokens INTEGER;
+        ALTER TABLE executions ADD COLUMN harness TEXT;
+        ALTER TABLE executions ADD COLUMN provider TEXT;
+        ALTER TABLE executions ADD COLUMN model_requested TEXT;
+        ALTER TABLE executions ADD COLUMN model_resolved TEXT;
+
+        ALTER TABLE provider_health ADD COLUMN status TEXT;
+        ALTER TABLE provider_health ADD COLUMN consecutive_failures INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE provider_health ADD COLUMN cooldown_level INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE provider_health ADD COLUMN cooldown_until TEXT;
+        ALTER TABLE provider_health ADD COLUMN last_failure_kind TEXT;
+        ALTER TABLE provider_health ADD COLUMN last_failure_at TEXT;
+        ALTER TABLE provider_health ADD COLUMN last_success_at TEXT;
+        ALTER TABLE provider_health ADD COLUMN probe_in_flight INTEGER NOT NULL DEFAULT 0 CHECK (probe_in_flight IN (0, 1));
+        ALTER TABLE provider_health ADD COLUMN probe_started_at TEXT;
+        CREATE TABLE provider_health_failures (
+          project_id TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          occurred_at TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          PRIMARY KEY (project_id, provider, occurred_at, kind),
+          FOREIGN KEY (project_id, provider) REFERENCES provider_health(project_id, provider) ON DELETE CASCADE
+        );
+
+        ALTER TABLE queues ADD COLUMN requested_json TEXT NOT NULL DEFAULT '[]';
+        ALTER TABLE queues ADD COLUMN branch_name TEXT;
+        ALTER TABLE queues ADD COLUMN no_branch INTEGER NOT NULL DEFAULT 0 CHECK (no_branch IN (0, 1));
+        ALTER TABLE queues ADD COLUMN pr_review INTEGER NOT NULL DEFAULT 0 CHECK (pr_review IN (0, 1));
+        ALTER TABLE queues ADD COLUMN truncated INTEGER NOT NULL DEFAULT 0 CHECK (truncated IN (0, 1));
+        ALTER TABLE queue_issues ADD COLUMN number INTEGER;
+        ALTER TABLE queue_issues ADD COLUMN title TEXT;
+        ALTER TABLE queue_issues ADD COLUMN url TEXT;
+        ALTER TABLE queue_issues ADD COLUMN source TEXT;
+        ALTER TABLE queue_issues ADD COLUMN origin TEXT;
+        ALTER TABLE queue_issues ADD COLUMN role TEXT;
+        ALTER TABLE queue_issues ADD COLUMN priority TEXT;
+        ALTER TABLE queue_issues ADD COLUMN heuristic INTEGER NOT NULL DEFAULT 0 CHECK (heuristic IN (0, 1));
+        ALTER TABLE queue_issues ADD COLUMN failed_phase TEXT;
+        ALTER TABLE queue_issues ADD COLUMN last_error_category TEXT;
+        ALTER TABLE queue_issues ADD COLUMN last_error_message TEXT;
+        ALTER TABLE queue_issues ADD COLUMN last_error_at TEXT;
+        ALTER TABLE queue_issues ADD COLUMN attempts INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE queue_issues ADD COLUMN blocked_reason TEXT;
+        ALTER TABLE queue_issues ADD COLUMN started_at TEXT;
+        ALTER TABLE queue_issues ADD COLUMN completed_at TEXT;
+        CREATE TABLE queue_dependencies (
+          queue_id TEXT NOT NULL REFERENCES queues(id) ON DELETE CASCADE,
+          issue_id TEXT NOT NULL,
+          depends_on_issue_id TEXT NOT NULL,
+          PRIMARY KEY (queue_id, issue_id, depends_on_issue_id),
+          CHECK (issue_id <> depends_on_issue_id)
+        );
+        CREATE TABLE user_story_numbering (
+          project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+          next_number INTEGER NOT NULL CHECK (next_number > 0),
+          source TEXT NOT NULL,
+          issue_id TEXT NOT NULL,
+          decided_at TEXT NOT NULL,
+          detail TEXT
+        );
+        CREATE UNIQUE INDEX events_run_sequence_idx ON events(run_id, sequence) WHERE run_id IS NOT NULL AND sequence IS NOT NULL;
+        CREATE INDEX snapshots_project_session_updated_idx ON snapshots(project_id, session_id, updated_at DESC);
+        CREATE INDEX events_project_session_sequence_idx ON events(project_id, session_id, sequence);
+        CREATE INDEX executions_project_purpose_started_idx ON executions(project_id, purpose, started_at);
+        CREATE INDEX queue_issues_project_status_idx ON queue_issues(project_id, status, position);
+        CREATE INDEX provider_health_failures_lookup_idx ON provider_health_failures(project_id, provider, occurred_at DESC);
+      `)
+  },
+  {
+    version: 5,
+    name: "preserve pr review target state",
+    up: (database) => database.exec("ALTER TABLE pipelines ADD COLUMN pr_review_pull_request_number INTEGER;")
+  },
+  {
+    version: 6,
+    name: "record completed project adoption and runtime phase history",
+    up: (database) => database.exec(`
+        CREATE TABLE project_imports (
+          project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+          completed_at TEXT NOT NULL
+        );
+        ALTER TABLE phases ADD COLUMN duration_ms INTEGER;
+        ALTER TABLE phases ADD COLUMN input_tokens INTEGER;
+        ALTER TABLE phases ADD COLUMN output_tokens INTEGER;
+        ALTER TABLE phases ADD COLUMN cache_read_tokens INTEGER;
+        ALTER TABLE phases ADD COLUMN cache_creation_tokens INTEGER;
+        ALTER TABLE phases ADD COLUMN cost_status TEXT;
+        ALTER TABLE phases ADD COLUMN cost_amount REAL;
+        CREATE INDEX phases_run_status_started_idx ON phases(run_id, status, started_at);
+        CREATE INDEX reviews_pull_request_created_idx ON reviews(pull_request_id, created_at DESC);
+      `)
+  },
+  {
+    version: 7,
+    name: "index execution history by harness and run",
+    up: (database) => database.exec(`
+        CREATE INDEX executions_harness_started_idx ON executions(harness, started_at);
+        CREATE INDEX executions_run_id_idx ON executions(run_id);
+      `)
+  },
+  {
+    version: 8,
+    name: "explicit issue closure authorization",
+    up: (database) => database.exec(`
+      ALTER TABLE pipelines ADD COLUMN close_issue INTEGER CHECK (close_issue IN (0, 1));
+      ALTER TABLE pipelines ADD COLUMN issue_closed_at TEXT;
+    `)
+  }
+];
+var CURRENT_SCHEMA_VERSION = migrations.at(-1)?.version ?? 0;
+function userVersion(database) {
+  return Number(
+    database.prepare("PRAGMA user_version").get()?.user_version ?? 0
+  );
+}
+function migrateDatabase(database) {
+  const current = userVersion(database);
+  if (current > CURRENT_SCHEMA_VERSION) {
+    throw new Error(
+      `Database schema version ${current} is newer than this Issue Flow supports (${CURRENT_SCHEMA_VERSION}). Upgrade Issue Flow before opening this database.`
+    );
+  }
+  database.exec(
+    "CREATE TABLE IF NOT EXISTS schema_migrations (version INTEGER PRIMARY KEY, name TEXT NOT NULL, applied_at TEXT NOT NULL)"
+  );
+  for (const migration of migrations) {
+    if (migration.version <= current) continue;
+    database.transaction(() => {
+      migration.up(database);
+      database.prepare("INSERT INTO schema_migrations (version, name, applied_at) VALUES (?, ?, ?)").run(migration.version, migration.name, (/* @__PURE__ */ new Date()).toISOString());
+      database.exec(`PRAGMA user_version = ${migration.version}`);
+    });
+  }
+  return CURRENT_SCHEMA_VERSION;
+}
+
+// src/storage/db/index.ts
+var DATABASE_FILENAME = "issue-flow.db";
+function getDatabasePath(options = {}) {
+  return join(getGlobalRoot(options), DATABASE_FILENAME);
+}
+var projectDatabaseOptions = /* @__PURE__ */ new Map();
+function registerProjectDatabaseOptions(projectId, options) {
+  projectDatabaseOptions.set(projectId, options);
+}
+function databaseOptionsForProject(projectId) {
+  return projectDatabaseOptions.get(projectId) ?? {};
+}
+function resetProjectDatabaseOptions() {
+  projectDatabaseOptions.clear();
+}
+async function openIssueFlowDatabase(options = {}) {
+  const database = await openDatabase(getDatabasePath(options), options);
+  try {
+    migrateDatabase(database);
+    return database;
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+}
+
+// src/storage/db/repository.ts
+var contexts = /* @__PURE__ */ new Map();
+var providerHealthContexts = /* @__PURE__ */ new Map();
+var verificationContexts = /* @__PURE__ */ new Map();
+var lastBranchContexts = /* @__PURE__ */ new Map();
+var queueContexts = /* @__PURE__ */ new Map();
+var agentProjectionWindows = /* @__PURE__ */ new Set();
+function storyNumber(id) {
+  const matches = id.match(/\d+/g);
+  if (matches === null || matches.length === 0) return null;
+  const value = Number.parseInt(matches.at(-1) ?? "", 10);
+  return Number.isNaN(value) ? null : value;
+}
+function registerPlanRepository(context) {
+  contexts.set(context.tasksPath, context);
+}
+function getPlanRepository(path) {
+  return contexts.get(path);
+}
+function registerQueueRepository(context) {
+  queueContexts.set(context.planFile, context);
+}
+function getQueueRepository(path) {
+  return queueContexts.get(path);
+}
+function registerStorageProjections(input) {
+  if (input.providersHealthFile !== void 0) {
+    providerHealthContexts.set(input.providersHealthFile, input.context);
+  }
+  if (input.verifyFile !== void 0) verificationContexts.set(input.verifyFile, input.context);
+  if (input.lastBranchFile !== void 0)
+    lastBranchContexts.set(input.lastBranchFile, input.context);
+}
+function getProviderHealthRepository(path) {
+  return providerHealthContexts.get(path);
+}
+function getVerificationRepository(path) {
+  return verificationContexts.get(path);
+}
+function getLastBranchRepository(path) {
+  return lastBranchContexts.get(path);
+}
+async function ensurePlanRepository(path) {
+  const known = getPlanRepository(path);
+  if (known !== void 0) return known;
+  const digest = createHash("sha256").update(path).digest("hex").slice(0, 24);
+  const context = {
+    tasksPath: path,
+    projectId: `projection-${digest}`,
+    issueId: `projection-${digest}`,
+    projectRoot: dirname2(path)
+  };
+  try {
+    const plan = parsePlan(await readFile(path, "utf-8"), path);
+    await saveStoredPlan(context, plan);
+    registerPlanRepository(context);
+    return context;
+  } catch {
+    return null;
+  }
+}
+function resetPlanRepositories() {
+  contexts.clear();
+  providerHealthContexts.clear();
+  verificationContexts.clear();
+  lastBranchContexts.clear();
+  queueContexts.clear();
+  agentProjectionWindows.clear();
+}
+function applyStoredRetention(database, projectId, retention) {
+  const trim = (table, limit) => {
+    if (limit === void 0 || limit === 0) return;
+    const timestamp = table === "executions" ? "started_at" : table === "events" ? "occurred_at" : "updated_at";
+    database.prepare(
+      `DELETE FROM ${table} WHERE id IN (
+           SELECT id FROM ${table} WHERE project_id = ?
+           ORDER BY ${timestamp} DESC, rowid DESC LIMIT -1 OFFSET ?
+         )`
+    ).run(projectId, limit);
+  };
+  trim("executions", retention?.executions);
+  trim("events", retention?.events);
+  trim("snapshots", retention?.snapshots);
+}
+function ensureStoredProject(database, context, timestamp) {
+  database.prepare(
+    `INSERT INTO projects (id, root, remote_url, created_at, updated_at) VALUES (?, ?, NULL, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET root = excluded.root, updated_at = excluded.updated_at`
+  ).run(context.projectId, context.projectRoot, timestamp, timestamp);
+}
+function ensureStoredIssue(database, context, timestamp) {
+  database.prepare(
+    `INSERT INTO issues (project_id, id, title, status, branch_name, created_at, updated_at)
+       VALUES (?, ?, NULL, 'pending', NULL, ?, ?)
+       ON CONFLICT(project_id, id) DO NOTHING`
+  ).run(context.projectId, context.issueId, timestamp, timestamp);
+}
+function setAgentProjectionWindow(path, active) {
+  if (active) agentProjectionWindows.add(path);
+  else agentProjectionWindows.delete(path);
+}
+function parsePlan(value, path) {
+  try {
+    return taskPlanSchema.parse(JSON.parse(value));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid SQLite task plan for ${path}: ${detail}`, { cause: error });
+  }
+}
+async function withDatabase(work, options = {}) {
+  const database = await openIssueFlowDatabase(options);
+  try {
+    return work(database);
+  } finally {
+    database.close();
+  }
+}
+async function loadStoredPlan(context) {
+  return withDatabase((database) => {
+    const row = database.prepare("SELECT * FROM pipelines WHERE project_id = ? AND issue_id = ?").get(context.projectId, context.issueId);
+    if (row === void 0) {
+      throw new Error(`No SQLite task plan exists for issue ${context.issueId}. Run plan first.`);
+    }
+    if (row.project === null || row.project === void 0) {
+      return parsePlan(String(row.state_json), context.tasksPath);
+    }
+    const dependencies = /* @__PURE__ */ new Map();
+    for (const dependency of database.prepare(
+      "SELECT story_id, depends_on_story_id FROM story_dependencies WHERE project_id = ? AND issue_id = ?"
+    ).all(context.projectId, context.issueId)) {
+      dependencies.set(dependency.story_id, [
+        ...dependencies.get(dependency.story_id) ?? [],
+        dependency.depends_on_story_id
+      ]);
+    }
+    const stories = database.prepare(
+      "SELECT * FROM stories WHERE project_id = ? AND issue_id = ? ORDER BY priority, rowid"
+    ).all(context.projectId, context.issueId).map((story) => ({
+      id: String(story.id),
+      title: String(story.title),
+      description: String(story.description ?? ""),
+      acceptanceCriteria: JSON.parse(String(story.acceptance_criteria_json ?? "[]")),
+      priority: Number(story.priority),
+      passes: Number(story.passes) === 1,
+      notes: String(story.notes ?? ""),
+      ...story.duration_seconds === null ? {} : { durationSeconds: Number(story.duration_seconds) },
+      ...story.status === null ? {} : { status: String(story.status) },
+      ...story.stage === null ? {} : { stage: String(story.stage) },
+      ...story.stage_since === null ? {} : { stageSince: String(story.stage_since) },
+      ...story.stage_detail === null ? {} : { stageDetail: String(story.stage_detail) },
+      ...story.input_tokens === null ? {} : { inputTokens: Number(story.input_tokens) },
+      ...story.output_tokens === null ? {} : { outputTokens: Number(story.output_tokens) },
+      ...story.cache_read_tokens === null ? {} : { cacheReadTokens: Number(story.cache_read_tokens) },
+      ...story.cache_creation_tokens === null ? {} : { cacheCreationTokens: Number(story.cache_creation_tokens) },
+      ...dependencies.has(String(story.id)) ? { dependencies: dependencies.get(String(story.id)) } : {}
+    }));
+    const plan = {
+      project: String(row.project),
+      issueNumber: String(row.issue_number),
+      issueUrl: String(row.issue_url ?? ""),
+      branchName: String(row.branch_name ?? ""),
+      ...Number(row.no_branch) === 1 ? { noBranch: true } : {},
+      ...row.close_issue == null ? {} : { closeIssue: Number(row.close_issue) === 1 },
+      ...row.issue_closed_at == null ? {} : { issueClosedAt: String(row.issue_closed_at) },
+      description: String(row.description ?? ""),
+      issueStatus: String(row.issue_status),
+      completedAt: row.completed_at ?? null,
+      lastAttemptAt: row.last_attempt_at ?? null,
+      lastError: row.last_error_category === null ? null : {
+        category: String(row.last_error_category),
+        message: String(row.last_error_message),
+        at: String(row.last_error_at)
+      },
+      correctionCycle: Number(row.correction_cycle),
+      maxCorrectionCycles: Number(row.max_correction_cycles),
+      lastReviewFindings: row.last_review_findings ?? null,
+      pipeline: {
+        ...Number(row.analyze_completed) === 1 ? { analyzeCompleted: true } : {},
+        prdCompleted: Number(row.prd_completed) === 1,
+        jsonCompleted: Number(row.json_completed) === 1,
+        executionCompleted: Number(row.execution_completed) === 1,
+        reviewCompleted: Number(row.review_completed) === 1,
+        prCreated: Number(row.pr_created) === 1,
+        ...row.pr_review_completed === null ? {} : { prReviewCompleted: Number(row.pr_review_completed) === 1 }
+      },
+      ...row.run_status === null ? {} : {
+        runState: {
+          status: row.run_status,
+          currentPhase: row.run_phase ?? null,
+          attempt: Number(row.run_attempt ?? 0),
+          lastHeartbeatAt: row.run_heartbeat_at ?? null,
+          blockedReason: row.run_blocked_reason ?? null,
+          owner: row.run_owner_pid === null ? null : {
+            pid: Number(row.run_owner_pid),
+            host: String(row.run_owner_host),
+            startedAt: String(row.run_owner_started_at)
+          }
+        }
+      },
+      ...row.pr_number === null ? {} : {
+        pullRequest: {
+          number: Number(row.pr_number),
+          url: String(row.pr_url),
+          headBranch: String(row.pr_head_branch),
+          createdAt: String(row.pr_created_at)
+        }
+      },
+      ...row.pr_review_enabled === null ? {} : {
+        prReview: {
+          enabled: Number(row.pr_review_enabled) === 1,
+          ...row.pr_review_pull_request_number === null ? {} : { pullRequestNumber: Number(row.pr_review_pull_request_number) },
+          rounds: Number(row.pr_review_rounds ?? 0),
+          ...row.pr_review_recommendation === null ? {} : {
+            lastRecommendation: String(row.pr_review_recommendation)
+          },
+          ...row.pr_reviewed_at === null ? {} : { lastReviewedAt: String(row.pr_reviewed_at) }
+        }
+      },
+      userStories: stories
+    };
+    const executions = database.prepare(
+      "SELECT payload_json FROM executions WHERE project_id = ? AND issue_id = ? ORDER BY started_at, rowid"
+    ).all(context.projectId, context.issueId).map((execution) => JSON.parse(execution.payload_json));
+    return executions.length > 0 ? { ...plan, executions } : plan;
+  }, context.databaseOptions);
+}
+function writePlanRows(database, context, plan) {
+  const timestamp = plan.lastAttemptAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  database.prepare(
+    `INSERT INTO projects (id, root, remote_url, created_at, updated_at) VALUES (?, ?, NULL, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET root = excluded.root, updated_at = excluded.updated_at`
+  ).run(context.projectId, context.projectRoot, timestamp, timestamp);
+  database.prepare(
+    `INSERT INTO issues (project_id, id, title, status, branch_name, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(project_id, id) DO UPDATE SET title = excluded.title, status = excluded.status,
+       branch_name = excluded.branch_name, updated_at = excluded.updated_at`
+  ).run(
+    context.projectId,
+    context.issueId,
+    plan.description || null,
+    plan.issueStatus,
+    plan.branchName || null,
+    timestamp,
+    timestamp
+  );
+  database.prepare(
+    `INSERT INTO pipelines (project_id, issue_id, state_json, updated_at) VALUES (?, ?, ?, ?)
+       ON CONFLICT(project_id, issue_id) DO UPDATE SET state_json = excluded.state_json,
+       updated_at = excluded.updated_at`
+  ).run(context.projectId, context.issueId, "{}", timestamp);
+  database.prepare(
+    `UPDATE pipelines SET project = ?, issue_number = ?, issue_url = ?, branch_name = ?, no_branch = ?,
+       description = ?, issue_status = ?, completed_at = ?, last_attempt_at = ?, last_error_category = ?,
+       last_error_message = ?, last_error_at = ?, correction_cycle = ?, max_correction_cycles = ?,
+       last_review_findings = ?, analyze_completed = ?, prd_completed = ?, json_completed = ?,
+       execution_completed = ?, review_completed = ?, pr_created = ?, pr_review_completed = ?, run_status = ?,
+       run_phase = ?, run_attempt = ?, run_heartbeat_at = ?, run_blocked_reason = ?, run_owner_pid = ?,
+       run_owner_host = ?, run_owner_started_at = ?, pr_number = ?, pr_url = ?, pr_head_branch = ?,
+       pr_created_at = ?, pr_review_enabled = ?, pr_review_pull_request_number = ?, pr_review_rounds = ?,
+       pr_review_recommendation = ?, pr_reviewed_at = ?, close_issue = ?, issue_closed_at = ? WHERE project_id = ? AND issue_id = ?`
+  ).run(
+    plan.project,
+    String(plan.issueNumber),
+    plan.issueUrl,
+    plan.branchName,
+    plan.noBranch === true ? 1 : 0,
+    plan.description,
+    plan.issueStatus,
+    plan.completedAt,
+    plan.lastAttemptAt,
+    plan.lastError?.category ?? null,
+    plan.lastError?.message ?? null,
+    plan.lastError?.at ?? null,
+    plan.correctionCycle,
+    plan.maxCorrectionCycles,
+    plan.lastReviewFindings,
+    plan.pipeline.analyzeCompleted === true ? 1 : 0,
+    plan.pipeline.prdCompleted ? 1 : 0,
+    plan.pipeline.jsonCompleted ? 1 : 0,
+    plan.pipeline.executionCompleted ? 1 : 0,
+    plan.pipeline.reviewCompleted ? 1 : 0,
+    plan.pipeline.prCreated ? 1 : 0,
+    plan.pipeline.prReviewCompleted === void 0 ? null : plan.pipeline.prReviewCompleted ? 1 : 0,
+    plan.runState?.status ?? null,
+    plan.runState?.currentPhase ?? null,
+    plan.runState?.attempt ?? null,
+    plan.runState?.lastHeartbeatAt ?? null,
+    plan.runState?.blockedReason ?? null,
+    plan.runState?.owner?.pid ?? null,
+    plan.runState?.owner?.host ?? null,
+    plan.runState?.owner?.startedAt ?? null,
+    plan.pullRequest?.number ?? null,
+    plan.pullRequest?.url ?? null,
+    plan.pullRequest?.headBranch ?? null,
+    plan.pullRequest?.createdAt ?? null,
+    plan.prReview === void 0 ? null : plan.prReview.enabled ? 1 : 0,
+    plan.prReview?.pullRequestNumber ?? null,
+    plan.prReview?.rounds ?? null,
+    plan.prReview?.lastRecommendation ?? null,
+    plan.prReview?.lastReviewedAt ?? null,
+    plan.closeIssue === void 0 ? null : plan.closeIssue ? 1 : 0,
+    plan.issueClosedAt ?? null,
+    context.projectId,
+    context.issueId
+  );
+  database.prepare("DELETE FROM story_dependencies WHERE project_id = ? AND issue_id = ?").run(context.projectId, context.issueId);
+  database.prepare("DELETE FROM stories WHERE project_id = ? AND issue_id = ?").run(context.projectId, context.issueId);
+  for (const story of plan.userStories) {
+    database.prepare(
+      `INSERT INTO stories (project_id, issue_id, id, title, priority, passes, notes, story_number)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      context.projectId,
+      context.issueId,
+      story.id,
+      story.title,
+      story.priority,
+      story.passes ? 1 : 0,
+      story.notes,
+      storyNumber(story.id)
+    );
+    database.prepare(
+      `UPDATE stories SET description = ?, acceptance_criteria_json = ?, duration_seconds = ?, status = ?,
+         stage = ?, stage_since = ?, stage_detail = ?, input_tokens = ?, output_tokens = ?,
+         cache_read_tokens = ?, cache_creation_tokens = ? WHERE project_id = ? AND issue_id = ? AND id = ?`
+    ).run(
+      story.description,
+      JSON.stringify(story.acceptanceCriteria),
+      story.durationSeconds ?? null,
+      story.status ?? null,
+      story.stage ?? null,
+      story.stageSince ?? null,
+      story.stageDetail ?? null,
+      story.inputTokens ?? null,
+      story.outputTokens ?? null,
+      story.cacheReadTokens ?? null,
+      story.cacheCreationTokens ?? null,
+      context.projectId,
+      context.issueId,
+      story.id
+    );
+  }
+  for (const story of plan.userStories) {
+    for (const dependency of story.dependencies ?? []) {
+      database.prepare(
+        `INSERT INTO story_dependencies (project_id, issue_id, story_id, depends_on_story_id)
+           VALUES (?, ?, ?, ?)`
+      ).run(context.projectId, context.issueId, story.id, dependency);
+    }
+  }
+  if (plan.pullRequest !== void 0) {
+    const pullRequestId = `pr:${context.projectId}:${context.issueId}:${plan.pullRequest.number}`;
+    database.prepare(
+      `INSERT INTO pull_requests (id, project_id, issue_id, number, url, status, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET url = excluded.url, status = excluded.status`
+    ).run(
+      pullRequestId,
+      context.projectId,
+      context.issueId,
+      plan.pullRequest.number,
+      plan.pullRequest.url,
+      plan.pipeline.prCreated ? "created" : "pending",
+      plan.pullRequest.createdAt
+    );
+    if (plan.prReview?.lastReviewedAt !== void 0) {
+      database.prepare(
+        `INSERT INTO reviews (id, pull_request_id, status, created_at, payload_json)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET status = excluded.status, created_at = excluded.created_at,
+             payload_json = excluded.payload_json`
+      ).run(
+        `review:${pullRequestId}:${plan.prReview.rounds}`,
+        pullRequestId,
+        plan.prReview.lastRecommendation ?? "unknown",
+        plan.prReview.lastReviewedAt,
+        JSON.stringify(plan.prReview)
+      );
+    }
+  }
+}
+async function saveStoredPlan(context, plan) {
+  await withDatabase(
+    (database) => database.transaction(() => writePlanRows(database, context, plan)),
+    context.databaseOptions
+  );
+  await materializePlan(context);
+}
+async function materializePlan(context, plan) {
+  const projection = plan ?? await loadStoredPlan(context);
+  const content = `${JSON.stringify(projection, null, 2)}
+`;
+  await writeFileAtomic(context.tasksPath, content);
+  const sha256 = createHash("sha256").update(content).digest("hex");
+  await withDatabase(
+    (database) => database.prepare(
+      `INSERT INTO migrated_artifacts (source_path, sha256, migrated_at, table_counts_json)
+           VALUES (?, ?, ?, ?)
+           ON CONFLICT(source_path) DO UPDATE SET sha256 = excluded.sha256,
+             migrated_at = excluded.migrated_at, table_counts_json = excluded.table_counts_json`
+    ).run(context.tasksPath, sha256, (/* @__PURE__ */ new Date()).toISOString(), "{}"),
+    context.databaseOptions
+  );
+}
+async function saveStoredQueue(context, plan) {
+  await withDatabase(
+    (database) => database.transaction(() => {
+      ensureStoredProject(
+        database,
+        {
+          tasksPath: "",
+          projectId: context.projectId,
+          issueId: "",
+          projectRoot: context.projectRoot
+        },
+        plan.updatedAt
+      );
+      database.prepare(
+        `INSERT INTO queues (id, project_id, status, payload_json, created_at, updated_at,
+              requested_json, branch_name, no_branch, pr_review, truncated)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET status = excluded.status, payload_json = excluded.payload_json,
+               updated_at = excluded.updated_at, requested_json = excluded.requested_json,
+               branch_name = excluded.branch_name, no_branch = excluded.no_branch,
+               pr_review = excluded.pr_review, truncated = excluded.truncated`
+      ).run(
+        plan.id,
+        context.projectId,
+        plan.status,
+        JSON.stringify(plan),
+        plan.createdAt,
+        plan.updatedAt,
+        JSON.stringify(plan.requested),
+        plan.branchName,
+        plan.noBranch ? 1 : 0,
+        plan.prReview ? 1 : 0,
+        plan.truncated ? 1 : 0
+      );
+      database.prepare("DELETE FROM queue_dependencies WHERE queue_id = ?").run(plan.id);
+      database.prepare("DELETE FROM queue_issues WHERE queue_id = ?").run(plan.id);
+      for (const entry of plan.issues) {
+        database.prepare(
+          `INSERT INTO issues (project_id, id, title, status, branch_name, created_at, updated_at)
+               VALUES (?, ?, ?, ?, NULL, ?, ?)
+               ON CONFLICT(project_id, id) DO UPDATE SET title = excluded.title, status = excluded.status,
+                 updated_at = excluded.updated_at`
+        ).run(
+          context.projectId,
+          entry.id,
+          entry.title,
+          entry.status,
+          plan.createdAt,
+          plan.updatedAt
+        );
+        database.prepare(
+          `INSERT INTO queue_issues (queue_id, project_id, issue_id, position, status, number, title, url,
+                source, origin, role, priority, heuristic, failed_phase, last_error_category,
+                last_error_message, last_error_at, attempts, blocked_reason, started_at, completed_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          plan.id,
+          context.projectId,
+          entry.id,
+          entry.position,
+          entry.status,
+          entry.number,
+          entry.title,
+          entry.url,
+          entry.source,
+          entry.origin,
+          entry.role,
+          entry.priority,
+          entry.heuristic ? 1 : 0,
+          entry.failedPhase,
+          entry.lastError?.category ?? null,
+          entry.lastError?.message ?? null,
+          entry.lastError?.at ?? null,
+          entry.attempts,
+          entry.blockedReason,
+          entry.startedAt,
+          entry.completedAt
+        );
+        for (const dependency of entry.dependsOn) {
+          database.prepare(
+            "INSERT INTO queue_dependencies (queue_id, issue_id, depends_on_issue_id) VALUES (?, ?, ?)"
+          ).run(plan.id, entry.id, dependency);
+        }
+      }
+    }),
+    context.databaseOptions
+  );
+  await mkdir(dirname2(context.planFile), { recursive: true });
+  await writeFileAtomic(context.planFile, `${JSON.stringify(plan, null, 2)}
+`);
+}
+async function loadStoredQueue(context) {
+  return withDatabase((database) => {
+    const row = database.prepare("SELECT payload_json FROM queues WHERE id = ? AND project_id = ?").get(
+      context.planFile === "" ? "" : basename(dirname2(context.planFile)),
+      context.projectId
+    );
+    return row === void 0 ? null : JSON.parse(row.payload_json);
+  }, context.databaseOptions);
+}
+async function ingestAgentPlan(context, baseline) {
+  const submitted = parsePlan(await readFile(context.tasksPath, "utf-8"), context.tasksPath);
+  await withDatabase(
+    (database) => database.transaction(() => {
+      for (const story of submitted.userStories) {
+        database.prepare(
+          "UPDATE stories SET passes = ?, notes = ? WHERE project_id = ? AND issue_id = ? AND id = ?"
+        ).run(story.passes ? 1 : 0, story.notes, context.projectId, context.issueId, story.id);
+      }
+      if (baseline !== void 0) {
+        if (submitted.lastReviewFindings === null) {
+          database.prepare(
+            "UPDATE pipelines SET last_review_findings = NULL WHERE project_id = ? AND issue_id = ? AND last_review_findings IS ?"
+          ).run(context.projectId, context.issueId, baseline.lastReviewFindings);
+        }
+        database.prepare(
+          `UPDATE pipelines SET last_error_category = ?, last_error_message = ?, last_error_at = ?
+         WHERE project_id = ? AND issue_id = ? AND last_error_category IS ? AND last_error_message IS ? AND last_error_at IS ?`
+        ).run(
+          submitted.lastError?.category ?? null,
+          submitted.lastError?.message ?? null,
+          submitted.lastError?.at ?? null,
+          context.projectId,
+          context.issueId,
+          baseline.lastError?.category ?? null,
+          baseline.lastError?.message ?? null,
+          baseline.lastError?.at ?? null
+        );
+      }
+    }),
+    context.databaseOptions
+  );
+  const merged = await loadStoredPlan(context);
+  await materializePlan(context, merged);
+  return merged;
+}
+async function ingestGeneratedPlan(context) {
+  const plan = parsePlan(await readFile(context.tasksPath, "utf-8"), context.tasksPath);
+  const current = await loadStoredPlan(context).catch((error) => {
+    if (error instanceof Error && error.message.startsWith("No SQLite task plan exists"))
+      return null;
+    throw error;
+  });
+  delete plan.closeIssue;
+  delete plan.issueClosedAt;
+  if (current?.closeIssue !== void 0) plan.closeIssue = current.closeIssue;
+  if (current?.issueClosedAt !== void 0) plan.issueClosedAt = current.issueClosedAt;
+  await saveStoredPlan(context, plan);
+  return plan;
+}
+function executionColumns(record) {
+  const cost = record.cost;
+  return {
+    status: String(record.status),
+    startedAt: String(record.startedAt),
+    finishedAt: record.finishedAt ?? null,
+    durationMs: record.durationMs ?? null,
+    costStatus: cost?.status ?? "unknown",
+    costAmount: cost?.status === "unknown" ? null : cost?.amount ?? null
+  };
+}
+async function saveExecution(context, execution) {
+  await withDatabase(
+    (database) => database.transaction(() => {
+      const columns = executionColumns(execution);
+      const agent = execution.agent;
+      const model = agent?.model;
+      const usage = execution.usage;
+      const runId = execution.sessionId ?? execution.id;
+      const phaseId = `phase:${runId}:${String(execution.purpose ?? "unknown")}`;
+      ensureStoredProject(database, context, columns.startedAt);
+      ensureStoredIssue(database, context, columns.startedAt);
+      database.prepare(
+        `INSERT INTO runs (id, project_id, issue_id, status, started_at, finished_at, session_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET status = excluded.status, finished_at = excluded.finished_at`
+      ).run(
+        runId,
+        context.projectId,
+        context.issueId,
+        columns.status,
+        columns.startedAt,
+        columns.finishedAt,
+        execution.sessionId ?? null
+      );
+      database.prepare(
+        `INSERT INTO phases
+         (id, run_id, name, status, started_at, finished_at, duration_ms, input_tokens, output_tokens,
+          cache_read_tokens, cache_creation_tokens, cost_status, cost_amount)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET status = excluded.status, finished_at = excluded.finished_at,
+           duration_ms = excluded.duration_ms, input_tokens = excluded.input_tokens,
+           output_tokens = excluded.output_tokens, cache_read_tokens = excluded.cache_read_tokens,
+           cache_creation_tokens = excluded.cache_creation_tokens, cost_status = excluded.cost_status,
+           cost_amount = excluded.cost_amount`
+      ).run(
+        phaseId,
+        runId,
+        String(execution.purpose ?? "unknown"),
+        columns.status,
+        columns.startedAt,
+        columns.finishedAt,
+        columns.durationMs,
+        usage?.inputTokens ?? null,
+        usage?.outputTokens ?? null,
+        usage?.cacheReadTokens ?? null,
+        usage?.cacheCreationTokens ?? null,
+        columns.costStatus,
+        columns.costAmount
+      );
+      database.prepare(
+        `INSERT INTO executions
+         (id, project_id, issue_id, run_id, phase_id, status, started_at, finished_at, duration_ms, cost_status, cost_amount, payload_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET status = excluded.status, finished_at = excluded.finished_at,
+         duration_ms = excluded.duration_ms, cost_status = excluded.cost_status, cost_amount = excluded.cost_amount,
+         payload_json = excluded.payload_json`
+      ).run(
+        execution.id,
+        context.projectId,
+        context.issueId,
+        runId,
+        phaseId,
+        columns.status,
+        columns.startedAt,
+        columns.finishedAt,
+        columns.durationMs,
+        columns.costStatus,
+        columns.costAmount,
+        JSON.stringify(execution)
+      );
+      database.prepare(
+        `UPDATE executions SET session_id = ?, purpose = ?, attempt = ?, trigger = ?, trigger_reason = ?,
+         input_tokens = ?, output_tokens = ?, cache_read_tokens = ?, cache_creation_tokens = ?, reasoning_tokens = ?,
+         harness = ?, provider = ?, model_requested = ?, model_resolved = ? WHERE id = ?`
+      ).run(
+        execution.sessionId ?? null,
+        execution.purpose ?? null,
+        execution.attempt ?? null,
+        execution.trigger ?? null,
+        execution.triggerReason ?? null,
+        usage?.inputTokens ?? null,
+        usage?.outputTokens ?? null,
+        usage?.cacheReadTokens ?? null,
+        usage?.cacheCreationTokens ?? null,
+        usage?.reasoningTokens ?? null,
+        agent?.harness ?? null,
+        agent?.provider ?? null,
+        model?.requested ?? null,
+        model?.resolved ?? null,
+        execution.id
+      );
+      applyStoredRetention(database, context.projectId, context.retention);
+    }),
+    context.databaseOptions
+  );
+  if (context.projectId.startsWith("projection-") && !agentProjectionWindows.has(context.tasksPath)) {
+    await materializePlan(context);
+  }
+}
+async function readStoredProvidersHealth(context) {
+  return withDatabase((database) => {
+    const providers = Object.fromEntries(
+      database.prepare("SELECT provider, payload_json FROM provider_health WHERE project_id = ?").all(context.projectId).map((row) => [row.provider, JSON.parse(row.payload_json)])
+    );
+    return { schemaVersion: 1, providers };
+  }, context.databaseOptions);
+}
+async function updateStoredProviderHealth(context, provider, update) {
+  return withDatabase(
+    (database) => database.transaction(() => {
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      ensureStoredProject(database, context, updatedAt);
+      const previous = database.prepare("SELECT payload_json FROM provider_health WHERE project_id = ? AND provider = ?").get(context.projectId, provider);
+      const current = previous === void 0 ? {
+        status: "healthy",
+        failures: [],
+        consecutiveFailures: 0,
+        cooldownLevel: 0,
+        cooldownUntil: null,
+        lastFailureKind: null,
+        lastFailureAt: null,
+        lastSuccessAt: null,
+        probeInFlight: false,
+        probeStartedAt: null
+      } : JSON.parse(previous.payload_json);
+      const next = update(current);
+      database.prepare(
+        `INSERT INTO provider_health
+           (project_id, provider, payload_json, updated_at, status, consecutive_failures, cooldown_level,
+            cooldown_until, last_failure_kind, last_failure_at, last_success_at, probe_in_flight, probe_started_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(project_id, provider) DO UPDATE SET payload_json = excluded.payload_json,
+             updated_at = excluded.updated_at, status = excluded.status,
+             consecutive_failures = excluded.consecutive_failures, cooldown_level = excluded.cooldown_level,
+             cooldown_until = excluded.cooldown_until, last_failure_kind = excluded.last_failure_kind,
+             last_failure_at = excluded.last_failure_at, last_success_at = excluded.last_success_at,
+             probe_in_flight = excluded.probe_in_flight, probe_started_at = excluded.probe_started_at`
+      ).run(
+        context.projectId,
+        provider,
+        JSON.stringify(next),
+        updatedAt,
+        next.status,
+        next.consecutiveFailures,
+        next.cooldownLevel,
+        next.cooldownUntil,
+        next.lastFailureKind,
+        next.lastFailureAt,
+        next.lastSuccessAt,
+        next.probeInFlight ? 1 : 0,
+        next.probeStartedAt
+      );
+      database.prepare("DELETE FROM provider_health_failures WHERE project_id = ? AND provider = ?").run(context.projectId, provider);
+      for (const failure of next.failures) {
+        database.prepare(
+          `INSERT INTO provider_health_failures (project_id, provider, occurred_at, kind)
+             VALUES (?, ?, ?, ?)`
+        ).run(context.projectId, provider, failure.at, failure.kind);
+      }
+      return next;
+    }),
+    context.databaseOptions
+  );
+}
+async function saveStoredVerification(context, evidence) {
+  await withDatabase((database) => {
+    database.transaction(() => {
+      const createdAt = String(evidence.at ?? (/* @__PURE__ */ new Date()).toISOString());
+      ensureStoredProject(database, context, createdAt);
+      ensureStoredIssue(database, context, createdAt);
+      database.prepare(
+        `INSERT INTO verifications (id, project_id, issue_id, status, created_at, payload_json)
+           VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(
+        randomUUID(),
+        context.projectId,
+        context.issueId,
+        String(evidence.verdict ?? "unknown"),
+        createdAt,
+        JSON.stringify(evidence)
+      );
+    });
+  }, context.databaseOptions);
+}
+async function loadStoredLastBranch(context) {
+  return withDatabase((database) => {
+    const row = database.prepare(
+      `SELECT payload_json FROM audit_log WHERE project_id = ? AND action = ?
+         ORDER BY occurred_at DESC, rowid DESC LIMIT 1`
+    ).get(context.projectId, `last_branch:${context.issueId}`);
+    if (row === void 0) return null;
+    const payload = JSON.parse(row.payload_json);
+    return typeof payload.branch === "string" && payload.branch !== "" ? payload.branch : null;
+  }, context.databaseOptions);
+}
+async function saveStoredLastBranch(context, branch) {
+  await withDatabase((database) => {
+    database.transaction(() => {
+      const occurredAt = (/* @__PURE__ */ new Date()).toISOString();
+      ensureStoredProject(database, context, occurredAt);
+      database.prepare(
+        `INSERT INTO audit_log (id, project_id, occurred_at, action, payload_json)
+           VALUES (?, ?, ?, ?, ?)`
+      ).run(
+        randomUUID(),
+        context.projectId,
+        occurredAt,
+        `last_branch:${context.issueId}`,
+        JSON.stringify({ branch })
+      );
+    });
+  }, context.databaseOptions);
+}
+async function saveStoredUserStoryNumbering(context, decision) {
+  await withDatabase((database) => {
+    database.transaction(() => {
+      ensureStoredProject(database, { ...context, tasksPath: "", issueId: "" }, decision.decidedAt);
+      database.prepare(
+        `INSERT INTO user_story_numbering (project_id, next_number, source, issue_id, decided_at, detail)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(project_id) DO UPDATE SET next_number = excluded.next_number,
+             source = excluded.source, issue_id = excluded.issue_id, decided_at = excluded.decided_at,
+             detail = excluded.detail`
+      ).run(
+        context.projectId,
+        decision.nextNumber,
+        decision.source,
+        decision.issueNumber,
+        decision.decidedAt,
+        decision.detail ?? null
+      );
+    });
+  }, context.databaseOptions);
+}
+async function saveSessionEvent(context, input) {
+  await withDatabase(
+    (database) => database.transaction(() => {
+      const updatedAt = input.snapshot.updatedAt ?? input.event.at;
+      const startedAt = input.snapshot.startedAt ?? input.event.at;
+      database.prepare(
+        `INSERT INTO projects (id, root, remote_url, created_at, updated_at) VALUES (?, ?, NULL, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET root = excluded.root, updated_at = excluded.updated_at`
+      ).run(context.projectId, context.projectRoot, startedAt, updatedAt);
+      database.prepare(
+        `INSERT INTO issues (project_id, id, title, status, branch_name, created_at, updated_at)
+             VALUES (?, ?, NULL, ?, NULL, ?, ?)
+             ON CONFLICT(project_id, id) DO UPDATE SET updated_at = excluded.updated_at`
+      ).run(context.projectId, context.issueId, "in_progress", startedAt, updatedAt);
+      database.prepare(
+        `INSERT INTO runs (id, project_id, issue_id, status, started_at, finished_at, session_id, heartbeat_at, pid, host)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET status = excluded.status, finished_at = excluded.finished_at,
+             heartbeat_at = excluded.heartbeat_at, pid = excluded.pid, host = excluded.host`
+      ).run(
+        input.sessionId,
+        context.projectId,
+        context.issueId,
+        input.snapshot.status,
+        startedAt,
+        input.snapshot.endedAt,
+        input.sessionId,
+        updatedAt,
+        process.pid,
+        process.env.HOSTNAME ?? null
+      );
+      database.prepare(
+        `INSERT INTO events (id, project_id, run_id, occurred_at, kind, payload_json, session_id, sequence)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        randomUUID(),
+        context.projectId,
+        input.sessionId,
+        input.event.at,
+        input.event.type,
+        JSON.stringify(input.event),
+        input.sessionId,
+        input.sequence
+      );
+      database.prepare(
+        `INSERT INTO snapshots (id, project_id, run_id, created_at, payload_json, issue_id, session_id, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        randomUUID(),
+        context.projectId,
+        input.sessionId,
+        updatedAt,
+        JSON.stringify(input.snapshot),
+        context.issueId,
+        input.sessionId,
+        updatedAt
+      );
+      applyStoredRetention(database, context.projectId, context.retention);
+    }),
+    context.databaseOptions
+  );
+}
+async function listStoredSessions(input) {
+  return withDatabase((database) => {
+    return database.prepare(
+      `SELECT project_id, issue_id, session_id, payload_json, updated_at FROM snapshots AS current
+         WHERE current.session_id IS NOT NULL AND current.updated_at >= ?
+         AND current.id = (
+           SELECT newer.id FROM snapshots AS newer
+           WHERE newer.project_id = current.project_id AND newer.session_id = current.session_id
+           ORDER BY newer.updated_at DESC, newer.rowid DESC LIMIT 1
+         )
+         ORDER BY current.updated_at DESC, current.rowid DESC`
+    ).all(input.activeSince).map((row) => ({
+      projectId: row.project_id,
+      issueId: row.issue_id,
+      sessionId: row.session_id,
+      snapshot: JSON.parse(row.payload_json),
+      updatedAt: row.updated_at
+    }));
+  }, input.databaseOptions);
+}
+async function listStoredRunSnapshots(input = {}) {
+  return withDatabase((database) => {
+    return database.prepare(
+      `SELECT run.project_id, run.issue_id, run.session_id, snapshot.payload_json, snapshot.updated_at
+         FROM runs AS run
+         JOIN snapshots AS snapshot ON snapshot.id = (
+           SELECT latest.id FROM snapshots AS latest
+           WHERE latest.run_id = run.id ORDER BY latest.updated_at DESC, latest.rowid DESC LIMIT 1
+         )
+         WHERE run.session_id IS NOT NULL`
+    ).all().map((row) => ({
+      projectId: row.project_id,
+      issueId: row.issue_id,
+      sessionId: row.session_id,
+      snapshot: JSON.parse(row.payload_json),
+      updatedAt: row.updated_at
+    }));
+  }, input.databaseOptions);
+}
+async function listStoredSessionEvents(input) {
+  return withDatabase(
+    (database) => database.prepare(
+      `SELECT sequence, payload_json FROM events
+         WHERE project_id = ? AND session_id = ? ORDER BY sequence, rowid`
+    ).all(input.projectId, input.sessionId).map((row) => ({ seq: row.sequence, event: JSON.parse(row.payload_json) })),
+    input.databaseOptions
+  );
+}
+async function touchStoredSession(context, sessionId, updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  await withDatabase((database) => {
+    database.transaction(() => {
+      database.prepare("UPDATE runs SET heartbeat_at = ? WHERE id = ? AND project_id = ?").run(updatedAt, sessionId, context.projectId);
+      const latest = database.prepare(
+        `SELECT id FROM snapshots WHERE project_id = ? AND session_id = ?
+           ORDER BY updated_at DESC, rowid DESC LIMIT 1`
+      ).get(context.projectId, sessionId);
+      if (latest !== void 0) {
+        database.prepare("UPDATE snapshots SET updated_at = ? WHERE id = ?").run(updatedAt, latest.id);
+      }
+    });
+  }, context.databaseOptions);
+}
+async function loadExecution(context, id) {
+  return withDatabase((database) => {
+    const row = database.prepare(
+      "SELECT payload_json FROM executions WHERE id = ? AND project_id = ? AND issue_id = ?"
+    ).get(id, context.projectId, context.issueId);
+    return row === void 0 ? null : JSON.parse(row.payload_json);
+  });
+}
+async function listStoredExecutions(input) {
+  return withDatabase((database) => {
+    const clauses = ["project_id = ?"];
+    const values = [input.projectId];
+    if (input.issueId !== void 0) {
+      clauses.push("issue_id = ?");
+      values.push(input.issueId);
+    }
+    if (input.since !== void 0) {
+      clauses.push("started_at >= ?");
+      values.push(input.since);
+    }
+    return database.prepare(
+      `SELECT payload_json FROM executions WHERE ${clauses.join(" AND ")} ORDER BY started_at, rowid`
+    ).all(...values).map((row) => JSON.parse(row.payload_json));
+  }, input.databaseOptions ?? databaseOptionsForProject(input.projectId));
+}
+async function findHighestStoredUserStoryNumber(input) {
+  return withDatabase((database) => {
+    const statement = input.excludeIssueId === void 0 ? "SELECT issue_id, id, story_number FROM stories WHERE project_id = ? AND story_number IS NOT NULL ORDER BY story_number DESC LIMIT 1" : "SELECT issue_id, id, story_number FROM stories WHERE project_id = ? AND issue_id <> ? AND story_number IS NOT NULL ORDER BY story_number DESC LIMIT 1";
+    const row = database.prepare(statement).get(
+      input.projectId,
+      ...input.excludeIssueId === void 0 ? [] : [input.excludeIssueId]
+    );
+    return row === void 0 ? null : { number: row.story_number, issueId: row.issue_id, storyId: row.id };
+  }, input.databaseOptions ?? databaseOptionsForProject(input.projectId));
+}
+async function exportStoredState(options = {}) {
+  return withDatabase((database) => {
+    const tables = [
+      "projects",
+      "issues",
+      "pipelines",
+      "stories",
+      "story_dependencies",
+      "runs",
+      "phases",
+      "executions",
+      "events",
+      "snapshots",
+      "pull_requests",
+      "reviews",
+      "verifications",
+      "provider_health",
+      "queues",
+      "queue_issues",
+      "queue_dependencies",
+      "user_story_numbering",
+      "provider_health_failures",
+      "migrated_artifacts",
+      "audit_log"
+    ];
+    return Object.fromEntries(
+      tables.map((table) => [table, database.prepare(`SELECT * FROM ${table}`).all()])
+    );
+  }, options);
+}
+
+export {
+  openDatabase,
+  CURRENT_SCHEMA_VERSION,
+  getDatabasePath,
+  registerProjectDatabaseOptions,
+  databaseOptionsForProject,
+  resetProjectDatabaseOptions,
+  openIssueFlowDatabase,
+  registerPlanRepository,
+  getPlanRepository,
+  registerQueueRepository,
+  getQueueRepository,
+  registerStorageProjections,
+  getProviderHealthRepository,
+  getVerificationRepository,
+  getLastBranchRepository,
+  ensurePlanRepository,
+  resetPlanRepositories,
+  setAgentProjectionWindow,
+  loadStoredPlan,
+  writePlanRows,
+  saveStoredPlan,
+  materializePlan,
+  saveStoredQueue,
+  loadStoredQueue,
+  ingestAgentPlan,
+  ingestGeneratedPlan,
+  saveExecution,
+  readStoredProvidersHealth,
+  updateStoredProviderHealth,
+  saveStoredVerification,
+  loadStoredLastBranch,
+  saveStoredLastBranch,
+  saveStoredUserStoryNumbering,
+  saveSessionEvent,
+  listStoredSessions,
+  listStoredRunSnapshots,
+  listStoredSessionEvents,
+  touchStoredSession,
+  loadExecution,
+  listStoredExecutions,
+  findHighestStoredUserStoryNumber,
+  exportStoredState
+};
+//# sourceMappingURL=chunk-7MJGYPHF.js.map