akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/storage/database.js

@@ -128,6 +128,13 @@ function bunOptions(opts) {
         out.readonly = opts.readonly;
     if (opts.create !== undefined)
         out.create = opts.create;
+    // bun:sqlite reads a partial options object as the full set of open flags:
+    // with neither `readonly` nor `readwrite` set the handle carries no access
+    // mode and every statement fails with SQLITE_MISUSE ("bad parameter or
+    // other API misuse"). Default to writable, matching the driver's no-options
+    // open and better-sqlite3's semantics.
+    if (!out.readonly)
+        out.readwrite = true;
     return out;
 }
 let bunSqliteModule;

package/dist/storage/engines/sqlite-migrations.js

@@ -1,115 +1,47 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Shared SQLite migration engine.
- *
- * state.db (`src/core/state-db.ts`) evolves its schema through this idempotent,
- * transaction-per-migration runner backed by a `schema_migrations` ledger. The
- * migrator's frozen pre-cutover workflow-schema roll
- * (`src/migrate/legacy/workflow-migrations-bodies.ts`, driven by
- * `config-migrate.ts`) reuses the SAME runner. The `bootstrap` hook — a one-line
- * pre-versioning back-fill — is now unused by live callers (the pre-cutover
- * workflow.db that once needed it fails closed at migrate time).
- *
- * This module factors that runner out once. Each caller supplies only its own
- * `MIGRATIONS` array (plus, historically, an optional `bootstrap` hook).
- *
- * Migration-safety contract:
- *   - `id` is permanent and must never be reused.
- *   - `up` must be idempotent (use IF NOT EXISTS, INSERT OR IGNORE, etc.).
- *   - `up` must not DROP any table that holds durable (non-regenerable) data.
- *   - `up` must not RENAME or change the type of an existing column.
- *   - To add a column: use `ALTER TABLE … ADD COLUMN … DEFAULT …`.
- *   - Applied IDs must be an exact ordered prefix of the registry.
- *   - Released migration bodies are sealed by SHA-256 in the same ledger.
- */
-import crypto from "node:crypto";
-export function migrationChecksum(migration) {
-    return crypto.createHash("sha256").update(migration.id).update("\0").update(migration.up).digest("hex");
+export function assertMigrationRegistry(migrations) {
+    const seen = new Set();
+    for (const migration of migrations) {
+        if (seen.has(migration.id))
+            throw new Error(`Migration registry contains duplicate ID ${migration.id}.`);
+        seen.add(migration.id);
+    }
 }
 function migrationsTableExists(db) {
     return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations'").get();
 }
-function ledgerHasChecksum(db) {
-    return db.prepare("PRAGMA table_info(schema_migrations)").all().some((column) => column.name === "checksum");
-}
-/**
- * Core ledger inspection against the expected ordered `{ id, checksum }`
- * registry. Both {@link inspectMigrationLedger} (bodies → checksums) and
- * {@link inspectSealedMigrationLedger} (frozen pre-computed checksums) route
- * here so the two entry points can never diverge.
- */
-function inspectLedgerAgainst(db, expected) {
-    const registryIds = expected.map((entry) => entry.id);
-    if (new Set(registryIds).size !== registryIds.length) {
-        return {
-            status: "inconsistent",
-            migrationIds: [],
-            checksums: [],
-            detail: "migration registry contains duplicate IDs",
-        };
-    }
+/** Inspect the database's applied IDs against the exact ordered registry prefix. */
+function inspectLedgerAgainst(db, registryIds) {
     if (!migrationsTableExists(db))
-        return { status: registryIds.length === 0 ? "current" : "old", migrationIds: [], checksums: [] };
-    const hasChecksum = ledgerHasChecksum(db);
-    const rows = db
-        .prepare(`SELECT id${hasChecksum ? ", checksum" : ""} FROM schema_migrations ORDER BY rowid`)
-        .all();
+        return { status: registryIds.length === 0 ? "current" : "old", migrationIds: [] };
+    const rows = db.prepare("SELECT id FROM schema_migrations ORDER BY rowid").all();
     const migrationIds = rows.map((row) => row.id);
-    const checksums = rows.map((row) => row.checksum ?? null);
-    for (let index = 0; index < rows.length; index += 1) {
-        const entry = expected[index];
-        const row = rows[index];
-        if (!entry) {
-            return { status: "newer", migrationIds, checksums, detail: `unknown migration ID ${row.id}` };
+    for (const [index, row] of rows.entries()) {
+        const expectedId = registryIds[index];
+        if (!expectedId) {
+            return { status: "newer", migrationIds, detail: `unknown migration ID ${row.id}` };
         }
-        if (row.id !== entry.id) {
+        if (row.id !== expectedId) {
             const knownLater = registryIds.includes(row.id);
             return {
                 status: knownLater ? "inconsistent" : "newer",
                 migrationIds,
-                checksums,
                 detail: knownLater
                     ? `migration ledger is not an exact ordered prefix at position ${index + 1}`
                     : `unknown migration ID ${row.id}`,
             };
         }
-        if (row.checksum && row.checksum !== entry.checksum) {
-            return {
-                status: "inconsistent",
-                migrationIds,
-                checksums,
-                detail: `migration ${row.id} checksum does not match the released migration body`,
-            };
-        }
-    }
-    const missingChecksum = checksums.indexOf(null);
-    if (missingChecksum >= 0) {
-        return {
-            status: "old",
-            migrationIds,
-            checksums,
-            detail: `migration ${migrationIds[missingChecksum]} has not been sealed with a checksum`,
-        };
     }
     return {
-        status: rows.length === expected.length ? "current" : "old",
+        status: rows.length === registryIds.length ? "current" : "old",
         migrationIds,
-        checksums,
     };
 }
 export function inspectMigrationLedger(db, migrations) {
-    return inspectLedgerAgainst(db, migrations.map((migration) => ({ id: migration.id, checksum: migrationChecksum(migration) })));
-}
-/**
- * Ledger inspection against a FROZEN `{ id, checksum }` copy of a migration
- * array whose live source is gone (plan §3.3 item 1). Behaviourally identical
- * to {@link inspectMigrationLedger} — the checksums are simply pre-computed
- * rather than derived from `up` bodies.
- */
-export function inspectSealedMigrationLedger(db, sealed) {
-    return inspectLedgerAgainst(db, sealed);
+    assertMigrationRegistry(migrations);
+    return inspectLedgerAgainst(db, migrations.map((migration) => migration.id));
 }
 export function assertMigrationLedger(db, migrations) {
     const state = inspectMigrationLedger(db, migrations);
@@ -136,12 +68,9 @@ export function ensureMigrationsTable(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS schema_migrations (
       id         TEXT    PRIMARY KEY,
-      applied_at TEXT    NOT NULL DEFAULT (datetime('now')),
-      checksum   TEXT
+      applied_at TEXT    NOT NULL DEFAULT (datetime('now'))
     );
   `);
-    if (!ledgerHasChecksum(db))
-        db.exec("ALTER TABLE schema_migrations ADD COLUMN checksum TEXT");
 }
 /**
  * Apply every pending migration, one transaction per migration.
@@ -154,9 +83,10 @@ export function ensureMigrationsTable(db) {
  *
  * @param db          The open SQLite database.
  * @param migrations  The module's ordered, append-only migration list.
- * @param opts        Optional `bootstrap` hook (see {@link RunMigrationsOptions}).
+ * @param opts        Migration execution options.
  */
 export function runMigrations(db, migrations, opts) {
+    assertMigrationRegistry(migrations);
     if (opts?.applyPending === false) {
         assertMigrationLedger(db, migrations);
         return;
@@ -164,24 +94,6 @@ export function runMigrations(db, migrations, opts) {
     if (migrationsTableExists(db))
         assertMigrationLedger(db, migrations);
     ensureMigrationsTable(db);
-    opts?.bootstrap?.(db);
-    const ledger = assertMigrationLedger(db, migrations);
-    db.transaction(() => {
-        const update = db.prepare("UPDATE schema_migrations SET checksum = ? WHERE id = ? AND checksum IS NULL");
-        for (let index = 0; index < ledger.migrationIds.length; index += 1) {
-            update.run(migrationChecksum(migrations[index]), ledger.migrationIds[index]);
-        }
-        if (opts?.generationMarker) {
-            db.exec(`
-        CREATE TABLE IF NOT EXISTS akm_migration_generation (
-          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-          operation_id TEXT NOT NULL,
-          phase TEXT NOT NULL
-        )
-      `);
-            db.prepare("INSERT INTO akm_migration_generation(singleton, operation_id, phase) VALUES (1, ?, ?) ON CONFLICT(singleton) DO UPDATE SET operation_id=excluded.operation_id, phase=excluded.phase").run(opts.generationMarker.operationId, opts.generationMarker.phase);
-        }
-    })();
     const appliedRows = db.prepare("SELECT id FROM schema_migrations ORDER BY rowid").all();
     const applied = new Set(appliedRows.map((r) => r.id));
     for (const migration of migrations) {
@@ -190,7 +102,7 @@ export function runMigrations(db, migrations, opts) {
         opts?.beforeMigration?.(migration);
         db.transaction(() => {
             db.exec(migration.up);
-            db.prepare("INSERT INTO schema_migrations (id, checksum) VALUES (?, ?)").run(migration.id, migrationChecksum(migration));
+            db.prepare("INSERT INTO schema_migrations (id) VALUES (?)").run(migration.id);
         })();
     }
 }

package/dist/storage/managed-db.js

@@ -29,10 +29,10 @@ import { applyStandardPragmas } from "./sqlite-pragmas.js";
  */
 export function openManagedDatabase(spec) {
     const dir = path.dirname(spec.path);
-    if (!fs.existsSync(dir)) {
+    if (spec.create !== false && !fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
-    const db = openDatabase(spec.path);
+    const db = spec.create === false ? openDatabase(spec.path, { create: false }) : openDatabase(spec.path);
     applyStandardPragmas(db, spec.pragmas ?? { dataDir: dir });
     spec.init?.(db);
     return db;

package/dist/storage/repositories/canaries-repository.js

@@ -45,7 +45,7 @@ export function listActiveCanarySetIds(db) {
 /**
  * Deactivate every canary row in a set. Rows are RETAINED (active = 0) so
  * historical improve_cycle_metrics rows keyed on the old canary_set_id stay
- * interpretable; only `akm improve canary --refresh` calls this.
+ * interpretable; only `bun scripts/refresh-canary-set.ts --refresh` calls this.
  */
 export function deactivateCanarySet(db, canarySetId) {
     const result = db

package/dist/storage/repositories/events-repository.js

@@ -38,12 +38,7 @@ export function eventRowToEnvelope(row) {
  */
 export function insertEvent(db, input) {
     try {
-        const result = db
-            .prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
-         VALUES (?, ?, ?, ?)
-         RETURNING id`)
-            .get(input.eventType, input.ts, input.ref ?? null, JSON.stringify(input.metadata ?? {}));
-        return result?.id;
+        return insertEventStrict(db, input);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -51,6 +46,17 @@ export function insertEvent(db, input) {
         return undefined;
     }
 }
+/** Insert an event without best-effort error swallowing for transaction-coupled mutations. */
+export function insertEventStrict(db, input) {
+    const result = db
+        .prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
+       VALUES (?, ?, ?, ?)
+       RETURNING id`)
+        .get(input.eventType, input.ts, input.ref ?? null, JSON.stringify(input.metadata ?? {}));
+    if (!result)
+        throw new Error(`Failed to persist ${input.eventType} event.`);
+    return result.id;
+}
 /** Strict idempotent event insert for durable mutation journals. */
 export function insertEventOnce(db, input) {
     const rows = db
@@ -77,10 +83,15 @@ export function insertEventOnce(db, input) {
 }
 /**
  * Read events from the database matching the filter. Returns events in
- * ascending id order so consumers can process them in emission order.
+ * ascending id order so consumers can process them in emission order —
+ * true even when `options.limit` selects the most-recent page (see
+ * {@link ReadStateEventsOptions.limit}).
  *
  * The returned `nextId` is the maximum id seen (or `sinceId` when no rows
- * match), suitable as the next `sinceId` cursor value.
+ * match), suitable as the next `sinceId` cursor value. This is unaffected by
+ * `limit`: it is always the id of the last row actually returned, which —
+ * because a `limit` page is the MOST RECENT matching rows — is the same
+ * value an unbounded read of the same filter would have produced.
  */
 export function readStateEvents(db, options = {}) {
     const conditions = [];
@@ -102,10 +113,15 @@ export function readStateEvents(db, options = {}) {
         params.push(options.ref);
     }
     const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const hasLimit = options.limit !== undefined && options.limit > 0;
+    const orderAndLimit = hasLimit ? "ORDER BY id DESC LIMIT ?" : "ORDER BY id ASC";
+    const queryParams = hasLimit ? [...params, options.limit] : params;
     const rows = db
-        .prepare(`SELECT id, event_type, ts, ref, metadata_json FROM events ${where} ORDER BY id ASC`)
-        .all(...params);
-    const events = rows.map(eventRowToEnvelope);
+        .prepare(`SELECT id, event_type, ts, ref, metadata_json FROM events ${where} ${orderAndLimit}`)
+        .all(...queryParams);
+    // A DESC-ordered LIMIT page comes back newest-first; reverse it so the
+    // returned array is always ascending by id, matching the unbounded path.
+    const events = (hasLimit ? rows.slice().reverse() : rows).map(eventRowToEnvelope);
     const nextId = events.length > 0 ? events[events.length - 1].id : (options.sinceId ?? 0);
     return { events, nextId };
 }

package/dist/storage/repositories/improve-runs-repository.js

@@ -41,19 +41,13 @@ export function computeImproveRunMetrics(result) {
             case "noop":
                 break;
         }
-        // Legacy: pre-gate action results may carry autoAccepted: true (reflect path).
-        const r = action.result;
-        if (r && r.autoAccepted === true)
-            autoAcceptedCount++;
     }
     // Add gate-promoted count from the unified PostPhaseAutoAcceptGate (all phases).
     autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
     // C1 (13-bus-factor): distill-skipped rows are folded into the bounded
     // `distillSkipped` aggregate and no longer live in `actions`. Add the
     // aggregate total to the skipped + total-actions counters so metrics_json
-    // reports the same numbers as before the fold. (Legacy rows that still carry
-    // per-ref distill-skipped in `actions` have no aggregate, so they are counted
-    // by the classify loop above — never double-counted.)
+    // keeps aggregate metrics aligned with the logical action count.
     const distillSkippedTotal = result.distillSkipped?.total ?? 0;
     skippedCount += distillSkippedTotal;
     return {
@@ -83,10 +77,10 @@ export function recordImproveRun(db, input) {
     const metricsObj = input.metrics ?? computeImproveRunMetrics(input.result);
     db.prepare(`
     INSERT INTO improve_runs
-       (id, started_at, completed_at, stash_dir, dry_run, profile, strategy,
+       (id, started_at, completed_at, stash_dir, dry_run, strategy,
        scope_mode, scope_value, guidance, ok, result_json, metrics_json, metadata_json)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(input.id, input.startedAt, input.completedAt, input.stashDir, input.dryRun ? 1 : 0, input.legacyProfile ?? null, input.strategy ?? null, input.scopeMode, input.scopeValue, input.guidance, input.ok ? 1 : 0, JSON.stringify(input.result), JSON.stringify(metricsObj), JSON.stringify(input.metadata ?? {}));
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(input.id, input.startedAt, input.completedAt, input.stashDir, input.dryRun ? 1 : 0, input.strategy, input.scopeMode, input.scopeValue, input.guidance, input.ok ? 1 : 0, JSON.stringify(input.result), JSON.stringify(metricsObj), JSON.stringify(input.metadata ?? {}));
 }
 /**
  * Read real (non-dry-run) improve_runs rows whose `started_at` falls in the
@@ -104,8 +98,8 @@ export function recordImproveRun(db, input) {
  */
 export function queryImproveRuns(db, since, until) {
     const sql = until
-        ? "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, profile AS legacyProfile, strategy, result_json FROM improve_runs WHERE started_at >= ? AND started_at < ? AND dry_run = 0 ORDER BY started_at DESC"
-        : "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, profile AS legacyProfile, strategy, result_json FROM improve_runs WHERE started_at >= ? AND dry_run = 0 ORDER BY started_at DESC";
+        ? "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, strategy, result_json FROM improve_runs WHERE started_at >= ? AND started_at < ? AND dry_run = 0 ORDER BY started_at DESC"
+        : "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, strategy, result_json FROM improve_runs WHERE started_at >= ? AND dry_run = 0 ORDER BY started_at DESC";
     return (until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since));
 }
 /**

package/dist/storage/repositories/index-connection.js

@@ -5,11 +5,10 @@
  * `index.db` connection lifecycle for the storage layer.
  *
  * Opens/closes the index database, arming the sqlite-vec extension and (for the
- * managed open path) running `ensureSchema`. Extracted verbatim from
- * `src/indexer/db/db.ts` (WI-5a); it now lives BELOW the indexer, so the storage
- * loan helpers (`index-db.ts`, `registry-cache.ts`) import their opener from a
- * sibling here instead of reaching up into the indexer — inverting the old
- * storage→indexer arrow.
+ * managed open path) running `ensureSchema`. This module lives BELOW the
+ * indexer, so the storage loan helpers (`index-db.ts`, `registry-cache.ts`)
+ * import their opener from a sibling here instead of reaching up into the
+ * indexer — inverting the old storage→indexer arrow.
  */
 import fs from "node:fs";
 import { createRequire } from "node:module";
@@ -63,7 +62,19 @@ export function openExistingDatabase(dbPath) {
     // Existing-DB callers must not mutate schema or embedding metadata on open,
     // but some paths still need write access to usage_events and other tables —
     // so init only loads the vec extension, it does not run ensureSchema.
-    return openManagedDatabase({ path: dbPath ?? getDbPath(), init: loadVecExtension });
+    //
+    // "Existing" is load-bearing: a missing file throws instead of being
+    // created. Create-on-open used to leave a schema-less index.db behind (a
+    // fire-and-forget telemetry read was enough), which every later opener then
+    // saw as an existing-but-broken index ("no such table: entries") — the
+    // curate→proposal file-order failure pinned by
+    // tests/storage/open-existing-database-no-create.test.ts. `create: false`
+    // below is the race-free backstop for this pre-check.
+    const resolvedPath = dbPath ?? getDbPath();
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Index database not found at ${resolvedPath}. Run 'akm index' to build it.`);
+    }
+    return openManagedDatabase({ path: resolvedPath, init: loadVecExtension, create: false });
 }
 /**
  * Open an existing index for queries without creating directories, a database