@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/capacity/codex.ts

@@ -1,17 +1,21 @@
-import { spawn } from 'node:child_process';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { CapacityReport, CapacityWindow } from './types.js';
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { CapacityReport, CapacityWindow } from "./types.js";
 
-type CodexUsageSource = 'pat' | 'oauth' | 'cli';
-type UsageSnapshot = { windows: CapacityWindow[]; creditsRemaining: number | null; source: CodexUsageSource };
+type CodexUsageSource = "pat" | "oauth" | "cli";
+type UsageSnapshot = {
+  windows: CapacityWindow[];
+  creditsRemaining: number | null;
+  source: CodexUsageSource;
+};
 
 type UnknownRecord = Record<string, unknown>;
 type RpcMessage = { id?: number; method: string; params?: UnknownRecord };
 type CliResponses = { rateLimits: unknown; account: unknown };
 type CodexRpc = (messages: RpcMessage[]) => Promise<CliResponses>;
 
-export const CODEX_APP_SERVER_ARGS = ['-s', 'read-only', '-a', 'untrusted', 'app-server'] as const;
+export const CODEX_APP_SERVER_ARGS = ["-s", "read-only", "-a", "untrusted", "app-server"] as const;
 
 type CodexProbeOptions = {
   installed: boolean;
@@ -25,23 +29,24 @@ type CodexProbeOptions = {
 };
 
 function record(value: unknown): UnknownRecord | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? value as UnknownRecord
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as UnknownRecord)
     : null;
 }
 
 function finiteNumber(value: unknown): number | null {
-  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
 function nonEmptyText(value: unknown): string | null {
-  return typeof value === 'string' && value.length > 0 ? value : null;
+  return typeof value === "string" && value.length > 0 ? value : null;
 }
 
 function resetTime(value: unknown): string | null {
   const seconds = finiteNumber(value);
   if (seconds !== null) return new Date(seconds * 1000).toISOString();
-  if (typeof value === 'string' && !Number.isNaN(Date.parse(value))) return new Date(value).toISOString();
+  if (typeof value === "string" && !Number.isNaN(Date.parse(value)))
+    return new Date(value).toISOString();
   return null;
 }
 
@@ -53,15 +58,11 @@ function safeIdentifier(value: unknown): string | null {
 }
 
 export function resolveCodexAuthPath(env: NodeJS.ProcessEnv = process.env): string {
-  const root = env.CODEX_HOME || join(env.HOME || '', '.codex');
-  return join(root, 'auth.json');
+  const root = env.CODEX_HOME || join(env.HOME || "", ".codex");
+  return join(root, "auth.json");
 }
 
-export function toRateWindow(
-  value: unknown,
-  id: string,
-  label: string
-): CapacityWindow | null {
+export function toRateWindow(value: unknown, id: string, label: string): CapacityWindow | null {
   const input = record(value);
   if (!input) return null;
   const used = finiteNumber(input.used_percent);
@@ -71,7 +72,7 @@ export function toRateWindow(
     label,
     durationMinutes: seconds === null ? null : seconds / 60,
     usedPercent: used,
-    resetsAt: resetTime(input.reset_at)
+    resetsAt: resetTime(input.reset_at),
   };
 }
 
@@ -84,23 +85,23 @@ function extraWindows(value: unknown): CapacityWindow[] {
     const windows = record(limit.rate_limit) ?? limit;
     return [
       toRateWindow(windows.primary_window, `${scope}:primary`, `${scope} primary`),
-      toRateWindow(windows.secondary_window, `${scope}:secondary`, `${scope} secondary`)
+      toRateWindow(windows.secondary_window, `${scope}:secondary`, `${scope} secondary`),
     ].filter((window): window is CapacityWindow => window !== null);
   });
 }
 
