pantheon-opencode 1.3.3 → 1.3.5-beta.52.c75b04d

package/src/agents/zeus.md

@@ -153,8 +153,12 @@ pantheon_delegate({prompt, agent, description?, read_only?})
   -> cria sessao filha, registra no board, retorna alias: [apo-1]
 pantheon_delegation_read({id: "apo-1"})
   -> BLOQUEIA ate o job terminar, retorna o report markdown, marca reconciled
+  -> durante a espera, mostra o que o agente esta fazendo: seccao final "## Agent Activity"
+     (amostra as messages do child a cada ~2s; tool calls + args truncados / texto)
 pantheon_delegation_list()
   -> lista jobs da sessao, com [unread] para jobs terminados nao lidos
+  -> jobs RUNNING mostram "last activity:" (ultima acao visivel do child)
+  -> fail-open: sem suporte a messages, formato atual inalterado
 ```
 
 - **Read-only enforcement:** agentes read-only (apollo, gaia — `read_only_agents` no routing.yml) tem `edit`, `write`, `bash`, `task` NEGADOS dentro da sessao delegada (o guard de `tool.execute.before` THROW com mensagem acionavel). Use `read_only: true` no delegate para qualquer agente de investigacao.
@@ -164,7 +168,7 @@ pantheon_delegation_list()
 ### DELEGATION_RULES (plugin path)
 
 1. **NUNCA** polle `pantheon_delegation_list` para checar se um job terminou.
-2. Voce SERA notificado via `task-notification` injetado no chat quando um job atinge estado terminal.
+2. Voce NAO recebe notificacao injetada no chat — politica do usuario: ZERO `task-notification` no transcript. Visibilidade de conclusao: marcador `[unread]` em `pantheon_delegation_list`, `pantheon_delegation_read({id})`, toasts TUI (pantheon-hooks) e carry-forward de compactacao.
 3. Use `pantheon_delegation_read({id})` APENAS para fan-in explicito / recuperacao de resultado sob demanda (bloqueia ate o fim).
 4. `pantheon_delegation_list` e para diagnostico, nao para polling.
 
@@ -282,7 +286,7 @@ Wave: dispare N, colete com tolerancia a falha
 ```
 
 ### Plugin Enforcer (auto — session.idle hook)
-O plugin re-injeta "Incomplete tasks remain..." em sessões root/não-board que
+O plugin re-injeta "Continue: pending todos remain — review and proceed." em sessões root/não-board que
 vão a idle com todos incompletos. Guards (todos no `src/pantheon/todo-enforcer.ts`):
 - **User-activity (30s)** — após uma mensagem do usuário (`chat.message` hook),
   a injeção é suprimida por `user_activity_quiet_ms: 30000`.

package/src/pantheon/background-job-board.ts

@@ -11,17 +11,19 @@
  */
 
 import { mkdir, rename, writeFile } from 'node:fs/promises'
-import { join, dirname } from 'node:path'
+import { dirname, join } from 'node:path'
+
+import { createPantheonLogger } from './logger.ts'
+
+// Silence-by-default TUI policy (pantheon-hooks L42-58): console output in a
+// plugin renders into the opencode TUI — the "lixo". Board internals log to
+// .pantheon/logs/hooks.log; console echo is opt-in via PANTHEON_HOOKS_LOG=1.
+const log = createPantheonLogger({ module: 'BackgroundJobBoard' })
 
 // ─── Types ─────────────────────────────────────────────────────────────
 
 /** Valid states for a background job. */
