akm-cli 0.9.0-beta.44 → 0.9.0-beta.46

package/dist/commands/wiki-cli.js

@@ -11,9 +11,9 @@
  * `process.exit(1)` after the wrapper when findings exist.
  */
 import { defineCommand } from "citty";
-import { getStringArg, hasSubcommand, parsePositiveIntFlag } from "../cli/parse-args.js";
-import { defineJsonCommand, output, runWithJsonErrors } from "../cli/shared.js";
-import { isHttpUrl, resolveStashDir } from "../core/common.js";
+import { getStringArg, parsePositiveIntFlag } from "../cli/parse-args.js";
+import { defineGroupCommand, defineJsonCommand, output, runWithJsonErrors } from "../cli/shared.js";
+import { resolveStashDir } from "../core/common.js";
 import { loadConfig, resolveConfiguredSources } from "../core/config/config.js";
 import { ConfigError, UsageError } from "../core/errors.js";
 import { getHyphenatedArg, getHyphenatedBoolean } from "../output/context.js";
@@ -168,13 +168,6 @@ const wikiStashCommand = defineJsonCommand({
     },
     async run({ args }) {
         const { stashRaw } = await import("../wiki/wiki.js");
-        const { content, preferredName } = await (async () => {
-            if (!isHttpUrl(args.source))
-                return readKnowledgeInput(args.source);
-            const { fetchWebsiteMarkdownSnapshot } = await import("../sources/website-ingest.js");
-            const snapshot = await fetchWebsiteMarkdownSnapshot(args.source);
-            return { content: snapshot.content, preferredName: args.as ?? snapshot.preferredName };
-        })();
         let stashDir;
         if (args.target) {
             // Resolve the named source to its filesystem path.
@@ -193,6 +186,7 @@ const wikiStashCommand = defineJsonCommand({
         else {
             stashDir = resolveStashDir();
         }
+        const { content, preferredName } = await readKnowledgeInput(args.source, { stashDir });
         const result = stashRaw({
             stashDir,
             wikiName: args.name,
@@ -274,34 +268,26 @@ const wikiIngestCommand = defineJsonCommand({
         });
     },
 });
-// Single source of truth: the routing set is derived from the subCommands keys
-// (M10) so adding a subcommand can never silently desync from `hasSubcommand`.
-const wikiSubCommands = {
-    create: wikiCreateCommand,
-    register: wikiRegisterCommand,
-    list: wikiListCommand,
-    show: wikiShowCommand,
-    remove: wikiRemoveCommand,
-    pages: wikiPagesCommand,
-    search: wikiSearchCommand,
-    stash: wikiStashCommand,
-    lint: wikiLintCommand,
-    ingest: wikiIngestCommand,
-};
-const WIKI_SUBCOMMAND_SET = new Set(Object.keys(wikiSubCommands));
-export const wikiCommand = defineCommand({
+export const wikiCommand = defineGroupCommand({
     meta: {
         name: "wiki",
         description: "Manage multiple markdown wikis (Karpathy-style). akm surfaces (lifecycle, raw/, lint, index); the agent writes pages.",
     },
-    subCommands: wikiSubCommands,
-    run({ args }) {
-        return runWithJsonErrors(async () => {
-            if (hasSubcommand(args, WIKI_SUBCOMMAND_SET))
-                return;
-            // Default action: list wikis
-            const { listWikis } = await import("../wiki/wiki.js");
-            output("wiki-list", { wikis: listWikis(resolveStashDir()) });
-        });
+    subCommands: {
+        create: wikiCreateCommand,
+        register: wikiRegisterCommand,
+        list: wikiListCommand,
+        show: wikiShowCommand,
+        remove: wikiRemoveCommand,
+        pages: wikiPagesCommand,
+        search: wikiSearchCommand,
+        stash: wikiStashCommand,
+        lint: wikiLintCommand,
+        ingest: wikiIngestCommand,
+    },
+    async defaultRun() {
+        // Default action: list wikis
+        const { listWikis } = await import("../wiki/wiki.js");
+        output("wiki-list", { wikis: listWikis(resolveStashDir()) });
     },
 });

package/dist/core/config/config.js

@@ -221,7 +221,18 @@ function maybeAutoMigrateConfigFile(configPath, text) {
     catch {
         return text; // Malformed JSON — let parseAndValidate surface the error.
     }
-    if (compareConfigVersion(obj.configVersion, CURRENT_CONFIG_VERSION) === 1) {
+    // Downgrade protection. Skip migration when the on-disk config is NEWER than
+    // this binary (=== 1), OR when it carries a configVersion we cannot order
+    // against ours (compareConfigVersion returns undefined for an unparseable
+    // value — e.g. one written by a newer/foreign akm). Migrating such a config
+    // could strip fields a newer binary added, a cross-version data-loss path.
+    //
+    // A MISSING configVersion (absent → undefined) is a legacy pre-versioning
+    // config that MUST still migrate, so the unparseable-skip is gated on the
+    // field being PRESENT (`onDiskVersion !== undefined`).
+    const onDiskVersion = obj.configVersion;
+    const versionOrder = compareConfigVersion(onDiskVersion, CURRENT_CONFIG_VERSION);
+    if (versionOrder === 1 || (onDiskVersion !== undefined && versionOrder === undefined)) {
         return text;
     }
     const { changed, result } = migrateConfigShape(obj);
@@ -450,7 +461,12 @@ function applyRuntimeEnvApiKeys(config) {
     }
     // LLM profile keys: AKM_LLM_API_KEY for the default profile, then
     // AKM_PROFILE_<UPPER>_API_KEY for any profile (per-profile wins).
-    const defaultProfile = next.defaults?.llm;
+    // Resolve the default profile the SAME way the rest of the config layer does
+    // (resolveDefaultLlmProfileName), so the implicit `profiles.llm.default`
+    // fallback is honored. Keying off the raw `defaults.llm` field alone silently
+    // dropped AKM_LLM_API_KEY for configs that rely on the implicit default —
+    // the same no-op-run class as the 2026-05-23 incident.
+    const defaultProfile = resolveDefaultLlmProfileName(next);
     if (next.profiles?.llm) {
         const updated = { ...next.profiles.llm };
         let changed = false;

package/dist/core/events.js

@@ -27,7 +27,7 @@
 import path from "node:path";
 import { rethrowIfTestIsolationError } from "./errors.js";
 import { getDataDir } from "./paths.js";
-import { insertEvent, openStateDatabase, readStateEvents } from "./state-db.js";
+import { insertEvent, openStateDatabase, readStateEvents, withStateDb } from "./state-db.js";
 import { error } from "./warn.js";
 /**
  * Legacy events.jsonl path — used only by the migration script
@@ -82,18 +82,14 @@ export function appendEvent(input, ctx) {
     // Default path: open, insert, close.
     const dbPath = resolveDbPath(ctx);
     try {
-        const db = openStateDatabase(dbPath);
-        try {
+        withStateDb((db) => {
             insertEvent(db, {
                 eventType: input.eventType,
                 ts,
                 ref: input.ref,
                 metadata: input.metadata,
             });
-        }
-        finally {
-            db.close();
-        }
+        }, { path: dbPath });
     }
     catch (err) {
         // Never mask the bun-test isolation guard as a silent "events failed".

package/dist/core/logs-db.js

@@ -16,8 +16,10 @@
  * Log lines are high-volume, append-only, and freely purgeable; state.db rows
  * (events, proposals, task_history) are durable records. Separating them keeps
  * state.db small and lets log retention be aggressive without touching durable
- * state. Cross-db queries (e.g. "failed task_history row → its log lines") use
- * SQLite ATTACH — see {@link attachStateDatabase}.
+ * state. Callers that need to correlate a task_history row with its log lines do
+ * an application-side join on the {@link buildTaskRunId} key (e.g. `health` via
+ * {@link getLoggedRunIds}) — no SQLite ATTACH, so the split survives a future
+ * provider change.
  *
  * ## run_id
  *
@@ -41,7 +43,6 @@ import { openDatabase } from "../storage/database.js";
 import { runMigrations as runSqliteMigrations } from "../storage/engines/sqlite-migrations.js";
 import { applyStandardPragmas } from "../storage/sqlite-pragmas.js";
 import { getDataDir } from "./paths.js";
-import { getStateDbPath } from "./state-db.js";
 // ── Path helper ──────────────────────────────────────────────────────────────
 /**
  * Default path: `<dataDir>/logs.db` — alongside state.db so cooperating
@@ -146,8 +147,8 @@ export function runMigrations(db) {
  * Encode a task run's identity — the unique `(task_id, started_at)` pair from
  * state.db `task_history` — as a single run_id string.
  *
- * The format MUST stay in sync with the SQL expression
- * `task_id || '@' || started_at` used by {@link queryFailedRunLogLines}.
+ * The format MUST stay in sync with the application-side join key that callers
+ * build from a `task_history` row's `task_id` and `started_at`.
  */
 export function buildTaskRunId(taskId, startedAtIso) {
     return `${taskId}@${startedAtIso}`;
@@ -230,64 +231,6 @@ export function getLoggedRunIds(db, runIds) {
     }
     return out;
 }
-// ── Cross-db: ATTACH state.db ────────────────────────────────────────────────
-/**
- * ATTACH state.db to an open logs.db handle under the schema name `state`,
- * enabling cross-db joins like task_history × task_logs.
- *
- * The state.db file must already exist (callers always open state.db first in
- * practice); attaching a non-existent path would silently create an empty,
- * unmigrated database file, so this throws instead.
- */
-export function attachStateDatabase(db, stateDbPath) {
-    const resolved = stateDbPath ?? getStateDbPath();
-    if (!fs.existsSync(resolved)) {
-        throw new Error(`Cannot ATTACH state.db: file does not exist at ${resolved}`);
-    }
-    // prepare().run() rather than db.run(): both drivers support parameterised
-    // ATTACH through a prepared statement, and no other call site uses db.run().
-    db.prepare("ATTACH DATABASE ? AS state").run(resolved);
-}
-/**
- * Convenience: open logs.db with state.db attached as `state`. The returned
- * handle supports cross-db queries such as {@link queryFailedRunLogLines}.
- * Close it like any other handle (DETACH is implicit on close).
- */
-export function openLogsDatabaseWithState(logsDbPath, stateDbPath) {
-    const db = openLogsDatabase(logsDbPath);
-    try {
-        attachStateDatabase(db, stateDbPath);
-    }
-    catch (err) {
-        db.close();
-        throw err;
-    }
-    return db;
-}
-/**
- * Cross-db join: every log line belonging to a FAILED task_history run whose
- * `started_at` is `>= since` (all failed runs when omitted). Requires a handle
- * opened via {@link openLogsDatabaseWithState}.
- *
- * The join key is the run_id encoding documented on {@link buildTaskRunId}:
- * `task_logs.run_id = task_history.task_id || '@' || task_history.started_at`.
- */
-export function queryFailedRunLogLines(db, options = {}) {
-    const conditions = ["th.status = 'failed'"];
-    const params = [];
-    if (options.since) {
-        conditions.push("th.started_at >= ?");
-        params.push(options.since);
-    }
-    const limit = options.limit !== undefined && options.limit >= 0 ? ` LIMIT ${Math.floor(options.limit)}` : "";
-    return db
-        .prepare(`SELECT th.task_id, l.run_id, th.started_at, th.status, l.ts, l.stream, l.level, l.line
-       FROM state.task_history th
-       JOIN task_logs l ON l.run_id = th.task_id || '@' || th.started_at
-       WHERE ${conditions.join(" AND ")}
-       ORDER BY th.started_at DESC, l.id ASC${limit}`)
-        .all(...params);
-}
 // ── Retention ────────────────────────────────────────────────────────────────
 /**
  * Delete task_logs rows older than `retentionDays` (default: 90). Mirrors

package/dist/core/parse.js

@@ -98,16 +98,24 @@ export function parseJsonResponse(raw) {
  * balanced `{ }` or `[ ]` structure in the text and attempts to parse that
  * substring. Returns `undefined` if no valid JSON structure is found.
  *
- * Non-array results are preferred: if a `{…}` object is found first, it is
- * returned immediately. Arrays (`[…]`) are captured as a fallback and
- * returned only when no object was found.
+ * Shape preference is controlled by {@link ParseEmbeddedJsonOptions.expect}:
+ * - `"any"` (default): non-array results are preferred — a `{…}` object found
+ *   first is returned immediately; arrays (`[…]`) are a fallback.
+ * - `"array"`: only top-level arrays are returned. The direct parse is
+ *   accepted only if it is an array, and the scanner returns the first
+ *   balanced `[…]` while skipping `{…}` openers entirely.
  */
-export function parseEmbeddedJsonResponse(raw) {
+export function parseEmbeddedJsonResponse(raw, options) {
+    const expectArray = options?.expect === "array";
     const direct = parseJsonResponse(raw);
-    if (direct !== undefined)
+    if (direct !== undefined && (!expectArray || Array.isArray(direct)))
         return direct;
     const text = escapeJsonStringControls(stripCodeFences(stripThinkBlocks(raw)));
     let arrayFallback;
+    // Scan only *top-level* balanced structures: once a `{…}`/`[…]` is matched we
+    // jump `start` past its closing bracket rather than re-scanning its interior.
+    // This keeps array mode from salvaging an array *nested inside* a leading
+    // object (e.g. the `entities` array of a bare `{entities,relations}` object).
     for (let start = 0; start < text.length; start++) {
         const opener = text[start];
         if (opener !== "{" && opener !== "[")
@@ -116,6 +124,7 @@ export function parseEmbeddedJsonResponse(raw) {
         let depth = 0;
         let inString = false;
         let escaped = false;
+        let end = -1;
         for (let i = start; i < text.length; i++) {
             const ch = text[i];
             if (inString) {
@@ -139,20 +148,31 @@ export function parseEmbeddedJsonResponse(raw) {
             if (ch === closer) {
                 depth -= 1;
                 if (depth === 0) {
-                    try {
-                        const parsed = JSON.parse(text.slice(start, i + 1));
-                        if (!Array.isArray(parsed)) {
-                            return parsed;
-                        }
-                        arrayFallback ??= parsed;
-                        break;
-                    }
-                    catch {
-                        break;
-                    }
+                    end = i;
+                    break;
                 }
             }
         }
+        if (end === -1)
+            continue; // never balanced — let the next opener try
+        try {
+            const parsed = JSON.parse(text.slice(start, end + 1));
+            if (Array.isArray(parsed)) {
+                // First valid array wins in array mode; in "any" mode it is the
+                // fallback returned only if no object is found.
+                if (expectArray)
+                    return parsed;
+                arrayFallback ??= parsed;
+            }
+            else if (!expectArray) {
+                return parsed;
+            }
+            // Skip past this balanced structure so we don't descend into it.
+            start = end;
+        }
+        catch {
+            // Malformed candidate — advance one char and try the next opener.
+        }
     }
     return arrayFallback;
 }