-export function parseUsage(raw: unknown, source: 'pat' | 'oauth'): UsageSnapshot {
+export function parseUsage(raw: unknown, source: "pat" | "oauth"): UsageSnapshot {
   const response = record(raw) ?? {};
   const limits = record(response.rate_limit) ?? {};
   const credits = record(response.credits) ?? {};
   return {
     windows: [
-      toRateWindow(limits.primary_window, 'session', 'Session'),
-      toRateWindow(limits.secondary_window, 'weekly', 'Weekly'),
-      ...extraWindows(response.additional_rate_limits)
+      toRateWindow(limits.primary_window, "session", "Session"),
+      toRateWindow(limits.secondary_window, "weekly", "Weekly"),
+      ...extraWindows(response.additional_rate_limits),
     ].filter((window): window is CapacityWindow => window !== null),
     creditsRemaining: finiteNumber(credits.balance),
-    source
+    source,
   };
 }
 
@@ -112,52 +113,58 @@ function cliWindow(value: unknown, id: string, label: string): CapacityWindow |
     label,
     durationMinutes: finiteNumber(input.windowDurationMins),
     usedPercent: finiteNumber(input.usedPercent),
-    resetsAt: resetTime(input.resetsAt)
+    resetsAt: resetTime(input.resetsAt),
   };
 }
 
 function cliSnapshotWindows(value: unknown, fallbackId: string): CapacityWindow[] {
   const snapshot = record(value);
   if (!snapshot) return [];
-  const scope = safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? 'codex';
+  const scope = safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? "codex";
   return [
     cliWindow(snapshot.primary, `${scope}:primary`, `${scope} primary`),
-    cliWindow(snapshot.secondary, `${scope}:secondary`, `${scope} secondary`)
+    cliWindow(snapshot.secondary, `${scope}:secondary`, `${scope} secondary`),
   ].filter((item): item is CapacityWindow => item !== null);
 }
 
 export function parseCliUsage(raw: unknown): UsageSnapshot {
   const response = record(raw) ?? {};
   const primary = record(response.rateLimits);
-  const windows = primary ? cliSnapshotWindows(primary, 'codex') : [];
+  const windows = primary ? cliSnapshotWindows(primary, "codex") : [];
   const buckets = record(response.rateLimitsByLimitId);
   if (buckets) {
-    for (const [id, snapshot] of Object.entries(buckets)) windows.push(...cliSnapshotWindows(snapshot, id));
+    for (const [id, snapshot] of Object.entries(buckets))
+      windows.push(...cliSnapshotWindows(snapshot, id));
   }
-  const unique = [...new Map(windows.map(window => [window.id, window])).values()];
-  return { windows: unique, creditsRemaining: null, source: 'cli' };
+  const unique = [...new Map(windows.map((window) => [window.id, window])).values()];
+  return { windows: unique, creditsRemaining: null, source: "cli" };
 }
 
