akm-cli 0.9.8 → 0.9.9-beta.1

package/dist/core/config/config.js

@@ -151,7 +151,7 @@ export function parseAndValidateConfigText(text, sourcePath) {
     // rewritten onto the first-class engine field they now shadow. This used
     // to happen silently, in memory, on every load; that ran forever and never
     // converged. The lift itself is now `akm migrate apply`'s job (see
-    // src/commands/migrate/config-extra-params.ts) and persists to disk, so a
+    // scripts/akm-migrate/migrate/config-extra-params.ts) and persists to disk, so a
     // config that has not been migrated yet fails closed here instead of
     // silently drifting from what's on disk.
     const where = sourcePath ? ` at ${sourcePath}` : "";

package/dist/core/config/schema/sources-bundles.js

@@ -7,9 +7,15 @@
  * change.
  */
 import { z } from "zod";
+// Dependency-free mirror of the adapter registry's id list (#909) — see
+// adapter-ids.ts's header for why config imports this leaf rather than
+// `core/adapter/registry.ts` (which would pull in all 11 concrete adapters
+// and, transitively, the indexer modules they delegate to).
+import { VALID_ADAPTER_IDS } from "../../adapter/adapter-ids.js";
 import { isBundleSlug } from "../../asset/asset-ref.js";
 import { hasRegistryUrlCredentials, REGISTRY_CREDENTIALS_UNSUPPORTED } from "../../registry-url.js";
 import { httpUrl, nonEmptyString, positiveInt } from "./primitives.js";
+const VALID_ADAPTER_IDS_SET = new Set(VALID_ADAPTER_IDS);
 // ── Sources / registries / installed ────────────────────────────────────────
 const SourceConfigEntryOptionsSchema = z.record(z.unknown());
 export const SourceConfigEntrySchema = z
@@ -165,6 +171,23 @@ export const BundleConfigEntrySchema = z
             message: "writable: true is only supported on path and git bundle sources",
         });
     }
