akm-cli 0.9.0-beta.32 → 0.9.0-beta.34

package/CHANGELOG.md

@@ -6,6 +6,37 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [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
+
+- **`akm extract` decoupled from the improve-stage toggle.** `processes.extract.enabled`
+  now gates extract only as a STAGE of `akm improve` (the active improve profile, per
+  #593/#594); an explicit `akm extract` command always runs. Previously dropping extract
+  from the daily improve profile silently disabled the standalone command (and its LLM
+  calls, via the shared `session_extraction` feature gate).
+- **`extract --session-id` now respects the content-hash ledger; `--force` overrides.**
+  Explicit single-session extraction previously bypassed the #602 already-extracted skip
+  unconditionally — re-paying the LLM on every call and risking double-extraction against
+  the cron. Now a targeted `extract --session-id <id>` is idempotent (skips an unchanged,
+  already-extracted session with zero LLM calls) and only `--force` re-extracts. This
+  makes a session-end hook firing `extract --session-id <id>` precise AND idempotent.
+
 ## [0.9.0-beta.32] — 2026-06-21
 
 ### Added

package/dist/commands/improve/extract.js

@@ -37,7 +37,7 @@ import { getAvailableHarnesses } from "../../integrations/session-logs/index.js"
 import { preFilterSession } from "../../integrations/session-logs/pre-filter.js";
 import { chatCompletion } from "../../llm/client.js";
 import { embed } from "../../llm/embedder.js";
-import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
+import { tryLlmFeature } from "../../llm/feature-gate.js";
 import { sha256Hex } from "../../runtime.js";
 import { createProposal, isProposalSkipped } from "../proposal/validators/proposals.js";
 import { buildExtractPrompt, EXTRACT_JSON_SCHEMA, parseExtractPayload } from "./extract-prompt.js";
@@ -180,7 +180,7 @@ triage, sessionIndexing, schemaSimilarityCtx,
 // prior row + bypass flags are threaded in from the caller. Skipping here still
 // costs ZERO LLM calls (the expensive resource #602 protects); only the cheap
 // file read is incurred.
-prior, force, singleSession) {
+prior, force) {
     const warnings = [];
     let data;
     try {
@@ -201,10 +201,12 @@ prior, force, singleSession) {
     // #602 — content-hash skip. Computed on the RAW event stream immediately after
     // a successful read, BEFORE the pre-filter / minContentChars / triage gates, so
     // an unchanged session never reaches the LLM. Hash-based ⇒ clock-independent
-    // (immune to the Jun 11-12 timestamp double-extract/over-throttle bug). --force
-    // and single-session (explicit sessionId) modes bypass the skip entirely.
+    // (immune to the Jun 11-12 timestamp double-extract/over-throttle bug). The skip
+    // applies UNIFORMLY — including explicit `--session-id` targeting (so a
+    // session-end hook firing `extract --session-id <id>` is idempotent). ONLY
+    // `--force` overrides it to re-extract a previously-extracted session.
     const contentHash = hashSessionContent(data);
-    if (!force && !singleSession && shouldSkipAlreadyExtractedSession(prior, contentHash)) {
+    if (!force && shouldSkipAlreadyExtractedSession(prior, contentHash)) {
         return {
             sessionId: sessionRef.sessionId,
             harness: harness.name,
@@ -470,9 +472,13 @@ export async function akmExtract(options) {
     const extractProcess = activeProfile
         ? activeProfile.processes?.extract
         : config.profiles?.improve?.default?.processes?.extract;
-    const extractEnabled = activeProfile
-        ? resolveProcessEnabled("extract", activeProfile)
-        : isLlmFeatureEnabled(config, "session_extraction");
+    // The `extract.enabled` process toggle gates extract as a STAGE of `akm improve`
+    // (the activeProfile path) — consistent with #593/#594 where the active profile,
+    // not `default`, is the source of truth. An EXPLICIT `akm extract` invocation
+    // (no activeProfile) is a direct user/cron action and always runs; gating it on
+    // the default improve profile's stage toggle was a footgun — dropping extract
+    // from the daily improve profile would silently disable the standalone command.
+    const extractEnabled = activeProfile ? resolveProcessEnabled("extract", activeProfile) : true;
     // Feature-gate early so we get a clean "skipped because disabled" envelope.
     if (!extractEnabled) {
         return {
@@ -685,7 +691,7 @@ export async function akmExtract(options) {
             break;
         }
         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, typeof options.sessionId === "string" && options.sessionId.length > 0);
+            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);
             // #626 — triage aggregation. A session reached the triage gate only when it
             // was NOT already preempted by an earlier skip (read_failed / too_short /

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/llm/feature-gate.js

@@ -30,10 +30,14 @@ const FEATURE_LOCATION = {
     proposal_quality_gate: (cfg) => cfg.profiles?.improve?.default?.processes?.reflect?.qualityGate?.enabled ?? false,
     // Legacy default: false
     memory_contradiction_detection: (cfg) => cfg.profiles?.improve?.default?.processes?.consolidate?.contradictionDetection?.enabled ?? false,
-    // Default: true. Session extraction replaces the akm-plugin checkpoint hook
-    // and is the primary path for capturing durable signal from real sessions.
-    // Opt out via `profiles.improve.default.processes.extract.enabled: false`.
-    session_extraction: (cfg) => cfg.profiles?.improve?.default?.processes?.extract?.enabled ?? true,
+    // Always on at the LLM-wrapper level. Enablement is decided ONCE at the
+    // extract entry point (`akmExtract`): the `extract.enabled` process toggle
+    // gates extract as a STAGE of `akm improve` (the active improve profile, per
+    // #593/#594), while an explicit `akm extract` command always runs. Gating the
+    // inner LLM calls on `default.processes.extract.enabled` here was a footgun —
+    // dropping extract from the daily improve profile silently disabled the
+    // standalone `akm extract` command. (cfg unused — kept for resolver signature.)
+    session_extraction: (_cfg) => true,
 };
 /**
  * Pure predicate: is the named feature gate enabled in `config`?

package/dist/scripts/migrate-storage.js

@@ -10934,9 +10934,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 +10993,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 +11050,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 +11101,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 +11248,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.32",
+  "version": "0.9.0-beta.34",
   "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": [