-function capacityFromSnapshot(snapshot: UsageSnapshot, context: CodexProbeOptions, raw?: unknown): CapacityReport {
-  const hasUsage = snapshot.windows.some(window => window.usedPercent !== null);
+function capacityFromSnapshot(
+  snapshot: UsageSnapshot,
+  context: CodexProbeOptions,
+  raw?: unknown,
+): CapacityReport {
+  const hasUsage = snapshot.windows.some((window) => window.usedPercent !== null);
   const rateLimits = record(record(raw)?.rateLimits);
   const reached = nonEmptyText(rateLimits?.rateLimitReachedType);
-  const resetCredits = record(record(raw)?.rateLimitResetCredits) ?? record(record(raw)?.usageLimitResetCredits);
+  const resetCredits =
+    record(record(raw)?.rateLimitResetCredits) ?? record(record(raw)?.usageLimitResetCredits);
   return {
-    provider: 'codex',
+    provider: "codex",
     generatedAt: context.checkedAt,
     authenticated: true,
-    available: reached ? 'no' : hasUsage ? 'yes' : 'unknown',
+    available: reached ? "no" : hasUsage ? "yes" : "unknown",
     windows: snapshot.windows,
-    creditsRemaining: snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount)
+    creditsRemaining: snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
   };
 }
 
 function jwtExpiry(token: string): number | null {
-  const part = token.split('.')[1];
+  const part = token.split(".")[1];
   if (!part) return null;
   try {
-    return finiteNumber(record(JSON.parse(Buffer.from(part, 'base64url').toString('utf8')))?.exp);
+    return finiteNumber(record(JSON.parse(Buffer.from(part, "base64url").toString("utf8")))?.exp);
   } catch {
     return null;
   }
@@ -166,7 +173,7 @@ function jwtExpiry(token: string): number | null {
 function staleOAuth(tokens: UnknownRecord, token: string, now: Date): boolean {
   const metadata = tokens.expires_at ?? tokens.expiresAt ?? tokens.expiry;
   let expiry: number | null = finiteNumber(metadata);
-  if (typeof metadata === 'string') {
+  if (typeof metadata === "string") {
     const parsed = Date.parse(metadata);
     expiry = Number.isNaN(parsed) ? null : parsed / 1000;
   }
@@ -174,12 +181,17 @@ function staleOAuth(tokens: UnknownRecord, token: string, now: Date): boolean {
   return expiry !== null && expiry <= now.getTime() / 1000;
 }
 
-async function fetchJson(fetcher: typeof globalThis.fetch, url: string, init: RequestInit, timeoutMs: number): Promise<unknown> {
+async function fetchJson(
+  fetcher: typeof globalThis.fetch,
+  url: string,
+  init: RequestInit,
+  timeoutMs: number,
+): Promise<unknown> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const response = await fetcher(url, { ...init, signal: controller.signal });
-    if (!response.ok) throw new Error(response.status === 401 ? 'unauthorized' : 'request failed');
+    if (!response.ok) throw new Error(response.status === 401 ? "unauthorized" : "request failed");
     return await response.json();
   } finally {
     clearTimeout(timer);
@@ -189,23 +201,28 @@ async function fetchJson(fetcher: typeof globalThis.fetch, url: string, init: Re
 async function apiSnapshot(
   token: string,
   accountId: string,
-  source: 'pat' | 'oauth',
-  options: CodexProbeOptions
+  source: "pat" | "oauth",
+  options: CodexProbeOptions,
 ): Promise<UsageSnapshot> {
   const fetcher = options.fetch ?? globalThis.fetch;
-  const raw = await fetchJson(fetcher, 'https://chatgpt.com/backend-api/wham/usage', {
-    headers: { Authorization: `Bearer ${token}`, 'ChatGPT-Account-Id': accountId }
-  }, options.timeoutMs ?? 5000);
+  const raw = await fetchJson(
+    fetcher,
+    "https://chatgpt.com/backend-api/wham/usage",
+    {
+      headers: { Authorization: `Bearer ${token}`, "ChatGPT-Account-Id": accountId },
+    },
+    options.timeoutMs ?? 5000,
+  );
   return parseUsage(raw, source);
 }
 
 function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResponses> {
   return new Promise((resolve, reject) => {
-    const child = spawn('codex', CODEX_APP_SERVER_ARGS, {
-      stdio: ['pipe', 'pipe', 'ignore']
+    const child = spawn("codex", CODEX_APP_SERVER_ARGS, {
+      stdio: ["pipe", "pipe", "ignore"],
     });
     const results: Partial<CliResponses> = {};
-    let buffer = '';
+    let buffer = "";
     let settled = false;
     const finish = (error?: Error) => {
       if (settled) return;
@@ -215,30 +232,37 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
       if (error) reject(error);
       else resolve(results as CliResponses);
     };
-    const timer = setTimeout(() => finish(new Error('codex probe timed out')), timeoutMs);
-    child.once('error', () => finish(new Error('codex app-server unavailable')));
-    child.once('exit', () => { if (!settled) finish(new Error('codex app-server exited')); });
-    child.stdout.setEncoding('utf8');
-    child.stdout.on('data', (chunk: string) => {
+    const timer = setTimeout(() => finish(new Error("codex probe timed out")), timeoutMs);
+    child.once("error", () => finish(new Error("codex app-server unavailable")));
+    child.once("exit", () => {
+      if (!settled) finish(new Error("codex app-server exited"));
+    });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
       buffer += chunk;
       for (;;) {
-        const newline = buffer.indexOf('\n');
+        const newline = buffer.indexOf("\n");
         if (newline < 0) break;
         const line = buffer.slice(0, newline).trim();
         buffer = buffer.slice(newline + 1);
         if (!line) continue;
         let message: UnknownRecord;
-        try { message = JSON.parse(line) as UnknownRecord; } catch { continue; }
+        try {
+          message = JSON.parse(line) as UnknownRecord;
+        } catch {
+          continue;
+        }
         if (message.id === 1) {
-          for (const request of messages.slice(1)) child.stdin.write(`${JSON.stringify(request)}\n`);
+          for (const request of messages.slice(1))
+            child.stdin.write(`${JSON.stringify(request)}\n`);
         } else if (message.id === 2) {
-          if (message.error) finish(new Error('codex rate-limit method failed'));
+          if (message.error) finish(new Error("codex rate-limit method failed"));
           else results.rateLimits = message.result;
         } else if (message.id === 3) {
-          if (message.error) finish(new Error('codex account method failed'));
+          if (message.error) finish(new Error("codex account method failed"));
           else results.account = message.result;
         }
-        if ('rateLimits' in results && 'account' in results) finish();
+        if ("rateLimits" in results && "account" in results) finish();
       }
     });
     child.stdin.write(`${JSON.stringify(messages[0])}\n`);
@@ -247,33 +271,46 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
 
 function unavailable(options: CodexProbeOptions): CapacityReport {
   return {
-    provider: 'codex',
+    provider: "codex",
     generatedAt: options.checkedAt,
     authenticated: null,
-    available: 'unknown',
+    available: "unknown",
     windows: [],
-    creditsRemaining: null
+    creditsRemaining: null,
   };
 }
 
 async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport> {
   if (!options.installed) return unavailable(options);
   const messages: RpcMessage[] = [
-    { id: 1, method: 'initialize', params: {
-      clientInfo: { name: 'ai-devkit', title: null, version: '1' }, capabilities: null
-    } },
-    { method: 'initialized' },
-    { id: 2, method: 'account/rateLimits/read' },
-    { id: 3, method: 'account/read' }
+    {
+      id: 1,
+      method: "initialize",
+      params: {
+        clientInfo: { name: "ai-devkit", title: null, version: "1" },
+        capabilities: null,
+      },
+    },
+    { method: "initialized" },
+    { id: 2, method: "account/rateLimits/read" },
+    { id: 3, method: "account/read" },
   ];
   try {
-    const rpc = options.rpc ?? (requests => appServerRpc(requests, options.timeoutMs));
+    const rpc = options.rpc ?? ((requests) => appServerRpc(requests, options.timeoutMs));
     const response = await rpc(messages);
-    const result = capacityFromSnapshot(parseCliUsage(response.rateLimits), options, response.rateLimits);
+    const result = capacityFromSnapshot(
+      parseCliUsage(response.rateLimits),
+      options,
+      response.rateLimits,
+    );
     const accountEnvelope = record(response.account);
-    if (accountEnvelope && Object.hasOwn(accountEnvelope, 'account') && !record(accountEnvelope.account)) {
+    if (
+      accountEnvelope &&
+      Object.hasOwn(accountEnvelope, "account") &&
+      !record(accountEnvelope.account)
+    ) {
       result.authenticated = false;
-      result.available = 'unknown';
+      result.available = "unknown";
     }
     return result;
   } catch {
@@ -284,7 +321,10 @@ async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport>
 export async function probeCodexCapacity(options: CodexProbeOptions): Promise<CapacityReport> {
   let parsed: UnknownRecord | null = null;
   try {
-    const contents = await (options.readFile ?? readFile)(resolveCodexAuthPath(options.env), 'utf8');
+    const contents = await (options.readFile ?? readFile)(
+      resolveCodexAuthPath(options.env),
+      "utf8",
+    );
     parsed = record(JSON.parse(contents));
   } catch {
     return cliFallback(options);
@@ -295,12 +335,17 @@ export async function probeCodexCapacity(options: CodexProbeOptions): Promise<Ca
   if (pat) {
     try {
       const fetcher = options.fetch ?? globalThis.fetch;
-      const whoami = record(await fetchJson(fetcher,
-        'https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami',
-        { headers: { Authorization: `Bearer ${pat}` } }, options.timeoutMs ?? 5000));
+      const whoami = record(
+        await fetchJson(
+          fetcher,
+          "https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami",
+          { headers: { Authorization: `Bearer ${pat}` } },
+          options.timeoutMs ?? 5000,
+        ),
+      );
       const accountId = nonEmptyText(whoami?.chatgpt_account_id);
-      if (!accountId) throw new Error('account unavailable');
-      return capacityFromSnapshot(await apiSnapshot(pat, accountId, 'pat', options), options);
+      if (!accountId) throw new Error("account unavailable");
+      return capacityFromSnapshot(await apiSnapshot(pat, accountId, "pat", options), options);
     } catch {
       // Continue to a separately available OAuth credential before using the CLI.
     }
@@ -309,9 +354,17 @@ export async function probeCodexCapacity(options: CodexProbeOptions): Promise<Ca
   const tokens = record(auth.tokens);
   const accessToken = nonEmptyText(tokens?.access_token);
   const accountId = nonEmptyText(tokens?.account_id);
-  if (tokens && accessToken && accountId && !staleOAuth(tokens, accessToken, (options.now ?? (() => new Date()))())) {
+  if (
+    tokens &&
+    accessToken &&
+    accountId &&
+    !staleOAuth(tokens, accessToken, (options.now ?? (() => new Date()))())
+  ) {
     try {
-      return capacityFromSnapshot(await apiSnapshot(accessToken, accountId, 'oauth', options), options);
+      return capacityFromSnapshot(
+        await apiSnapshot(accessToken, accountId, "oauth", options),
+        options,
+      );
     } catch {
       return cliFallback(options);
     }

package/src/capacity/index.ts

@@ -1,10 +1,10 @@
-import { constants } from 'node:fs';
-import { access as fsAccess } from 'node:fs/promises';
-import path from 'node:path';
-import { probeCodexCapacity } from './codex.js';
-import type { CapacityReport } from './types.js';
+import { constants } from "node:fs";
+import { access as fsAccess } from "node:fs/promises";
+import path from "node:path";
+import { probeCodexCapacity } from "./codex.js";
+import type { CapacityReport } from "./types.js";
 
-export type { CapacityReport, CapacityWindow } from './types.js';
+export type { CapacityReport, CapacityWindow } from "./types.js";
 
 export type CapacityProbeOptions = {
   now?: () => Date;
@@ -22,10 +22,13 @@ async function canAccess(target: string, mode: number): Promise<boolean> {
   }
 }
 
-async function isCodexInstalled(pathValue: string, checkAccess?: (target: string) => Promise<void>): Promise<boolean> {
+async function isCodexInstalled(
+  pathValue: string,
+  checkAccess?: (target: string) => Promise<void>,
+): Promise<boolean> {
   const directories = pathValue.split(path.delimiter).filter(Boolean);
   for (const directory of directories) {
-    const executable = path.join(directory, 'codex');
+    const executable = path.join(directory, "codex");
     if (checkAccess) {
       try {
         await checkAccess(executable);
@@ -39,19 +42,21 @@ async function isCodexInstalled(pathValue: string, checkAccess?: (target: string
   return false;
 }
 
-export async function getCodexCapacityReport(options: CapacityProbeOptions = {}): Promise<CapacityReport> {
+export async function getCodexCapacityReport(
+  options: CapacityProbeOptions = {},
+): Promise<CapacityReport> {
   const generatedAt = (options.now?.() ?? new Date()).toISOString();
-  const installed = await isCodexInstalled(options.path ?? process.env.PATH ?? '', options.access);
+  const installed = await isCodexInstalled(options.path ?? process.env.PATH ?? "", options.access);
   try {
     return await (options.probe ?? probeCodexCapacity)({ installed, checkedAt: generatedAt });
   } catch {
     return {
-      provider: 'codex',
+      provider: "codex",
       generatedAt,
       authenticated: null,
-      available: 'unknown',
+      available: "unknown",
       windows: [],
-      creditsRemaining: null
+      creditsRemaining: null,
     };
   }
 }

package/src/capacity/types.ts

@@ -1,4 +1,4 @@
-export type Availability = 'yes' | 'no' | 'unknown';
+export type Availability = "yes" | "no" | "unknown";
 
 export interface CapacityWindow {
   id: string;

package/src/database/connection.ts

@@ -1,91 +1,96 @@
-import Database from 'better-sqlite3';
-import { existsSync, mkdirSync } from 'fs';
-import { dirname, join } from 'path';
-import { homedir } from 'os';
-import { initializeSchema } from './schema.js';
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+import { initializeSchema } from "./schema.js";
 
-export const DEFAULT_AGENT_REGISTRY_DB_PATH = join(homedir(), '.ai-devkit', 'agents.db');
+export const DEFAULT_AGENT_REGISTRY_DB_PATH = join(homedir(), ".ai-devkit", "agents.db");
 
 export interface DatabaseOptions {
-    dbPath?: string;
-    verbose?: boolean | ((message: string) => void);
-    readonly?: boolean;
+  dbPath?: string;
+  verbose?: boolean | ((message: string) => void);
+  readonly?: boolean;
 }
 
 export function resolveAgentRegistryDbPath(filePath?: string): string {
-    if (!filePath) return DEFAULT_AGENT_REGISTRY_DB_PATH;
-    return filePath.endsWith('.json') ? filePath.replace(/\.json$/, '.db') : filePath;
+  if (!filePath) return DEFAULT_AGENT_REGISTRY_DB_PATH;
+  return filePath.endsWith(".json") ? filePath.replace(/\.json$/, ".db") : filePath;
 }
 
 export class DatabaseConnection {
-    private db: Database.Database;
-    private readonly dbPath: string;
-    private readonly readonly: boolean;
+  private db: Database.Database;
+  private readonly dbPath: string;
+  private readonly readonly: boolean;
 
-    constructor(options: DatabaseOptions = {}) {
-        this.dbPath = options.dbPath ?? DEFAULT_AGENT_REGISTRY_DB_PATH;
-        this.readonly = options.readonly ?? false;
-        if (this.readonly && !existsSync(this.dbPath)) {
-            throw new Error(`Cannot open readonly agent database because it does not exist: ${this.dbPath}`);
-        }
-        if (!this.readonly) mkdirSync(dirname(this.dbPath), { recursive: true });
+  constructor(options: DatabaseOptions = {}) {
+    this.dbPath = options.dbPath ?? DEFAULT_AGENT_REGISTRY_DB_PATH;
+    this.readonly = options.readonly ?? false;
+    if (this.readonly && !existsSync(this.dbPath)) {
+      throw new Error(
+        `Cannot open readonly agent database because it does not exist: ${this.dbPath}`,
+      );
+    }
+    if (!this.readonly) mkdirSync(dirname(this.dbPath), { recursive: true });
 
-        this.db = new Database(this.dbPath, {
-            readonly: this.readonly,
-            timeout: 5000,
-            verbose: typeof options.verbose === 'function'
-                ? options.verbose
-                : options.verbose ? console.log : undefined,
-        });
+    this.db = new Database(this.dbPath, {
+      readonly: this.readonly,
+      timeout: 5000,
+      verbose:
+        typeof options.verbose === "function"
+          ? options.verbose
+          : options.verbose
+            ? console.log
+            : undefined,
+    });
 
-        if (this.readonly) {
-            const version = this.db.pragma('user_version', { simple: true }) as number;
-            if (version < 3) {
-                this.db.close();
-                throw new Error(`Readonly agent database requires schema version 3 (found ${version}).`);
-            }
-        } else {
-            this.configure();
-            initializeSchema(this);
-        }
+    if (this.readonly) {
+      const version = this.db.pragma("user_version", { simple: true }) as number;
+      if (version < 3) {
+        this.db.close();
+        throw new Error(`Readonly agent database requires schema version 3 (found ${version}).`);
+      }
+    } else {
+      this.configure();
+      initializeSchema(this);
     }
+  }
 
-    private configure(): void {
-        const journalMode = this.db.pragma('journal_mode', { simple: true }) as string;
-        if (journalMode.toLowerCase() !== 'wal') this.db.pragma('journal_mode = WAL');
-        this.db.pragma('foreign_keys = ON');
-        this.db.pragma('synchronous = NORMAL');
-        this.db.pragma('busy_timeout = 5000');
-        this.db.pragma('mmap_size = 268435456');
-    }
+  private configure(): void {
+    const journalMode = this.db.pragma("journal_mode", { simple: true }) as string;
+    if (journalMode.toLowerCase() !== "wal") this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("mmap_size = 268435456");
+  }
 
-    get instance(): Database.Database {
-        return this.db;
-    }
+  get instance(): Database.Database {
+    return this.db;
+  }
 
-    get path(): string {
-        return this.dbPath;
-    }
+  get path(): string {
+    return this.dbPath;
+  }
 
-    query<T>(sql: string, params: unknown[] = []): T[] {
-        return this.db.prepare(sql).all(...params) as T[];
-    }
+  query<T>(sql: string, params: unknown[] = []): T[] {
+    return this.db.prepare(sql).all(...params) as T[];
+  }
 
-    queryOne<T>(sql: string, params: unknown[] = []): T | undefined {
-        return this.db.prepare(sql).get(...params) as T | undefined;
-    }
+  queryOne<T>(sql: string, params: unknown[] = []): T | undefined {
+    return this.db.prepare(sql).get(...params) as T | undefined;
+  }
 
-    execute(sql: string, params: unknown[] = []): Database.RunResult {
-        return this.db.prepare(sql).run(...params);
-    }
+  execute(sql: string, params: unknown[] = []): Database.RunResult {
+    return this.db.prepare(sql).run(...params);
+  }
 
-    transaction<T>(fn: () => T): T {
-        return this.db.transaction(fn)();
-    }
+  transaction<T>(fn: () => T): T {
+    return this.db.transaction(fn)();
+  }
 
-    close(): void {
-        if (this.db.open) {
-            this.db.close();
-        }
+  close(): void {
+    if (this.db.open) {
+      this.db.close();
     }
+  }
 }