+    // #909: an unrecognized `components.*.adapter` used to silently fall back
+    // to `akm` at detect-time with no error and no disclosure — a typo
+    // (`agent_skills`, `akm-native`, …) then silently changed which files got
+    // indexed. Reject it here instead, the same treatment other enum-valued
+    // config fields get, listing the accepted values (derived from the
+    // adapter registry, never hardcoded — see adapter-ids.ts).
+    if (componentEntry !== undefined) {
+        const [componentName, componentValue] = componentEntry;
+        const adapterValue = componentValue.adapter;
+        if (adapterValue !== undefined && !VALID_ADAPTER_IDS_SET.has(adapterValue)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["components", componentName, "adapter"],
+                message: `unrecognized adapter "${adapterValue}"; expected one of: ${VALID_ADAPTER_IDS.join(", ")}`,
+            });
+        }
+    }
 });
 /**
  * `bundles` map. Keys are workspace bundle slugs (spec §11.1 / D-R5 charset).

package/dist/core/extra-params.js

@@ -125,7 +125,7 @@ export function formatExtraParamsIssue(label, issue) {
  * (#852, following #815).
  *
  * Pure: never touches the filesystem. Two callers use this differently:
- * `akm migrate apply` (src/commands/migrate/config-extra-params.ts) uses the
+ * `akm migrate apply` (scripts/akm-migrate/migrate/config-extra-params.ts) uses the
  * returned `config` to persist the rewrite to disk, once; `parseAndValidateConfigText`
  * (src/core/config/config.ts) calls this only to detect whether a lift is
  * needed and discards `config` — an unmigrated config fails closed there

package/dist/core/state/migrations.js

@@ -1187,8 +1187,7 @@ export function runMigrations(db, options) {
         }
         if (!options.allowHistoricalDestructiveStateUpgrade) {
             throw new Error("Refusing to migrate an existing unversioned state.db during an ordinary managed open. " +
-                "Run `akm upgrade --force` to snapshot it before migration 001, " +
-                "or `akm upgrade --state-only` where akm cannot reinstall itself (container/global install).");
+                "Run `akm upgrade` (or `akm migrate apply`) to snapshot it before migration 001 and apply it deliberately.");
         }
         const ledger = assertMigrationLedger(lockedDb, STATE_MIGRATIONS);
         if (ledger.migrationIds.length !== 0) {
@@ -1218,8 +1217,7 @@ export function runMigrations(db, options) {
             assertMigrationLedger(lockedDb, STATE_MIGRATIONS);
             if (!options?.allowHistoricalDestructiveStateUpgrade) {
                 throw new Error(`Refusing to apply historical destructive state migration ${migration.id} during an ordinary managed open. ` +
-                    "Run `akm upgrade --force` to create a sibling state.db safety copy and apply it deliberately, " +
-                    "or `akm upgrade --state-only` where akm cannot reinstall itself (container/global install).");
+                    "Run `akm upgrade` (or `akm migrate apply`) to create a sibling state.db safety copy and apply it deliberately.");
             }
             if (!options.beforeHistoricalDestructiveMigration) {
                 throw new Error(`Historical destructive state migration ${migration.id} requires a verified safety-copy hook.`);

package/dist/core/state-db.js

@@ -407,8 +407,8 @@ export function openStateDatabase(dbPath, options) {
                 existingUnversionedDatabase = ledger.migrationIds.length === 0;
                 if (existingUnversionedDatabase && !options?.allowHistoricalDestructiveStateUpgrade) {
                     throw new Error("Refusing to migrate an existing unversioned state.db during an ordinary managed open. " +
-                        "Run `akm upgrade --force` to create a verified snapshot before migration 001, " +
-                        "or `akm upgrade --state-only` where akm cannot reinstall itself (container/global install).");
+                        "Run `akm upgrade` (or `akm migrate apply`) to create a verified snapshot before migration 001 " +
+                        "and apply it deliberately.");
                 }
             }
             finally {
@@ -499,13 +499,36 @@ export function openStateDatabase(dbPath, options) {
     }
 }
 /**
- * Narrow state-schema step owned by `akm upgrade` after executable replacement.
- * Missing/current databases are no-ops. A pre-018 exact ledger is snapshotted
- * beside state.db and verified before the immutable released migration runs.
+ * Read-only: the state migration IDs the running akm would apply to `dbPath`,
+ * in ledger order. Empty when the database is missing or current. Throws on a
+ * ledger this akm cannot own (newer, or not an exact ordered prefix) -- the
+ * same refusal a managed open makes.
  */