-export type BackgroundJobState =
-  | 'running'
-  | 'completed'
-  | 'error'
-  | 'cancelled'
-  | 'reconciled'
+export type BackgroundJobState = 'running' | 'completed' | 'error' | 'cancelled' | 'reconciled'
 
 /** Terminal states that can transition to reconciled. */
 const TERMINAL_STATES: ReadonlySet<BackgroundJobState> = new Set([
@@ -35,10 +37,7 @@ const TERMINAL_STATES: ReadonlySet<BackgroundJobState> = new Set([
  * Each entry defines which target states are reachable from the current state.
  * Only running → terminal, or same-terminal → same-terminal (idempotent re-notify).
  */
-const UPDATE_TRANSITIONS: Record<
-  BackgroundJobState,
-  ReadonlySet<BackgroundJobState>
-> = {
+const UPDATE_TRANSITIONS: Record<BackgroundJobState, ReadonlySet<BackgroundJobState>> = {
   running: new Set(['completed', 'error', 'cancelled']),
   completed: new Set(['completed']),
   error: new Set(['error']),
@@ -371,6 +370,13 @@ export class BackgroundJobBoard {
    * Valid: only `completed`, `error`, or `cancelled` → `reconciled`.
    * Idempotent: already-reconciled jobs are returned as-is.
    * Rejected: `running` → `reconciled`.
+   *
+   * Reconcile is an ACKNOWLEDGMENT, not a completion event: it does NOT fire
+   * the terminal listeners (onTerminal) and does NOT resolve waiters — the
+   * terminal transition already did both. Firing them here produced a second
+   * `<task-notification>` per job (completed + reconciled) in the parent
+   * transcript; waiters are covered by `waitForTerminal` resolving immediately
+   * for already-terminal/reconciled jobs.
    */
   async markReconciled(taskID: string): Promise<BackgroundJobRecord | undefined> {
     const job = this.jobs.get(taskID)
@@ -386,7 +392,6 @@ export class BackgroundJobBoard {
       )
     }
 
-    const wasTerminalUnreconciled = job.terminalUnreconciled
     job.state = 'reconciled'
     job.updatedAt = Date.now()
     job.terminalUnreconciled = false
@@ -394,10 +399,6 @@ export class BackgroundJobBoard {
     await this.persistRecord(job)
     await this.writeSignal(job)
 
-    if (wasTerminalUnreconciled) {
-      this.notifyTerminal(job.taskID)
-    }
-
     return job
   }
 
@@ -415,17 +416,14 @@ export class BackgroundJobBoard {
   list(parentSessionID?: string): BackgroundJobRecord[] {
     const all = Array.from(this.jobs.values())
     if (!parentSessionID) return [...all]
-    return all.filter(j => j.parentSessionID === parentSessionID)
+    return all.filter((j) => j.parentSessionID === parentSessionID)
   }
 
   /**
    * Resolve a job by either taskID or alias within a parent session.
    * Checks exact taskID first, then falls back to alias matching.
    */
-  resolve(
-    parentSessionID: string,
-    taskIDOrAlias: string,
-  ): BackgroundJobRecord | undefined {
+  resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined {
     // Exact taskID match (session-scoped)
     const byID = this.jobs.get(taskIDOrAlias)
     if (byID?.parentSessionID === parentSessionID) return byID
@@ -538,7 +536,7 @@ export class BackgroundJobBoard {
     const jobs = this.list(parentSessionID)
     if (jobs.length === 0) return undefined
 
-    const lines = jobs.map(j => {
+    const lines = jobs.map((j) => {
       const status =
         j.state === 'completed'
           ? 'OK'
@@ -595,10 +593,7 @@ export class BackgroundJobBoard {
     try {
       await this.persistence.saveJob(record)
     } catch (err) {
-      console.error(
-        `[BackgroundJobBoard] Failed to persist job ${record.taskID}:`,
-        err,
-      )
+      log.error(`[BackgroundJobBoard] Failed to persist job ${record.taskID}:`, err)
     }
   }
 
@@ -607,10 +602,7 @@ export class BackgroundJobBoard {
     try {
       await this.persistence.deleteJob(taskID)
     } catch (err) {
-      console.error(
-        `[BackgroundJobBoard] Failed to delete persisted job ${taskID}:`,
-        err,
-      )
+      log.error(`[BackgroundJobBoard] Failed to delete persisted job ${taskID}:`, err)
     }
   }
 
@@ -619,10 +611,7 @@ export class BackgroundJobBoard {
       try {
         listener(taskID)
       } catch (err) {
-        console.error(
-          `[BackgroundJobBoard] Terminal listener error for ${taskID}:`,
-          err,
-        )
+        log.error(`[BackgroundJobBoard] Terminal listener error for ${taskID}:`, err)
       }
     }
     this.resolveTerminalWaiters(taskID)
@@ -648,10 +637,7 @@ export class BackgroundJobBoard {
       await writeFile(tmpPath, content, 'utf-8')
       await rename(tmpPath, signalPath)
     } catch (err) {
-      console.error(
-        `[BackgroundJobBoard] Failed to write signal for ${record.alias}:`,
-        err,
-      )
+      log.error(`[BackgroundJobBoard] Failed to write signal for ${record.alias}:`, err)
     }
   }
 }

package/src/pantheon/chat-reminders.ts

@@ -0,0 +1,79 @@
+/**
+ * Chat Reminders (release-134 Phase 4) — the SHARED <system-reminder> buffer.
+ *
+ * WHY a shared module (not owned by pantheon-hooks.ts):
+ *   1. opencode's legacy plugin loader (verified in the 1.18.16 source,
+ *      packages/opencode/src/plugin/index.ts getLegacyPlugins) does
+ *      `Object.values(mod)` and treats EVERY export as a plugin factory —
+ *      a non-function export throws `TypeError("Plugin export is not a
+ *      function")` and a function export is invoked with a PluginInput.
+ *      pantheon-hooks.ts therefore cannot EXPORT the enqueue API.
+ *   2. src/plugin.ts (a separate plugin file) must ENQUEUE into the SAME
+ *      buffer the pantheon-hooks `chat.message` hook drains — a local copy
+ *      would enqueue into a buffer that is never delivered.
+ *   3. opencode loads plugins via plain `await import(entry)` (PluginLoader),
+ *      so both plugin files importing this module resolve to ONE module
+ *      instance (Bun/Node module cache) → one shared buffer.
+ *
+ * release-134 Phase 4 uses this buffer for the post-compaction state
+ * re-assertion: `reassertAfterCompaction` (compaction-assert.ts) enqueues a
+ * fresh-state block here, and the existing chat.message delivery path
+ * (pantheon-hooks.ts) injects it as a <system-reminder> into the session's
+ * next message. Zero new delivery code — the P0 messageID guard already
+ * protects subagent promptAsync fires.
+ *
+ * Bounded: at most CHAT_REMINDER_MAX entries, each expiring
+ * CHAT_REMINDER_TTL_MS after enqueue. Full-buffer enqueues are SKIPPED,
+ * never unbounded. No background timers — expiry is only checked on enqueue
+ * and on delivery (drainFreshChatReminders).
+ *
+ * @module chat-reminders
+ */
+
+/**
+ * Hard cap on queued reminder entries (anti-spam philosophy, matching the
+ * "throttled signals are skipped, never backlogged" rule).
+ */
+export const CHAT_REMINDER_MAX = 10
+
+/** How long a queued reminder stays deliverable (pruned after ~60s). */
+export const CHAT_REMINDER_TTL_MS = 60_000
+
+/** One queued reminder: the text plus its enqueue timestamp. */
+export interface ChatReminderEntry {
+  text: string
+  at: number
+}
+
+/** The shared buffer — module-level state, consumed by the chat.message hook. */
+export const pendingChatReminders: ChatReminderEntry[] = []
+
+/**
+ * Queue one chat-reminder entry, pruning expired entries first. Never throws.
+ * A full buffer skips the push (bounded, never backlogged).
+ */
+export function enqueueChatReminder(text: string): void {
+  const now = Date.now()
+  for (let i = pendingChatReminders.length - 1; i >= 0; i--) {
+    const r = pendingChatReminders[i]
+    if (r !== undefined && now - r.at > CHAT_REMINDER_TTL_MS) pendingChatReminders.splice(i, 1)
+  }
+  if (pendingChatReminders.length >= CHAT_REMINDER_MAX) return
+  pendingChatReminders.push({ text, at: now })
+}
+
+/**
+ * Deliver (drain) every FRESH reminder as one joined block: expired entries
+ * are dropped, the buffer is cleared in all cases (no leak). Returns
+ * undefined when nothing fresh remains — the caller skips injection.
+ *
+ * This is the delivery helper the pantheon-hooks `chat.message` hook calls
+ * AFTER its P0 messageID guard (empty messageID → early return, buffer kept).
+ */
+export function drainFreshChatReminders(): string | undefined {
+  const now = Date.now()
+  const fresh = pendingChatReminders.filter((r) => now - r.at <= CHAT_REMINDER_TTL_MS)
+  pendingChatReminders.length = 0
+  if (fresh.length === 0) return undefined
+  return fresh.map((r) => r.text).join('\n')
+}

package/src/pantheon/compaction-assert.ts

@@ -0,0 +1,160 @@
+/**
+ * Compaction Re-Assert (release-134 Phase 4) — re-inject fresh state after
+ * compaction.
+ *
+ * WHY: after a session is compacted, the system state may have changed since
+ * the summary was built (new background delegations launched, results
+ * delivered, goals updated). The compacted session's context is frozen at
+ * summary time — the model would operate on stale state.
+ *
+ * HOW: the `session.compacted` event hook calls `reassertAfterCompaction`,
+ * which builds a COMPACT fresh-state block (running + unread delegations from
+ * the board, active goals from the GoalStore — same gating as Phase 2) and
+ * enqueues it into the SHARED chat-reminder buffer (chat-reminders.ts). The
+ * existing pantheon-hooks `chat.message` hook delivers it as a
+ * <system-reminder> into the session's next message — zero new delivery
+ * code, and the P0 messageID guard already protects subagent fires.
+ *
+ * Deliberately NOT `session.promptAsync({noReply:true})`: the sprint 4+7
+ * spike refuted noReply as a push mechanism on this opencode build (nothing
+ * is delivered to the parent).
+ *
+ * FAIL-OPEN: every source (board list, goals list, enqueue) is wrapped —
+ * a failure logs a warn via the silence-by-default logger and the hook never
+ * throws. A session with NO fresh state (nothing running/unread/goals) is a
+ * SILENT skip (no warn, no reminder). The block is capped at
+ * REASSERT_MAX_LINES item lines (1 header) so it stays compact.
+ *
+ * Pure TypeScript — zero runtime deps beyond the board/goal types and the
+ * shared reminder buffer.
+ *
+ * @module compaction-assert
+ */
+import type { BackgroundJobBoard } from './background-job-board.ts'
+import { enqueueChatReminder } from './chat-reminders.ts'
+import type { CompactionGoalSource } from './delegation-compaction.ts'
+import { createPantheonLogger } from './logger.ts'
+
+// Silence-by-default TUI policy (pantheon-hooks L42-58): console echo is
+// opt-in via PANTHEON_HOOKS_LOG=1. `deps.logger` injection stays for tests.
+const log = createPantheonLogger({ module: 'pantheon-compaction' })
+
+// ─── Constants ─────────────────────────────────────────────────────────
+
+/** Max fresh-state item lines (running + unread + goals) in the block. */
+export const REASSERT_MAX_LINES = 10
+
+/** Header line — tells the model the summary may be stale. */
+export const REASSERT_HEADER = 'State re-assertion after compaction — the summary may be stale:'
+
+// ─── Types ─────────────────────────────────────────────────────────────
+
+/** Dependencies threaded to reassertAfterCompaction (wired from plugin.ts). */
+export interface CompactionAssertDeps {
+  /** The compacted session whose next message receives the reminder. */
+  sessionID: string
+  /** Board query surface — `list` is all the re-assertion needs. */
+  board: Pick<BackgroundJobBoard, 'list'>
+  /** Goal source for the goals block (optional — same gating as Phase 2). */
+  goals?: CompactionGoalSource
+  /** Injectable enqueue (testable). Defaults to the shared chat buffer. */
+  enqueue?: (text: string) => void
+  /** Injectable warn logger (testable). Defaults to silence-by-default. */
+  logger?: { warn: (message: string) => void }
+}
+
+// ─── Formatting ────────────────────────────────────────────────────────
+
+/** One-line terminal status label, mirroring formatForPrompt. */
+function terminalLabel(state: string): string {
+  switch (state) {
+    case 'completed':
+      return 'OK'
+    case 'error':
+      return 'ERR'
+    case 'cancelled':
+      return 'CAN'
+    default:
+      return state.toUpperCase()
+  }
+}
+
+/** Collapse whitespace and truncate a description/objective. */
+function truncate(text: string, max = 80): string {
+  const flat = text.trim().replace(/\s+/g, ' ')
+  return flat.length <= max ? flat : `${flat.slice(0, max)}…`
+}
+
+// ─── Build ─────────────────────────────────────────────────────────────
+
+/**
+ * Build the compact fresh-state lines: running delegations first (active work
+ * is the freshest signal), then unread terminal delegations, then active
+ * goals (only while the line budget allows). Returns undefined when there is
+ * nothing to assert (silent skip) or a source failed (warn + skip).
+ */
+async function buildStateLines(
+  deps: CompactionAssertDeps,
+  warn: (message: string) => void,
+): Promise<string[] | undefined> {
+  const lines: string[] = []
+  try {
+    const jobs = deps.board.list(deps.sessionID)
+    const running = jobs
+      .filter((j) => j.state === 'running')
+      .sort((a, b) => a.launchedAt - b.launchedAt)
+    const unread = jobs
+      .filter((j) => j.terminalUnreconciled)
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+
+    for (const job of running) {
+      if (lines.length >= REASSERT_MAX_LINES) break
+      lines.push(`  running [${job.alias}] ${job.agent} — ${truncate(job.description)}`)
+    }
+    for (const job of unread) {
+      if (lines.length >= REASSERT_MAX_LINES) break
+      lines.push(
+        `  unread [${job.alias}] ${job.agent} — ${truncate(job.description)} — ${terminalLabel(job.state)}`,
+      )
+    }
+
+    const source = deps.goals
+    if (lines.length < REASSERT_MAX_LINES && source !== undefined && source.enabled) {
+      const goals = await source.list(deps.sessionID)
+      for (const goal of goals.filter((g) => g.status !== 'done')) {
+        if (lines.length >= REASSERT_MAX_LINES) break
+        lines.push(`  goal [${goal.id}] ${truncate(goal.objective)} — ${goal.status}`)
+      }
+    }
+  } catch (err: unknown) {
+    const reason = err instanceof Error ? err.message : String(err)
+    warn(`compaction re-assert failed for session ${deps.sessionID}: ${reason}`)
+    return undefined
+  }
+  return lines.length === 0 ? undefined : lines
+}
+
+/**
+ * Re-assert fresh state for a compacted session: build the compact block and
+ * enqueue it as a chat reminder (delivered on the session's next message).
+ *
+ * Returns true when a reminder was enqueued; false when there was nothing to
+ * assert (silent skip) or a source failed (warned). NEVER throws — the event
+ * hook must never break the session.
+ */
+export async function reassertAfterCompaction(deps: CompactionAssertDeps): Promise<boolean> {
+  // Silence-by-default logger: file-only warn, console echo opt-in via
+  // PANTHEON_HOOKS_LOG=1 (TUI pollution policy, pantheon-hooks L42-58).
+  const warn = deps.logger?.warn ?? ((message: string) => log.warn(message))
+  try {
+    const lines = await buildStateLines(deps, warn)
+    if (lines === undefined) return false
+    const enqueue = deps.enqueue ?? enqueueChatReminder
+    enqueue(`${REASSERT_HEADER}\n${lines.join('\n')}`)
+    return true
+  } catch (err: unknown) {
+    const reason = err instanceof Error ? err.message : String(err)
+    warn(`compaction re-assert failed for session ${deps.sessionID}: ${reason}`)
+    return false
+  }
+}

package/src/pantheon/cost-command.ts

@@ -10,8 +10,9 @@
  *   - missing/unreadable db → FRIENDLY error string, never a crash (tools
  *     return errors as TEXT).
  *
- * dbPath resolution: explicit option > env PANTHEON_COST_DB > XDG data
- * home > ~/.local/share/opencode/opencode.db. The tool is wired in
+ * dbPath resolution: explicit option > env PANTHEON_COST_DB > the version-aware
+ * default selected by PANTHEON_OPENCODE_VERSION (v1 or v2). An unset version
+ * deliberately preserves V1 behavior. The tool is wired in
  * plugin.ts alongside the delegation toolset (usable by zeus and any agent
  * with tool access — no routing change needed).
  *
@@ -41,6 +42,8 @@ export interface CostCommandOptions {
   dbPath?: string
 }
 
+export type OpenCodeVersion = 'v1' | 'v2'
+
 /** One cost tool: description + zod args shape + execute (delegation.ts shape). */
 export interface CostTool<Args extends z.ZodRawShape = typeof costArgs> {
   description: string
@@ -62,15 +65,32 @@ const costArgs = {
     .describe('Number of days of delegation history to include (default 7).'),
 } satisfies z.ZodRawShape
 
-/** Resolve candidate db paths in priority order (env override first). */
-function dbCandidates(): string[] {
-  const candidates: string[] = []
-  const env = process.env.PANTHEON_COST_DB
-  if (env !== undefined && env !== '') candidates.push(env)
+/** Return the safe, isolated state DB name for an OpenCode version. */
+function defaultDbPath(version: OpenCodeVersion | undefined): string {
   const xdg = process.env.XDG_DATA_HOME
   const dataHome = xdg !== undefined && xdg !== '' ? xdg : join(homedir(), '.local', 'share')
-  candidates.push(join(dataHome, 'opencode', 'opencode.db'))
-  return candidates
+  const filename = version === 'v2' ? 'opencode-v2.db' : 'opencode.db'
+  return join(dataHome, 'opencode', filename)
+}
+
+/**
+ * Resolve the database without probing another version's database.
+ *
+ * Explicit paths always win. A version selector changes exactly one default
+ * filename; it never falls back to V1, which prevents a V2 report from
+ * silently reading V1 history (or vice versa).
+ */
+export function resolveCostDbPath(options?: CostCommandOptions): string {
+  const explicit = options?.dbPath || process.env.PANTHEON_COST_DB
+  if (explicit) return explicit
+
+  const configuredVersion = process.env.PANTHEON_OPENCODE_VERSION
+  if (configuredVersion !== undefined && configuredVersion !== 'v1' && configuredVersion !== 'v2') {
+    throw new Error(
+      `invalid PANTHEON_OPENCODE_VERSION "${configuredVersion}"; expected "v1" or "v2"`,
+    )
+  }
+  return defaultDbPath(configuredVersion as OpenCodeVersion | undefined)
 }
 
 /**
@@ -79,11 +99,28 @@ function dbCandidates(): string[] {
  * to the real opencode.db).
  */
 function findExistingDb(override?: string): string | undefined {
-  const candidates = override !== undefined && override !== '' ? [override] : dbCandidates()
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate
+  const candidate =
+    override === undefined ? resolveCostDbPath() : resolveCostDbPath({ dbPath: override })
+  return existsSync(candidate) ? candidate : undefined
+}
+
+function assertCompatibleSchema(db: {
+  prepare(sql: string): { get(): unknown; all(...args: unknown[]): unknown[] }
+}): void {
+  const row = db
+    .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'message'")
+    .get()
+  if (row === undefined) {
+    throw new Error('incompatible opencode.db schema: required "message" table is missing')
+  }
+  const columns = db.prepare('PRAGMA table_info(message)').all() as Array<{ name?: unknown }>
+  const names = new Set(columns.map((column) => column.name))
+  const missing = ['data', 'time_created'].filter((name) => !names.has(name))
+  if (missing.length > 0) {
+    throw new Error(
+      `incompatible opencode.db schema: message table is missing ${missing.join(', ')}; select the matching V1/V2 database`,
+    )
   }
-  return undefined
 }
 
 /** Aggregate cost + tokens by agent via node:sqlite (read-only). */
@@ -91,6 +128,7 @@ async function queryWithNodeSqlite(dbPath: string, days: number): Promise<CostRo
   const sqlite = await import('node:sqlite')
   const db = new sqlite.DatabaseSync(dbPath, { readOnly: true })
   try {
+    assertCompatibleSchema(db)
     const since = Date.now() - days * 86_400_000
     const rows = db.prepare('SELECT data FROM message WHERE time_created >= ?').all(since)
     return aggregateMessages(rows.map((row) => String(row.data)))
@@ -180,16 +218,17 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
     try {
       const dbPath = findExistingDb(options?.dbPath)
       if (dbPath === undefined) {
-        const expected =
-          options?.dbPath ?? process.env.PANTHEON_COST_DB ?? '~/.local/share/opencode/opencode.db'
+        const expected = resolveCostDbPath(options)
         return (
           `pantheon_cost failed: opencode.db not found (expected at ${expected}). ` +
           `No cost history is available until opencode has stored session data.`
         )
       }
-      const rows = await queryWithNodeSqlite(dbPath, days).catch(async () =>
-        queryWithScript(scriptPath, dbPath, days),
-      )
+      const rows = await queryWithNodeSqlite(dbPath, days).catch(async (err: unknown) => {
+        if (err instanceof Error && err.message.startsWith('incompatible opencode.db schema'))
+          throw err
+        return queryWithScript(scriptPath, dbPath, days)
+      })
       return renderMarkdown(rows, days)
     } catch (err: unknown) {
       const reason = err instanceof Error ? err.message : String(err)