akm-cli 0.9.0-beta.33 → 0.9.0-beta.35

package/CHANGELOG.md

@@ -6,6 +6,49 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.0-beta.35] — 2026-06-21
+
+### Fixed
+
+- **Default extract discovery window is now "since the last run" (floored at 48h),
+  not a fixed 24h.** An intermittently-online host that was off for longer than
+  the old 24h window could permanently miss sessions that ended during the gap.
+  Discovery now looks back to the last recorded extract run for the harness, never
+  less than 48h. Widening is free of redundant LLM cost — the content-hash ledger
+  skips unchanged sessions with zero LLM calls. An explicit `--since`/`defaultSince`
+  still wins.
+- **Per-session lock prevents concurrent double-extraction.** A session-end hook
+  firing `extract --session-id` while the periodic `akm improve` extract pass runs
+  discovery could both LLM-process the SAME session (duplicate spend + near-dup
+  proposals). A per-(harness, session) advisory lock (co-located with state.db,
+  PID + age staleness recovery) now makes the second run skip without any LLM call.
+- **`minNewSessions` is read from the ACTIVE improve profile, not always `default`.**
+  A non-default profile (e.g. `frequent`) setting `minNewSessions` was silently
+  ignored because the gate (and its candidate-count discovery window) read
+  `profiles.improve.default`. They now read the resolved active profile, matching
+  how `extract.enabled` already resolves.
+
+### Docs
+
+- Documented that `processes.extract.indexSessions` (default on) makes a second
+  LLM call per processed session (the session summary); set it to `false` to halve
+  per-session extract cost. Unchanged/skipped sessions still cost zero.
+
+## [0.9.0-beta.34] — 2026-06-21
+
+### Fixed
+
+- **`akm extract --type opencode` reads opencode's SQLite session store.** opencode
+  migrated session storage from per-file JSON (`storage/session/<projectId>/<id>.json`
+  + `storage/message/<id>/*.json`) to a single Drizzle-managed database at
+  `<base>/opencode.db` (tables `session`/`message`/`part`; message text lives in
+  `part` rows with `data` JSON `type:"text"`). The legacy JSON layout went stale
+  ~2026-02, so extract discovered 0 sessions on current opencode and the
+  `session.idle` extract hook had nothing to read. `OpenCodeProvider` now prefers
+  `opencode.db` when present (read-only, via the cross-driver `openDatabase` seam)
+  and falls back to the JSON layout. Verified end-to-end through the plugin's
+  `session.idle` hook.
+
 ## [0.9.0-beta.33] — 2026-06-21
 
 ### Fixed

package/dist/commands/improve/extract.js

@@ -23,12 +23,15 @@
  *     descriptionQualityValidator passes — same pattern as the
  *     consolidate-writer fix.
  */