-export function upgradeHistoricalStateDatabase(dbPath = getStateDbPath()) {
+export function listPendingStateMigrations(dbPath = getStateDbPath()) {
     if (!fs.existsSync(dbPath))
-        return { upgraded: false };
+        return [];
+    const preflight = openDatabase(dbPath, { readonly: true });
+    try {
+        preflight.exec("PRAGMA busy_timeout = 30000");
+        const ledger = assertMigrationLedger(preflight, STATE_MIGRATIONS);
+        return STATE_MIGRATIONS.slice(ledger.migrationIds.length).map((migration) => migration.id);
+    }
+    finally {
+        preflight.close();
+    }
+}
+/**
+ * Apply every pending state migration, historical-destructive ones included:
+ * the one step `akm upgrade` and `akm migrate apply` share, and the only
+ * caller that may admit migration 018 (an ordinary managed open refuses it by
+ * design). Missing/current databases are no-ops. A pre-018 exact ledger, or an
+ * unversioned database, is snapshotted beside state.db and verified before the
+ * immutable released migration runs.
+ */
+export function upgradeHistoricalStateDatabase(dbPath = getStateDbPath()) {
+    const pending = listPendingStateMigrations(dbPath);
+    if (pending.length === 0)
+        return { upgraded: false, applied: [] };
     let safetyCopyPath;
     try {
         const db = openStateDatabase(dbPath, {
@@ -521,7 +544,7 @@ export function upgradeHistoricalStateDatabase(dbPath = getStateDbPath()) {
         const recovery = safetyCopyPath ? ` Verified safety copy: ${safetyCopyPath}.` : "";
         throw new Error(`${detail}${recovery}`);
     }
-    return safetyCopyPath ? { upgraded: true, safetyCopyPath } : { upgraded: false };
+    return safetyCopyPath ? { upgraded: true, applied: pending, safetyCopyPath } : { upgraded: true, applied: pending };
 }
 /**
  * Run `fn` against state.db, owning the handle unless one is borrowed. The loan

package/dist/indexer/indexer.js

@@ -13,7 +13,7 @@ import { classifyPathAccess, describeInaccessiblePath } from "../core/path-acces
 import { getDbPath } from "../core/paths.js";
 import { SCRIPT_EXTENSIONS } from "../core/recognition-util.js";
 import { withStateDb } from "../core/state-db.js";
-import { isVerbose, warn, warnVerbose } from "../core/warn.js";
+import { isVerbose, warn, warnOnce, warnVerbose } from "../core/warn.js";
 import { disposeLoweredExecutionDispatchLease, } from "../integrations/agent/execution-lowering.js";
 import { isLlmFeatureEnabled } from "../llm/feature-gate.js";
 import { resolveIndexPassExecution } from "../llm/index-passes.js";
@@ -750,6 +750,67 @@ function sourceSnapshotRemovals(db, currentStashDir, bundleId, currentDirs, allI
         reason: { kind: "not-in-source-snapshot" },
     }));
 }
+/**
+ * Warn ONCE per process (#908) when the chosen adapter for a component
+ * entirely skips a top-level directory that holds files the `akm` adapter —
+ * the format-neutral superset — would have indexed. `detectAdapterId` now
+ * corrects this for AUTO-DETECTION (a mixed layout detects as `akm`); this
+ * covers the case detection cannot see, an EXPLICITLY configured narrow
+ * adapter (`components.<name>.adapter: "agent-skills"`, say) sitting next to
+ * ordinary akm content. One line for the whole process — not one per bundle,
+ * not one per directory — naming the count and the directories is enough to
+ * point an operator at the fix.
+ */
+function warnIfAdapterSkipsAkmContent(component, files, adapter) {
+    if (adapter.id === "akm")
+        return;
+    const akm = adapterForId("akm");
+    if (!akm)
+        return;
+    const byTopDir = new Map();
+    for (const file of files) {
+        const top = file.ancestorDirs[0];
+        if (!top)
+            continue; // a root-level file is not a "skipped directory" concern
+        const group = byTopDir.get(top);
+        if (group)
+            group.push(file);
+        else
+            byTopDir.set(top, [file]);
+    }
+    const akmComponent = { ...component, adapter: "akm" };
+    let skippedCount = 0;
+    const skippedDirs = [];
+    for (const [dir, dirFiles] of byTopDir) {
+        const chosenRecognizesAny = dirFiles.some((file) => {
+            try {
+                return adapter.recognize(component, file) !== null;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (chosenRecognizesAny)
+            continue; // the chosen adapter owns this dir; nothing skipped
+        const akmCandidates = dirFiles.filter((file) => {
+            try {
+                return akm.recognize(akmComponent, file) !== null;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (akmCandidates.length === 0)
+            continue; // akm would drop it too — not a shadowing case
+        skippedCount += akmCandidates.length;
+        skippedDirs.push(dir);
+    }
+    if (skippedCount === 0)
+        return;
+    skippedDirs.sort();
+    warnOnce("adapter-skip-akm-content", `${adapter.id} adapter skipped ${skippedCount} file${skippedCount === 1 ? "" : "s"} in ` +
+        `${skippedDirs.map((dir) => `${dir}/`).join(", ")} — set components.<name>.adapter to "akm" to index them`);
+}
 function buildSourceScanPlans(db, allSourceEntries, isIncremental, reconcileMissingDirs) {
     const componentBySource = buildComponentBySource(allSourceEntries);
     const handoffDirs = new Set();
@@ -775,6 +836,8 @@ function buildSourceScanPlans(db, allSourceEntries, isIncremental, reconcileMiss
         });
         const dirGroups = groupFileContextsByDir(walked.files);
         const adapter = adapterForId(component.adapter);
+        if (adapter)
+            warnIfAdapterSkipsAkmContent(component, walked.files, adapter);
         return {
             currentStashDir,
             component,