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

package/dist/core/adapter/adapters/akm-workflow-adapter.js

@@ -0,0 +1,180 @@
+// 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/.
+/**
+ * The `akm-workflow` adapter — akm 0.9.0 format-family work item (#46).
+ *
+ * A native akm workflow bundle (spec §6/§7). One format now (workflow-format-
+ * unification): `.md` files, orchestration graph in frontmatter, per-step
+ * prose in the body. Recognition is frontmatter `type: workflow`, or — since
+ * this adapter's whole domain IS workflows — simply residing under this
+ * bundle's root; no content sniffing. conceptId strips the `.md` extension. A
+ * plain `.md` that opts out via an explicit non-workflow `type:` frontmatter
+ * key is abstained on.
+ *
+ * ── validate (spec §6 workflow row) ──
+ *
+ * Reuses the akm adapter's per-type workflow checks (shared base checks +
+ * `placeholder-stub` + `invalid-workflow-structure`). Delegates to the SAME
+ * `perTypeValidateChecks` / `runBaseValidateChecks` the `akm` adapter uses, so
+ * workflow validation has one home.
+ *
+ * Conformance oracle (authored, DO NOT modify): fixture
+ * `tests/fixtures/bundles/akm-workflow/` + goldens
+ * `tests/fixtures/format-family-goldens/akm-workflow/{recognition,placement,lint,renderer}.json`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parseFrontmatter } from "../../asset/frontmatter.js";
+import { perTypeValidateChecks } from "./akm-lint.js";
+import { hashContent, nonEmptyString, readTags, runBaseValidateChecks } from "./shared.js";
+/** A native workflow bundle is single-component; its one component is `main`. */
+const COMPONENT_ID = "main";
+/** One recognized workflow extension now (workflow-format-unification): `.md`. */
+const WORKFLOW_EXTS = new Set([".md"]);
+/** Upper bound on the bounded `content` FTS field (mirrors okf-adapter). */
+const MAX_CONTENT_CHARS = 100_000;
+function toPosix(p) {
+    return p.replace(/\\/g, "/");
+}
+/** Strip the recognized workflow extension from a component-root-relative path → conceptId. */
+function conceptIdOf(relPath) {
+    return toPosix(relPath).replace(/\.md$/i, "");
+}
+/** `README.md` (case-insensitive) is documentation, never the typed asset — mirrors the akm matcher stack's D-R6 reserved-file exclusion (`TYPED_DIR_DOC_FILES`). */
+function isReservedDocFile(fileName) {
+    return fileName.toLowerCase() === "readme.md";
+}
+/**
+ * Recognition gate: any `.md` file in this bundle IS a workflow (this
+ * adapter's entire domain is workflows — spec §2.5, "residence under
+ * workflows/"), UNLESS its frontmatter declares a DIFFERENT non-empty
+ * `type:` (an explicit opt-out, e.g. a README-shaped doc that wants to be
+ * something else). No content sniffing.
+ */
+function isWorkflowFile(raw) {
+    const data = parseFrontmatter(raw).data;
+    const type = data.type;
+    return type === undefined || type === "workflow";
+}
+function recognize(c, file) {
+    if (!WORKFLOW_EXTS.has(file.ext))
+        return null;
+    if (isReservedDocFile(file.fileName))
+        return null;
+    const raw = file.content();
+    if (!isWorkflowFile(raw))
+        return null;
+    const conceptId = conceptIdOf(file.relPath);
+    const name = conceptId.split("/").pop() ?? conceptId;
+    const parsed = parseFrontmatter(raw);
+    const description = nonEmptyString(parsed.data.description);
+    const body = parsed.content;
+    const tags = readTags(parsed.data.tags);
+    const doc = {
+        ref: `${c.id}//${conceptId}`,
+        bundle: c.id,
+        component: COMPONENT_ID,
+        conceptId,
+        path: file.absPath,
+        hash: hashContent(raw),
+        adapterId: "akm-workflow",
+        type: "workflow",
+        name,
+        content: body.length > MAX_CONTENT_CHARS ? body.slice(0, MAX_CONTENT_CHARS) : body,
+    };
+    if (description !== undefined)
+        doc.description = description;
+    if (tags !== undefined)
+        doc.tags = tags;
+    return doc;
+}
+async function validate(c, changes, ctx) {
+    const diagnostics = [];
+    for (const change of changes) {
+        if (change.op === "delete")
+            continue;
+        const raw = change.after ?? (await ctx.readFile(change.path));
+        if (typeof raw !== "string")
+            continue;
+        const ext = path.extname(change.path).toLowerCase();
+        if (!WORKFLOW_EXTS.has(ext) || isReservedDocFile(path.basename(change.path)) || !isWorkflowFile(raw))
+            continue;
+        const relPath = toPosix(change.path);
+        const p = parseFrontmatter(raw);
+        const parsed = { data: p.data, content: p.content, frontmatter: p.frontmatter };
+        diagnostics.push(...(await runBaseValidateChecks(relPath, parsed, c.root, ctx)));
+        diagnostics.push(...(await perTypeValidateChecks({
+            type: "workflow",
+            relPath,
+            raw,
+            data: parsed.data,
+            frontmatter: parsed.frontmatter,
+            body: parsed.content,
+            ext,
+            ctx,
+        })));
+    }
+    return diagnostics;
+}
+/**
+ * True when a top-level file in `root` is workflow-shaped (used by
+ * looksLikeRoot). Unlike `isWorkflowFile` (which admits an absent `type:` —
+ * the lenient default ONCE a source is already known to be this bundle),
+ * this requires an EXPLICIT `type: workflow` — the install-time probe is
+ * choosing WHICH adapter owns an unconfigured root among several candidates
+ * (spec §1.2), and an incidental `.md` with no frontmatter type at all
+ * (common in an OKF or llm-wiki bundle) must not misclassify that root as
+ * akm-workflow's.
+ */
+function hasTopLevelWorkflowFile(root, entries) {
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!WORKFLOW_EXTS.has(ext) || isReservedDocFile(entry.name))
+            continue;
+        let raw;
+        try {
+            raw = fs.readFileSync(path.join(root, entry.name), "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (parseFrontmatter(raw).data.type === "workflow")
+            return true;
+    }
+    return false;
+}
+export const akmWorkflowAdapter = {
+    id: "akm-workflow",
+    version: "0.9.0",
+    extensions: [".md"],
+    recognize,
+    validate,
+    /** Markdown placement; an explicit `.md` conceptId short-circuits to that extension. */
+    placeNew(c, conceptId) {
+        const posix = toPosix(conceptId);
+        if (/\.md$/i.test(posix))
+            return path.join(c.root, posix);
+        return path.join(c.root, `${posix}.md`);
+    },
+    /** Workflows live anywhere under the component root. */
+    directoryList() {
+        return ["."];
+    },
+    /**
+     * Install-time probe (§1.2): a root holding a workflow-shaped `.md` file at
+     * top level (frontmatter `type: workflow` or no `type:` at all).
+     */
+    looksLikeRoot(root) {
+        let entries;
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        return hasTopLevelWorkflowFile(root, entries);
+    },
+};

