akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/commands/wiki-cli.js

@@ -1,292 +0,0 @@
-// 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/.
-/**
- * `akm wiki` command family. Extracted verbatim from src/cli.ts (WS6) so the
- * God Module shrinks; the `main.subCommands.wiki` key and every subcommand's
- * args/output shape are byte-identical. Handlers whose body is a plain
- * `runWithJsonErrors(...) + output(...)` are migrated to `defineJsonCommand`,
- * which emits the same JSON envelope (stdout/stderr/exit-code) as the inline
- * form. `wiki lint` keeps an explicit `runWithJsonErrors` because it calls
- * `process.exit(1)` after the wrapper when findings exist.
- */
-import { defineCommand } from "citty";
-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 { akmAgentDispatch } from "./agent/agent-dispatch.js";
-import { readKnowledgeInput } from "./read/knowledge.js";
-import { buildWebsiteOptions } from "./sources/add-cli.js";
-const wikiCreateCommand = defineJsonCommand({
-    meta: { name: "create", description: "Scaffold a new wiki under <stashDir>/wikis/<name>/" },
-    args: {
-        name: { type: "positional", description: "Wiki name (lowercase, digits, hyphens)", required: true },
-    },
-    async run({ args }) {
-        const { createWiki } = await import("../wiki/wiki.js");
-        const stashDir = resolveStashDir();
-        const result = createWiki(stashDir, args.name);
-        output("wiki-create", result);
-    },
-});
-const wikiRegisterCommand = defineJsonCommand({
-    meta: {
-        name: "register",
-        description: "Register an existing directory or repo as a first-class wiki without copying or mutating it; refreshes source and wiki search state immediately",
-    },
-    args: {
-        name: { type: "positional", description: "Wiki name (lowercase, digits, hyphens)", required: true },
-        ref: { type: "positional", description: "Path or repo ref for the external wiki source", required: true },
-        writable: {
-            type: "boolean",
-            description: "Mark a git-backed source as writable so changes can be pushed back",
-            default: false,
-        },
-        "max-pages": { type: "string", description: "Maximum pages to crawl for website sources (default: 50)" },
-        "max-depth": { type: "string", description: "Maximum crawl depth for website sources (default: 3)" },
-    },
-    async run({ args }) {
-        const { registerWikiSource } = await import("./sources/source-add.js");
-        const result = await registerWikiSource({
-            ref: args.ref.trim(),
-            name: args.name,
-            options: Object.keys(buildWebsiteOptions(args)).length > 0 ? buildWebsiteOptions(args) : undefined,
-            writable: args.writable,
-        });
-        output("wiki-register", result);
-    },
-});
-const wikiListCommand = defineJsonCommand({
-    meta: { name: "list", description: "List wikis with page/raw counts and last-modified timestamps" },
-    async run() {
-        const { listWikis } = await import("../wiki/wiki.js");
-        const stashDir = resolveStashDir();
-        const wikis = listWikis(stashDir);
-        output("wiki-list", { wikis });
-    },
-});
-const wikiShowCommand = defineJsonCommand({
-    meta: { name: "show", description: "Show a wiki's path, description, counts, and last 3 log entries" },
-    args: {
-        name: { type: "positional", description: "Wiki name", required: true },
-    },
-    async run({ args }) {
-        const { showWiki } = await import("../wiki/wiki.js");
-        const stashDir = resolveStashDir();
-        const result = showWiki(stashDir, args.name);
-        output("wiki-show", result);
-    },
-});
-const wikiRemoveCommand = defineJsonCommand({
-    meta: {
-        name: "remove",
-        description: "Remove a wiki and refresh the index. Preserves raw/ by default; pass --with-sources to also delete raw/",
-    },
-    args: {
-        name: { type: "positional", description: "Wiki name", required: true },
-        yes: {
-            type: "boolean",
-            alias: "y",
-            description: "Skip confirmation prompt (required in non-interactive shells)",
-            default: false,
-        },
-        "with-sources": {
-            type: "boolean",
-            description: "Also delete the raw/ directory (immutable ingested sources)",
-            default: false,
-        },
-    },
-    async run({ args }) {
-        const { confirmDestructive } = await import("../cli/confirm.js");
-        const confirmed = await confirmDestructive(`Remove wiki "${args.name}"? This cannot be undone.`, {
-            yes: args.yes === true,
-        });
-        if (!confirmed) {
-            process.stderr.write("Aborted.\n");
-            return;
-        }
-        const withSources = args["with-sources"];
-        const { removeWiki } = await import("../wiki/wiki.js");
-        const { akmIndex } = await import("../indexer/indexer.js");
-        const stashDir = resolveStashDir();
-        const result = removeWiki(stashDir, args.name, { withSources });
-        await akmIndex({ stashDir });
-        output("wiki-remove", result);
-    },
-});
-const wikiPagesCommand = defineJsonCommand({
-    meta: {
-        name: "pages",
-        description: "List wiki pages (ref + frontmatter description), excluding schema/index/log/raw",
-    },
-    args: {
-        name: { type: "positional", description: "Wiki name", required: true },
-    },
-    async run({ args }) {
-        const { listPages } = await import("../wiki/wiki.js");
-        const stashDir = resolveStashDir();
-        const pages = listPages(stashDir, args.name);
-        output("wiki-pages", { wiki: args.name, pages });
-    },
-});
-const wikiSearchCommand = defineJsonCommand({
-    meta: {
-        name: "search",
-        description: "Search wiki pages within a single wiki (scoped wrapper over `akm search --type wiki`; excludes raw/schema/index/log and returns canonical wiki refs)",
-    },
-    args: {
-        name: { type: "positional", description: "Wiki name", required: true },
-        query: { type: "positional", description: "Search query", required: true },
-        limit: { type: "string", description: "Max hits (default 20)", required: false },
-    },
-    async run({ args }) {
-        const { resolveWikiSource, searchInWiki } = await import("../wiki/wiki.js");
-        const stashDir = resolveStashDir();
-        resolveWikiSource(stashDir, args.name);
-        const parsedLimit = args.limit ? Number(args.limit) : undefined;
-        const limit = typeof parsedLimit === "number" && Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : undefined;
-        const response = await searchInWiki({ stashDir, wikiName: args.name, query: args.query, limit });
-        output("search", response);
-    },
-});
-const wikiStashCommand = defineJsonCommand({
-    meta: {
-        name: "stash",
-        description: "Copy a source into wikis/<name>/raw/<slug>.md with frontmatter. Source may be a file path, URL, or '-' for stdin.",
-    },
-    args: {
-        name: { type: "positional", description: "Wiki name", required: true },
-        source: { type: "positional", description: "Source file path, URL, or '-' to read from stdin", required: true },
-        as: { type: "string", description: "Preferred slug base (defaults to source filename or first-line slug)" },
-        target: {
-            type: "string",
-            description: "Name of a writable stash source to write into instead of the default stash. Must match a configured source name (run `akm list` to see sources).",
-        },
-    },
-    async run({ args }) {
-        const { stashRaw } = await import("../wiki/wiki.js");
-        let stashDir;
-        if (args.target) {
-            // Resolve the named source to its filesystem path.
-            const cfg = loadConfig();
-            const sources = resolveConfiguredSources(cfg);
-            const match = sources.find((s) => s.name === args.target);
-            if (!match) {
-                throw new UsageError(`--target must reference a configured source name. No source named "${args.target}" found. Run \`akm list\` to see available sources.`, "INVALID_FLAG_VALUE");
-            }
-            const spec = match.source;
-            if (spec.type !== "filesystem" && spec.type !== "local") {
-                throw new ConfigError(`Source "${args.target}" is not a filesystem source and cannot be used as a wiki stash target.`, "INVALID_CONFIG_FILE", `Use a source with type "filesystem" or "local", or omit --target to use the default stash.`);
-            }
-            stashDir = spec.path;
-        }
-        else {
-            stashDir = resolveStashDir();
-        }
-        const { content, preferredName } = await readKnowledgeInput(args.source, { stashDir });
-        const result = stashRaw({
-            stashDir,
-            wikiName: args.name,
-            content,
-            preferredName: args.as ?? preferredName,
-            explicitSlug: args.as !== undefined,
-        });
-        output("wiki-stash", { ok: true, wiki: args.name, source: args.source, ...result });
-    },
-});
-const wikiLintCommand = defineCommand({
-    meta: {
-        name: "lint",
-        description: "Structural lint for a wiki: orphans, broken xrefs, missing descriptions, uncited raws, stale index",
-    },
-    args: {
-        name: { type: "positional", description: "Wiki name", required: true },
-    },
-    async run({ args }) {
-        let findingCount = 0;
-        await runWithJsonErrors(async () => {
-            const { lintWiki } = await import("../wiki/wiki.js");
-            const stashDir = resolveStashDir();
-            const report = lintWiki(stashDir, args.name);
-            output("wiki-lint", report);
-            findingCount = report.findings.length;
-        });
-        if (findingCount > 0)
-            process.exit(1); // EXIT_GENERAL
-    },
-});
-const wikiIngestCommand = defineJsonCommand({
-    meta: {
-        name: "ingest",
-        description: "Dispatch an agent to execute the ingest workflow for this wiki. Uses --profile or config.defaults.agent.",
-    },
-    args: {
-        name: { type: "positional", description: "Wiki name", required: true },
-        profile: {
-            type: "string",
-            description: "Agent profile to use (default: config.defaults.agent).",
-        },
-        model: {
-            type: "string",
-            description: "Model override — accepts aliases (opus, sonnet, haiku) or exact platform model IDs.",
-        },
-        "timeout-ms": { type: "string", description: "Override the agent CLI timeout in milliseconds." },
-    },
-    async run({ args }) {
-        const { buildIngestWorkflow } = await import("../wiki/wiki.js");
-        const stashDir = resolveStashDir();
-        const built = buildIngestWorkflow(stashDir, args.name);
-        const config = loadConfig();
-        const profileName = getStringArg(args, "profile") ?? config.defaults?.agent;
-        if (!profileName) {
-            throw new UsageError("akm wiki ingest requires an agent profile. Pass --profile <name> or set defaults.agent in config.", "MISSING_REQUIRED_ARGUMENT", "Available profiles are listed under profiles.agent in your config. Run `akm config get profiles.agent` to inspect.");
-        }
-        const timeoutMs = parsePositiveIntFlag(args["timeout-ms"], "--timeout-ms");
-        const model = getStringArg(args, "model");
-        const { getDefaultLlmConfig } = await import("../core/config/config.js");
-        const dispatchResult = await akmAgentDispatch({
-            profileName,
-            agentConfig: config,
-            llmConfig: getDefaultLlmConfig(config),
-            prompt: built.workflow,
-            dispatch: {
-                prompt: built.workflow,
-                ...(model !== undefined ? { model } : {}),
-            },
-            ...(timeoutMs !== undefined && Number.isFinite(timeoutMs) ? { timeoutMs } : {}),
-        });
-        output("wiki-ingest", {
-            wiki: built.wiki,
-            path: built.path,
-            schemaPath: built.schemaPath,
-            dispatched: true,
-            profile: profileName,
-            agentResult: dispatchResult,
-        });
-    },
-});
-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: {
-        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/asset/asset-registry.js

@@ -1,76 +0,0 @@
-// 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/.
-/**
- * Central registry for asset type renderer and action builder maps.
- *
- * Previously these maps lived in `db-search.ts` (then `local-search.ts`) and
- * were wired into `asset-spec.ts` via a fragile `_setAssetTypeHooks` deferred
- * callback pattern. If the search module was imported after
- * `registerAssetType()` calls, hooks would be silently dropped.
- *
- * This module is a simple singleton that both `asset-spec.ts` and
- * `db-search.ts` import from, eliminating the import-order dependency
- * entirely.
- */
-import { buildWorkflowAction } from "../../output/renderers.js";
-/** Map asset types to their primary renderer names. */
-export const TYPE_TO_RENDERER = {
-    script: "script-source",
-    skill: "skill-md",
-    command: "command-md",
-    agent: "agent-md",
-    knowledge: "knowledge-md",
-    lesson: "lesson-md",
-    memory: "memory-md",
-    workflow: "workflow-md",
-    env: "env-file",
-    secret: "secret-file",
-    wiki: "wiki-md",
-    task: "task-yaml",
-    session: "session-md",
-    fact: "fact-md",
-};
-/** Map asset types to action builder functions for search results. */
-export const ACTION_BUILDERS = {
-    script: (ref) => `akm show ${ref} -> execute the run command`,
-    skill: (ref) => `akm show ${ref} -> follow the instructions`,
-    command: (ref) => `akm show ${ref} -> fill placeholders and dispatch`,
-    agent: (ref) => `akm show ${ref} -> dispatch with full prompt`,
-    knowledge: (ref) => `akm show ${ref} -> read reference material`,
-    lesson: (ref) => `akm show ${ref} -> read the lesson and apply when_to_use`,
-    memory: (ref) => `akm show ${ref} -> recall context`,
-    workflow: (ref) => buildWorkflowAction(ref),
-    env: (ref) => `akm show ${ref} -> inspect key names; akm env run ${ref} -- <command> -> run with the whole .env injected (prefer --clean to minimize inherited parent env; child stdout is not redacted). akm env export ${ref} --out <file> writes a sourceable script (values to a file, not stdout).`,
-    secret: (ref) => `akm show ${ref} -> name only (value never shown); akm secret path ${ref} -> file path; akm secret run ${ref} <VAR> -- <command> -> run with value injected into $VAR`,
-    wiki: (ref) => `akm show ${ref} -> read the wiki page`,
-    task: (ref) => `akm tasks show ${ref.replace(/^task:/, "")} -> inspect; akm tasks run <id> -> run now; akm tasks remove <id> -> unschedule`,
-    session: (ref) => `akm show ${ref} -> read the session summary; follow the \`access\` frontmatter to open the raw log at \`log_path\``,
-    fact: (ref) => `akm show ${ref} -> read the stash fact and apply it as durable context`,
-};
-/**
- * Register a type-to-renderer mapping.
- *
- * Called by `registerAssetType()` in `asset-spec.ts` when a spec includes
- * `rendererName`, or directly by extension code.
- */
-export function registerTypeRenderer(type, rendererName) {
-    TYPE_TO_RENDERER[type] = rendererName;
-}
-/**
- * Register an action builder for an asset type.
- *
- * Called by `registerAssetType()` in `asset-spec.ts` when a spec includes
- * `actionBuilder`, or directly by extension code.
- */
-export function registerActionBuilder(type, builder) {
-    ACTION_BUILDERS[type] = builder;
-}
-export const defaultRendererRegistry = {
-    rendererNameFor(type) {
-        return TYPE_TO_RENDERER[type];
-    },
-    actionBuilderFor(type) {
-        return ACTION_BUILDERS[type];
-    },
-};

package/dist/core/asset/asset-spec.js

@@ -1,259 +0,0 @@
-// 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/.
-import path from "node:path";
-import { buildWorkflowAction } from "../../output/renderers.js";
-import { registerActionBuilder, registerTypeRenderer } from "./asset-registry.js";
-function toPosix(input) {
-    return input.replace(/\\/g, "/");
-}
-const buildTaskAction = (ref) => `akm tasks show ${ref.replace(/^task:/, "")} -> inspect; akm tasks run <id> -> run now; akm tasks remove <id> -> unschedule`;
-const markdownSpec = {
-    isRelevantFile: (fileName) => path.extname(fileName).toLowerCase() === ".md",
-    toCanonicalName: (typeRoot, filePath) => {
-        const rel = toPosix(path.relative(typeRoot, filePath));
-        // Strip .md extension from canonical names (agent:code-reviewer, not agent:code-reviewer.md)
-        return rel.endsWith(".md") ? rel.slice(0, -3) : rel;
-    },
-    toAssetPath: (typeRoot, name) => {
-        // Accept both with and without .md extension
-        const withExt = name.endsWith(".md") ? name : `${name}.md`;
-        return path.join(typeRoot, withExt);
-    },
-};
-/** All recognized script extensions for the script asset type */
-export const SCRIPT_EXTENSIONS = new Set([
-    ".sh",
-    ".ts",
-    ".js",
-    ".ps1",
-    ".cmd",
-    ".bat",
-    ".py",
-    ".rb",
-    ".go",
-    ".pl",
-    ".php",
-    ".lua",
-    ".r",
-    ".swift",
-    ".kt",
-    ".kts",
-]);
-const scriptSpec = {
-    isRelevantFile: (fileName) => SCRIPT_EXTENSIONS.has(path.extname(fileName).toLowerCase()),
-    toCanonicalName: (typeRoot, filePath) => toPosix(path.relative(typeRoot, filePath)),
-    toAssetPath: (typeRoot, name) => path.join(typeRoot, name),
-};
-const ASSET_SPECS_INTERNAL = {
-    skill: {
-        stashDir: "skills",
-        isRelevantFile: (fileName) => fileName === "SKILL.md",
-        toCanonicalName: (typeRoot, filePath) => {
-            const relDir = toPosix(path.dirname(path.relative(typeRoot, filePath)));
-            if (!relDir || relDir === ".")
-                return undefined;
-            return relDir;
-        },
-        toAssetPath: (typeRoot, name) => path.join(typeRoot, name, "SKILL.md"),
-    },
-    command: { stashDir: "commands", ...markdownSpec },
-    agent: { stashDir: "agents", ...markdownSpec },
-    knowledge: { stashDir: "knowledge", ...markdownSpec },
-    workflow: {
-        stashDir: "workflows",
-        ...markdownSpec,
-        rendererName: "workflow-md",
-        actionBuilder: (ref) => buildWorkflowAction(ref),
-    },
-    script: { stashDir: "scripts", ...scriptSpec },
-    memory: { stashDir: "memories", ...markdownSpec },
-    // Environment assets — whole `.env` files sourced/injected wholesale. Replaced
-    // the deprecated `vault` type (removed in 0.9.0). Only key NAMES are surfaced
-    // as metadata; values and comment text are never read for indexing (comments
-    // routinely contain commented-out credentials).
-    env: {
-        stashDir: "env",
-        isRelevantFile: (fileName) => fileName === ".env" || fileName.endsWith(".env"),
-        toCanonicalName: (typeRoot, filePath) => {
-            const rel = toPosix(path.relative(typeRoot, filePath));
-            const fileName = path.basename(rel);
-            // Treat ".env" as the "default" env; "<name>.env" → "<name>"
-            if (fileName === ".env") {
-                const dir = path.dirname(rel);
-                return dir === "." || dir === "" ? "default" : `${dir}/default`;
-            }
-            const stripped = rel.endsWith(".env") ? rel.slice(0, -4) : rel;
-            return stripped;
-        },
-        toAssetPath: (typeRoot, name) => {
-            if (name === "default")
-                return path.join(typeRoot, ".env");
-            return path.join(typeRoot, name.endsWith(".env") ? name : `${name}.env`);
-        },
-        rendererName: "env-file",
-        actionBuilder: (ref) => `akm show ${ref} -> inspect key names; akm env run ${ref} -- <command> -> run with the whole .env injected (prefer --clean to minimize inherited parent env; child stdout is not redacted); akm env export ${ref} --out <file> -> write a sourceable script to a file`,
-    },
-    // Secrets — a single sensitive value used on its own for authentication (a
-    // PEM key, API token, TLS cert). Unlike `env` (a group of related .env
-    // configuration), the ENTIRE file is the one secret value — there is no safe
-    // region to parse, so only the filename is ever surfaced as metadata. The
-    // value reaches a command only via `akm secret run` (injected into a child
-    // env var) or `akm secret path` (Docker `_FILE` convention). A secret is any
-    // regular file under `secrets/` except `.lock`/`.sensitive` sidecars; the
-    // canonical name preserves the natural filename (e.g. `id_rsa`, `team/deploy.key`).
-    secret: {
-        stashDir: "secrets",
-        isRelevantFile: (fileName) => !fileName.endsWith(".lock") && !fileName.endsWith(".sensitive"),
-        toCanonicalName: (typeRoot, filePath) => toPosix(path.relative(typeRoot, filePath)),
-        toAssetPath: (typeRoot, name) => path.join(typeRoot, name),
-        rendererName: "secret-file",
-        actionBuilder: (ref) => `akm show ${ref} -> name only (value never shown); akm secret path ${ref} -> file path; akm secret run ${ref} <VAR> -- <command> -> run with value injected into $VAR`,
-    },
-    wiki: {
-        stashDir: "wikis",
-        ...markdownSpec,
-        rendererName: "wiki-md",
-        actionBuilder: (ref) => `akm show ${ref} -> read the wiki page`,
-    },
-    // v1 spec §13 — `lesson` asset type. Required frontmatter fields are
-    // `description` and `when_to_use`; lint enforces both (see
-    // `src/core/lesson-lint.ts`). Lessons normally arrive as proposals via
-    // `akm distill <ref>` (§14.5) and are promoted via `akm proposal accept`,
-    // but they can also be authored directly with `akm import` /
-    // `akm remember`-style flows.
-    lesson: {
-        stashDir: "lessons",
-        ...markdownSpec,
-        rendererName: "lesson-md",
-        actionBuilder: (ref) => `akm show ${ref} -> read the lesson and apply when_to_use`,
-    },
-    // Scheduled tasks. A task file pairs a cron-style schedule with a target
-    // (workflow ref, prompt, or command) that `akm tasks` registers with the
-    // OS-native scheduler (cron / launchd / schtasks). Stored as pure YAML
-    // under <stash>/tasks/<id>.yml.
-    task: {
-        stashDir: "tasks",
-        isRelevantFile: (fileName) => path.extname(fileName).toLowerCase() === ".yml",
-        toCanonicalName: (typeRoot, filePath) => {
-            const rel = toPosix(path.relative(typeRoot, filePath));
-            return rel.endsWith(".yml") ? rel.slice(0, -4) : rel;
-        },
-        toAssetPath: (typeRoot, name) => {
-            const withExt = name.endsWith(".yml") ? name : `${name}.yml`;
-            return path.join(typeRoot, withExt);
-        },
-        rendererName: "task-yaml",
-        actionBuilder: buildTaskAction,
-    },
-    // #561 — agent sessions indexed as a first-class searchable asset type.
-    // Generated (derived) markdown written by the `extract` pass to
-    // `sessions/<harness>/<session-id>.md`; carries `log_path` + `access`
-    // frontmatter so any agent can navigate into the raw session log. A plain
-    // markdown spec — the summary body is the searchable surface.
-    session: {
-        stashDir: "sessions",
-        ...markdownSpec,
-        rendererName: "session-md",
-        actionBuilder: (ref) => `akm show ${ref} -> read the session summary; follow the \`access\` frontmatter to open the raw log at \`log_path\``,
-    },
-    // Durable stash-level semantic knowledge — facts about the user, team, or
-    // project (personal details, team tool stacks, coding conventions /
-    // "constitution", and stash-meta like naming conventions or the active
-    // projects list). Unlike `memory` (episodic, recency-decayed) these are
-    // mostly-static declarations meant to be reliably surfaced as context. A
-    // plain markdown spec; `category` frontmatter scopes the fact and
-    // `pinned: true` marks the small always-injected core. See
-    // docs/design/fact-asset-type.md.
-    fact: {
-        stashDir: "facts",
-        ...markdownSpec,
-        rendererName: "fact-md",
-        actionBuilder: (ref) => `akm show ${ref} -> read the stash fact and apply it as durable context`,
-    },
-};
-export const ASSET_SPECS = ASSET_SPECS_INTERNAL;
-/**
- * Register a custom asset type with the akm asset system.
- *
- * ## Full extension registration API
- *
- * Providing `rendererName` and/or `actionBuilder` in the spec automatically
- * registers the renderer and action builder so that search results and `show`
- * output work out of the box without additional calls.
- *
- * ### Minimal registration (filesystem layout only)
- * ```ts
- * registerAssetType("widget", {
- *   stashDir: "widgets",
- *   isRelevantFile: (f) => f.endsWith(".widget"),
- *   toCanonicalName: (root, fp) => path.basename(fp, ".widget"),
- *   toAssetPath: (root, name) => path.join(root, `${name}.widget`),
- * });
- * ```
- *
- * ### Full registration (filesystem + renderer + action)
- * ```ts
- * registerAssetType("widget", {
- *   stashDir: "widgets",
- *   isRelevantFile: (f) => f.endsWith(".widget"),
- *   toCanonicalName: (root, fp) => path.basename(fp, ".widget"),
- *   toAssetPath: (root, name) => path.join(root, `${name}.widget`),
- *   rendererName: "widget-md",        // registered via registerRenderer() separately
- *   actionBuilder: (ref) => `akm show ${ref} -> use widget`,
- * });
- * ```
- *
- * Renderer and action builder registration is handled directly via the
- * `asset-registry` singleton — no deferred hooks or import-order concerns.
- */
-export function registerAssetType(type, spec) {
-    ASSET_SPECS_INTERNAL[type] = spec;
-    TYPE_DIRS[type] = spec.stashDir;
-    // Auto-register renderer and action builder if provided in spec
-    if (spec.rendererName) {
-        registerTypeRenderer(type, spec.rendererName);
-    }
-    if (spec.actionBuilder) {
-        registerActionBuilder(type, spec.actionBuilder);
-    }
-}
-/**
- * Remove a previously-registered asset type.
- *
- * Primarily used by tests for cleanup after `registerAssetType` calls so
- * subsequent tests see a pristine type registry. Built-in types should not
- * normally be deregistered at runtime.
- */
-export function deregisterAssetType(type) {
-    delete ASSET_SPECS_INTERNAL[type];
-    delete TYPE_DIRS[type];
-}
-export function getAssetTypes() {
-    return Object.keys(ASSET_SPECS_INTERNAL);
-}
-export const TYPE_DIRS = Object.fromEntries(Object.entries(ASSET_SPECS_INTERNAL).map(([type, spec]) => [type, spec.stashDir]));
-export function isRelevantAssetFile(assetType, fileName) {
-    return ASSET_SPECS[assetType]?.isRelevantFile(fileName) ?? false;
-}
-export function deriveCanonicalAssetName(assetType, typeRoot, filePath) {
-    return ASSET_SPECS[assetType]?.toCanonicalName(typeRoot, filePath);
-}
-export function deriveCanonicalAssetNameFromStashRoot(assetType, stashRoot, filePath) {
-    const relPath = toPosix(path.relative(stashRoot, filePath));
-    const segments = relPath.split("/").filter(Boolean);
-    const firstSegment = segments[0];
-    // When the first segment matches the canonical type dir (e.g. "agents"),
-    // use it as the type root so canonical names are relative to it.
-    // Otherwise fall back to stashRoot — this preserves the full relative path
-    // as the canonical name, which is correct for installed stashes that live
-    // under custom directories (e.g. "tools/agents/svelte-file-editor").
-    const typeRoot = firstSegment === TYPE_DIRS[assetType] ? path.join(stashRoot, firstSegment) : stashRoot;
-    return deriveCanonicalAssetName(assetType, typeRoot, filePath);
-}
-export function resolveAssetPathFromName(assetType, typeRoot, name) {
-    const spec = ASSET_SPECS[assetType];
-    if (!spec)
-        throw new Error(`Unknown asset type: "${assetType}"`);
-    return spec.toAssetPath(typeRoot, name);
-}