@h-rig/server 0.0.6-alpha.0

package/dist/src/inspector/analysis.js

@@ -0,0 +1,41 @@
+// @bun
+// packages/server/src/inspector/analysis.ts
+function summarizeInspectorJournal(options) {
+  const now = options.now ?? (() => new Date().toISOString());
+  const counts = options.journal.getCounts();
+  const activeRuns = options.journal.listActiveRuns();
+  const recentFindings = options.journal.listRecentFindings({ limit: 50 });
+  const severityCounts = recentFindings.reduce((acc, finding) => {
+    acc[finding.severity] = (acc[finding.severity] ?? 0) + 1;
+    return acc;
+  }, {});
+  const conflictCount = activeRuns.filter((run) => run.conflictState !== "none").length;
+  const summary = `Inspector journal summary: observations=${counts.observations}, decisions=${counts.decisions}, ` + `actions=${counts.actions}, followups=${counts.followups}, activeRuns=${activeRuns.length}, conflicts=${conflictCount}`;
+  options.journal.appendAnalysisReport({
+    id: options.reportId,
+    dedupeKey: `${options.reportType}:${options.reportId}`,
+    reportType: options.reportType,
+    status: "completed",
+    summary,
+    details: {
+      ...counts,
+      activeRuns: activeRuns.length,
+      conflictCount,
+      severityCounts
+    },
+    createdAt: now()
+  });
+  return {
+    status: "completed",
+    summary,
+    details: {
+      ...counts,
+      activeRuns: activeRuns.length,
+      conflictCount,
+      severityCounts
+    }
+  };
+}
+export {
+  summarizeInspectorJournal
+};

package/dist/src/inspector/discovery.js

@@ -0,0 +1,137 @@
+// @bun
+// packages/server/src/inspector/discovery.ts
+import {
+  runStatus
+} from "@rig/runtime/control-plane/native/run-ops";
+import {
+  listAuthorityRuns,
+  readAuthorityRun
+} from "@rig/runtime/control-plane/authority-files";
+function providerFromRuntimeAdapter(runtimeAdapter) {
+  if (!runtimeAdapter) {
+    return null;
+  }
+  return runtimeAdapter;
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function preferString(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0) ?? null;
+}
+function chooseStatus(surfaces) {
+  const authority = surfaces.find((surface) => surface.source === "authority-record");
+  if (authority?.status) {
+    return authority.status;
+  }
+  return preferString(...surfaces.map((surface) => surface.status)) ?? "unknown";
+}
+function chooseUpdatedAt(surfaces) {
+  const timestamps = uniqueStrings(surfaces.map((surface) => surface.updatedAt)).sort();
+  return timestamps.at(-1) ?? "";
+}
+function buildConflict(surfaces) {
+  const statuses = uniqueStrings(surfaces.map((surface) => surface.status));
+  const titles = uniqueStrings(surfaces.map((surface) => surface.title));
+  const activeSurface = surfaces.find((surface) => new Set(["preparing", "running", "validating", "reviewing"]).has(surface.status));
+  const authoritySurface = surfaces.find((surface) => surface.source === "authority-record");
+  if (activeSurface && authoritySurface && new Set(["failed", "stopped", "completed", "done"]).has(authoritySurface.status)) {
+    return {
+      state: "stale-active",
+      summary: `Run ${authoritySurface.runId} is still reported active by ${activeSurface.source} but authority says ${authoritySurface.status}.`
+    };
+  }
+  if (statuses.length > 1 || titles.length > 1) {
+    const sourceSummary = surfaces.map((surface) => `${surface.source}:${surface.status}:${surface.title}`).join(" | ");
+    return {
+      state: "source-disagreement",
+      summary: `Conflicting run surfaces for ${surfaces[0]?.runId ?? "unknown"}: ${sourceSummary}`
+    };
+  }
+  return { state: "none", summary: null };
+}
+function mergeRunSurfaces(surfaces) {
+  const authority = surfaces.find((surface) => surface.source === "authority-record") ?? null;
+  const conflict = buildConflict(surfaces);
+  return {
+    runId: surfaces[0].runId,
+    workspaceId: preferString(authority?.workspaceId, ...surfaces.map((surface) => surface.workspaceId)),
+    taskId: preferString(authority?.taskId, ...surfaces.map((surface) => surface.taskId)),
+    provider: preferString(authority?.provider, ...surfaces.map((surface) => surface.provider)),
+    runtimeAdapter: preferString(authority?.runtimeAdapter, ...surfaces.map((surface) => surface.runtimeAdapter)),
+    threadId: preferString(authority?.threadId, ...surfaces.map((surface) => surface.threadId)),
+    status: chooseStatus(surfaces),
+    title: preferString(authority?.title, ...surfaces.map((surface) => surface.title)) ?? surfaces[0].runId,
+    source: authority?.source ?? surfaces[0].source,
+    rawSourceKinds: uniqueStrings(surfaces.map((surface) => surface.source)),
+    conflictState: conflict.state,
+    conflictSummary: conflict.summary,
+    worktreePath: preferString(authority?.worktreePath, ...surfaces.map((surface) => surface.worktreePath)),
+    artifactRoot: preferString(authority?.artifactRoot, ...surfaces.map((surface) => surface.artifactRoot)),
+    logRoot: preferString(authority?.logRoot, ...surfaces.map((surface) => surface.logRoot)),
+    sessionPath: preferString(authority?.sessionPath, ...surfaces.map((surface) => surface.sessionPath)),
+    sessionLogPath: preferString(authority?.sessionLogPath, ...surfaces.map((surface) => surface.sessionLogPath)),
+    startedAt: preferString(authority?.startedAt, ...surfaces.map((surface) => surface.startedAt)),
+    updatedAt: chooseUpdatedAt(surfaces),
+    completedAt: preferString(authority?.completedAt, ...surfaces.map((surface) => surface.completedAt))
+  };
+}
+function discoverInspectorRuns(options) {
+  const summary = options.statusSummary ?? runStatus(options.projectRoot);
+  const discovered = new Map;
+  const pushSurface = (surface) => {
+    const existing = discovered.get(surface.runId) ?? [];
+    existing.push(surface);
+    discovered.set(surface.runId, existing);
+  };
+  for (const authorityEntry of listAuthorityRuns(options.projectRoot)) {
+    const run = readAuthorityRun(options.projectRoot, authorityEntry.runId);
+    if (!run) {
+      continue;
+    }
+    pushSurface({
+      runId: run.runId,
+      workspaceId: run.workspaceId ?? null,
+      taskId: run.taskId ?? null,
+      provider: providerFromRuntimeAdapter(run.runtimeAdapter ?? null),
+      runtimeAdapter: run.runtimeAdapter ?? null,
+      threadId: run.threadId ?? null,
+      status: run.status ?? "unknown",
+      title: run.title ?? run.taskId ?? run.runId,
+      source: "authority-record",
+      worktreePath: run.worktreePath ?? null,
+      artifactRoot: run.artifactRoot ?? null,
+      logRoot: run.logRoot ?? null,
+      sessionPath: run.sessionPath ?? null,
+      sessionLogPath: run.sessionLogPath ?? null,
+      startedAt: run.startedAt ?? null,
+      updatedAt: run.updatedAt,
+      completedAt: run.completedAt ?? null
+    });
+  }
+  for (const entry of [...summary.activeRuns, ...summary.recentRuns]) {
+    pushSurface({
+      runId: entry.runId,
+      workspaceId: null,
+      taskId: entry.taskId ?? null,
+      provider: null,
+      runtimeAdapter: null,
+      threadId: null,
+      status: entry.status,
+      title: entry.title,
+      source: "run-status",
+      worktreePath: null,
+      artifactRoot: null,
+      logRoot: null,
+      sessionPath: null,
+      sessionLogPath: null,
+      startedAt: null,
+      updatedAt: "",
+      completedAt: null
+    });
+  }
+  return [...discovered.values()].map((surfaces) => mergeRunSurfaces(surfaces)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+export {
+  discoverInspectorRuns
+};

package/dist/src/inspector/journal.js

@@ -0,0 +1,518 @@
+// @bun
+// packages/server/src/inspector/journal.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+
+// packages/server/src/bootstrap.ts
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { RIG_DEFINITION_DIRNAME, resolveMonorepoRoot } from "@rig/runtime";
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveRigServerPaths(projectRoot) {
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  const explicitStateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  const explicitLogsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  const explicitSessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  const hostStateRoot = resolve(projectRoot, ".rig");
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const monorepoStateRoot = resolve(monorepoRoot, ".rig");
+  const stateRoot = taskWorkspace ? resolve(taskWorkspace, ".rig") : explicitStateDir ? dirname(resolve(explicitStateDir)) : explicitLogsDir ? dirname(resolve(explicitLogsDir)) : explicitSessionFile ? dirname(dirname(resolve(explicitSessionFile))) : existsSync(hostStateRoot) ? hostStateRoot : monorepoStateRoot;
+  const stateDir = explicitStateDir ? resolve(explicitStateDir) : resolve(stateRoot, "state");
+  const logsDir = explicitLogsDir ? resolve(explicitLogsDir) : resolve(stateRoot, "logs");
+  const taskConfigPath = taskWorkspace ? resolve(taskWorkspace, ".rig", "task-config.json") : existsSync(resolve(projectRoot, ".rig", "task-config.json")) ? resolve(projectRoot, ".rig", "task-config.json") : resolve(monorepoStateRoot, "task-config.json");
+  return {
+    stateRoot,
+    stateDir,
+    logsDir,
+    controlPlaneEventsFile: resolve(logsDir, "control-plane.events.jsonl"),
+    taskConfigPath,
+    notificationsFile: resolve(projectRoot, "rig", "notifications", "targets.json"),
+    keybindingsPath: resolve(projectRoot, "rig", "keybindings.json")
+  };
+}
+
+// packages/server/src/inspector/journal.ts
+var SCHEMA = [
+  `CREATE TABLE IF NOT EXISTS inspector_runs (
+    run_id TEXT PRIMARY KEY,
+    workspace_id TEXT,
+    task_id TEXT,
+    runtime_adapter TEXT,
+    provider TEXT,
+    status TEXT NOT NULL,
+    conflict_state TEXT NOT NULL DEFAULT 'none',
+    conflict_summary TEXT,
+    source TEXT,
+    title TEXT,
+    started_at TEXT,
+    updated_at TEXT NOT NULL,
+    completed_at TEXT
+  )`,
+  `CREATE TABLE IF NOT EXISTS inspector_observations (
+    id TEXT PRIMARY KEY,
+    run_id TEXT,
+    dedupe_key TEXT,
+    kind TEXT NOT NULL,
+    severity TEXT NOT NULL,
+    source TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    details_json TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS inspector_decisions (
+    id TEXT PRIMARY KEY,
+    run_id TEXT,
+    dedupe_key TEXT,
+    decision_type TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    rationale TEXT NOT NULL,
+    details_json TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS inspector_actions (
+    id TEXT PRIMARY KEY,
+    run_id TEXT,
+    dedupe_key TEXT,
+    action_type TEXT NOT NULL,
+    status TEXT NOT NULL,
+    target TEXT,
+    input_json TEXT,
+    result_json TEXT,
+    started_at TEXT NOT NULL,
+    completed_at TEXT
+  )`,
+  `CREATE TABLE IF NOT EXISTS inspector_reviews (
+    id TEXT PRIMARY KEY,
+    run_id TEXT,
+    dedupe_key TEXT,
+    reviewer_type TEXT NOT NULL,
+    status TEXT NOT NULL,
+    findings_json TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS inspector_followups (
+    id TEXT PRIMARY KEY,
+    origin_run_id TEXT,
+    dedupe_key TEXT,
+    task_id TEXT,
+    kind TEXT NOT NULL,
+    status TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    details_json TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS upstream_sync_scans (
+    id TEXT PRIMARY KEY,
+    dedupe_key TEXT,
+    started_at TEXT NOT NULL,
+    completed_at TEXT,
+    status TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    details_json TEXT
+  )`,
+  `CREATE TABLE IF NOT EXISTS analysis_reports (
+    id TEXT PRIMARY KEY,
+    dedupe_key TEXT,
+    report_type TEXT NOT NULL,
+    status TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    details_json TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_inspector_observations_dedupe
+    ON inspector_observations(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_inspector_decisions_dedupe
+    ON inspector_decisions(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_inspector_actions_dedupe
+    ON inspector_actions(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_inspector_reviews_dedupe
+    ON inspector_reviews(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_inspector_followups_dedupe
+    ON inspector_followups(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_upstream_sync_scans_dedupe
+    ON upstream_sync_scans(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_analysis_reports_dedupe
+    ON analysis_reports(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  `CREATE INDEX IF NOT EXISTS idx_inspector_runs_status_updated
+    ON inspector_runs(status, updated_at DESC)`,
+  `CREATE INDEX IF NOT EXISTS idx_inspector_observations_run_created
+    ON inspector_observations(run_id, created_at DESC)`
+];
+function jsonText(value) {
+  return value == null ? null : JSON.stringify(value);
+}
+function parseJsonRecord(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  return JSON.parse(value);
+}
+function normalizeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function safeWrite(sqlite, record, fn) {
+  try {
+    fn();
+    const row = sqlite.prepare("SELECT changes() AS count").get();
+    return { ok: true, record, changed: Number(row?.count ?? 0) > 0 };
+  } catch (error) {
+    return { ok: false, error: normalizeError(error) };
+  }
+}
+function resolveInspectorJournalPath(projectRoot) {
+  return resolve2(resolveRigServerPaths(projectRoot).stateDir, "inspector", "journal.sqlite");
+}
+function createInspectorJournal(options) {
+  const dbPath = resolve2(options.dbPath ?? resolveInspectorJournalPath(options.projectRoot));
+  mkdirSync2(dirname2(dbPath), { recursive: true });
+  const sqlite = new Database(dbPath, { create: true, strict: true });
+  sqlite.exec("PRAGMA journal_mode = WAL");
+  sqlite.exec("PRAGMA busy_timeout = 50");
+  for (const statement of SCHEMA) {
+    sqlite.exec(statement);
+  }
+  const upsertRunStatement = sqlite.prepare(`
+    INSERT INTO inspector_runs (
+      run_id, workspace_id, task_id, runtime_adapter, provider, status, conflict_state, conflict_summary,
+      source, title, started_at, updated_at, completed_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(run_id) DO UPDATE SET
+      workspace_id = excluded.workspace_id,
+      task_id = excluded.task_id,
+      runtime_adapter = excluded.runtime_adapter,
+      provider = excluded.provider,
+      status = excluded.status,
+      conflict_state = excluded.conflict_state,
+      conflict_summary = excluded.conflict_summary,
+      source = excluded.source,
+      title = excluded.title,
+      started_at = excluded.started_at,
+      updated_at = excluded.updated_at,
+      completed_at = excluded.completed_at
+  `);
+  const observationStatement = sqlite.prepare(`
+    INSERT OR IGNORE INTO inspector_observations (
+      id, run_id, dedupe_key, kind, severity, source, summary, details_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const decisionStatement = sqlite.prepare(`
+    INSERT OR IGNORE INTO inspector_decisions (
+      id, run_id, dedupe_key, decision_type, summary, rationale, details_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const actionStatement = sqlite.prepare(`
+    INSERT OR IGNORE INTO inspector_actions (
+      id, run_id, dedupe_key, action_type, status, target, input_json, result_json, started_at, completed_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const reviewStatement = sqlite.prepare(`
+    INSERT OR IGNORE INTO inspector_reviews (
+      id, run_id, dedupe_key, reviewer_type, status, findings_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const followupStatement = sqlite.prepare(`
+    INSERT OR IGNORE INTO inspector_followups (
+      id, origin_run_id, dedupe_key, task_id, kind, status, summary, details_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const scanStatement = sqlite.prepare(`
+    INSERT OR IGNORE INTO upstream_sync_scans (
+      id, dedupe_key, started_at, completed_at, status, summary, details_json
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const reportStatement = sqlite.prepare(`
+    INSERT OR IGNORE INTO analysis_reports (
+      id, dedupe_key, report_type, status, summary, details_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const attachFollowupTaskStatement = sqlite.prepare(`
+    UPDATE inspector_followups
+    SET task_id = ?, status = ?, details_json = ?
+    WHERE dedupe_key = ?
+  `);
+  const getFollowupByDedupeKeyStatement = sqlite.prepare(`
+    SELECT id, origin_run_id, dedupe_key, task_id, kind, status, summary, details_json, created_at
+    FROM inspector_followups
+    WHERE dedupe_key = ?
+    LIMIT 1
+  `);
+  const listActiveRunsStatement = sqlite.prepare(`
+    SELECT
+      run_id,
+      workspace_id,
+      task_id,
+      runtime_adapter,
+      provider,
+      status,
+      conflict_state,
+      conflict_summary,
+      source,
+      title,
+      started_at,
+      updated_at,
+      completed_at
+    FROM inspector_runs
+    WHERE status IN ('preparing', 'running', 'validating', 'reviewing')
+    ORDER BY updated_at DESC
+  `);
+  const listRecentFindingsStatement = sqlite.prepare(`
+    SELECT id, run_id, kind, severity, source, summary, details_json, created_at
+    FROM inspector_observations
+    ORDER BY created_at DESC
+    LIMIT ?
+  `);
+  const listRecentDecisionsStatement = sqlite.prepare(`
+    SELECT id, run_id, decision_type, summary, rationale, details_json, created_at
+    FROM inspector_decisions
+    ORDER BY created_at DESC
+    LIMIT ?
+  `);
+  const listRecentActionsStatement = sqlite.prepare(`
+    SELECT id, run_id, action_type, status, target, input_json, result_json, started_at, completed_at
+    FROM inspector_actions
+    ORDER BY started_at DESC
+    LIMIT ?
+  `);
+  function mapFollowupRow(row) {
+    return {
+      id: String(row.id),
+      originRunId: row.origin_run_id == null ? null : String(row.origin_run_id),
+      dedupeKey: row.dedupe_key == null ? null : String(row.dedupe_key),
+      taskId: row.task_id == null ? null : String(row.task_id),
+      kind: String(row.kind),
+      status: String(row.status),
+      summary: String(row.summary),
+      details: parseJsonRecord(row.details_json),
+      createdAt: String(row.created_at)
+    };
+  }
+  return {
+    path: dbPath,
+    upsertRun(record) {
+      return safeWrite(sqlite, record, () => {
+        upsertRunStatement.run(record.runId, record.workspaceId, record.taskId, record.runtimeAdapter, record.provider, record.status, record.conflictState, record.conflictSummary, record.source, record.title, record.startedAt, record.updatedAt, record.completedAt);
+      });
+    },
+    appendObservation(record) {
+      return safeWrite(sqlite, record, () => {
+        observationStatement.run(record.id, record.runId, record.dedupeKey ?? null, record.kind, record.severity, record.source, record.summary, jsonText(record.details), record.createdAt);
+      });
+    },
+    appendDecision(record) {
+      return safeWrite(sqlite, record, () => {
+        decisionStatement.run(record.id, record.runId, record.dedupeKey ?? null, record.decisionType, record.summary, record.rationale, jsonText(record.details), record.createdAt);
+      });
+    },
+    appendAction(record) {
+      return safeWrite(sqlite, record, () => {
+        actionStatement.run(record.id, record.runId, record.dedupeKey ?? null, record.actionType, record.status, record.target, jsonText(record.input), jsonText(record.result), record.startedAt, record.completedAt);
+      });
+    },
+    appendReview(record) {
+      return safeWrite(sqlite, record, () => {
+        reviewStatement.run(record.id, record.runId, record.dedupeKey ?? null, record.reviewerType, record.status, jsonText(record.findings), record.createdAt);
+      });
+    },
+    appendFollowup(record) {
+      return safeWrite(sqlite, record, () => {
+        followupStatement.run(record.id, record.originRunId, record.dedupeKey ?? null, record.taskId, record.kind, record.status, record.summary, jsonText(record.details), record.createdAt);
+      });
+    },
+    attachFollowupTask(input) {
+      const record = {
+        dedupeKey: input.dedupeKey,
+        taskId: input.taskId,
+        status: input.status,
+        details: input.details ?? null
+      };
+      return safeWrite(sqlite, record, () => {
+        attachFollowupTaskStatement.run(input.taskId, input.status, jsonText(input.details), input.dedupeKey);
+      });
+    },
+    getFollowupByDedupeKey(dedupeKey) {
+      const row = getFollowupByDedupeKeyStatement.get(dedupeKey);
+      return row ? mapFollowupRow(row) : null;
+    },
+    appendUpstreamSyncScan(record) {
+      return safeWrite(sqlite, record, () => {
+        scanStatement.run(record.id, record.dedupeKey ?? null, record.startedAt, record.completedAt, record.status, record.summary, jsonText(record.details));
+      });
+    },
+    appendAnalysisReport(record) {
+      return safeWrite(sqlite, record, () => {
+        reportStatement.run(record.id, record.dedupeKey ?? null, record.reportType, record.status, record.summary, jsonText(record.details), record.createdAt);
+      });
+    },
+    listActiveRuns() {
+      return listActiveRunsStatement.all().map((row) => ({
+        runId: String(row.run_id),
+        workspaceId: row.workspace_id == null ? null : String(row.workspace_id),
+        taskId: row.task_id == null ? null : String(row.task_id),
+        runtimeAdapter: row.runtime_adapter == null ? null : String(row.runtime_adapter),
+        provider: row.provider == null ? null : String(row.provider),
+        status: String(row.status),
+        conflictState: String(row.conflict_state),
+        conflictSummary: row.conflict_summary == null ? null : String(row.conflict_summary),
+        source: row.source == null ? null : String(row.source),
+        title: row.title == null ? null : String(row.title),
+        startedAt: row.started_at == null ? null : String(row.started_at),
+        updatedAt: String(row.updated_at),
+        completedAt: row.completed_at == null ? null : String(row.completed_at)
+      }));
+    },
+    listRecentFindings(options2 = {}) {
+      const limit = options2.limit ?? 10;
+      return listRecentFindingsStatement.all(limit).map((row) => ({
+        id: String(row.id),
+        runId: row.run_id == null ? null : String(row.run_id),
+        kind: String(row.kind),
+        severity: String(row.severity),
+        source: String(row.source),
+        summary: String(row.summary),
+        details: parseJsonRecord(row.details_json),
+        createdAt: String(row.created_at)
+      }));
+    },
+    listRecentDecisions(options2 = {}) {
+      const limit = options2.limit ?? 10;
+      return listRecentDecisionsStatement.all(limit).map((row) => ({
+        id: String(row.id),
+        runId: row.run_id == null ? null : String(row.run_id),
+        decisionType: String(row.decision_type),
+        summary: String(row.summary),
+        rationale: String(row.rationale),
+        details: parseJsonRecord(row.details_json),
+        createdAt: String(row.created_at)
+      }));
+    },
+    listRecentActions(options2 = {}) {
+      const limit = options2.limit ?? 10;
+      return listRecentActionsStatement.all(limit).map((row) => ({
+        id: String(row.id),
+        runId: row.run_id == null ? null : String(row.run_id),
+        actionType: String(row.action_type),
+        status: String(row.status),
+        target: row.target == null ? null : String(row.target),
+        input: parseJsonRecord(row.input_json),
+        result: parseJsonRecord(row.result_json),
+        startedAt: String(row.started_at),
+        completedAt: row.completed_at == null ? null : String(row.completed_at)
+      }));
+    },
+    listDecisions(runId) {
+      return sqlite.prepare(`
+        SELECT id, run_id, decision_type, summary, rationale, details_json, created_at
+        FROM inspector_decisions
+        WHERE run_id = ?
+        ORDER BY created_at DESC
+      `).all(runId).map((row) => ({
+        id: String(row.id),
+        runId: row.run_id == null ? null : String(row.run_id),
+        decisionType: String(row.decision_type),
+        summary: String(row.summary),
+        rationale: String(row.rationale),
+        details: parseJsonRecord(row.details_json),
+        createdAt: String(row.created_at)
+      }));
+    },
+    listActions(runId) {
+      return sqlite.prepare(`
+        SELECT id, run_id, action_type, status, target, input_json, result_json, started_at, completed_at
+        FROM inspector_actions
+        WHERE run_id = ?
+        ORDER BY started_at DESC
+      `).all(runId).map((row) => ({
+        id: String(row.id),
+        runId: row.run_id == null ? null : String(row.run_id),
+        actionType: String(row.action_type),
+        status: String(row.status),
+        target: row.target == null ? null : String(row.target),
+        input: parseJsonRecord(row.input_json),
+        result: parseJsonRecord(row.result_json),
+        startedAt: String(row.started_at),
+        completedAt: row.completed_at == null ? null : String(row.completed_at)
+      }));
+    },
+    listReviews(runId) {
+      return sqlite.prepare(`
+        SELECT id, run_id, reviewer_type, status, findings_json, created_at
+        FROM inspector_reviews
+        WHERE run_id = ?
+        ORDER BY created_at DESC
+      `).all(runId).map((row) => ({
+        id: String(row.id),
+        runId: row.run_id == null ? null : String(row.run_id),
+        reviewerType: String(row.reviewer_type),
+        status: String(row.status),
+        findings: parseJsonRecord(row.findings_json),
+        createdAt: String(row.created_at)
+      }));
+    },
+    listFollowups() {
+      return sqlite.prepare(`
+        SELECT id, origin_run_id, dedupe_key, task_id, kind, status, summary, details_json, created_at
+        FROM inspector_followups
+        ORDER BY created_at DESC
+      `).all().map(mapFollowupRow);
+    },
+    listUpstreamSyncScans() {
+      return sqlite.prepare(`
+        SELECT id, started_at, completed_at, status, summary, details_json
+        FROM upstream_sync_scans
+        ORDER BY started_at DESC
+      `).all().map((row) => ({
+        id: String(row.id),
+        startedAt: String(row.started_at),
+        completedAt: row.completed_at == null ? null : String(row.completed_at),
+        status: String(row.status),
+        summary: String(row.summary),
+        details: parseJsonRecord(row.details_json)
+      }));
+    },
+    listAnalysisReports() {
+      return sqlite.prepare(`
+        SELECT id, report_type, status, summary, details_json, created_at
+        FROM analysis_reports
+        ORDER BY created_at DESC
+      `).all().map((row) => ({
+        id: String(row.id),
+        reportType: String(row.report_type),
+        status: String(row.status),
+        summary: String(row.summary),
+        details: parseJsonRecord(row.details_json),
+        createdAt: String(row.created_at)
+      }));
+    },
+    getCounts() {
+      const row = sqlite.prepare(`
+        SELECT
+          (SELECT COUNT(*) FROM inspector_observations) AS observations,
+          (SELECT COUNT(*) FROM inspector_decisions) AS decisions,
+          (SELECT COUNT(*) FROM inspector_actions) AS actions,
+          (SELECT COUNT(*) FROM inspector_followups) AS followups
+      `).get();
+      return {
+        observations: Number(row?.observations ?? 0),
+        decisions: Number(row?.decisions ?? 0),
+        actions: Number(row?.actions ?? 0),
+        followups: Number(row?.followups ?? 0)
+      };
+    },
+    beginExclusiveTransaction() {
+      sqlite.exec("BEGIN EXCLUSIVE");
+    },
+    rollbackTransaction() {
+      sqlite.exec("ROLLBACK");
+    },
+    close() {
+      sqlite.close();
+    }
+  };
+}
+export {
+  resolveInspectorJournalPath,
+  createInspectorJournal
+};