package/dist/core/adapter/adapters/claude-adapter.js

@@ -0,0 +1,61 @@
+// 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/.
+/**
+ * The `claude` tool-directory adapter — akm 0.9.0 format-family work item (#46).
+ *
+ * Recognizes a Claude Code `.claude` layout (spec §6/§7, real-world:
+ * https://code.claude.com/docs/en/claude-directory): a root `CLAUDE.md` →
+ * `instruction`, `commands/*.md` → `command`, `agents/*.md` → `agent`,
+ * `skills/<name>/SKILL.md` → `skill` (item = the dir; bundled resources abstain),
+ * and ABSTAINS on runtime config (`settings.json`, `.mcp.json`). The component
+ * id is the PROVENANCE `.claude`; the ref prefix is the bundle id (`c.id`).
+ *
+ * All behavior lives in the shared tool-dir codec ({@link makeToolDirAdapter});
+ * this module supplies only the `.claude` layout + the install-time probe.
+ *
+ * Conformance oracle (authored, DO NOT modify): fixture
+ * `tests/fixtures/bundles/claude/` + goldens
+ * `tests/fixtures/format-family-goldens/claude/{recognition,placement,lint,renderer}.json`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { makeToolDirAdapter } from "./tool-dir-shared.js";
+const LAYOUT = {
+    adapterId: "claude",
+    componentId: ".claude",
+    instructionFile: "CLAUDE.md",
+    instructionConceptId: "CLAUDE",
+    commandDirs: new Set(["commands"]),
+    agentDirs: new Set(["agents"]),
+    skillDirs: new Set(["skills"]),
+};
+/** True when `root` carries a directory. */
+function dirExists(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Install-time probe (§1.2): a root is a `.claude` tool dir when it carries a
+ * root `CLAUDE.md` AND at least one of the `commands/`/`agents/`/`skills/` tool
+ * dirs. The tool-dir requirement keeps a bare project `CLAUDE.md` (no `.claude`
+ * structure) from being mistaken for a claude bundle, and — because it demands
+ * `CLAUDE.md`, which an akm workspace / okf / wiki root never carries — the
+ * probe is registered AHEAD of `akm` so a `.claude` root (whose `commands/`
+ * etc. also look like akm stash subdirs) is claimed by `claude`, not shadowed.
+ */
+function claudeLooksLikeRoot(root) {
+    try {
+        if (!fs.existsSync(path.join(root, "CLAUDE.md")))
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return ["commands", "agents", "skills"].some((d) => dirExists(path.join(root, d)));
+}
+export const claudeAdapter = makeToolDirAdapter(LAYOUT, claudeLooksLikeRoot);

package/dist/core/adapter/adapters/dotenv-adapter.js

@@ -0,0 +1,187 @@
+// 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/.
+/**
+ * The `dotenv` adapter — akm 0.9.0 format-family work item (#46).
+ *
+ * A metadata-only env/secret bundle (spec §6/§7, normative §21.2). REDACTION IS
+ * A HARD CONTRACT keyed on the ADAPTER, never on the open `type` value (a
+ * frontmatter `type:` cannot opt out):
+ *   - `env/*.env` → `type: env` — only the KEY NAMES are surfaced (on `hints`);
+ *     VALUES, COMMENTS, and raw CONTENT are NEVER read into the index.
+ *   - any file under `secrets/` → `type: secret` — only the FILE NAME is
+ *     surfaced; the whole file is the value and is never read. A `.env` UNDER
+ *     `secrets/` is a SECRET (the dir gate wins) — name-only, MORE redacted than
+ *     an `env/` file even though it has KEY=VALUE lines.
+ * conceptId: env strips `.env`; secret keeps its natural path (including any
+ * extension). Neither branch ever writes a value onto the emitted document.
+ *
+ * ── validate (spec §6 env/secret validation column) ──
+ *
+ * The dangerous-key scan (`dangerous-env-key`), reusing the akm adapter's
+ * `dangerousEnvKeyDiagnostics` — which preserves the code-grounded narrowness:
+ * it runs ONLY on `*.env`-suffixed files, so `secrets/<bare-name>` is never
+ * scanned (its whole content is an opaque secret value). Reads KEY NAMES only.
+ *
+ * Conformance oracle (authored, DO NOT modify): fixture
+ * `tests/fixtures/bundles/dotenv/` + goldens
+ * `tests/fixtures/format-family-goldens/dotenv/{recognition,placement,lint,renderer}.json`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { assetPathForName, typeForStashDir } from "../../asset/asset-placement.js";
+import { dangerousEnvKeyDiagnostics } from "./akm-lint.js";
+import { hashContent } from "./shared.js";
+/** A dotenv bundle is single-component; its one component is `main`. */
+const COMPONENT_ID = "main";
+/** The `env/` content subdir (KEY=VALUE files). */
+const ENV_DIR = "env";
+/** The `secrets/` content subdir (whole-file secrets). */
+const SECRETS_DIR = "secrets";
+/** Non-secret marker suffixes under `secrets/` (spec §6 secret row). */
+const SECRET_SKIP_SUFFIXES = [".lock", ".sensitive"];
+/** Matches a KEY=value assignment line, capturing only the key (mirrors akm-lint scanKeys). */
+const ASSIGN_RE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
+function toPosix(p) {
+    return p.replace(/\\/g, "/");
+}
+/** Classify a component-root-relative file as env / secret, or null (abstain). */
+function classify(relPath) {
+    const posix = toPosix(relPath);
+    const segs = posix.split("/").filter((s) => s.length > 0);
+    if (segs.length < 2)
+        return null;
+    const head = segs[0];
+    const base = segs[segs.length - 1];
+    if (head === ENV_DIR) {
+        return base === ".env" || base.endsWith(".env") ? "env" : null;
+    }
+    if (head === SECRETS_DIR) {
+        return SECRET_SKIP_SUFFIXES.some((s) => base.endsWith(s)) ? null : "secret";
+    }
+    return null;
+}
+/** Extract KEY NAMES (never values) from an env file's raw content, first-appearance order, deduped. */
+function scanKeyNames(raw) {
+    const keys = [];
+    const seen = new Set();
+    for (const line of raw.split(/\r?\n/)) {
+        const m = line.match(ASSIGN_RE);
+        if (!m)
+            continue;
+        const key = m[1];
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        keys.push(key);
+    }
+    return keys;
+}
+function recognize(c, file) {
+    const type = classify(file.relPath);
+    if (type === null)
+        return null;
+    const posix = toPosix(file.relPath);
+    const raw = file.content();
+    if (type === "env") {
+        // env: strip `.env`; surface KEY NAMES only (never values/comments/content).
+        const conceptId = posix.replace(/\.env$/i, "");
+        const name = (conceptId.split("/").pop() ?? conceptId) || "default";
+        const keys = scanKeyNames(raw);
+        const doc = {
+            ref: `${c.id}//${conceptId}`,
+            bundle: c.id,
+            component: COMPONENT_ID,
+            conceptId,
+            path: file.absPath,
+            hash: hashContent(raw),
+            adapterId: "dotenv",
+            type: "env",
+            name,
+        };
+        if (keys.length > 0)
+            doc.hints = keys;
+        return doc;
+    }
+    // secret: keep the natural path; surface the FILE NAME only — never keys/content.
+    const name = posix.split("/").pop() ?? posix;
+    return {
+        ref: `${c.id}//${posix}`,
+        bundle: c.id,
+        component: COMPONENT_ID,
+        conceptId: posix,
+        path: file.absPath,
+        hash: hashContent(raw),
+        adapterId: "dotenv",
+        type: "secret",
+        name,
+    };
+}
+async function validate(_c, changes, ctx) {
+    const diagnostics = [];
+    for (const change of changes) {
+        if (change.op === "delete")
+            continue;
+        const raw = change.after ?? (await ctx.readFile(change.path));
+        if (typeof raw !== "string")
+            continue;
+        const type = classify(change.path);
+        if (type === null)
+            continue;
+        // dangerousEnvKeyDiagnostics is `.env`-suffix-narrow: a bare secret file is never scanned.
+        diagnostics.push(...dangerousEnvKeyDiagnostics(type, toPosix(change.path), raw));
+    }
+    return diagnostics;
+}
+export const dotenvAdapter = {
+    id: "dotenv",
+    version: "0.9.0",
+    extensions: [".env"],
+    recognize,
+    validate,
+    /**
+     * env places to `env/<name>.env`, secret to `secrets/<name>` (identity join,
+     * no extension logic) — reusing the shared `assetPathForName` so the env
+     * default-alias / already-suffixed / nested-secret edge cases match the akm
+     * placement convention exactly.
+     */
+    placeNew(c, conceptId) {
+        const posix = toPosix(conceptId);
+        const slash = posix.indexOf("/");
+        if (slash > 0) {
+            const head = posix.slice(0, slash);
+            const rest = posix.slice(slash + 1);
+            const type = typeForStashDir(head);
+            if ((type === "env" || type === "secret") && rest.length > 0) {
+                return assetPathForName(type, path.join(c.root, head), rest);
+            }
+        }
+        return path.join(c.root, posix);
+    },
+    /** The dotenv bundle owns its `env/` + `secrets/` dirs. */
+    directoryList() {
+        return [ENV_DIR, SECRETS_DIR];
+    },
+    /**
+     * Install-time probe (§1.2): a root whose ONLY content dirs are `env/` and/or
+     * `secrets/` (at least one present). The env/secrets-ONLY requirement keeps a
+     * full akm workspace — which also carries `env/` + `secrets/` alongside many
+     * other stash subdirs — from being mistaken for a dotenv bundle, so the probe
+     * is registered ahead of `akm` without shadowing it.
+     */
+    looksLikeRoot(root) {
+        let entries;
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        if (dirs.length === 0)
+            return false;
+        if (!dirs.every((d) => d === ENV_DIR || d === SECRETS_DIR))
+            return false;
+        return dirs.includes(ENV_DIR) || dirs.includes(SECRETS_DIR);
+    },
+};

package/dist/core/adapter/adapters/generic-files-adapter.js

@@ -0,0 +1,119 @@
+// 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/.
+/**
+ * The `generic-files` adapter — akm 0.9.0 format-family work item (#46).
+ *
+ * The AKM-native FALLBACK family (spec §7). Any leftover file is classified by
+ * extension (open-question-5, RESOLVED — maintainer 2026-07):
+ *   - a SCRIPT_EXTENSIONS extension → `script` (conceptId KEEPS the extension);
+ *   - markdown / plain-text → `document` (conceptId STRIPS the extension);
+ *   - everything else → `file` (conceptId keeps the extension).
+ * Placement is IDENTITY: `document` appends `.md`, `script`/`file` keep their
+ * natural path. D-R6 reserved files (`index.md`/`log.md`) are excluded from the
+ * catch-all so a structural listing is never indexed as a `document`.
+ *
+ * EXPLICIT-CONFIG ONLY: `generic-files` is never in the §1.2 auto-probe order —
+ * a user opts in deliberately — so `looksLikeRoot` NEVER fires. It has no
+ * type-specific validators (`validate` runs base checks only).
+ *
+ * Conformance oracle (authored, DO NOT modify): fixture
+ * `tests/fixtures/bundles/generic-files/` + goldens
+ * `tests/fixtures/format-family-goldens/generic-files/{recognition,placement,lint,renderer}.json`.
+ */
+import path from "node:path";
+import { parseFrontmatter } from "../../asset/frontmatter.js";
+import { SCRIPT_EXTENSIONS } from "../../recognition-util.js";
+import { hashContent, nonEmptyString, readTags, runBaseValidateChecks } from "./shared.js";
+/** A generic-files bundle is single-component; its one component is `main`. */
+const COMPONENT_ID = "main";
+/** Markdown / plain-text extensions classified as `document`. */
+const DOCUMENT_EXTENSIONS = new Set([".md", ".markdown", ".txt", ".text"]);
+/** OKF reserved structural files (D-R6) — excluded from the catch-all, case-insensitive. */
+const RESERVED_FILES = new Set(["index.md", "log.md"]);
+/** Upper bound on the bounded `content` FTS field (mirrors okf-adapter). */
+const MAX_CONTENT_CHARS = 100_000;
+function toPosix(p) {
+    return p.replace(/\\/g, "/");
+}
+function isReserved(base) {
+    return RESERVED_FILES.has(base.toLowerCase());
+}
+/** Classify by extension (open-question-5 predicate). */
+function classify(ext) {
+    if (SCRIPT_EXTENSIONS.has(ext))
+        return "script";
+    if (DOCUMENT_EXTENSIONS.has(ext))
+        return "document";
+    return "file";
+}
+function recognize(c, file) {
+    const posix = toPosix(file.relPath);
+    const base = posix.split("/").pop() ?? posix;
+    if (isReserved(base))
+        return null; // D-R6: never index a structural listing
+    const type = classify(file.ext);
+    // document strips its extension; script/file keep the natural path.
+    const conceptId = type === "document" ? posix.replace(/\.[^./]+$/, "") : posix;
+    const name = conceptId.split("/").pop() ?? conceptId;
+    const raw = file.content();
+    const parsed = parseFrontmatter(raw);
+    const body = parsed.content;
+    const doc = {
+        ref: `${c.id}//${conceptId}`,
+        bundle: c.id,
+        component: COMPONENT_ID,
+        conceptId,
+        path: file.absPath,
+        hash: hashContent(raw),
+        adapterId: "generic-files",
+        type,
+        name,
+        content: body.length > MAX_CONTENT_CHARS ? body.slice(0, MAX_CONTENT_CHARS) : body,
+    };
+    if (type !== "script")
+        doc.ownsPresentation = true;
+    const description = nonEmptyString(parsed.data.description);
+    if (description !== undefined)
+        doc.description = description;
+    const tags = readTags(parsed.data.tags);
+    if (tags !== undefined)
+        doc.tags = tags;
+    return doc;
+}
+async function validate(c, changes, ctx) {
+    const diagnostics = [];
+    for (const change of changes) {
+        if (change.op === "delete")
+            continue;
+        const raw = change.after ?? (await ctx.readFile(change.path));
+        if (typeof raw !== "string")
+            continue;
+        // No type-specific validators — base checks only (spec §6 script/document/file rows).
+        diagnostics.push(...(await runBaseValidateChecks(toPosix(change.path), parseFrontmatter(raw), c.root, ctx)));
+    }
+    return diagnostics;
+}
+export const genericFilesAdapter = {
+    id: "generic-files",
+    version: "0.9.0",
+    // Non-exhaustive HINT: generic-files recognizes ANY file — recognize() is the
+    // source of truth (empty extension list would drop the extension-strip hint).
+    extensions: [".md", ".txt"],
+    recognize,
+    validate,
+    /**
+     * IDENTITY placement (open-question-5): a conceptId that carries an extension
+     * (`script`/`file`) places to itself; an extension-less conceptId (a
+     * `document`) appends `.md`.
+     */
+    placeNew(c, conceptId) {
+        const posix = toPosix(conceptId);
+        const hasExt = path.extname(posix) !== "";
+        return path.join(c.root, hasExt ? posix : `${posix}.md`);
+    },
+    /** generic-files is EXPLICIT-CONFIG ONLY — never auto-selected (§1.2), so this never fires. */
+    looksLikeRoot() {
+        return false;
+    },
+};

package/dist/core/adapter/adapters/index.js

@@ -0,0 +1,80 @@
+// 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 { agentSkillsAdapter } from "./agent-skills-adapter.js";
+import { akmAdapter } from "./akm-adapter.js";
+import { akmTaskAdapter } from "./akm-task-adapter.js";
+import { akmWorkflowAdapter } from "./akm-workflow-adapter.js";
+import { claudeAdapter } from "./claude-adapter.js";
+import { dotenvAdapter } from "./dotenv-adapter.js";
+import { genericFilesAdapter } from "./generic-files-adapter.js";
+import { llmWikiAdapter } from "./llm-wiki-adapter.js";
+import { okfAdapter } from "./okf-adapter.js";
+import { opencodeAdapter } from "./opencode-adapter.js";
+import { websiteSnapshotAdapter } from "./website-snapshot-adapter.js";
+export { agentSkillsAdapter } from "./agent-skills-adapter.js";
+export { akmAdapter } from "./akm-adapter.js";
+export { akmTaskAdapter } from "./akm-task-adapter.js";
+export { akmWorkflowAdapter } from "./akm-workflow-adapter.js";
+export { claudeAdapter } from "./claude-adapter.js";
+export { dotenvAdapter } from "./dotenv-adapter.js";
+export { genericFilesAdapter } from "./generic-files-adapter.js";
+export { llmWikiAdapter } from "./llm-wiki-adapter.js";
+export { okfAdapter } from "./okf-adapter.js";
+export { opencodeAdapter } from "./opencode-adapter.js";
+export { websiteSnapshotAdapter } from "./website-snapshot-adapter.js";
+/**
+ * Every built-in adapter, frozen in the §1.2 install-time probe order: the first
+ * adapter whose `looksLikeRoot` fires claims a root, so MORE-SPECIFIC probes
+ * come FIRST. This ARRAY ORDER is the executable probe order (`getAdapters()`
+ * returns it verbatim) and is pinned by the conformance suite's ordered-owner
+ * matrix — it, not the spec §1.2(3) 5-adapter prose listing, is authoritative
+ * for the implemented 11-family set.
+ *
+ * Probe-precedence rationale (grounds "cannot shadow the existing three"):
+ *
+ *  - The three loosest probes — `llm-wiki`, `akm`, and `okf` — stay LAST.
+ *    Native AKM evidence wins before OKF because AKM Markdown is an OKF
+ *    superset; the AKM probe is correspondingly strict enough not to claim an
+ *    OKF bundle merely because it contains one familiar directory name.
+ *  - `akm.looksLikeRoot` fires on ANY root carrying a stash-subdir-named
+ *    directory — which includes a `.claude`/`.opencode` tool dir (`commands/`,
+ *    `agents/`, `skills/`) and a dotenv bundle (`env/`, `secrets/`). So
+ *    `claude` / `opencode` / `dotenv` come AHEAD of `akm`; their tighter
+ *    markers (CLAUDE.md+tooldir / AGENTS.md|opencode.json / env-secrets-ONLY)
+ *    claim those roots first, and `akm` still wins its own workspace root (which
+ *    those tighter probes reject).
+ *  - `website-snapshot` (manifest.json), `agent-skills` (a `<name>/SKILL.md`
+ *    package), `akm-workflow` (a workflow-shaped top-level file), and `akm-task`
+ *    (a schedule-bearing top-level `.yml`) carry disjoint, specific markers that
+ *    fire on none of the other roots; they come at the front for clarity.
+ *  - `generic-files` is EXPLICIT-CONFIG ONLY (§1.2) — its `looksLikeRoot` never
+ *    fires — so it is LAST and can never shadow anything.
+ */
+export const BUILTIN_ADAPTERS = Object.freeze([
+    // Specific, disjoint markers first.
+    websiteSnapshotAdapter,
+    agentSkillsAdapter,
+    // Tool dirs + dotenv BEFORE akm (they share stash-subdir-shaped structure).
+    claudeAdapter,
+    opencodeAdapter,
+    dotenvAdapter,
+    // Native akm sub-formats (disjoint content-shape probes).
+    akmWorkflowAdapter,
+    akmTaskAdapter,
+    // Loose probes: specific native layouts before the portable OKF baseline.
+    llmWikiAdapter,
+    akmAdapter,
+    okfAdapter,
+    // Explicit-config fallback (never auto-selected) — last.
+    genericFilesAdapter,
+]);
+/**
+ * DEPRECATED no-op retained for test back-compat only. The built-in set is now
+ * the static, frozen {@link BUILTIN_ADAPTERS}, exposed by the registry at
+ * module load (normative §12.6), so there is nothing to register. New code MUST
+ * NOT call this — `getAdapters()` / `adapterForId()` are always populated.
+ */
+export function registerBuiltinAdapters() {
+    // intentionally empty — BUILTIN_ADAPTERS is static; see the doc comment above.
+}