akm-cli 0.9.0-beta.5 → 0.9.0-beta.50

package/dist/commands/read/search-cli.js

@@ -63,6 +63,11 @@ export const searchCommand = defineJsonCommand({
             description: "Disable the automatic project-context ranking boost (also disabled by AKM_DISABLE_PROJECT_CONTEXT=1).",
             default: false,
         },
+        "include-sessions": {
+            type: "boolean",
+            description: "Include session assets (excluded from default search results via config.search.defaultExcludeTypes).",
+            default: false,
+        },
     },
     async run({ args }) {
         const query = (args.query ?? "").trim();
@@ -79,6 +84,7 @@ export const searchCommand = defineJsonCommand({
         const includeProposed = args["include-proposed"] === true;
         const belief = parseBeliefFilterMode(typeof args.belief === "string" ? args.belief : undefined);
         const noProjectContext = getHyphenatedBoolean(args, "no-project-context");
+        const includeSessions = getHyphenatedBoolean(args, "include-sessions");
         // --no-project-context sets env so searchDatabase picks it up without
         // threading the flag through the entire call stack.
         if (noProjectContext)
@@ -91,6 +97,7 @@ export const searchCommand = defineJsonCommand({
             filters,
             includeProposed,
             belief,
+            includeSessions,
             eventSource: resolveEventSource(),
         });
         output("search", result);

package/dist/commands/read/search.js

@@ -108,6 +108,7 @@ export async function akmSearch(input) {
             // Without this, the index (which spans every configured source)
             // would leak hits from sources the caller did not request.
             restrictToSources: namedSourceName !== undefined,
+            includeExcludedTypes: input.includeSessions === true,
         });
     const registryResult = source === "stash" ? undefined : await searchRegistry(query, { limit, registries: config.registries });
     if (source === "stash") {

package/dist/commands/read/show.js

@@ -22,18 +22,22 @@ import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { META_DIR, parseMetaRef, resolveMetaFilePath } from "../../core/asset/stash-meta.js";
 import { asNonEmptyString } from "../../core/common.js";
-import { loadConfig } from "../../core/config/config.js";
+import { getIndexPassConfig, loadConfig } from "../../core/config/config.js";
 import { NotFoundError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
-import { findEntryIdByRef } from "../../indexer/db/db.js";
+import { closeDatabase, computeBodyHash, findEntryIdByRef, openExistingDatabase } from "../../indexer/db/db.js";
+import { hasGraphData } from "../../indexer/db/graph-db.js";
 import { ensureIndex } from "../../indexer/ensure-index.js";
 import { listRelatedPathsForFile } from "../../indexer/graph/graph-boost.js";
+import { extractGraphForSingleFile } from "../../indexer/graph/graph-extraction.js";
 import { lookup } from "../../indexer/indexer.js";
 import { buildEditHint, findSourceForPath, isEditable, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
 import { buildFileContext, buildRenderContext, getRenderer, runMatchers } from "../../indexer/walk/file-context.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
+import { resolveIndexPassLLM } from "../../llm/index-passes.js";
 import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
+import { resolveStorageLocations } from "../../storage/locations.js";
 import { withIndexDb } from "../../storage/repositories/index-db.js";
 // Eagerly import source providers to trigger self-registration.
 import "../../sources/providers/index.js";
@@ -383,6 +387,15 @@ export async function showLocal(input) {
     if (activeRun) {
         fullResponse.activeRun = activeRun;
     }
+    // #624-P3: opt-in inline graph extraction. Default OFF — when the flag is
+    // unset this whole block is skipped (no hasGraphData check, no LLM call), so
+    // behavior is byte-identical to today. When ON, it extracts graph data for an
+    // ungraphed asset, but ONLY when a model is configured (model-available
+    // guard) and ALWAYS bounded by a 30s timeout so `show` can never hang. Any
+    // timeout/model-unavailable/error path returns the response unchanged.
+    if (getIndexPassConfig(config.index, "graph")?.lazyGraphExtraction === true) {
+        await maybeExtractGraphInline(config, sourceStashDir, assetPath);
+    }
     if (input.detail === "brief") {
         return buildBriefResponse(fullResponse, assetPath);
     }
@@ -391,6 +404,58 @@ export async function showLocal(input) {
     }
     return fullResponse;
 }
+/**
+ * #624-P3 — opt-in inline graph extraction for `akm show`. Best-effort and
+ * timeout-bounded: never throws, never hangs, never mutates the response.
+ *
+ * Preconditions (caller already checked the flag): a model must be configured
+ * (model-available guard via {@link resolveIndexPassLLM}) and the asset must be
+ * ungraphed ({@link hasGraphData}). Extraction races a 30s timeout so `show`
+ * cannot block on a slow provider; any timeout/error/missing-model path is
+ * swallowed and `show` returns its already-assembled response unchanged.
+ */
+async function maybeExtractGraphInline(config, sourceStashDir, assetPath) {
+    try {
+        // Model-available guard — no provider configured ⇒ silent skip, no LLM call.
+        if (!resolveIndexPassLLM("graph", config))
+            return;
+        let alreadyGraphed = false;
+        let bodyHash;
+        try {
+            const raw = fs.readFileSync(assetPath, "utf8");
+            bodyHash = computeBodyHash(parseFrontmatter(raw).content.trim());
+        }
+        catch {
+            return; // file gone/unreadable ⇒ nothing to extract
+        }
+        withIndexDb((db) => {
+            alreadyGraphed = hasGraphData(db, sourceStashDir, assetPath);
+        });
+        if (alreadyGraphed)
+            return;
+        // Open the db for the async extraction ourselves: `withIndexDb` is
+        // synchronous and would close the connection the instant the async fn
+        // returns its Promise (before extraction completes). Close it explicitly
+        // after the race settles instead.
+        const db = openExistingDatabase(resolveStorageLocations().indexDb);
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(resolve, 30_000);
+        });
+        try {
+            await Promise.race([extractGraphForSingleFile(db, sourceStashDir, assetPath, bodyHash, { config }), timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            closeDatabase(db);
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        // Any other failure: silently return the unchanged show response.
+    }
+}
 /**
  * Minimal `show`: ref → indexer lookup → file contents. Used by callers that
  * just need the raw file (e.g. clone, write-source) and don't want the full

package/dist/commands/sources/init.js

@@ -53,6 +53,8 @@ function assertInitSandbox(stashDir, dirExplicitlyProvided) {
     throw new ConfigError(`refusing to persist --dir stashDir to a temporary path while under test runner; set AKM_FORCE_INIT_TMP_STASH=1 if you really mean it (stashDir=${stashDir})`, "INIT_TMP_STASH_REFUSED");
 }
 export async function akmInit(options) {
+    const dirExplicitlyProvided = options?.dir != null;
+    const setDefault = options?.setDefault === true;
     const stashDir = options?.dir ? path.resolve(options.dir) : getDefaultStashDir();
     // Safety check (#473): refuse stashDir at /, $HOME, /etc, ~/.config, etc.
     // Runs BEFORE any disk write — a fat-fingered `akm init --dir /` or
@@ -61,7 +63,7 @@ export async function akmInit(options) {
     assertSafeStashDir(stashDir);
     // Defense-in-depth: refuse to persist an explicit --dir /tmp/... stashDir
     // to config under a test runner. Default HOME-resolved paths are exempt.
-    assertInitSandbox(stashDir, options?.dir != null);
+    assertInitSandbox(stashDir, dirExplicitlyProvided);
     let created = false;
     if (!fs.existsSync(stashDir)) {
         fs.mkdirSync(stashDir, { recursive: true });
@@ -75,15 +77,40 @@ export async function akmInit(options) {
     }
     // Ensure the default stash is a local git repo (no remote required)
     ensureGitRepo(stashDir);
-    if (created) {
-        copyStashSkeleton(stashDir);
-        scaffoldStashMeta(stashDir);
-    }
-    // Persist stashDir in config.json
+    // Run seeding UNCONDITIONALLY (not just when the stash was newly created) so
+    // re-running `akm init` on an existing stash backfills any missing skeleton
+    // files — the README, the per-type SOFT convention templates under
+    // facts/conventions/assets/, and the `.meta/index.md` orientation doc. Both
+    // helpers are absent-only: they never overwrite a file a user has edited.
+    copyStashSkeleton(stashDir);
+    scaffoldStashMeta(stashDir);
+    // Persist stashDir in config.json — but ONLY when the user is actually
+    // setting up / opting into a default. A bare `akm init --dir <secondary>`
+    // must NOT silently repoint the user's real default stash (the footgun
+    // documented in memory:akm-init-persists-stashdir-warning).
+    //
+    // Decision matrix — persist when ANY of:
+    //   (a) no --dir provided           → default HOME-resolved setup flow
+    //   (b) --dir AND no existing stashDir in config → first-time bootstrap
+    //   (c) --dir AND --set-default      → explicit opt-in
+    // Otherwise (--dir + existing default + no --set-default) leave the default
+    // pointer alone; the target dir is still scaffolded above.
     const configPath = getConfigPath();
     const existing = loadUserConfig();
-    if (!existing.stashDir || existing.stashDir !== stashDir) {
-        saveConfig({ ...existing, stashDir });
+    const existingStashDir = existing.stashDir;
+    const shouldPersist = !dirExplicitlyProvided || !existingStashDir || setDefault;
+    let defaultStashUpdated = false;
+    let previousStashDir;
+    if (shouldPersist) {
+        if (!existingStashDir || existingStashDir !== stashDir) {
+            saveConfig({ ...existing, stashDir });
+            defaultStashUpdated = true;
+        }
+        // else: already pointed here — no-op, no spurious rewrite.
+    }
+    else {
+        // Default left untouched; surface it so the CLI can inform the user.
+        previousStashDir = existingStashDir;
     }
     // Ensure ripgrep is available (install to cache/bin if needed)
     let ripgrep;
@@ -95,7 +122,7 @@ export async function akmInit(options) {
     catch {
         // Non-fatal: ripgrep is optional, search works without it
     }
-    return { stashDir, created, configPath, ripgrep };
+    return { stashDir, created, configPath, defaultStashUpdated, previousStashDir, ripgrep };
 }
 /** Initialise `dir` as a git repository if it is not already one. */
 function ensureGitRepo(dir) {

package/dist/commands/sources/installed-stashes.js

@@ -205,7 +205,11 @@ async function updateRegistryEntry(entry, force) {
     const synced = await syncFromRef(entry.ref, { force });
     const installedEntry = {
         id: synced.id,
-        source: synced.source,
+        // Preserve the original source classification. syncFromRef() re-derives the
+        // source type from the ref scheme (e.g. "github:" → source: "github"), but
+        // an update should not reclassify an existing entry. A writable entry stored
+        // as source: "git" would fail config validation if rewritten to "github".
+        source: entry.source,
         ref: synced.ref,
         artifactUrl: synced.artifactUrl,
         resolvedVersion: synced.resolvedVersion,

package/dist/commands/sources/schema-repair.js

@@ -17,7 +17,9 @@ import path from "node:path";
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { assembleAsset } from "../../core/asset/asset-serialize.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
+import { authoringRulesForType } from "../../core/authoring-rules.js";
 import { appendEvent, readEvents } from "../../core/events.js";
+import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
 import { info, warn } from "../../core/warn.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
 import { chatCompletion, parseEmbeddedJsonResponse } from "../../llm/client.js";
@@ -94,6 +96,16 @@ export async function runSchemaRepairPass(failures, options) {
             const fieldList = missingFields.join(" and ");
             info(`[improve] schema-repair ${failure.ref} (${fieldList})`);
             const bodyPreview = (fm.content ?? raw).slice(0, 2000);
+            // Standards "rulebook" for this target — wiki schema (wiki page) or stash
+            // convention/meta facts (non-wiki asset); empty when neither fires or no
+            // stash dir is available. `resolveStandardsContext` dispatches on the ref.
+            const standardsContext = stashDir ? resolveStandardsContext(failure.ref, stashDir) : "";
+            const standardsSection = standardsContext.trim()
+                ? `\n\nStandards to follow (the rulebook for this target):\n${standardsContext.trim()}`
+                : "";
+            const assetType = parseAssetRef(failure.ref).type;
+            const authoringRules = authoringRulesForType(assetType);
+            const authoringRulesSection = authoringRules ? `\n\n${authoringRules}` : "";
             const llmResponse = await chatFn(llmConfig, [
                 {
                     role: "system",
@@ -101,7 +113,7 @@ export async function runSchemaRepairPass(failures, options) {
                 },
                 {
                     role: "user",
-                    content: `Generate the missing frontmatter fields (${fieldList}) for this ${parseAssetRef(failure.ref).type} asset. Return ONLY valid JSON like {"description": "...", "when_to_use": "..."}\n\n${bodyPreview}`,
+                    content: `Generate the missing frontmatter fields (${fieldList}) for this ${assetType} asset. Return ONLY valid JSON like {"description": "...", "when_to_use": "..."}${standardsSection}${authoringRulesSection}\n\n${bodyPreview}`,
                 },
             ]);
             const parsed = parseEmbeddedJsonResponse(llmResponse.trim());

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";
@@ -48,12 +48,20 @@ export const initCommand = defineJsonCommand({
     },
     args: {
         dir: { type: "string", description: "Custom stash directory path (default: ~/akm)" },
+        "set-default": {
+            type: "boolean",
+            description: "Make --dir the default stash (write stashDir to config.json). Without this, `akm init --dir X` scaffolds X but leaves your existing default stash unchanged.",
+            default: false,
+        },
     },
     async run({ args }) {
         // Accept both historical spellings for backwards compatibility with
         // older docs/scripts that used `--stashDir`.
         const legacyDir = parseFlagValue(process.argv, "--stashDir") ?? parseFlagValue(process.argv, "--stash-dir");
-        const result = await akmInit({ dir: args.dir ?? legacyDir });
+        const result = await akmInit({
+            dir: args.dir ?? legacyDir,
+            setDefault: getHyphenatedBoolean(args, "set-default"),
+        });
         output("init", result);
     },
 });
@@ -71,6 +79,11 @@ export const indexCommand = defineCommand({
             description: "When combined with --clean, report stale entries without deleting them.",
             default: false,
         },
+        background: {
+            type: "boolean",
+            description: "Run as a background process (suppresses interactive output, manages PID file).",
+            default: false,
+        },
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
@@ -80,6 +93,7 @@ export const indexCommand = defineCommand({
             if (getHyphenatedBoolean(args, "re-enrich") || parseFlagValue(process.argv, "--re-enrich") !== undefined) {
                 throw new UsageError("`akm index --re-enrich` has been removed. Re-enrichment of index-time LLM passes is not exposed in this slice.");
             }
+            const isBackground = args.background === true;
             const outputMode = getOutputMode();
             const controller = new AbortController();
             const abort = () => controller.abort(new Error("index interrupted"));
@@ -88,7 +102,7 @@ export const indexCommand = defineCommand({
             const indexLogFile = path.join(getCacheDir(), "logs", "index", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
             setLogFile(indexLogFile);
             const verbose = isVerbose();
-            const spin = !verbose && outputMode.format === "text" ? p.spinner() : null;
+            const spin = !verbose && !isBackground && outputMode.format === "text" ? p.spinner() : null;
             if (spin) {
                 spin.start(`Building search index${args.full ? " (full rebuild)" : ""}...`);
             }
@@ -114,7 +128,9 @@ export const indexCommand = defineCommand({
                 if (spin) {
                     spin.stop(`Indexed ${result.totalEntries} assets.`);
                 }
-                output("index", result);
+                if (!isBackground) {
+                    output("index", result);
+                }
             }
             catch (error) {
                 if (spin) {
@@ -137,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",
@@ -198,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/sources/stash-skeleton.js

@@ -6,27 +6,42 @@ import path from "node:path";
 import { getDirname } from "../../runtime.js";
 const SKELETON_DIR = path.join(getDirname(import.meta.url), "../../assets/stash-skeleton");
 /**
- * Copy the default stash skeleton into a newly created stash directory.
+ * Copy the default stash skeleton into a stash directory.
  *
- * Each file in src/assets/stash-skeleton/ is written to the stash root only
- * if the destination does not already exist — existing files are never
- * overwritten. Non-fatal: if the skeleton directory is missing or a copy
- * fails the caller continues normally.
+ * The skeleton tree under src/assets/stash-skeleton/ is mirrored **recursively**
+ * into the stash root, preserving relative subpaths (e.g.
+ * `facts/conventions/assets/skill.md` lands at the matching stash subpath).
+ * Each file is written only if the destination does not already exist — existing
+ * (possibly user-edited) files are never overwritten. Intermediate directories
+ * are created as needed.
+ *
+ * Idempotent and absent-only: running it again on an existing stash backfills
+ * any skeleton files that are missing without clobbering present ones. Non-fatal:
+ * if the skeleton directory is missing or a copy fails the caller continues.
  */
 export function copyStashSkeleton(stashDir) {
+    copySkeletonDir(SKELETON_DIR, stashDir);
+}
+/** Recursively mirror `srcDir` into `destDir`, writing files only when absent. */
+function copySkeletonDir(srcDir, destDir) {
     let entries;
     try {
-        entries = fs.readdirSync(SKELETON_DIR);
+        entries = fs.readdirSync(srcDir, { withFileTypes: true });
     }
     catch {
         return;
     }
     for (const entry of entries) {
-        const src = path.join(SKELETON_DIR, entry);
-        const dest = path.join(stashDir, entry);
+        const src = path.join(srcDir, entry.name);
+        const dest = path.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+            copySkeletonDir(src, dest);
+            continue;
+        }
         if (fs.existsSync(dest))
             continue;
         try {
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
             fs.copyFileSync(src, dest);
         }
         catch {

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);
     },
 });

package/dist/commands/tasks/tasks.js

@@ -20,7 +20,7 @@ import { listAgentProfileNames } from "../../integrations/agent/index.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
 import { backendNameForPlatform, selectBackend } from "../../tasks/backends/index.js";
 import { parseTaskDocument } from "../../tasks/parser.js";
-import { resolveAkmInvocation } from "../../tasks/resolveAkmBin.js";
+import { resolveAkmInvocation } from "../../tasks/resolve-akm-bin.js";
 import { exitCodeForStatus, readTaskHistory, runTask } from "../../tasks/runner.js";
 import { parseSchedule, SCHEDULE_SUPPORTED_SUBSET_HINT, translateToCron } from "../../tasks/schedule.js";
 import { validateTaskDocument } from "../../tasks/validator.js";

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()) });
     },
 });