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

package/dist/commands/improve/recombine.js

@@ -46,7 +46,7 @@ import { getDefaultLlmConfig, loadConfig } from "../../core/config/config.js";
 import { appendEvent } from "../../core/events.js";
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
 import { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
-import { decayUnseenRecombineHypotheses, findMatchingRecombineHypothesis, getRecombineHypothesis, getStateDbPath, markRecombineHypothesisPromoted, openStateDatabase, recordRecombineInduction, } from "../../core/state-db.js";
+import { decayUnseenRecombineHypotheses, findMatchingRecombineHypothesis, getRecombineHypothesis, markRecombineHypothesisPromoted, recordRecombineInduction, withStateDbAsync, } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
 import { closeDatabase, getAllEntries, getEntitiesByEntryIds, openExistingDatabase, } from "../../indexer/db/db.js";
 import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integrations/agent/runner.js";
@@ -586,18 +586,16 @@ export async function akmRecombine(opts) {
         warnings.push("recombine: no LLM configured — skipping");
         return finish({ clustersFormed: 0 });
     }
-    // #625 — open the confirmation-count store once per run via the ctx seam,
-    // reusing a long-lived ctx.db handle when the caller provided one (mirrors
-    // proposals.ts). Only handles WE opened are closed in the finally below.
-    const ownStateDb = opts.ctx?.db ? undefined : openStateDatabase(opts.ctx?.dbPath ?? getStateDbPath());
-    const stateDb = opts.ctx?.db ?? ownStateDb;
     // Refs re-induced (defensible generalization passed the quality gate) THIS
     // run — everything else is decayed after the loop.
     const seenThisRun = new Set();
     // Recombine output is knowledge/lesson (non-wiki) → stash authoring
     // standards. Resolved ONCE per run and passed to each cluster prompt.
     const standardsContext = resolveStashStandards(stashDir);
-    try {
+    // #625 — open the confirmation-count store once per run via the ctx seam,
+    // reusing a long-lived ctx.db handle when the caller provided one (mirrors
+    // proposals.ts). Only handles WE opened are closed by the seam.
+    await withStateDbAsync(async (stateDb) => {
         for (const cluster of clusters) {
             if (opts.signal?.aborted) {
                 warnings.push("aborted-mid-run");
@@ -782,11 +780,7 @@ export async function akmRecombine(opts) {
                 }, opts.ctx);
             }
         }
-    }
-    finally {
-        if (ownStateDb)
-            ownStateDb.close();
-    }
+    }, { path: opts.ctx?.dbPath, borrowed: opts.ctx?.db });
     return finish({ clustersFormed, proposalsEmitted, lessonsPromoted, nullsReturned });
 }
 /** Serialize frontmatter + body into a markdown asset string. */

package/dist/commands/improve/reflect.js

@@ -24,7 +24,6 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { assertNever } from "../../core/assert.js";
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { assembleAssetFromString, serializeFrontmatter } from "../../core/asset/asset-serialize.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
@@ -41,6 +40,7 @@ import { runAgent, } from "../../integrations/agent/index.js";
 import { resolveProcessAgentProfile } from "../../integrations/agent/config.js";
 import { buildReflectPrompt, extractDraftConfidence, parseAgentProposalPayload, } from "../../integrations/agent/prompts.js";
 import { resolveImproveProcessRunnerFromProfile, runnerIsLlm, runnerSupportsFileWrite, } from "../../integrations/agent/runner.js";
+import { executeRunner } from "../../integrations/agent/runner-dispatch.js";
 import { runOpencodeSdk } from "../../integrations/harnesses/opencode-sdk/index.js";
 import { chatCompletion } from "../../llm/client.js";
 import { isLlmFeatureEnabled } from "../../llm/feature-gate.js";
@@ -954,44 +954,39 @@ export async function akmReflect(options = {}) {
                 iterResult = await runAgent(resolvedProfile, prompt, runOptions);
             }
             else if (runnerSpec) {
-                // v2: dispatch through unified RunnerSpec
+                // v2: dispatch through the unified RunnerSpec seam (X3). The `agent` /
+                // `sdk` arms route to the default profile runners; the `llm` arm is
+                // reflect-specific (wraps `runReflectViaLlm` — its bespoke iteration
+                // shape) so it is supplied as the `llm` handler.
                 const runOptions = {
                     stdio: "captured",
                     parseOutput: "text",
                     ...(Object.keys(agentEnv).length > 0 ? { env: agentEnv } : {}),
                 };
-                switch (runnerSpec.kind) {
-                    case "llm":
-                        // LLM HTTP path — `draftFilePath` is accepted for type symmetry
-                        // (see `RunReflectViaLlmOptions.draftFilePath` docstring) but is
-                        // intentionally a no-op. The prompt builder above also did not
-                        // include the file-write contract for this kind, so the LLM is
-                        // still asked for JSON via stdout.
-                        iterResult = await runReflectViaLlm({
-                            prompt,
-                            connection: runnerSpec.connection,
-                            timeoutMs: runnerSpec.timeoutMs ?? (typeof resolvedTimeoutMs === "number" ? resolvedTimeoutMs : undefined),
-                            priorDraft,
-                            iteration: iter,
-                            responseSchema: REFLECT_JSON_SCHEMA,
-                            chat: options.chat,
-                            ...(maxTokensForLlm !== undefined ? { maxTokens: maxTokensForLlm } : {}),
-                        });
-                        break;
-                    case "sdk":
-                        iterResult = await runOpencodeSdk(runnerSpec.profile, prompt ?? "", runOptions);
-                        break;
-                    case "agent":
-                        iterResult = await runAgent(runnerSpec.profile, prompt, {
-                            ...runOptions,
-                            ...(runnerSpec.timeoutMs !== undefined ? { timeoutMs: runnerSpec.timeoutMs } : {}),
-                        });
-                        break;
-                    default:
-                        // Exhaustiveness arm (H1): a 4th RunnerSpec kind becomes a compile
-                        // error here instead of leaving `iterResult` unassigned at runtime.
-                        assertNever(runnerSpec);
-                }
+                iterResult = await executeRunner(runnerSpec, prompt ?? "", runOptions, {
+                    llm: async (spec) => 
+                    // LLM HTTP path — `draftFilePath` is accepted for type symmetry
+                    // (see `RunReflectViaLlmOptions.draftFilePath` docstring) but is
+                    // intentionally a no-op. The prompt builder above also did not
+                    // include the file-write contract for this kind, so the LLM is
+                    // still asked for JSON via stdout.
+                    runReflectViaLlm({
+                        prompt,
+                        connection: spec.connection,
+                        timeoutMs: spec.timeoutMs ?? (typeof resolvedTimeoutMs === "number" ? resolvedTimeoutMs : undefined),
+                        priorDraft,
+                        iteration: iter,
+                        responseSchema: REFLECT_JSON_SCHEMA,
+                        chat: options.chat,
+                        ...(maxTokensForLlm !== undefined ? { maxTokens: maxTokensForLlm } : {}),
+                    }),
+                    // The `agent` arm (and only the agent arm — preserving prior behavior)
+                    // overlays `spec.timeoutMs` onto the base run options.
+                    runAgent: (profile, p, opts) => runAgent(profile, p, {
+                        ...opts,
+                        ...(runnerSpec.timeoutMs !== undefined ? { timeoutMs: runnerSpec.timeoutMs } : {}),
+                    }),
+                });
             }
             else {
                 // Production path (v1): dispatch directly to the appropriate runner.

package/dist/commands/proposal/drain.js

@@ -36,14 +36,12 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { assertNever } from "../../core/assert.js";
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { resolveAssetPathFromName, TYPE_DIRS } from "../../core/asset/asset-spec.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { appendEvent } from "../../core/events.js";
 import { info, warn } from "../../core/warn.js";
-import { runAgent } from "../../integrations/agent/index.js";
-import { runOpencodeSdk } from "../../integrations/harnesses/opencode-sdk/index.js";
+import { executeRunner } from "../../integrations/agent/runner-dispatch.js";
 import { chatCompletion, stripJsonFences } from "../../llm/client.js";
 import { akmProposalAccept, akmProposalReject } from "./proposal.js";
 import { listProposals, recordGateDecision } from "./validators/proposals.js";
@@ -209,59 +207,38 @@ export function parseJudgmentVerdict(raw) {
     return { decision, reason: typeof reason === "string" ? reason : "" };
 }
 /**
- * Dispatch a single judgment prompt to the resolved runner. The switch mirrors
- * the canonical consumer at `reflect.ts:1060-1090`: llm → `chatCompletion`
- * (no filesystem), agent → `runAgent`, sdk → `runOpencodeSdk`.
+ * Dispatch a single judgment prompt to the resolved runner via the unified
+ * {@link executeRunner} seam (X3). The `llm` arm is drain-specific (wraps
+ * `chatCompletion` — no filesystem) so it is supplied as the `llm` handler; the
+ * byte-identical `agent` / `sdk` arms route to the default profile runners (or
+ * the injected {@link JudgmentSeams} test fakes). A failed spawn warns and
+ * yields `null`, matching the prior per-arm behavior.
  */
 async function dispatchJudgment(runner, prompt, seams) {
-    let raw;
-    switch (runner.kind) {
-        case "llm": {
-            const messages = [{ role: "user", content: prompt }];
-            raw = seams.chat
-                ? await seams.chat(runner, messages)
-                : await chatCompletion(runner.connection, messages, {
-                    ...(runner.timeoutMs !== undefined ? { timeoutMs: runner.timeoutMs } : {}),
-                });
-            break;
-        }
-        case "agent": {
-            const stdout = await runProfileJudgment(seams.runAgentFn ?? runAgent, runner.profile, prompt, "agent", runner.timeoutMs);
-            if (stdout === null)
-                return null;
-            raw = stdout;
-            break;
-        }
-        case "sdk": {
-            const stdout = await runProfileJudgment(seams.runSdkFn ?? runOpencodeSdk, runner.profile, prompt, "sdk", runner.timeoutMs);
-            if (stdout === null)
-                return null;
-            raw = stdout;
-            break;
-        }
-        default:
-            // Exhaustiveness arm (H1): a 4th RunnerSpec kind becomes a compile error
-            // here instead of leaving `raw` undefined at runtime.
-            return assertNever(runner);
-    }
-    return parseJudgmentVerdict(raw);
-}
-/**
- * Shared spawn-runner dispatch for the byte-identical `agent` / `sdk` arms: run
- * the profile-based runner, log a labelled warning on failure, and return the
- * captured stdout (or `null` on failure). `label` only changes the warn prefix.
- */
-async function runProfileJudgment(run, profile, prompt, label, timeoutMs) {
-    const result = await run(profile, prompt, {
+    const runOptions = {
         stdio: "captured",
         parseOutput: "text",
-        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        ...(runner.timeoutMs !== undefined ? { timeoutMs: runner.timeoutMs } : {}),
+    };
+    const result = await executeRunner(runner, prompt, runOptions, {
+        llm: async (spec, p) => {
+            const messages = [{ role: "user", content: p }];
+            const raw = seams.chat
+                ? await seams.chat(spec, messages)
+                : await chatCompletion(spec.connection, messages, {
+                    ...(spec.timeoutMs !== undefined ? { timeoutMs: spec.timeoutMs } : {}),
+                });
+            // chatCompletion has no failure envelope — a returned string is success.
+            return { ok: true, exitCode: 0, stdout: raw, stderr: "", durationMs: 0 };
+        },
+        ...(seams.runAgentFn ? { runAgent: seams.runAgentFn } : {}),
+        ...(seams.runSdkFn ? { runSdk: seams.runSdkFn } : {}),
     });
     if (!result.ok) {
-        warn(`[triage] judgment ${label} failed: ${result.error ?? result.reason ?? "unknown error"}`);
+        warn(`[triage] judgment ${runner.kind} failed: ${result.error ?? result.reason ?? "unknown error"}`);
         return null;
     }
-    return result.stdout;
+    return parseJudgmentVerdict(result.stdout);
 }
 /**
  * Run the judgment tier over the deferred items. The runner only *judges*; the

package/dist/commands/proposal/proposal-cli.js

@@ -9,9 +9,8 @@
  * and emits the same JSON envelope (stdout/stderr/exit-code) as the inline
  * `runWithJsonErrors` form it replaces.
  */
-import { defineCommand } from "citty";
-import { hasSubcommand, parsePositiveIntFlag } from "../../cli/parse-args.js";
-import { defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
+import { parsePositiveIntFlag } from "../../cli/parse-args.js";
+import { defineGroupCommand, defineJsonCommand, output } from "../../cli/shared.js";
 import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
@@ -448,19 +447,7 @@ const proposalDrainCommand = defineJsonCommand({
 // (`proposals`/`accept`/`reject`/`diff`/`revert`) remain as deprecated aliases
 // that warn to stderr and delegate to the same command bodies; they are removed
 // in 0.9.0. Bare `akm proposal` behaves as `proposal list` (mirrors `akm env`).
-// 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 proposalSubCommands = {
-    list: proposalListCommand,
-    show: proposalShowCommand,
-    diff: proposalDiffCommand,
-    accept: proposalAcceptCommand,
-    reject: proposalRejectCommand,
-    revert: proposalRevertCommand,
-    drain: proposalDrainCommand,
-};
-const PROPOSAL_SUBCOMMAND_SET = new Set(Object.keys(proposalSubCommands));
-export const proposalCommand = defineCommand({
+export const proposalCommand = defineGroupCommand({
     meta: { name: "proposal", description: "Manage the proposal queue: list, show, diff, accept, reject, revert" },
     args: {
         status: {
@@ -470,21 +457,24 @@ export const proposalCommand = defineCommand({
         ref: { type: "string", description: "Filter by asset ref (type:name)" },
         type: { type: "string", description: "Filter by asset type" },
     },
-    subCommands: proposalSubCommands,
-    run({ args }) {
-        return runWithJsonErrors(() => {
-            // citty runs the group body even after a subcommand; short-circuit so the
-            // default-to-list body only fires for bare `akm proposal [--status …]`.
-            if (hasSubcommand(args, PROPOSAL_SUBCOMMAND_SET))
-                return;
-            const status = parseProposalStatus(args.status);
-            const result = akmProposalList({
-                status,
-                ref: args.ref,
-                type: args.type,
-                includeArchive: status === "accepted" || status === "rejected" || status === "reverted",
-            });
-            output("proposal-list", result);
+    subCommands: {
+        list: proposalListCommand,
+        show: proposalShowCommand,
+        diff: proposalDiffCommand,
+        accept: proposalAcceptCommand,
+        reject: proposalRejectCommand,
+        revert: proposalRevertCommand,
+        drain: proposalDrainCommand,
+    },
+    // Default body fires only for bare `akm proposal [--status …]`.
+    defaultRun({ args }) {
+        const status = parseProposalStatus(args.status);
+        const result = akmProposalList({
+            status,
+            ref: args.ref,
+            type: args.type,
+            includeArchive: status === "accepted" || status === "rejected" || status === "reverted",
         });
+        output("proposal-list", result);
     },
 });

package/dist/commands/proposal/validators/proposals.js

@@ -50,7 +50,7 @@ import { makeAssetRef, parseAssetRef } from "../../../core/asset/asset-ref.js";
 import { resolveAssetPathFromName, TYPE_DIRS } from "../../../core/asset/asset-spec.js";
 import { NotFoundError, UsageError } from "../../../core/errors.js";
 import { appendEvent } from "../../../core/events.js";
-import { getStateDbPath, getStateProposal, hasImportedFsProposals, insertProposalIfAbsent, listStateProposalIdsByPrefix, listStateProposals, openStateDatabase, recordFsProposalsImport, upsertProposal, withImmediateTransaction, } from "../../../core/state-db.js";
+import { getStateProposal, hasImportedFsProposals, insertProposalIfAbsent, listStateProposalIdsByPrefix, listStateProposals, recordFsProposalsImport, upsertProposal, withImmediateTransaction, withStateDb, } from "../../../core/state-db.js";
 import { repairTruncatedDescription } from "../../../core/text-truncation.js";
 import { warn } from "../../../core/warn.js";
 import { commitWriteTargetBoundary, formatRefForMessage, resolveWriteTarget, writeAssetToSource, } from "../../../core/write-source.js";
@@ -161,14 +161,10 @@ function newId(ctx) {
  * guaranteed to have run before any read or write.
  */
 function withProposalsDb(stashDir, ctx, fn) {
-    const db = openStateDatabase(ctx?.dbPath ?? getStateDbPath());
-    try {
+    return withStateDb((db) => {
         importLegacyProposalFiles(db, stashDir);
         return fn(db);
-    }
-    finally {
-        db.close();
-    }
+    }, { path: ctx?.dbPath });
 }
 // ── Legacy filesystem import (#578) ─────────────────────────────────────────
 /** Legacy (pre-0.9.0) proposal directory: `<stashDir>/.akm/proposals[/archive]`. */

package/dist/commands/read/curate.js

@@ -278,33 +278,89 @@ export function deriveCurateFallbackQueries(query) {
     return tokens;
 }
 export function mergeCurateSearchResponses(base, extras) {
-    const hitsByRef = new Map();
+    // The base (full-query) ranking is the relevance signal — keyword fallback
+    // searches exist only to ADD recall when that ranking is thin, never to
+    // re-rank it. So we PRESERVE base order and APPEND fallback-only hits below
+    // it. A single-token fallback match on an exact title/path normalizes to a
+    // high FTS score, but those scores are not comparable to the full-query
+    // (hybrid) scores; re-sorting the union by raw score (the prior behaviour)
+    // let that keyword junk leapfrog the contextually-relevant full-query hits.
+    // Dup refs (present in both base and a fallback) keep their base POSITION but
+    // take the MAX score, since matching both the full query and a key term is a
+    // stronger relevance signal for the downstream score floor.
+    const bestExtraStashScore = new Map();
+    for (const result of extras) {
+        for (const hit of result.hits.filter((entry) => entry.type !== "registry")) {
+            const prev = bestExtraStashScore.get(hit.ref);
+            if (prev === undefined || (hit.score ?? 0) > prev)
+                bestExtraStashScore.set(hit.ref, hit.score ?? 0);
+        }
+    }
+    const baseRefs = new Set();
+    const baseStash = [];
     for (const hit of base.hits.filter((entry) => entry.type !== "registry")) {
-        hitsByRef.set(hit.ref, hit);
+        baseRefs.add(hit.ref);
+        const extraScore = bestExtraStashScore.get(hit.ref);
+        baseStash.push(extraScore !== undefined && extraScore > (hit.score ?? 0) ? { ...hit, score: extraScore } : hit);
     }
+    const extraOnly = new Map();
     for (const result of extras) {
         for (const hit of result.hits.filter((entry) => entry.type !== "registry")) {
-            const existing = hitsByRef.get(hit.ref);
-            if (!existing || (hit.score ?? 0) > (existing.score ?? 0)) {
-                hitsByRef.set(hit.ref, hit);
-            }
+            if (baseRefs.has(hit.ref))
+                continue;
+            const existing = extraOnly.get(hit.ref);
+            if (!existing || (hit.score ?? 0) > (existing.score ?? 0))
+                extraOnly.set(hit.ref, hit);
         }
     }
-    const registryById = new Map();
+    // Fallback-only hits must rank BELOW every full-query hit through the rest of
+    // the pipeline. The downstream selector (`selectCuratedStashHits`) RE-SORTS by
+    // score and derives its relevance floor from the top score, so preserving
+    // order here is not enough — a single-token FTS match (normalized ~0.9) would
+    // otherwise become the leader and evict the contextual full-query memories.
+    // We therefore restamp fallback-only scores into a band strictly below the
+    // minimum base score (keeping their own relative order). When there are no
+    // base hits, fallback IS the result, so scores are kept as-is.
+    const sortedExtra = [...extraOnly.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    const minBaseScore = baseStash.length
+        ? Math.min(...baseStash.map((hit) => hit.score ?? 0))
+        : Number.POSITIVE_INFINITY;
+    const cappedExtra = baseStash.length
+        ? sortedExtra.map((hit, i) => ({ ...hit, score: minBaseScore - 1e-6 * (i + 1) }))
+        : sortedExtra;
+    const mergedHits = [...baseStash, ...cappedExtra];
+    // Registry hits are supplemental fill — same rule: base first (max score on
+    // dups), then fallback-only registry hits appended by score.
+    const bestExtraRegScore = new Map();
+    for (const result of extras) {
+        for (const hit of result.registryHits ?? []) {
+            const prev = bestExtraRegScore.get(hit.id);
+            if (prev === undefined || (hit.score ?? 0) > prev)
+                bestExtraRegScore.set(hit.id, hit.score ?? 0);
+        }
+    }
+    const baseRegIds = new Set();
+    const baseReg = [];
     for (const hit of base.registryHits ?? []) {
-        registryById.set(hit.id, hit);
+        baseRegIds.add(hit.id);
+        const extraScore = bestExtraRegScore.get(hit.id);
+        baseReg.push(extraScore !== undefined && extraScore > (hit.score ?? 0) ? { ...hit, score: extraScore } : hit);
     }
+    const extraRegOnly = new Map();
     for (const result of extras) {
         for (const hit of result.registryHits ?? []) {
-            const existing = registryById.get(hit.id);
-            if (!existing || (hit.score ?? 0) > (existing.score ?? 0)) {
-                registryById.set(hit.id, hit);
-            }
+            if (baseRegIds.has(hit.id))
+                continue;
+            const existing = extraRegOnly.get(hit.id);
+            if (!existing || (hit.score ?? 0) > (existing.score ?? 0))
+                extraRegOnly.set(hit.id, hit);
         }
     }
     const warnings = Array.from(new Set([...(base.warnings ?? []), ...extras.flatMap((result) => result.warnings ?? [])]));
-    const mergedHits = [...hitsByRef.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-    const mergedRegistryHits = [...registryById.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    const mergedRegistryHits = [
+        ...baseReg,
+        ...[...extraRegOnly.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)),
+    ];
     return {
         ...base,
         hits: mergedHits,

package/dist/commands/read/knowledge.js

@@ -101,10 +101,10 @@ export function readKnowledgeContent(source) {
  * URLs are fetched via `fetchWebsiteMarkdownSnapshot`; local sources delegate
  * to `readKnowledgeContent`.
  */
-export async function readKnowledgeInput(source) {
+export async function readKnowledgeInput(source, options) {
     if (!isHttpUrl(source))
         return readKnowledgeContent(source);
-    const snapshot = await fetchWebsiteMarkdownSnapshot(source);
+    const snapshot = await fetchWebsiteMarkdownSnapshot(source, { stashDir: options?.stashDir });
     return { content: snapshot.content, preferredName: snapshot.preferredName };
 }
 // ── Asset writing ────────────────────────────────────────────────────────────

package/dist/commands/sources/self-update.js

@@ -306,8 +306,8 @@ export async function performUpgrade(check, opts) {
  * The new binary's `akm index` does the work for us:
  *   1. loadConfig() runs at startup — auto-migrates legacy `stashes` →
  *      `sources` if the on-disk config still uses the old key.
- *   2. ensureSchema() detects DB_VERSION mismatch and rebuilds index.db
- *      tables (preserving usage_events).
+ *   2. ensureSchema() converges index.db forward via its idempotent baseline
+ *      schema + additive migrations (no destructive rebuild).
  *   3. The full reindex repopulates entries + workflow_documents + FTS.
  */
 function runPostUpgradeTasks(akmBin, opts) {

package/dist/commands/sources/stash-cli.js

@@ -5,20 +5,20 @@
  * Stash-lifecycle command cluster — the create/index/ingest/inspect verbs for
  * the working stash and its index database: `akm init` (create the stash +
  * persist stashDir), `akm index` (build/refresh the search index), `akm import`
- * (ingest a knowledge doc/URL), `akm db` (+ nested `backups` — inspect the
- * SQLite data dir), and `akm info` (system capabilities + index stats).
+ * (ingest a knowledge doc/URL), and `akm info` (system capabilities + index
+ * stats).
  * Extracted verbatim from src/cli.ts (WS6) so the God Module shrinks; the
- * `main.subCommands.{init,index,import,db,info}` keys and every subcommand's
+ * `main.subCommands.{init,index,import,info}` keys and every subcommand's
  * args/output shape stay byte-identical.
  *
  * These share no private helper with any command still inline in cli.ts — every
  * dependency is already exported from a shared module (core/paths, core/warn,
  * core/errors, core/events, output/context, cli/shared, cli/parse-args, plus the
- * per-command implementations in ./init, ./indexer, ./info, ./db-cli, ./knowledge,
+ * per-command implementations in ./init, ./indexer, ./info, ./knowledge,
  * ./core/asset-create, ./core/common), so the cluster moves with zero hoisting.
  *
  * The leaf handlers whose body is a plain `runWithJsonErrors(...) + output(...)`
- * (`init`, `import`, `info`, `db`, `db backups`) are migrated onto
+ * (`init`, `import`, `info`) are migrated onto
  * `defineJsonCommand`, which emits the same JSON envelope (stdout/stderr/
  * exit-code) as the inline form. `index` keeps a plain `defineCommand` wrapping
  * `runWithJsonErrors` because its body owns a spinner, an AbortController, and
@@ -27,17 +27,17 @@
 import path from "node:path";
 import * as p from "@clack/prompts";
 import { defineCommand } from "citty";
-import { hasSubcommand } from "../../cli/parse-args.js";
 import { defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
 import { assertFlatAssetName } from "../../core/asset/asset-create.js";
 import { isHttpUrl } from "../../core/common.js";
+import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { getCacheDir } from "../../core/paths.js";
 import { clearLogFile, info, isVerbose, setLogFile } from "../../core/warn.js";
+import { resolveWriteTarget } from "../../core/write-source.js";
 import { akmIndex } from "../../indexer/indexer.js";
 import { getHyphenatedBoolean, getOutputMode, parseFlagValue } from "../../output/context.js";
-import { akmDbBackups } from "../db-cli.js";
 import { readKnowledgeInput, writeMarkdownAsset } from "../read/knowledge.js";
 import { assembleInfo } from "./info.js";
 import { akmInit } from "./init.js";
@@ -153,35 +153,6 @@ export const infoCommand = defineJsonCommand({
         output("info", result);
     },
 });
-// MVP DB administration. Currently only `akm db backups`; restore is manual —
-// stop akm and run `scripts/migrations/restore-data-dir.sh <backup>`.
-// 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 dbSubCommands = {
-    backups: defineJsonCommand({
-        meta: {
-            name: "backups",
-            description: "List pre-upgrade snapshots of the data directory (newest first). Backups are created automatically before destructive DB version upgrades unless AKM_DB_BACKUP=0.",
-        },
-        run() {
-            output("db-backups", akmDbBackups());
-        },
-    }),
-};
-const DB_SUBCOMMAND_SET = new Set(Object.keys(dbSubCommands));
-export const dbCommand = defineJsonCommand({
-    meta: {
-        name: "db",
-        description: "Inspect the AKM SQLite data directory. Currently exposes `backups`; to restore from a snapshot, stop akm and run scripts/migrations/restore-data-dir.sh against the chosen backup.",
-    },
-    subCommands: dbSubCommands,
-    run({ args }) {
-        if (hasSubcommand(args, DB_SUBCOMMAND_SET))
-            return;
-        // Default action: list backups.
-        output("db-backups", akmDbBackups());
-    },
-});
 export const importKnowledgeCommand = defineJsonCommand({
     meta: {
         name: "import",
@@ -214,7 +185,8 @@ export const importKnowledgeCommand = defineJsonCommand({
     async run({ args }) {
         // `--name` is a flat name; subdirectory placement is `--path`'s job.
         assertFlatAssetName(args.name);
-        const { content, preferredName } = await readKnowledgeInput(args.source);
+        const stashDir = resolveWriteTarget(loadConfig(), args.target).source.path;
+        const { content, preferredName } = await readKnowledgeInput(args.source, { stashDir });
         const result = await writeMarkdownAsset({
             type: "knowledge",
             content,

package/dist/commands/tasks/tasks-cli.js

@@ -13,8 +13,8 @@
  * with the family.
  */
 import { defineCommand } from "citty";
-import { hasSubcommand, parsePositiveIntFlag } from "../../cli/parse-args.js";
-import { defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
+import { parsePositiveIntFlag } from "../../cli/parse-args.js";
+import { defineGroupCommand, defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
 import { getHyphenatedArg } from "../../output/context.js";
 import { detectServerDefault, registerDefaultTasks } from "./default-tasks.js";
 import { akmTasksAdd, akmTasksDoctor, akmTasksHistory, akmTasksList, akmTasksRemove, akmTasksRun, akmTasksSetEnabled, akmTasksShow, akmTasksSync, parseTaskRef, } from "./tasks.js";
@@ -176,35 +176,27 @@ const tasksDoctorCommand = defineJsonCommand({
         output("tasks-doctor", result);
     },
 });
-// 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 tasksSubCommands = {
-    add: tasksAddCommand,
-    init: tasksInitCommand,
-    list: tasksListCommand,
-    show: tasksShowCommand,
-    remove: tasksRemoveCommand,
-    enable: tasksEnableCommand,
-    disable: tasksDisableCommand,
-    run: tasksRunCommand,
-    history: tasksHistoryCommand,
-    sync: tasksSyncCommand,
-    doctor: tasksDoctorCommand,
-};
-const TASKS_SUBCOMMAND_SET = new Set(Object.keys(tasksSubCommands));
-export const tasksCommand = defineCommand({
+export const tasksCommand = defineGroupCommand({
     meta: {
         name: "tasks",
         alias: "task",
         description: "Schedule workflows or prompts via the OS-native scheduler (cron / launchd / schtasks)",
     },
-    subCommands: tasksSubCommands,
-    run({ args }) {
-        return runWithJsonErrors(async () => {
-            if (hasSubcommand(args, TASKS_SUBCOMMAND_SET))
-                return;
-            const result = await akmTasksList();
-            output("tasks-list", result);
-        });
+    subCommands: {
+        add: tasksAddCommand,
+        init: tasksInitCommand,
+        list: tasksListCommand,
+        show: tasksShowCommand,
+        remove: tasksRemoveCommand,
+        enable: tasksEnableCommand,
+        disable: tasksDisableCommand,
+        run: tasksRunCommand,
+        history: tasksHistoryCommand,
+        sync: tasksSyncCommand,
+        doctor: tasksDoctorCommand,
+    },
+    async defaultRun() {
+        const result = await akmTasksList();
+        output("tasks-list", result);
     },
 });