akm-cli 0.9.17 → 0.9.18

package/CHANGELOG.md

@@ -6,6 +6,28 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.18] - 2026-09-29
+
+### Fixed
+
+- **A running `akm improve` no longer loses its SQLite file locks, which let
+  an older `sqlite3` delete `state.db`'s WAL.** Copying a database file
+  inside a process that also holds it open drops every POSIX lock the process
+  holds on it, and `akm improve` did exactly that (its read snapshots copy
+  `state.db`, hundreds of times a run). A peer on SQLite older than 3.51 (the
+  system `sqlite3` command, Python's `sqlite3` module) that then opened
+  `state.db` read-write, even just for `.backup`, saw no reader and deleted
+  `state.db-wal`/`-shm` at close, leaving colliding rowids, stale index
+  entries and lost rows. Affected: every release since 0.9.2 through the
+  snapshot, and 0.9.2 through 0.9.16 also on every `openStateDatabase` (fixed
+  in 0.9.17-alpha.4). The snapshot now copies in a child `cp` (Windows keeps
+  the in-process copy; its locks belong to the handle), and `improve` reads
+  proposals through its own connection instead of snapshotting per asset.
+  `akm health`'s `state-db-integrity` check now runs `PRAGMA integrity_check`,
+  since `quick_check` does not compare indexes with their tables and reported
+  this damage as `ok`. On earlier releases, open a live database only with
+  `sqlite3 -readonly`.
+
 ## [0.9.17] - 2026-09-29
 
 ### Added

package/dist/commands/health/checks.js

@@ -888,7 +888,7 @@ export const HEALTH_CHECKS = [
         // R0: nothing looked at state.db's own SQLite-level integrity before
         // this — the round-trip probe above only proves one row can be appended
         // and read back, which stays true on a database that fails
-        // `PRAGMA quick_check` elsewhere (corrupt indexes, out-of-order rowids).
+        // `PRAGMA integrity_check` elsewhere (corrupt indexes, out-of-order rowids).
         // Also reports the freelist ratio (fraction of pages VACUUM could
         // reclaim) so a bloated-but-uncorrupted file is visible as a warning
         // rather than silence.
@@ -904,8 +904,8 @@ export const HEALTH_CHECKS = [
                     kind: "deterministic",
                     status: "fail",
                     confidence: "high",
-                    message: `state.db failed PRAGMA quick_check: ${detail}. Repair: back up state.db, then run ` +
-                        `sqlite3 state.db ".recover" | sqlite3 state.new.db, verify state.new.db passes quick_check, stop ` +
+                    message: `state.db failed PRAGMA integrity_check: ${detail}. Repair: back up state.db, then run ` +
+                        `sqlite3 -readonly state.db ".recover" | sqlite3 state.new.db, verify state.new.db passes integrity_check, stop ` +
                         "every akm process, then delete state.db-wal and state.db-shm before swapping state.new.db in as " +
                         "state.db — a leftover WAL from the OLD database is replayed onto the new one and corrupts it.",
                     evidence: { path: ctx.stateDbPath, lines, freelistRatio },
@@ -917,7 +917,7 @@ export const HEALTH_CHECKS = [
                     kind: "deterministic",
                     status: "fail",
                     confidence: "high",
-                    message: `state.db passed PRAGMA quick_check, but reading its freelist/page-count failed: ${freelistError}.`,
+                    message: `state.db passed PRAGMA integrity_check, but reading its freelist/page-count failed: ${freelistError}.`,
                     evidence: { path: ctx.stateDbPath, lines, freelistError },
                 };
             }
@@ -928,8 +928,8 @@ export const HEALTH_CHECKS = [
                 status: freelistWarn ? "warn" : "pass",
                 confidence: "high",
                 message: freelistWarn
-                    ? `state.db passed PRAGMA quick_check, but ${(freelistRatio * 100).toFixed(1)}% of its pages are free (reclaimable by VACUUM).`
-                    : "state.db passed PRAGMA quick_check.",
+                    ? `state.db passed PRAGMA integrity_check, but ${(freelistRatio * 100).toFixed(1)}% of its pages are free (reclaimable by VACUUM).`
+                    : "state.db passed PRAGMA integrity_check.",
                 evidence: {
                     path: ctx.stateDbPath,
                     freelistCount: ctx.stateDbFreelist.freelistCount,

package/dist/commands/health.js

@@ -17,7 +17,7 @@ import { countImproveRunsSince } from "../storage/repositories/improve-runs-repo
 import { closeDatabase, openReadonlyExistingDatabase } from "../storage/repositories/index-connection.js";
 import { getAllEntries } from "../storage/repositories/index-entries-repository.js";
 import { queryTaskHistory } from "../storage/repositories/task-history-repository.js";
-import { getStateDbFreelistInfo, runStateDbQuickCheck } from "../storage/state-db-integrity.js";
+import { getStateDbFreelistInfo, runStateDbIntegrityCheck } from "../storage/state-db-integrity.js";
 import { pkgVersion } from "../version.js";
 import { collectArchiveUsageAdvisory } from "./health/archive-usage.js";
 import { HEALTH_CHECKS, probeActiveImproveStrategy, runHealthEngineProbes, runPendingStateMigrationsCheck, SESSION_EXTRACTION_LEDGER_WINDOW_DAYS, } from "./health/checks.js";
@@ -182,10 +182,10 @@ function gatherTaskHistoryPhase(db, since, stateDbPath, now) {
     const requiredTables = ["events", "proposals", "schema_migrations", "task_history"];
     const missingTables = requiredTables.filter((name) => !tableNames.includes(name));
     const probe = probeStateDbRoundTrip(stateDbPath);
-    // R0: read-only, independent of the round-trip probe above — quick_check
+    // R0: read-only, independent of the round-trip probe above — integrity_check
     // catches corruption a successful append/read cannot (out-of-order rowids,
     // bad index entry counts), and the freelist reading is purely informational.
-    const stateDbIntegrity = runStateDbQuickCheck(stateDbPath);
+    const stateDbIntegrity = runStateDbIntegrityCheck(stateDbPath);
     const stateDbFreelist = getStateDbFreelistInfo(stateDbPath);
     // D8 (spec §5.3): a marked "command" row or a legacy (unmarked) "prompt"
     // row is the agent/LLM arm; an unmarked "command" row is the legacy

package/dist/commands/improve/consolidate/pair-pass.js

@@ -635,7 +635,7 @@ seams = {}) {
     // also be judged as part of another until that decision resolves.
     const pendingRetireRefs = new Set();
     try {
-        for (const p of listProposalsReadOnly(stashDir, { status: "pending" })) {
+        for (const p of listProposalsReadOnly(stashDir, { status: "pending" }, opts.proposalsCtx)) {
             if (!isRetireProposal(p))
                 continue;
             pendingRetireRefs.add(stripBundle(p.ref));
@@ -657,7 +657,7 @@ seams = {}) {
     const rejectedPairKeys = new Set();
     try {
         for (const status of ["rejected", "reverted"]) {
-            for (const p of listProposalsReadOnly(stashDir, { status, includeArchive: true })) {
+            for (const p of listProposalsReadOnly(stashDir, { status, includeArchive: true }, opts.proposalsCtx)) {
                 if (!isRetireProposal(p) || !p.retirement)
                     continue;
                 rejectedPairKeys.add(rejectedPairKey(p.retirement.retiredRef, p.retirement.successorRef, p.retirement.retiredContentHash, p.retirement.successorContentHash));

package/dist/commands/improve/consolidate.js

@@ -222,10 +222,10 @@ function injectRandomClusterMembers(memories, profile, warnings) {
     return out;
 }
 /** Body hashes of pending consolidate proposals, so the prompt can mark memories already queued. */
-function loadPendingConsolidateProposalHashes(stashDir) {
+function loadPendingConsolidateProposalHashes(stashDir, proposalsCtx) {
     const hashes = new Set();
     try {
-        for (const p of listProposalsReadOnly(stashDir, { status: "pending" })) {
+        for (const p of listProposalsReadOnly(stashDir, { status: "pending" }, proposalsCtx)) {
             if (p.source !== "consolidate")
                 continue;
             try {
@@ -622,7 +622,7 @@ async function planConsolidation(opts, config, stashDir, memories, warnings, sta
         assertRunnerCredentials(llmRunner);
     const { ordered, embedTelemetry } = await clusterMemoriesBySimilarity(budgeted, config, stateDb, opts.signal);
     const chunks = slice(injectRandomClusterMembers(ordered, opts.improveProfile, warnings));
-    const pendingProposalBodyHashes = loadPendingConsolidateProposalHashes(stashDir);
+    const pendingProposalBodyHashes = loadPendingConsolidateProposalHashes(stashDir, opts.proposalsCtx);
     warn(`[consolidate] ${budgeted.length} memories / ${chunks.length} chunk(s) / chunk_size=${chunkSize}` +
         ` / pending-proposal hashes: ${pendingProposalBodyHashes.size}`);
     const planned = await judgeConsolidationChunks({

package/dist/commands/improve/distill.js

@@ -799,7 +799,7 @@ function readDistillFeedback(run) {
 }
 /** System + user prompt: rejected-proposal context, optional CLS neighbours, stash standards. */
 async function buildDistillMessages(run, feedback, kind, outputRef) {
-    const rejectedProposals = rejectedProposalContext(run.stash, run.inputRef, run.options.ctx);
+    const rejectedProposals = rejectedProposalContext(run.stash, run.inputRef, run.options.ctx, run.options.eventsCtx);
     // CLS interleaving (default off): show related lessons so the model does not overwrite them.
     const cls = getImproveProcessConfig("distill", run.profile)?.cls ?? {};
     let clsContext = "";

package/dist/commands/improve/preparation.js

@@ -209,6 +209,8 @@ async function runConsolidationPass(args) {
             maxChunkSize: processConfig?.maxChunkSize,
             signal: args.budgetSignal,
             p90ChunkSecondsDefault: processConfig?.p90ChunkSecondsDefault,
+            // Its read-only proposal lookups go through the run's own state.db handle.
+            ...(eventsCtx?.db ? { proposalsCtx: { db: eventsCtx.db } } : {}),
         }));
     }
     return { consolidation, plan: planned.plan };

package/dist/commands/improve/reflect.js

@@ -761,7 +761,7 @@ async function gatherReflectPromptSources(options, stash, parsedRef, assetConten
         relatedLessons: options.ref && parsedRef
             ? await readRelatedLessons(stash, options.ref, parsedRef, options.itemRef, options.eventsCtx)
             : [],
-        rejectedProposals: rejectedProposalContext(stash, options.ref, options.ctx),
+        rejectedProposals: rejectedProposalContext(stash, options.ref, options.ctx, options.eventsCtx),
         standardsContext: resolveStandardsContext(options.ref, stash),
     };
 }

package/dist/commands/improve/stage.js

@@ -100,12 +100,14 @@ export const MAX_REJECTED_PROPOSALS = 3;
 /**
  * Reflexion context: the newest reviewer rejections for `ref`. Procedural
  * refusals (expiry, stale target, missing asset) are not judgements on the
- * content and are left out. Reads never create state.db.
+ * content and are left out. Reads never create state.db, and an improve run's
+ * live connection (`eventsCtx.db`) is read through, not copied.
  */
-export function rejectedProposalContext(stash, ref, ctx) {
+export function rejectedProposalContext(stash, ref, ctx, eventsCtx) {
     if (!ref)
         return [];
-    return listProposalsReadOnly(stash, { ref, status: "rejected", includeArchive: true }, ctx)
+    const proposalsCtx = eventsCtx?.db ? { ...ctx, db: eventsCtx.db } : ctx;
+    return listProposalsReadOnly(stash, { ref, status: "rejected", includeArchive: true }, proposalsCtx)
         .filter((p) => !isProceduralRejection(p))
         .sort((a, b) => new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime())
         .slice(0, MAX_REJECTED_PROPOSALS)

package/dist/commands/proposal/repository.js

@@ -373,9 +373,13 @@ export function listProposals(stashDir, options = {}, ctx) {
 /**
  * {@link listProposals} on a read snapshot that never creates or migrates
  * state.db: prompt building runs before the first dispatch has validated its
- * credentials, and a missing store is simply empty.
+ * credentials, and a missing store is simply empty. A caller that already
+ * holds a live connection (`ctx.db`) reads through it: a snapshot would copy
+ * the whole database for nothing.
  */
 export function listProposalsReadOnly(stashDir, options = {}, ctx) {
+    if (ctx?.db)
+        return queryProposals(ctx.db, stashDir, options);
     const dbPath = ctx?.dbPath ?? getStateDbPath();
     if (!fs.existsSync(dbPath))
         return [];

package/dist/scripts/akm-migrate-node.js

@@ -52064,6 +52064,7 @@ import os6 from "node:os";
 import path44 from "node:path";
 
 // src/storage/sqlite-read-snapshot.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
 import fs36 from "node:fs";
 import os5 from "node:os";
 import path43 from "node:path";
@@ -52108,6 +52109,26 @@ function fingerprintsEqual(left, right) {
   const sameFile = (a, b) => a?.size === b?.size && a?.mtimeNs === b?.mtimeNs && a?.ctimeNs === b?.ctimeNs;
   return sameFile(left.main, right.main) && sameFile(left.wal, right.wal);
 }
+function copyFileOutsideThisProcess(source, destination) {
+  if (process.platform === "win32") {
+    fs36.copyFileSync(source, destination);
+    return;
+  }
+  const result = spawnSync5("cp", ["--", source, destination], {
+    encoding: "utf8",
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+  if (result.error) {
+    throw new SqliteReadSnapshotUnavailableError(`cannot run cp to copy ${source}: ${result.error.message}`);
+  }
+  if (result.status === 0)
+    return;
+  if (fileFingerprint(source) === undefined) {
+    throw Object.assign(new Error(`${source} disappeared while it was being copied`), { code: "ENOENT" });
+  }
+  const reason = result.stderr.trim() || (result.signal ? `killed by ${result.signal}` : `exit status ${result.status}`);
+  throw new Error(`cp could not copy ${source}: ${reason}`);
+}
 function openSqliteReadSnapshot(dbPath) {
   if (!pathExists(dbPath))
     return;
@@ -52123,9 +52144,9 @@ function openSqliteReadSnapshot(dbPath) {
         if (pathExists(`${dbPath}-journal`))
           continue;
         const before = databaseFingerprint(dbPath);
-        fs36.copyFileSync(dbPath, snapshotPath);
+        copyFileOutsideThisProcess(dbPath, snapshotPath);
         if (before.wal)
-          fs36.copyFileSync(`${dbPath}-wal`, `${snapshotPath}-wal`);
+          copyFileOutsideThisProcess(`${dbPath}-wal`, `${snapshotPath}-wal`);
         else
           fs36.rmSync(`${snapshotPath}-wal`, { force: true });
         const after = databaseFingerprint(dbPath);

package/dist/scripts/akm-migrate.js

@@ -52059,6 +52059,7 @@ import os6 from "os";
 import path44 from "path";
 
 // src/storage/sqlite-read-snapshot.ts
+import { spawnSync as spawnSync5 } from "child_process";
 import fs36 from "fs";
 import os5 from "os";
 import path43 from "path";
@@ -52103,6 +52104,26 @@ function fingerprintsEqual(left, right) {
   const sameFile = (a, b) => a?.size === b?.size && a?.mtimeNs === b?.mtimeNs && a?.ctimeNs === b?.ctimeNs;
   return sameFile(left.main, right.main) && sameFile(left.wal, right.wal);
 }
+function copyFileOutsideThisProcess(source, destination) {
+  if (process.platform === "win32") {
+    fs36.copyFileSync(source, destination);
+    return;
+  }
+  const result = spawnSync5("cp", ["--", source, destination], {
+    encoding: "utf8",
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+  if (result.error) {
+    throw new SqliteReadSnapshotUnavailableError(`cannot run cp to copy ${source}: ${result.error.message}`);
+  }
+  if (result.status === 0)
+    return;
+  if (fileFingerprint(source) === undefined) {
+    throw Object.assign(new Error(`${source} disappeared while it was being copied`), { code: "ENOENT" });
+  }
+  const reason = result.stderr.trim() || (result.signal ? `killed by ${result.signal}` : `exit status ${result.status}`);
+  throw new Error(`cp could not copy ${source}: ${reason}`);
+}
 function openSqliteReadSnapshot(dbPath) {
   if (!pathExists(dbPath))
     return;
@@ -52118,9 +52139,9 @@ function openSqliteReadSnapshot(dbPath) {
         if (pathExists(`${dbPath}-journal`))
           continue;
         const before = databaseFingerprint(dbPath);
-        fs36.copyFileSync(dbPath, snapshotPath);
+        copyFileOutsideThisProcess(dbPath, snapshotPath);
         if (before.wal)
-          fs36.copyFileSync(`${dbPath}-wal`, `${snapshotPath}-wal`);
+          copyFileOutsideThisProcess(`${dbPath}-wal`, `${snapshotPath}-wal`);
         else
           fs36.rmSync(`${snapshotPath}-wal`, { force: true });
         const after = databaseFingerprint(dbPath);

package/dist/storage/sqlite-read-snapshot.js

@@ -9,7 +9,12 @@
  * must not do that. This helper copies a stable main/WAL pair and opens that
  * private copy, so SQLite never attaches to the operator's original
  * main/WAL/SHM files.
+ *
+ * The copy itself is made by a child process, never by this one: see
+ * {@link copyFileOutsideThisProcess} for why an in-process read of a live
+ * database is unsafe.
  */
+import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -57,6 +62,45 @@ function fingerprintsEqual(left, right) {
     const sameFile = (a, b) => a?.size === b?.size && a?.mtimeNs === b?.mtimeNs && a?.ctimeNs === b?.ctimeNs;
     return sameFile(left.main, right.main) && sameFile(left.wal, right.wal);
 }
+/**
+ * Copy `source` to `destination` without opening `source` in THIS process.
+ *
+ * POSIX advisory locks belong to the process, not to the descriptor: when a
+ * process closes ANY descriptor for a file, the kernel drops every lock that
+ * process holds on it, including the SHARED lock a live SQLite connection in
+ * this same process (`akm improve` keeps one on state.db for the whole run)
+ * holds. A peer using an older SQLite (< 3.51) read-write would then see no
+ * reader, take EXCLUSIVE when it closes, and delete the `-wal`/`-shm` this
+ * process is still using. The read therefore happens in a child `cp`, whose
+ * descriptors and locks are its own. Windows locks belong to the handle, so
+ * an in-process copy cannot release another handle's lock there (and there is
+ * no `cp`).
+ *
+ * A source that vanished (a WAL checkpointed away mid-copy) throws an
+ * `ENOENT` error, which {@link openSqliteReadSnapshot} retries.
+ */
+function copyFileOutsideThisProcess(source, destination) {
+    if (process.platform === "win32") {
+        fs.copyFileSync(source, destination);
+        return;
+    }
+    const result = spawnSync("cp", ["--", source, destination], {
+        encoding: "utf8",
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    if (result.error) {
+        throw new SqliteReadSnapshotUnavailableError(`cannot run cp to copy ${source}: ${result.error.message}`);
+    }
+    if (result.status === 0)
+        return;
+    // `cp` reports its errors as text, so the vanished-source case is recognised
+    // by looking at the source itself.
+    if (fileFingerprint(source) === undefined) {
+        throw Object.assign(new Error(`${source} disappeared while it was being copied`), { code: "ENOENT" });
+    }
+    const reason = result.stderr.trim() || (result.signal ? `killed by ${result.signal}` : `exit status ${result.status}`);
+    throw new Error(`cp could not copy ${source}: ${reason}`);
+}
 /**
  * Open an isolated copy of an existing SQLite database.
  *
@@ -82,9 +126,9 @@ export function openSqliteReadSnapshot(dbPath) {
                 if (pathExists(`${dbPath}-journal`))
                     continue;
                 const before = databaseFingerprint(dbPath);
-                fs.copyFileSync(dbPath, snapshotPath);
+                copyFileOutsideThisProcess(dbPath, snapshotPath);
                 if (before.wal)
-                    fs.copyFileSync(`${dbPath}-wal`, `${snapshotPath}-wal`);
+                    copyFileOutsideThisProcess(`${dbPath}-wal`, `${snapshotPath}-wal`);
                 else
                     fs.rmSync(`${snapshotPath}-wal`, { force: true });
                 const after = databaseFingerprint(dbPath);

package/dist/storage/state-db-integrity.js

@@ -7,7 +7,7 @@
  *
  * `akm health`'s `state-db-integrity` check (src/commands/health/checks.ts)
  * is a pure projection like every other check, so the actual IO lives here:
- * a read-only `PRAGMA quick_check` and a read-only freelist/page-count read.
+ * a read-only `PRAGMA integrity_check` and a read-only freelist/page-count read.
  * Both open their own short-lived read-only connection via the plain
  * {@link openDatabase} opener rather than `openStateDatabase`
  * (src/core/state-db.ts), since a corrupt database must not need a clean
@@ -27,8 +27,8 @@
 import { appendEvent } from "../core/events.js";
 import { openDatabase } from "./database.js";
 import { applyReadonlyPragmas } from "./sqlite-pragmas.js";
-/** How many corruption errors `PRAGMA quick_check` collects before it stops scanning and returns. */
-const QUICK_CHECK_ERROR_LIMIT = 10;
+/** How many corruption errors `PRAGMA integrity_check` collects before it stops scanning and returns. */
+const INTEGRITY_CHECK_ERROR_LIMIT = 10;
 /**
  * Above this fraction of free pages, `state-db-integrity` warns, and
  * {@link vacuumIfReclaimable} compacts state.db (after improve's retention
@@ -48,16 +48,19 @@ function openReadonlyStateDb(dbPath) {
     return db;
 }
 /**
- * Run `PRAGMA quick_check(N)` against `dbPath` read-only. Sub-second on a
- * healthy multi-hundred-MB file; on a corrupt one, `N` bounds how many errors
- * SQLite collects before it stops scanning, which keeps the check's runtime
- * bounded even against a badly corrupt file.
+ * Run `PRAGMA integrity_check(N)` against `dbPath` read-only. Unlike
+ * `quick_check`, it also verifies every index against its table ("row N
+ * missing from index", "wrong # of entries in index"): the damage a WAL
+ * deleted under a live connection leaves behind, which `quick_check` reports
+ * as `ok`. Sub-second on a healthy state.db of a few hundred MB; on a corrupt
+ * one, `N` bounds how many errors SQLite collects before it stops scanning,
+ * which keeps the check's runtime bounded even against a badly corrupt file.
  */
-export function runStateDbQuickCheck(dbPath) {
+export function runStateDbIntegrityCheck(dbPath) {
     let db;
     try {
         db = openReadonlyStateDb(dbPath);
-        const rows = db.prepare(`PRAGMA quick_check(${QUICK_CHECK_ERROR_LIMIT})`).all();
+        const rows = db.prepare(`PRAGMA integrity_check(${INTEGRITY_CHECK_ERROR_LIMIT})`).all();
         const lines = rows.map((row) => String(firstColumn(row)));
         const ok = lines.length === 1 && lines[0] === "ok";
         return { ok, lines };

package/docs/migration/v0.7-to-v0.8.md

@@ -988,7 +988,7 @@ akm-migrate storage --dry-run
 and look for import warnings. You can also inspect `state.db` directly:
 
 ```sh
-sqlite3 ~/.local/share/akm/state.db 'SELECT COUNT(*) FROM events;'
+sqlite3 -readonly ~/.local/share/akm/state.db 'SELECT COUNT(*) FROM events;'
 ```
 
 **`akm list` shows empty stashes.**
@@ -1039,7 +1039,7 @@ If you need to roll back to 0.7.x:
    wrote new events on 0.8.0 and need them in 0.7.x, export them:
 
    ```sh
-   sqlite3 ~/.local/share/akm/state.db \
+   sqlite3 -readonly ~/.local/share/akm/state.db \
      "SELECT json_object('schemaVersion', schema_version, 'ts', ts, 'eventType', event_type, 'ref', ref, 'metadata', json(metadata)) FROM events ORDER BY id;" \
      >> ~/.cache/akm/events.jsonl
    ```

package/docs/reference/data-and-telemetry.md

@@ -344,10 +344,13 @@ rm -rf ~/.cache/akm/config-backups/
 
 # Delete the events log from state.db (non-reversible)
 # There is no akm CLI command to do this directly (`akm log` only exposes
-# `list`/`tail`, no delete/purge verb). Use SQLite directly:
+# `list`/`tail`, no delete/purge verb). Use SQLite directly.
+# Stop akm first (no `akm` process or scheduled task running): an older
+# `sqlite3` (< 3.51) opened read-write alongside a running akm can corrupt
+# the database.
 sqlite3 ~/.local/share/akm/state.db "DELETE FROM events;"
 
-# Delete all proposals
+# Delete all proposals (same precondition: stop akm first)
 sqlite3 ~/.local/share/akm/state.db "DELETE FROM proposals;"
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.17",
+  "version": "0.9.18",
   "type": "module",
   "description": "akm (Agent Knowledge Manager) — a portable, local-first capability library for AI agents. Discover, load, share, and improve reusable skills, scripts, workflows, and knowledge across any shell-capable coding agent, including Claude Code, OpenCode, and Cursor.",
   "keywords": [