+import fs from "node:fs";
+import path from "node:path";
 import { assembleAsset } from "../../core/asset/asset-serialize.js";
 import { resolveStashDir, timestampForFilename } from "../../core/common.js";
 import { getDefaultLlmConfig, loadConfig } from "../../core/config/config.js";
 import { ConfigError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
-import { getExtractedSessionsMap, openStateDatabase, shouldSkipAlreadyExtractedSession, upsertExtractedSession, } from "../../core/state-db.js";
+import { probeLock, releaseLock, tryAcquireLockSync } from "../../core/file-lock.js";
+import { getExtractedSessionsMap, getLastExtractRunAt, getStateDbPath, openStateDatabase, shouldSkipAlreadyExtractedSession, upsertExtractedSession, } from "../../core/state-db.js";
 import { repairTruncatedDescription } from "../../core/text-truncation.js";
 import { warn } from "../../core/warn.js";
 import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integrations/agent/runner.js";
@@ -63,6 +66,88 @@ const DEFAULT_MIN_CONTENT_CHARS = 10;
  * processed by subsequent runs, so coverage is preserved — just spread out.
  */
 const DEFAULT_MAX_SESSIONS_PER_RUN = 25;
+/**
+ * Floor for the default discovery window (48h). When no explicit `--since` /
+ * `defaultSince` is configured, discovery looks back to the LAST recorded
+ * extract run for the harness (so an intermittently-online host that was off for
+ * days still rediscovers sessions that ended during the gap), but never LESS
+ * than this — looking back less than the prior window could drop a session that
+ * a previous run deferred via `maxSessionsPerRun`. Widening is free of redundant
+ * LLM cost: the content-hash ledger skips unchanged sessions with zero LLM calls.
+ */
+const DEFAULT_SINCE_FLOOR_MS = 48 * 60 * 60 * 1000;
+/**
+ * Staleness window for the per-session extract lock. A single session's
+ * processing is bounded by the per-session LLM timeout (default 60s) plus the
+ * session-summary call, so a lock older than this must belong to a crashed
+ * holder and is safe to reclaim.
+ */
+const EXTRACT_SESSION_LOCK_STALE_MS = 5 * 60 * 1000;
+/**
+ * Resolve the discovery `sinceMs` cutoff when no explicit `since`/`defaultSince`
+ * is set: the later of (last recorded extract run for this harness) and
+ * (now − 48h). See {@link DEFAULT_SINCE_FLOOR_MS}. Best-effort — any state.db
+ * error falls back to the 48h floor.
+ */
+function resolveDefaultSinceMs(harnessName, now, opts) {
+    const floor = now - DEFAULT_SINCE_FLOOR_MS;
+    if (opts.skipTracking)
+        return floor;
+    let db = opts.stateDb;
+    let opened = false;
+    try {
+        if (!db) {
+            db = openStateDatabase(opts.stateDbPath);
+            opened = true;
+        }
+        const lastRun = getLastExtractRunAt(db, harnessName);
+        return lastRun != null ? Math.min(lastRun, floor) : floor;
+    }
+    catch {
+        return floor;
+    }
+    finally {
+        if (opened && db) {
+            try {
+                db.close();
+            }
+            catch {
+                // best-effort close
+            }
+        }
+    }
+}
+/** Filesystem-safe per-session lock path, co-located with the state.db. */
+function getExtractSessionLockPath(harness, sessionId, stateDbPath) {
+    const safe = `${harness}-${sessionId}`.replace(/[^A-Za-z0-9._-]/g, "_");
+    return path.join(path.dirname(stateDbPath), "extract-locks", `extract-${safe}.lock`);
+}
+/**
+ * Try to claim the per-session extract lock so a concurrent extract (e.g. a
+ * session-end hook firing `--session-id` while the hourly improve pass runs
+ * discovery) cannot double-process the SAME session — duplicate LLM spend and
+ * near-duplicate proposals. Reclaims a stale lock (dead holder PID or age past
+ * {@link EXTRACT_SESSION_LOCK_STALE_MS}). Returns false when another LIVE run
+ * holds it — the caller then skips the session without any LLM call. Best-effort:
+ * any filesystem error resolves to `true` (proceed) so locking never blocks
+ * extraction outright.
+ */
+function acquireExtractSessionLock(lockPath) {
+    try {
+        fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+        if (tryAcquireLockSync(lockPath, String(process.pid)))
+            return true;
+        const probe = probeLock(lockPath, { staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS });
+        if (probe.state === "held")
+            return false;
+        // absent (released between attempt + probe) or stale → reclaim and retry once.
+        releaseLock(lockPath);
+        return tryAcquireLockSync(lockPath, String(process.pid));
+    }
+    catch {
+        return true;
+    }
+}
 // ── Helpers ──────────────────────────────────────────────────────────────────
 /**
  * Parse a since-string into an absolute ms-epoch cutoff. Accepts:
@@ -625,7 +710,16 @@ export async function akmExtract(options) {
         candidates = [target];
     }
     else {
-        const sinceMs = parseSinceArg(effectiveSince);
+        // No explicit `--since`/`defaultSince` → default to "since the last run"
+        // (floored at 48h) so an intermittently-online host doesn't lose sessions
+        // that ended while it was off. See {@link resolveDefaultSinceMs}.
+        const sinceMs = effectiveSince
+            ? parseSinceArg(effectiveSince)
+            : resolveDefaultSinceMs(harness.name, startMs, {
+                ...(options.stateDb ? { stateDb: options.stateDb } : {}),
+                ...(options.stateDbPath ? { stateDbPath: options.stateDbPath } : {}),
+                ...(options.skipTracking ? { skipTracking: options.skipTracking } : {}),
+            });
         candidates = harness.listSessions({
             sinceMs,
             ...(options.location ? { location: options.location } : {}),
@@ -690,6 +784,31 @@ export async function akmExtract(options) {
             topLevelWarnings.push(`Reached maxSessionsPerRun=${maxSessionsPerRun}; ${candidates.length - processedCount - skippedCount} session(s) deferred to a later run.`);
             break;
         }
+        // Q5 — per-session lock so two concurrent extracts (e.g. a session-end hook
+        // firing `--session-id` while the hourly improve discovery pass runs) can't
+        // both LLM-process the SAME session. The holder records the outcome; a
+        // second run skips without any LLM call. Engaged only for real cross-process
+        // runs (those that open their own state.db): dry-run is read-only, an
+        // injected `stateDb` handle is an in-process/test scenario with no cross-
+        // process race, and skip-tracking-off opts out entirely.
+        let sessionLockPath;
+        if (trackingEnabled && !dryRun && !options.stateDb) {
+            sessionLockPath = getExtractSessionLockPath(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath());
+            if (!acquireExtractSessionLock(sessionLockPath)) {
+                sessions.push({
+                    sessionId: summary.sessionId,
+                    harness: harness.name,
+                    candidateCount: 0,
+                    proposalIds: [],
+                    preFilter: { inputCount: 0, outputCount: 0, truncatedCount: 0 },
+                    warnings: ["concurrent extract holds this session's lock — skipped (handled by the other run)"],
+                    skipped: true,
+                    skipReason: "locked_concurrent",
+                });
+                skippedCount += 1;
+                continue;
+            }
+        }
         try {
             const result = await processSession(harness, summary, stashDir, config, llmConfig, chat, options.ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, triage, sessionIndexing, schemaSimilarityCtx, prior, options.force === true);
             sessions.push(result);
@@ -779,6 +898,10 @@ export async function akmExtract(options) {
             });
             skippedCount += 1;
         }
+        finally {
+            if (sessionLockPath)
+                releaseLock(sessionLockPath);
+        }
     }
     // Close the state.db connection we opened. Callers that injected stateDb
     // via the test seam own its lifecycle.
@@ -838,13 +961,21 @@ export async function akmExtract(options) {
 export function countNewExtractCandidates(config, options = {}) {
     const extractProcess = config.profiles?.improve?.default?.processes?.extract;
     const effectiveSince = options.since ?? extractProcess?.defaultSince;
-    const sinceMs = parseSinceArg(effectiveSince);
+    // Mirror akmExtract: when no explicit window is set, default per-harness to
+    // "since the last run" (floored at 48h) instead of a fixed 24h. Keeps this
+    // gate's discovery window identical to what akmExtract will actually scan.
+    const explicitSinceMs = effectiveSince ? parseSinceArg(effectiveSince) : undefined;
     const harnesses = (options.harnesses ?? getAvailableHarnesses()).filter((h) => h.isAvailable());
     let stateDb = options.stateDb;
     let openedStateDb = false;
     let total = 0;
     try {
         for (const harness of harnesses) {
+            const sinceMs = explicitSinceMs ??
+                resolveDefaultSinceMs(harness.name, Date.now(), {
+                    ...(options.stateDb ? { stateDb: options.stateDb } : {}),
+                    ...(options.stateDbPath ? { stateDbPath: options.stateDbPath } : {}),
+                });
             const candidates = harness.listSessions({ sinceMs });
             if (candidates.length === 0)
                 continue;

package/dist/commands/improve/improve.js

@@ -1887,7 +1887,10 @@ async function runImprovePreparationStage(args) {
     // memory mtimes, so a skipped extract never flags work for the NEXT run's
     // consolidation mtime-gate (the downstream trigger #554 asks us to suppress).
     const EXTRACT_DEFAULT_MIN_NEW_SESSIONS = 0;
-    const configuredMinNewSessions = extractConfig.profiles?.improve?.default?.processes?.extract?.minNewSessions;
+    // Read from the ACTIVE resolved profile (not always `default`), matching how
+    // `extract.enabled` resolves — otherwise a non-default profile (e.g.
+    // `frequent`) setting `minNewSessions` was silently ignored.
+    const configuredMinNewSessions = improveProfile.processes?.extract?.minNewSessions;
     const minNewSessions = typeof configuredMinNewSessions === "number" ? configuredMinNewSessions : EXTRACT_DEFAULT_MIN_NEW_SESSIONS;
     // #593/#594: the ACTIVE resolved improve profile is the single source of
     // truth for whether extract runs. (Previously this also ANDed in the legacy
@@ -1904,6 +1907,11 @@ async function runImprovePreparationStage(args) {
             const countFn = options.extractCandidateCountFn ?? countNewExtractCandidates;
             const newCandidateCount = countFn(extractConfig, {
                 ...(options.extractHarnesses ? { harnesses: options.extractHarnesses } : {}),
+                // Use the ACTIVE profile's discovery window so the gate counts over the
+                // same window akmExtract will scan (not always `default`).
+                ...(improveProfile.processes?.extract?.defaultSince
+                    ? { since: improveProfile.processes.extract.defaultSince }
+                    : {}),
                 // C2: pin the candidate-count state.db open to the boundary-resolved path.
                 ...(eventsCtx?.dbPath ? { stateDbPath: eventsCtx.dbPath } : {}),
             });

package/dist/core/config/config-schema.js

@@ -208,6 +208,11 @@ export const ImproveProcessConfigSchema = z
     maxSessionsPerRun: z.number().int().min(0).optional(),
     // #561 — index agent sessions as a searchable `session` asset (extract
     // process). Absent = on-when-an-LLM-is-available (fail-open when offline).
+    // COST: when on, each processed session makes a SECOND LLM call (the session
+    // summary) on top of the extraction call — i.e. ~2 LLM calls/session. Set to
+    // false to halve per-session extract cost at the price of unsearchable
+    // sessions. (Unchanged/skip sessions still cost zero — the content-hash
+    // ledger gates both calls upstream.)
     indexSessions: z.boolean().optional(),
     // #561 — minimum session duration in minutes for session indexing. 0
     // disables the gate. Absent = default 5. Only meaningful on `extract`.

package/dist/core/state-db.js

@@ -1520,6 +1520,23 @@ export function getExtractedSessionsMap(db, harness, sessionIds) {
     }
     return out;
 }
+/**
+ * The most recent extract-run time for a harness — `MAX(processed_at)` across
+ * its ledger rows, as ms epoch — or `null` when the harness has never been
+ * extracted. Used to default the discovery window to "since the last run" so an
+ * intermittently-online host that was off for days still rediscovers sessions
+ * that ended during the gap (the content-hash ledger keeps the widened window
+ * free of redundant LLM cost).
+ */
+export function getLastExtractRunAt(db, harness) {
+    const row = db
+        .prepare("SELECT MAX(processed_at) AS last FROM extract_sessions_seen WHERE harness = ?")
+        .get(harness);
+    if (!row?.last)
+        return null;
+    const ms = Date.parse(row.last);
+    return Number.isFinite(ms) ? ms : null;
+}
 /**
  * Decide whether a session should be skipped because the extractor has already
  * processed BYTE-IDENTICAL content (#602). The skip authority is the content

package/dist/integrations/harnesses/opencode/session-log.js

@@ -4,6 +4,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { openDatabase } from "../../../storage/database.js";
 import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
 function getOpenCodeBaseDir() {
     if (process.platform === "darwin") {
@@ -12,28 +13,48 @@ function getOpenCodeBaseDir() {
     return path.join(os.homedir(), ".local", "share", "opencode");
 }
 /**
- * Opencode storage layout (observed 2026-05):
- *   <base>/storage/session/<projectId>/<sessionId>.json    — metadata
- *   <base>/storage/message/<sessionId>/<messageId>.json    — one per message
+ * Opencode storage layouts:
+ *
+ *   SQLite (current, observed 2026-06): `<base>/opencode.db` — a Drizzle-managed
+ *   database with `session` / `message` / `part` tables. Message text lives in
+ *   `part` rows (`data` JSON, `type: "text"`); `message.data` holds role/timing.
+ *   This is the layout current opencode builds write; it is preferred whenever
+ *   `opencode.db` exists.
+ *
+ *   JSON files (legacy, observed 2026-05): `<base>/storage/session/<projectId>/
+ *   <sessionId>.json` (metadata) + `<base>/storage/message/<sessionId>/
+ *   <messageId>.json` (one per message). Read only when `opencode.db` is absent.
  *
  * Older builds wrote logs directly into `<base>/log/` and `<base>/*.log`;
  * those are still scanned by {@link OpenCodeProvider.readEvents} for
  * backward compatibility with the existing failure-pattern aggregator.
  */
+/** Filename of opencode's SQLite session store, relative to its base dir. */
+const OPENCODE_DB_FILENAME = "opencode.db";
 export class OpenCodeProvider {
     name = "opencode";
     #baseDir = getOpenCodeBaseDir();
     isAvailable() {
         return fs.existsSync(this.#baseDir);
     }
+    /** Absolute path to opencode's SQLite store under `base`. */
+    #dbPath(base) {
+        return path.join(base, OPENCODE_DB_FILENAME);
+    }
     /**
-     * Directory holding opencode's per-project session metadata files
-     * (`<base>/storage/session`). Returns `[]` when it does not exist on this
-     * machine. See {@link SessionLogHarness.watchRoots}.
+     * Directories/files opencode writes session data under. Returns the base dir
+     * when the SQLite store (`opencode.db`) exists, the legacy JSON session root
+     * (`<base>/storage/session`) when present, or both during a migration overlap.
+     * Empty when neither exists. See {@link SessionLogHarness.watchRoots}.
      */
     watchRoots() {
+        const roots = [];
+        if (fs.existsSync(this.#dbPath(this.#baseDir)))
+            roots.push(this.#baseDir);
         const sessionRoot = path.join(this.#baseDir, "storage", "session");
-        return fs.existsSync(sessionRoot) ? [sessionRoot] : [];
+        if (fs.existsSync(sessionRoot))
+            roots.push(sessionRoot);
+        return roots;
     }
     *readEvents(input) {
         // Legacy behavior: stream raw log lines from the top-level dir and `log/`
@@ -91,6 +112,9 @@ export class OpenCodeProvider {
     listSessions(input = {}) {
         const base = input.location ?? this.#baseDir;
         const sinceMs = input.sinceMs ?? 0;
+        const dbPath = this.#dbPath(base);
+        if (fs.existsSync(dbPath))
+            return this.#listSessionsFromDb(dbPath, sinceMs);
         const sessionRoot = path.join(base, "storage", "session");
         if (!fs.existsSync(sessionRoot))
             return [];
@@ -151,6 +175,8 @@ export class OpenCodeProvider {
         return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
     }
     readSession(ref) {
+        if (path.basename(ref.filePath) === OPENCODE_DB_FILENAME)
+            return this.#readSessionFromDb(ref);
         let meta = {};
         try {
             meta = JSON.parse(fs.readFileSync(ref.filePath, "utf8"));
@@ -208,6 +234,141 @@ export class OpenCodeProvider {
             inlineRefs,
         };
     }
+    /**
+     * List sessions from the SQLite store. `filePath` on each summary is the
+     * `opencode.db` path so {@link readSession} can route back to the DB reader.
+     * Returns `[]` (never throws) when the DB is unreadable or lacks the expected
+     * schema — callers treat a missing harness as "no sessions".
+     */
+    #listSessionsFromDb(dbPath, sinceMs) {
+        let db;
+        try {
+            db = openDatabase(dbPath, { readonly: true, create: false });
+        }
+        catch {
+            return [];
+        }
+        try {
+            const rows = db
+                .prepare("SELECT id, title, directory, time_created, time_updated FROM session WHERE time_updated >= ? ORDER BY time_updated DESC")
+                .all(sinceMs);
+            return rows.map((r) => {
+                const startedAt = typeof r.time_created === "number" ? r.time_created : undefined;
+                const endedAt = typeof r.time_updated === "number" ? r.time_updated : undefined;
+                const title = typeof r.title === "string" && r.title.length > 0 ? r.title : undefined;
+                const projectHint = typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined;
+                return {
+                    harness: this.name,
+                    sessionId: r.id,
+                    filePath: dbPath,
+                    ...(startedAt !== undefined ? { startedAt } : {}),
+                    ...(endedAt !== undefined ? { endedAt } : {}),
+                    ...(projectHint ? { projectHint } : {}),
+                    ...(title ? { title } : {}),
+                };
+            });
+        }
+        catch {
+            // Missing `session` table / unexpected schema — treat as no sessions.
+            return [];
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Read one session from the SQLite store. Message text lives in `part` rows
+     * (`type: "text"`); `message.data` carries role + timing. One event per
+     * message, text-parts concatenated in time order. Returns empty events
+     * (never throws) when the DB is unreadable.
+     */
+    #readSessionFromDb(ref) {
+        const emptyRef = { harness: this.name, sessionId: ref.sessionId, filePath: ref.filePath };
+        let db;
+        try {
+            db = openDatabase(ref.filePath, { readonly: true, create: false });
+        }
+        catch {
+            return { ref: emptyRef, events: [], inlineRefs: [] };
+        }
+        try {
+            const meta = db
+                .prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?")
+                .get(ref.sessionId);
+            const startedAt = typeof meta?.time_created === "number" ? meta.time_created : undefined;
+            const endedAt = typeof meta?.time_updated === "number" ? meta.time_updated : undefined;
+            const title = typeof meta?.title === "string" && meta.title.length > 0 ? meta.title : undefined;
+            const projectHint = typeof meta?.directory === "string" && meta.directory.length > 0 ? meta.directory : undefined;
+            const messages = db
+                .prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+                .all(ref.sessionId);
+            const parts = db
+                .prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+                .all(ref.sessionId);
+            // Group text-part bodies by their parent message.
+            const textByMessage = new Map();
+            for (const part of parts) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(part.data);
+                }
+                catch {
+                    continue;
+                }
+                if (parsed?.type !== "text")
+                    continue;
+                const text = parsed.text;
+                if (typeof text !== "string" || text.length < 1)
+                    continue;
+                const bucket = textByMessage.get(part.message_id) ?? [];
+                bucket.push(text);
+                textByMessage.set(part.message_id, bucket);
+            }
+            const events = [];
+            const inlineRefs = [];
+            for (const message of messages) {
+                let mdata = {};
+                try {
+                    mdata = JSON.parse(message.data);
+                }
+                catch {
+                    // role/timing unavailable — fall through with defaults
+                }
+                const role = typeof mdata.role === "string" ? mdata.role : "unknown";
+                const mtime = mdata.time?.created;
+                const ts = typeof mtime === "number"
+                    ? mtime
+                    : typeof message.time_created === "number"
+                        ? message.time_created
+                        : undefined;
+                const text = (textByMessage.get(message.id) ?? []).join("\n").trim();
+                if (text.length < 1)
+                    continue;
+                events.push({ harness: this.name, text, ts, sessionId: ref.sessionId, role, filePath: ref.filePath });
+                inlineRefs.push(...extractInlineRefMentions(text, ts));
+            }
+            events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+            return {
+                ref: {
+                    harness: this.name,
+                    sessionId: ref.sessionId,
+                    filePath: ref.filePath,
+                    ...(startedAt !== undefined ? { startedAt } : {}),
+                    ...(endedAt !== undefined ? { endedAt } : {}),
+                    ...(projectHint ? { projectHint } : {}),
+                    ...(title ? { title } : {}),
+                },
+                events,
+                inlineRefs,
+            };
+        }
+        catch {
+            return { ref: emptyRef, events: [], inlineRefs: [] };
+        }
+        finally {
+            db.close();
+        }
+    }
     /**
      * Derive opencode base dir from a session metadata file path so a caller
      * passing a custom `--location` can still find the message dir.

package/dist/scripts/migrate-storage.js

@@ -8998,6 +8998,7 @@ __export(exports_state_db, {
   getStateDbPath: () => getStateDbPath,
   getRecombineHypothesis: () => getRecombineHypothesis,
   getPhaseThreshold: () => getPhaseThreshold,
+  getLastExtractRunAt: () => getLastExtractRunAt,
   getExtractedSessionsMap: () => getExtractedSessionsMap,
   getExtractedSession: () => getExtractedSession,
   getConsolidationJudgedMap: () => getConsolidationJudgedMap,
@@ -9437,6 +9438,13 @@ function getExtractedSessionsMap(db, harness, sessionIds) {
   }
   return out;
 }
+function getLastExtractRunAt(db, harness) {
+  const row = db.prepare("SELECT MAX(processed_at) AS last FROM extract_sessions_seen WHERE harness = ?").get(harness);
+  if (!row?.last)
+    return null;
+  const ms = Date.parse(row.last);
+  return Number.isFinite(ms) ? ms : null;
+}
 function shouldSkipAlreadyExtractedSession(prior, currentContentHash) {
   if (!prior)
     return false;
@@ -10934,9 +10942,17 @@ class OpenCodeProvider {
   isAvailable() {
     return fs10.existsSync(this.#baseDir);
   }
+  #dbPath(base) {
+    return path9.join(base, OPENCODE_DB_FILENAME);
+  }
   watchRoots() {
+    const roots = [];
+    if (fs10.existsSync(this.#dbPath(this.#baseDir)))
+      roots.push(this.#baseDir);
     const sessionRoot = path9.join(this.#baseDir, "storage", "session");
-    return fs10.existsSync(sessionRoot) ? [sessionRoot] : [];
+    if (fs10.existsSync(sessionRoot))
+      roots.push(sessionRoot);
+    return roots;
   }
   *readEvents(input) {
     const candidates = [this.#baseDir, path9.join(this.#baseDir, "log")];
@@ -10985,6 +11001,9 @@ class OpenCodeProvider {
   listSessions(input = {}) {
     const base = input.location ?? this.#baseDir;
     const sinceMs = input.sinceMs ?? 0;
+    const dbPath = this.#dbPath(base);
+    if (fs10.existsSync(dbPath))
+      return this.#listSessionsFromDb(dbPath, sinceMs);
     const sessionRoot = path9.join(base, "storage", "session");
     if (!fs10.existsSync(sessionRoot))
       return [];
@@ -11039,6 +11058,8 @@ class OpenCodeProvider {
     return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
   }
   readSession(ref) {
+    if (path9.basename(ref.filePath) === OPENCODE_DB_FILENAME)
+      return this.#readSessionFromDb(ref);
     let meta = {};
     try {
       meta = JSON.parse(fs10.readFileSync(ref.filePath, "utf8"));
@@ -11088,6 +11109,106 @@ class OpenCodeProvider {
       inlineRefs
     };
   }
+  #listSessionsFromDb(dbPath, sinceMs) {
+    let db;
+    try {
+      db = openDatabase(dbPath, { readonly: true, create: false });
+    } catch {
+      return [];
+    }
+    try {
+      const rows = db.prepare("SELECT id, title, directory, time_created, time_updated FROM session WHERE time_updated >= ? ORDER BY time_updated DESC").all(sinceMs);
+      return rows.map((r) => {
+        const startedAt = typeof r.time_created === "number" ? r.time_created : undefined;
+        const endedAt = typeof r.time_updated === "number" ? r.time_updated : undefined;
+        const title = typeof r.title === "string" && r.title.length > 0 ? r.title : undefined;
+        const projectHint = typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined;
+        return {
+          harness: this.name,
+          sessionId: r.id,
+          filePath: dbPath,
+          ...startedAt !== undefined ? { startedAt } : {},
+          ...endedAt !== undefined ? { endedAt } : {},
+          ...projectHint ? { projectHint } : {},
+          ...title ? { title } : {}
+        };
+      });
+    } catch {
+      return [];
+    } finally {
+      db.close();
+    }
+  }
+  #readSessionFromDb(ref) {
+    const emptyRef = { harness: this.name, sessionId: ref.sessionId, filePath: ref.filePath };
+    let db;
+    try {
+      db = openDatabase(ref.filePath, { readonly: true, create: false });
+    } catch {
+      return { ref: emptyRef, events: [], inlineRefs: [] };
+    }
+    try {
+      const meta = db.prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?").get(ref.sessionId);
+      const startedAt = typeof meta?.time_created === "number" ? meta.time_created : undefined;
+      const endedAt = typeof meta?.time_updated === "number" ? meta.time_updated : undefined;
+      const title = typeof meta?.title === "string" && meta.title.length > 0 ? meta.title : undefined;
+      const projectHint = typeof meta?.directory === "string" && meta.directory.length > 0 ? meta.directory : undefined;
+      const messages = db.prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(ref.sessionId);
+      const parts = db.prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(ref.sessionId);
+      const textByMessage = new Map;
+      for (const part of parts) {
+        let parsed;
+        try {
+          parsed = JSON.parse(part.data);
+        } catch {
+          continue;
+        }
+        if (parsed?.type !== "text")
+          continue;
+        const text = parsed.text;
+        if (typeof text !== "string" || text.length < 1)
+          continue;
+        const bucket = textByMessage.get(part.message_id) ?? [];
+        bucket.push(text);
+        textByMessage.set(part.message_id, bucket);
+      }
+      const events = [];
+      const inlineRefs = [];
+      for (const message of messages) {
+        let mdata = {};
+        try {
+          mdata = JSON.parse(message.data);
+        } catch {}
+        const role = typeof mdata.role === "string" ? mdata.role : "unknown";
+        const mtime = mdata.time?.created;
+        const ts = typeof mtime === "number" ? mtime : typeof message.time_created === "number" ? message.time_created : undefined;
+        const text = (textByMessage.get(message.id) ?? []).join(`
+`).trim();
+        if (text.length < 1)
+          continue;
+        events.push({ harness: this.name, text, ts, sessionId: ref.sessionId, role, filePath: ref.filePath });
+        inlineRefs.push(...extractInlineRefMentions(text, ts));
+      }
+      events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+      return {
+        ref: {
+          harness: this.name,
+          sessionId: ref.sessionId,
+          filePath: ref.filePath,
+          ...startedAt !== undefined ? { startedAt } : {},
+          ...endedAt !== undefined ? { endedAt } : {},
+          ...projectHint ? { projectHint } : {},
+          ...title ? { title } : {}
+        },
+        events,
+        inlineRefs
+      };
+    } catch {
+      return { ref: emptyRef, events: [], inlineRefs: [] };
+    } finally {
+      db.close();
+    }
+  }
   #inferBaseFromSessionPath(filePath) {
     const dir = path9.dirname(filePath);
     const parts = dir.split(path9.sep);
@@ -11135,7 +11256,9 @@ class OpenCodeProvider {
     };
   }
 }
+var OPENCODE_DB_FILENAME = "opencode.db";
 var init_session_log2 = __esm(() => {
+  init_database();
   init_inline_refs();
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.0-beta.33",
+  "version": "0.9.0-beta.35",
   "type": "module",
   "description": "akm (Agent Knowledge Management) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [