diffowl 0.3.0 → 0.3.1

package/dist/cli.js

@@ -112,7 +112,10 @@ function findConfigPath() {
   return join(process.cwd(), CONFIG_FILENAME);
 }
 async function loadConfig() {
-  const configPath = findConfigPath();
+  return loadConfigFromRoot(dirname(findConfigPath()));
+}
+async function loadConfigFromRoot(root) {
+  const configPath = join(root, CONFIG_FILENAME);
   if (!existsSync(configPath)) {
     return parseConfigInput({});
   }
@@ -213,6 +216,9 @@ async function ensureServer(port) {
       return baseUrl;
     }
   }
+  if (await stopUnhealthyServerListener(port)) {
+    await waitUntilPortFree(port);
+  }
   await spawnServer(port);
   for (let i = 0; i < MAX_RETRIES; i++) {
     await sleep(STARTUP_WAIT_MS / MAX_RETRIES);
@@ -323,6 +329,19 @@ async function stopManagedServer() {
   }
   return true;
 }
+async function stopUnhealthyServerListener(port) {
+  const listenerPid = await findOpencodeListenerPid(port);
+  if (listenerPid === null) {
+    return false;
+  }
+  try {
+    process.kill(listenerPid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  await cleanupPidFile();
+  return true;
+}
 async function cleanupPidFile() {
   const pidFile = join2(getDiffOwlDir(), "server.pid");
   if (!existsSync2(pidFile)) {
@@ -376,12 +395,12 @@ async function findOpencodeListenerPidWindows(port) {
 async function waitUntilPortFree(port) {
   const deadline = Date.now() + PORT_RELEASE_WAIT_MS;
   while (Date.now() < deadline) {
-    if (!await isServerRunning(port)) {
+    if (await findOpencodeListenerPid(port) === null) {
       return;
     }
     await sleep(PORT_RELEASE_POLL_MS);
   }
-  if (await isServerRunning(port)) {
+  if (await findOpencodeListenerPid(port) !== null) {
     throw new Error(
       `OpenCode server on port ${port} did not stop within ${PORT_RELEASE_WAIT_MS}ms. Retry: diffowl server stop && diffowl server start`
     );
@@ -1005,6 +1024,59 @@ function listAvailableModels(payload) {
   ).sort();
 }
 
+// src/review/usage.ts
+function parseAssistantUsage(info) {
+  if (!info || typeof info !== "object") return void 0;
+  const value = info;
+  if (value["role"] !== "assistant") return void 0;
+  const tokens = parseUsageTokens(value["tokens"]);
+  if (!tokens) return void 0;
+  const cost = typeof value["cost"] === "number" ? value["cost"] : null;
+  return { tokens, cost };
+}
+function aggregateReviewUsage(entries) {
+  if (entries.length === 0) return void 0;
+  const tokens = {
+    input: 0,
+    output: 0,
+    reasoning: 0,
+    cache: { read: 0, write: 0 }
+  };
+  let costSum = 0;
+  let hasCost = false;
+  for (const entry of entries) {
+    tokens.input += entry.tokens.input;
+    tokens.output += entry.tokens.output;
+    tokens.reasoning += entry.tokens.reasoning;
+    tokens.cache.read += entry.tokens.cache.read;
+    tokens.cache.write += entry.tokens.cache.write;
+    if (entry.cost !== null) {
+      costSum += entry.cost;
+      hasCost = true;
+    }
+  }
+  return { tokens, cost: hasCost ? costSum : null };
+}
+function parseUsageTokens(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const tokens = value;
+  const cache = tokens["cache"];
+  if (!cache || typeof cache !== "object") return void 0;
+  const cacheValue = cache;
+  if (typeof tokens["input"] !== "number" || typeof tokens["output"] !== "number" || typeof tokens["reasoning"] !== "number" || typeof cacheValue["read"] !== "number" || typeof cacheValue["write"] !== "number") {
+    return void 0;
+  }
+  return {
+    input: tokens["input"],
+    output: tokens["output"],
+    reasoning: tokens["reasoning"],
+    cache: {
+      read: cacheValue["read"],
+      write: cacheValue["write"]
+    }
+  };
+}
+
 // src/opencode/client.ts
 var ReviewCancelledError = class extends Error {
   name = "ReviewCancelledError";
@@ -1012,6 +1084,18 @@ var ReviewCancelledError = class extends Error {
 function isReviewCancellation(error) {
   return error instanceof ReviewCancelledError;
 }
+function resolveReviewPrompts(options) {
+  const user = options.userPrompt ?? buildReviewPrompt(
+    options.target,
+    options.config.rules,
+    options.config.include,
+    options.config.exclude,
+    options.localContext,
+    options.depth
+  );
+  const system = options.systemPrompt ?? REVIEW_AGENT_PROMPT;
+  return { system, user };
+}
 function normalizeOpenCodeEvent(event, expectedSessionId) {
   if (!event || typeof event !== "object") return void 0;
   const payload = event.payload;
@@ -1093,11 +1177,13 @@ function normalizeAssistantMessage(info, expectedSessionId) {
   if (value["role"] !== "assistant" || typeof value["sessionID"] !== "string" || typeof value["id"] !== "string" || expectedSessionId !== void 0 && value["sessionID"] !== expectedSessionId) {
     return void 0;
   }
+  const usage = parseAssistantUsage(value);
   return {
     type: "assistant-message",
     sessionId: value["sessionID"],
     messageId: value["id"],
-    ...value["error"] ? { error: new Error(describeSessionError(value["error"]) || "Review failed") } : {}
+    ...value["error"] ? { error: new Error(describeSessionError(value["error"]) || "Review failed") } : {},
+    ...usage ? { usage } : {}
   };
 }
 async function runReview(options) {
@@ -1133,14 +1219,14 @@ async function runReview(options) {
   const tools = await buildToolPolicy(client, depth);
   recordTiming(timings, onProgress, "tool-policy", "OpenCode tool policy", toolPolicyStart);
   const promptStart = performance.now();
-  const prompt = buildReviewPrompt(
+  const { system, user: prompt } = resolveReviewPrompts({
     target,
-    config.rules,
-    config.include,
-    config.exclude,
-    localContext,
-    depth
-  );
+    config,
+    depth,
+    ...localContext !== void 0 ? { localContext } : {},
+    ...options.systemPrompt !== void 0 ? { systemPrompt: options.systemPrompt } : {},
+    ...options.userPrompt !== void 0 ? { userPrompt: options.userPrompt } : {}
+  });
   recordTiming(timings, onProgress, "prompt-build", "Review prompt build", promptStart);
   const parts = config.model.split("/");
   const providerID = parts[0];
@@ -1166,6 +1252,7 @@ async function runReview(options) {
     })
   );
   recordTiming(timings, onProgress, "event-stream", "OpenCode event stream connection", eventStart);
+  const usageByMessageId = /* @__PURE__ */ new Map();
   const responsePromise = handledAwaitable(
     new Promise((resolve2, reject) => {
       const assistantMessageIds = /* @__PURE__ */ new Set();
@@ -1222,6 +1309,9 @@ async function runReview(options) {
                 break;
               case "assistant-message": {
                 assistantMessageIds.add(normalized.messageId);
+                if (normalized.usage) {
+                  usageByMessageId.set(normalized.messageId, normalized.usage);
+                }
                 const text = textPartsByMessageId.get(normalized.messageId);
                 settlement.acceptAssistantMessage({ text, error: normalized.error });
                 break;
@@ -1284,7 +1374,7 @@ async function runReview(options) {
         path: { id: sessionId },
         ...directoryOptions,
         body: {
-          system: REVIEW_AGENT_PROMPT,
+          system,
           model: { providerID, modelID },
           tools,
           ...reasoning.variant ? { variant: reasoning.variant } : {},
@@ -1304,9 +1394,16 @@ async function runReview(options) {
     const report = parseStructuredReview(raw);
     recordTiming(timings, onProgress, "parse-review", "Review JSON parsing", parseStart);
     const diagnostics = [...report.diagnostics ?? [], ...reasoning.diagnostics];
+    const usage = aggregateReviewUsage([...usageByMessageId.values()]);
     return {
-      report: { ...report, ...diagnostics.length > 0 ? { diagnostics } : {}, timings },
-      sessionId
+      report: {
+        ...report,
+        ...diagnostics.length > 0 ? { diagnostics } : {},
+        timings,
+        ...usage ? { usage } : {}
+      },
+      sessionId,
+      ...usage ? { usage } : {}
     };
   } finally {
     signal?.removeEventListener("abort", cancelReview);
@@ -1515,13 +1612,6 @@ function getOpenCodeFailureGuidance(message) {
   if (normalized.includes("timed out") || normalized.includes("timeout")) {
     return ["Retry with less context: diffowl review --depth shallow"];
   }
-  if (normalized.includes("node_module_version") || normalized.includes("better-sqlite3") && normalized.includes("compiled against a different node.js version")) {
-    return [
-      "Native module ABI mismatch. Rebuild for your active Node: pnpm rebuild better-sqlite3",
-      "Reinstall the hook so it uses the same Node as the CLI: diffowl hook install",
-      "Compare the required NODE_MODULE_VERSION with the Hook Node ABI from `diffowl hook install`."
-    ];
-  }
   if (normalized.includes("session_message.seq") || normalized.includes("not null constraint failed") && normalized.includes("seq")) {
     return [
       "OpenCode server version may be stale. Check: diffowl server status",
@@ -1562,7 +1652,7 @@ import {
   writeFileSync,
   writeSync
 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { basename, dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
 import { execa as execa2 } from "execa";
 import { z as z4 } from "zod";
@@ -1599,10 +1689,16 @@ async function getHooksDir() {
   }
   return hooksDir;
 }
-async function installHook() {
+async function getHookPath() {
   const hooksDir = await getHooksDir();
-  await mkdir2(hooksDir, { recursive: true });
-  const hookPath = join3(hooksDir, "post-commit");
+  if (basename(hooksDir) === "_" && basename(dirname2(hooksDir)) === ".husky") {
+    return join3(dirname2(hooksDir), "post-commit");
+  }
+  return join3(hooksDir, "post-commit");
+}
+async function installHook() {
+  const hookPath = await getHookPath();
+  await mkdir2(dirname2(hookPath), { recursive: true });
   const command = await resolveHookCommand();
   if (existsSync3(hookPath)) {
     const existing = await readFile4(hookPath, "utf-8");
@@ -1619,8 +1715,7 @@ ${hookSection}` : generateHookScript(command);
   return hookPath;
 }
 async function uninstallHook() {
-  const hooksDir = await getHooksDir();
-  const hookPath = join3(hooksDir, "post-commit");
+  const hookPath = await getHookPath();
   if (!existsSync3(hookPath)) return false;
   const content = await readFile4(hookPath, "utf-8");
   if (!content.includes(HOOK_MARKER)) return false;
@@ -1633,8 +1728,7 @@ async function uninstallHook() {
   return true;
 }
 async function isHookInstalled() {
-  const hooksDir = await getHooksDir();
-  const hookPath = join3(hooksDir, "post-commit");
+  const hookPath = await getHookPath();
   if (!existsSync3(hookPath)) return false;
   const content = await readFile4(hookPath, "utf-8");
   return content.includes(HOOK_MARKER);
@@ -1732,9 +1826,6 @@ function isHookQueueStopFailure(message) {
   if (normalized.includes("server is not running") || normalized.includes("failed to start opencode server") || normalized.includes("econnrefused") || normalized.includes("connection refused")) {
     return true;
   }
-  if (normalized.includes("node_module_version") || normalized.includes("better-sqlite3") && normalized.includes("compiled against a different node.js version")) {
-    return true;
-  }
   if (normalized.includes("opencode not found") || normalized.includes("opencode: command not found") || normalized.includes("enoent") && normalized.includes("opencode")) {
     return true;
   }
@@ -1970,13 +2061,12 @@ function isHookReviewLockActive(lockFile) {
   }
 }
 async function checkHookStale() {
-  let hooksDir;
+  let hookPath;
   try {
-    hooksDir = await getHooksDir();
+    hookPath = await getHookPath();
   } catch {
     return { installed: false, stale: false, reason: "Not a git repository" };
   }
-  const hookPath = join3(hooksDir, "post-commit");
   if (!existsSync3(hookPath)) {
     return { installed: false, stale: false, reason: "No post-commit hook found" };
   }
@@ -2125,57 +2215,64 @@ function shellQuote(value) {
 
 // src/git/diff.ts
 import { execa as execa3 } from "execa";
-import { basename, extname } from "path";
+import { basename as basename2, extname } from "path";
 var MAX_DIFF_OUTPUT_BYTES = 2 * 1024 * 1024;
-async function getResolvedCommitDiff(commit) {
-  const raw = await collectGitDiff([
-    "-c",
-    "diff.noprefix=false",
-    "-c",
-    "diff.mnemonicprefix=false",
-    "show",
-    "--format=",
-    "--diff-merges=combined",
-    "--stat",
-    "--patch",
-    commit
-  ]);
+async function getResolvedCommitDiff(commit, cwd) {
+  const raw = await collectGitDiff(
+    [
+      "-c",
+      "diff.noprefix=false",
+      "-c",
+      "diff.mnemonicprefix=false",
+      "show",
+      "--format=",
+      "--diff-merges=combined",
+      "--stat",
+      "--patch",
+      commit
+    ],
+    cwd
+  );
   return parseDiff(raw.stdout, raw.diagnostics);
 }
-async function resolveCommitRef(ref) {
+async function resolveCommitRef(ref, cwd) {
   const trimmed = ref.trim();
   if (trimmed === "") {
     throw new Error("Commit ref must not be empty.");
   }
   try {
-    const { stdout } = await execa3("git", [
-      "rev-parse",
-      "--verify",
-      "--quiet",
-      "--end-of-options",
-      `${trimmed}^{commit}`
-    ]);
+    const { stdout } = await execa3(
+      "git",
+      ["rev-parse", "--verify", "--quiet", "--end-of-options", `${trimmed}^{commit}`],
+      cwd ? { cwd } : {}
+    );
     return stdout.trim();
   } catch {
     throw new Error(`Invalid commit ref: ${ref}`);
   }
 }
-async function getStagedDiff() {
-  const raw = await collectGitDiff([
-    "-c",
-    "diff.noprefix=false",
-    "-c",
-    "diff.mnemonicprefix=false",
-    "diff",
-    "--staged",
-    "--stat",
-    "--patch"
-  ]);
+async function getStagedDiff(cwd) {
+  const raw = await collectGitDiff(
+    [
+      "-c",
+      "diff.noprefix=false",
+      "-c",
+      "diff.mnemonicprefix=false",
+      "diff",
+      "--staged",
+      "--stat",
+      "--patch"
+    ],
+    cwd
+  );
   return parseDiff(raw.stdout, raw.diagnostics);
 }
-async function collectGitDiff(args) {
+async function collectGitDiff(args, cwd) {
   try {
-    const { stdout } = await execa3("git", args, { maxBuffer: MAX_DIFF_OUTPUT_BYTES });
+    const { stdout } = await execa3("git", args, {
+      maxBuffer: MAX_DIFF_OUTPUT_BYTES,
+      ...cwd ? { cwd } : {}
+    });
     return { stdout, diagnostics: [] };
   } catch (err) {
     if (isMaxBufferError(err)) {
@@ -2418,7 +2515,7 @@ var DOC_BASENAME_PATTERNS = [
   /^TODO/i
 ];
 function isDocFile(path) {
-  const base = basename(path);
+  const base = basename2(path);
   const extension = extname(base).toLowerCase();
   if (DOC_EXTENSIONS.has(extension)) return true;
   if (extension) return false;
@@ -2429,7 +2526,7 @@ function isDocOnlyDiff(diff) {
 }
 
 // src/review/context.ts
-import { basename as basename3, dirname as dirname3, extname as extname5, join as join6 } from "path";
+import { basename as basename4, dirname as dirname3, extname as extname5, join as join6 } from "path";
 import picomatch from "picomatch";
 
 // src/review/ast/index.ts
@@ -2629,7 +2726,7 @@ function isCodePath(path) {
 }
 
 // src/review/context-references.ts
-import { basename as basename2, extname as extname3 } from "path";
+import { basename as basename3, extname as extname3 } from "path";
 var MAX_REFERENCES_PER_TERM = 8;
 var MAX_REFERENCE_TERMS = 8;
 var MAX_REFERENCE_LINE_CHARS = 220;
@@ -2644,7 +2741,7 @@ async function buildReferenceContexts(source, changedFiles, skippedFiles, diagno
     ...skippedFiles.map((file) => file.path)
   ]);
   for (const file of changedFiles) {
-    terms.add(basename2(file.file.path, extname3(file.file.path)));
+    terms.add(basename3(file.file.path, extname3(file.file.path)));
     for (const symbol of file.symbols.slice(0, 4)) {
       terms.add(symbol);
     }
@@ -3063,24 +3160,24 @@ async function loadReviewSnapshot(root, target) {
       return {
         root,
         target,
-        diff: await getStagedDiff(),
+        diff: await getStagedDiff(root),
         source: createGitContextSource(root, { kind: "staged" })
       };
     case "commit": {
-      const sha = await resolveCommitRef(target.ref);
+      const sha = await resolveCommitRef(target.ref, root);
       return {
         root,
         target,
-        diff: await getResolvedCommitDiff(sha),
+        diff: await getResolvedCommitDiff(sha, root),
         source: createGitContextSource(root, { kind: "commit", sha })
       };
     }
     case "last-commit": {
-      const sha = await resolveCommitRef("HEAD");
+      const sha = await resolveCommitRef("HEAD", root);
       return {
         root,
         target,
-        diff: await getResolvedCommitDiff(sha),
+        diff: await getResolvedCommitDiff(sha, root),
         source: createGitContextSource(root, { kind: "commit", sha })
       };
     }
@@ -3186,7 +3283,7 @@ async function buildRelatedFileContexts(source, files) {
   return related;
 }
 function shouldReviewFile(path, config) {
-  if (LOCKFILE_EXCLUDES.has(basename3(path))) return false;
+  if (LOCKFILE_EXCLUDES.has(basename4(path))) return false;
   const include = config.include.length > 0 ? config.include : ["**/*"];
   if (!include.some((pattern) => picomatch.isMatch(path, pattern))) {
     return false;
@@ -3307,7 +3404,7 @@ function getChangedLinesByFile(rawDiff) {
 function testCandidates(path) {
   const dir = dirname3(path);
   const ext = extname5(path);
-  const base = basename3(path, ext);
+  const base = basename4(path, ext);
   return [
     join6(dir, `${base}.test${ext}`),
     join6(dir, `${base}.spec${ext}`),
@@ -3334,6 +3431,29 @@ function addUniqueDiagnostics(target, diagnostics) {
   }
 }
 
+// src/review/filters.ts
+function filterFindingsByConfidence(findings, minConfidence) {
+  const levels = ["low", "medium", "high"];
+  const minIndex = levels.indexOf(minConfidence);
+  const kept = findings.filter((finding) => {
+    const index = levels.indexOf(finding.confidence.toLowerCase());
+    return index >= minIndex;
+  });
+  return { findings: kept, dropped: findings.length - kept.length };
+}
+function filterFindingsByChangedFiles(findings, changedFiles) {
+  const kept = [];
+  const suppressed = [];
+  for (const finding of findings) {
+    if (changedFiles.has(finding.file)) {
+      kept.push(finding);
+    } else {
+      suppressed.push(finding);
+    }
+  }
+  return { findings: kept, suppressed };
+}
+
 // src/review/formatter.ts
 import chalk from "chalk";
 import { writeFile as writeFile5, mkdir as mkdir3 } from "fs/promises";
@@ -3560,7 +3680,7 @@ function formatExcludedCandidateSummary(belowConfidence, outsideChangedFiles) {
 
 // src/review/report-path.ts
 import { readFile as readFile6, readdir as readdir2 } from "fs/promises";
-import { basename as basename4, isAbsolute, join as join8, resolve } from "path";
+import { basename as basename5, isAbsolute, join as join8, resolve } from "path";
 function resolveReviewReportPath(report) {
   if (isAbsolute(report)) return report;
   if (report.includes("/") || report.includes("\\")) {
@@ -3574,7 +3694,7 @@ async function listReviewReportPaths() {
     listMarkdownFiles(reviews),
     listMarkdownFiles(join8(reviews, "resolved"))
   ]);
-  return entries.flat().filter((path) => basename4(path) !== "latest.md").sort((a, b) => basename4(b).localeCompare(basename4(a)));
+  return entries.flat().filter((path) => basename5(path) !== "latest.md").sort((a, b) => basename5(b).localeCompare(basename5(a)));
 }
 function canSelectReviewInteractively(inputIsTTY, outputIsTTY) {
   return inputIsTTY === true && outputIsTTY === true;
@@ -3609,7 +3729,6 @@ import { createHash as createHash2 } from "crypto";
 // src/state/db.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { join as join9 } from "path";
-import Database from "better-sqlite3";
 
 // src/state/migrations/001-initial-schema.ts
 var MIGRATION_001_INITIAL_SCHEMA = `
@@ -3681,6 +3800,117 @@ CREATE TABLE finding_events (
 CREATE INDEX idx_finding_events_finding_id ON finding_events(finding_id);
 `;
 
+// src/state/sqlite.ts
+var sqliteModule;
+async function openSqliteDatabase(path) {
+  const { DatabaseSync } = await loadSqliteModule();
+  return new NodeSqliteDatabase(new DatabaseSync(path));
+}
+async function loadSqliteModule() {
+  sqliteModule ??= importNodeSqliteWithoutWarning();
+  return sqliteModule;
+}
+async function importNodeSqliteWithoutWarning() {
+  const emitWarning = process.emitWarning;
+  process.emitWarning = function suppressNodeSqliteExperimentalWarning(warning, ...args) {
+    const message = typeof warning === "string" ? warning : warning.message;
+    if (message.includes("SQLite is an experimental feature")) {
+      return;
+    }
+    emitWarning.call(process, warning, ...args);
+  };
+  try {
+    const nodeSqlite = ["node", "sqlite"].join(":");
+    return await import(nodeSqlite);
+  } finally {
+    process.emitWarning = emitWarning;
+  }
+}
+var NodeSqliteDatabase = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  #open = true;
+  #transactionDepth = 0;
+  get open() {
+    return this.#open;
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  prepare(sql) {
+    return new NodeSqliteStatement(this.db.prepare(sql));
+  }
+  pragma(sql, options = {}) {
+    const rows = this.prepare(`PRAGMA ${sql}`).all();
+    if (!options.simple) {
+      return rows;
+    }
+    const first = rows[0];
+    if (!first || typeof first !== "object") {
+      return void 0;
+    }
+    return Object.values(first)[0];
+  }
+  transaction(fn) {
+    return ((...args) => {
+      const depth = this.#transactionDepth;
+      const savepoint = `diffowl_tx_${depth}`;
+      this.#transactionDepth++;
+      try {
+        this.exec(depth === 0 ? "BEGIN" : `SAVEPOINT ${savepoint}`);
+        const result = fn(...args);
+        this.exec(depth === 0 ? "COMMIT" : `RELEASE SAVEPOINT ${savepoint}`);
+        return result;
+      } catch (error) {
+        try {
+          this.exec(depth === 0 ? "ROLLBACK" : `ROLLBACK TO SAVEPOINT ${savepoint}`);
+          if (depth > 0) {
+            this.exec(`RELEASE SAVEPOINT ${savepoint}`);
+          }
+        } catch {
+        }
+        throw error;
+      } finally {
+        this.#transactionDepth--;
+      }
+    });
+  }
+  close() {
+    this.db.close();
+    this.#open = false;
+  }
+};
+var NodeSqliteStatement = class {
+  constructor(statement) {
+    this.statement = statement;
+  }
+  statement;
+  get(...params) {
+    return normalizeRow(this.namedStatement.get(...params));
+  }
+  all(...params) {
+    return this.namedStatement.all(...params).map(normalizeRow);
+  }
+  run(...params) {
+    const result = this.namedStatement.run(...params);
+    return {
+      changes: Number(result.changes),
+      lastInsertRowid: result.lastInsertRowid
+    };
+  }
+  get namedStatement() {
+    return this.statement;
+  }
+};
+function normalizeRow(row) {
+  if (!row || typeof row !== "object" || Object.getPrototypeOf(row) !== null) {
+    return row;
+  }
+  return { ...row };
+}
+
 // src/state/types.ts
 import { randomUUID } from "crypto";
 var CURRENT_SCHEMA_VERSION = 1;
@@ -3708,7 +3938,7 @@ function getStateDbPath(diffOwlDir) {
 async function openStateDatabase(diffOwlDir) {
   await mkdir4(diffOwlDir, { recursive: true });
   const path = getStateDbPath(diffOwlDir);
-  const db = new Database(path);
+  const db = await openSqliteDatabase(path);
   try {
     configureDatabase(db);
     assertCompatibleSchema(db);
@@ -4647,7 +4877,8 @@ function buildReviewJsonDocument(input) {
       below_confidence: input.suppressed.belowConfidence
     },
     diagnostics: input.review.diagnostics,
-    timings: input.timings ?? input.review.timings
+    timings: input.timings ?? input.review.timings,
+    ...input.usage !== void 0 ? { usage: input.usage } : {}
   };
 }
 function renderReviewJsonDocument(document) {
@@ -5110,13 +5341,13 @@ function toFindingDetail(db, finding) {
 
 // src/cli.ts
 import { readFile as readFile7 } from "fs/promises";
-import { basename as basename5, dirname as dirname4 } from "path";
+import { basename as basename6, dirname as dirname4 } from "path";
 import { execa as execa5 } from "execa";
 
 // package.json
 var package_default = {
   name: "diffowl",
-  version: "0.3.0",
+  version: "0.3.1",
   description: "Local AI code review agent powered by OpenCode",
   keywords: [
     "ai",
@@ -5142,14 +5373,14 @@ var package_default = {
   ],
   type: "module",
   scripts: {
-    "check:native-runtime": "node scripts/check-native-runtime.mjs",
-    prebuild: "pnpm run check:native-runtime",
+    "check:runtime": "node scripts/check-runtime.mjs",
+    prebuild: "pnpm run check:runtime",
     build: "tsup",
-    predev: "pnpm run check:native-runtime",
+    predev: "pnpm run check:runtime",
     dev: "tsup --watch",
-    pretest: "pnpm run check:native-runtime",
+    pretest: "pnpm run check:runtime",
     test: "vitest run",
-    pretypecheck: "pnpm run check:native-runtime",
+    pretypecheck: "pnpm run check:runtime",
     typecheck: "tsc --noEmit",
     lint: "oxlint . && pnpm run typecheck",
     format: "oxfmt --write .",
@@ -5159,7 +5390,6 @@ var package_default = {
   },
   dependencies: {
     "@opencode-ai/sdk": "^1.15.11",
-    "better-sqlite3": "^12.10.0",
     chalk: "^5.6.2",
     commander: "^14.0.3",
     execa: "^9.6.1",
@@ -5169,7 +5399,6 @@ var package_default = {
     zod: "^4.4.3"
   },
   devDependencies: {
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.9.1",
     "@types/picomatch": "^4.0.3",
     oxfmt: "^0.52.0",
@@ -5179,14 +5408,9 @@ var package_default = {
     vitest: "^4.1.7"
   },
   engines: {
-    node: ">=22.14.0 <23"
+    node: ">=22.14.0"
   },
-  packageManager: "pnpm@10.15.1",
-  pnpm: {
-    onlyBuiltDependencies: [
-      "better-sqlite3"
-    ]
-  }
+  packageManager: "pnpm@10.15.1"
 };
 
 // src/cli.ts
@@ -5512,7 +5736,8 @@ program.command("review", { isDefault: true }).description("Review the last comm
           belowConfidence: confidenceFilter.dropped
         },
         verbose,
-        timings: [...timings, ...report.timings ?? []]
+        timings: [...timings, ...report.timings ?? []],
+        usage: reviewResult.usage ?? null
       });
     } else {
       console.log(colorizeMarkdown(markdown));
@@ -5603,9 +5828,9 @@ async function selectReviewInteractively() {
   }
   console.log(chalk3.bold("\nSelect a review:\n"));
   for (const [index, report] of reports.entries()) {
-    const resolved = basename5(dirname4(report)) === "resolved";
+    const resolved = basename6(dirname4(report)) === "resolved";
     console.log(
-      `  ${chalk3.cyan(`${index + 1}.`)} ${basename5(report)}${resolved ? chalk3.dim(" (resolved)") : ""}`
+      `  ${chalk3.cyan(`${index + 1}.`)} ${basename6(report)}${resolved ? chalk3.dim(" (resolved)") : ""}`
     );
   }
   const rl = createInterface({
@@ -6031,27 +6256,6 @@ async function loadConfigOrExit() {
     process.exit(1);
   }
 }
-function filterFindingsByConfidence(findings, minConfidence) {
-  const levels = ["low", "medium", "high"];
-  const minIndex = levels.indexOf(minConfidence);
-  const kept = findings.filter((f) => {
-    const idx = levels.indexOf(f.confidence.toLowerCase());
-    return idx >= minIndex;
-  });
-  return { findings: kept, dropped: findings.length - kept.length };
-}
-function filterFindingsByChangedFiles(findings, changedFiles) {
-  const kept = [];
-  const suppressed = [];
-  for (const finding of findings) {
-    if (changedFiles.has(finding.file)) {
-      kept.push(finding);
-    } else {
-      suppressed.push(finding);
-    }
-  }
-  return { findings: kept, suppressed };
-}
 function buildDocOnlySkipMarkdown(diff) {
   const lines = [];
   lines.push("### Summary");
@@ -6133,7 +6337,8 @@ async function emitReviewJsonSuccess(input) {
       belowConfidence: input.suppressed.belowConfidence
     },
     verbose: input.verbose,
-    ...input.timings ? { timings: input.timings } : {}
+    ...input.timings ? { timings: input.timings } : {},
+    ...input.usage !== void 0 ? { usage: input.usage } : {}
   });
   writeReviewJsonSuccess(document);
 }