akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/core/asset/frontmatter.js

@@ -8,11 +8,12 @@
  * (block scalars, multi-line strings, nested objects, flow sequences, escape
  * sequences) is handled correctly without a brittle hand-rolled state machine.
  */
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 import { existingFileMode, writeFileAtomic } from "../common.js";
 import { recordWrittenPath } from "../write-provenance.js";
-import { assembleAsset, serializeFrontmatter } from "./asset-serialize.js";
+import { assembleAsset, assembleAssetFromString, serializeFrontmatter } from "./asset-serialize.js";
 /**
  * Parse YAML frontmatter from a Markdown (or similar) string.
  *
@@ -451,6 +452,110 @@ export function parseYamlScalar(value) {
     }
     return value;
 }
+// ── Bookkeeping-insensitive freshness (STALE, R20) ────────────────────────────
+/**
+ * Frontmatter keys akm's own improve/index passes write into an EXISTING
+ * asset as pipeline bookkeeping — never a change to the asset's authored
+ * meaning. `salience`/`salienceInputs` come from {@link writeSalienceToFrontmatter}
+ * (distill); `inferenceProcessed` comes from memory inference
+ * (`indexer/passes/memory-inference.ts`). A pending proposal's mint-time
+ * before-hash is sensitive to these rewrites even though nothing a reviewer
+ * or the proposal's own diff cares about actually changed, which stales out
+ * proposals that a same-run bookkeeping pass touches after mint. See
+ * {@link computeNormalizedContentHash} and {@link carryForwardBookkeepingFrontmatter}.
+ *
+ * Deliberately excludes `beliefState`/`contradictedBy`/`supersededBy`: those
+ * are editorial state (contradiction/supersession demotions), not derived
+ * audit metadata — a promote should still refuse when one of those changed
+ * underneath a pending proposal.
+ */
+export const BOOKKEEPING_FRONTMATTER_KEYS = ["salience", "salienceInputs", "inferenceProcessed"];
+function sha256Hex(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+/**
+ * Hash of `raw` with {@link BOOKKEEPING_FRONTMATTER_KEYS} removed from its
+ * frontmatter and the remaining frontmatter re-serialized with sorted keys,
+ * so pipeline-only bookkeeping rewrites (and incidental key-order churn)
+ * cannot change the result. The body's boundary is normalized the same way
+ * {@link assembleAssetFromString} normalizes it (leading newlines stripped,
+ * exactly one trailing newline) before hashing, so the body-boundary shift
+ * that `writeSalienceToFrontmatter` and the `assembleAsset` bookkeeping
+ * rewrite both introduce cannot change the result either; the body's
+ * interior is still hashed verbatim.
+ *
+ * An empty frontmatter block (`---\n---\n…`) is treated as `{}` rather than
+ * falling back to the raw hash, so adding bookkeeping keys to a memory with
+ * no prior frontmatter fields is still insensitive.
+ *
+ * Falls back to hashing `raw` verbatim when there is no frontmatter block at
+ * all or it fails to parse — normalizing unparsable frontmatter isn't safe,
+ * and the caller's existing raw-hash check already covers that case.
+ */
+export function computeNormalizedContentHash(raw) {
+    const block = parseFrontmatterBlock(raw);
+    if (!block)
+        return sha256Hex(raw);
+    let data;
+    try {
+        data = block.frontmatter.trim() ? yamlParse(block.frontmatter) : {};
+    }
+    catch {
+        return sha256Hex(raw);
+    }
+    if (data === null || typeof data !== "object" || Array.isArray(data))
+        return sha256Hex(raw);
+    const normalized = { ...data };
+    for (const key of BOOKKEEPING_FRONTMATTER_KEYS)
+        delete normalized[key];
+    const canonicalFrontmatter = yamlStringify(normalized, { sortMapEntries: true }).trimEnd();
+    return sha256Hex(assembleAssetFromString(canonicalFrontmatter, block.content));
+}
+/**
+ * Fold the live target's {@link BOOKKEEPING_FRONTMATTER_KEYS} into
+ * `proposedRaw` wherever the proposal's own frontmatter does not already set
+ * them, so promoting a proposal minted before a bookkeeping rewrite never
+ * drops that bookkeeping (STALE, R20) — e.g. dropping `inferenceProcessed`
+ * would make memory inference reprocess the memory.
+ *
+ * Returns `proposedRaw` unchanged when either side has no parseable
+ * frontmatter block or nothing needs to carry forward.
+ */
+export function carryForwardBookkeepingFrontmatter(proposedRaw, liveRaw) {
+    const proposedBlock = parseFrontmatterBlock(proposedRaw);
+    const liveBlock = parseFrontmatterBlock(liveRaw);
+    if (!proposedBlock || !liveBlock)
+        return proposedRaw;
+    let proposedData;
+    let liveData;
+    try {
+        const parsedProposed = proposedBlock.frontmatter.trim() ? yamlParse(proposedBlock.frontmatter) : {};
+        const parsedLive = liveBlock.frontmatter.trim() ? yamlParse(liveBlock.frontmatter) : {};
+        if (parsedProposed === null || typeof parsedProposed !== "object" || Array.isArray(parsedProposed)) {
+            return proposedRaw;
+        }
+        if (parsedLive === null || typeof parsedLive !== "object" || Array.isArray(parsedLive))
+            return proposedRaw;
+        proposedData = parsedProposed;
+        liveData = parsedLive;
+    }
+    catch {
+        return proposedRaw;
+    }
+    const merged = { ...proposedData };
+    let changed = false;
+    for (const key of BOOKKEEPING_FRONTMATTER_KEYS) {
+        if (!(key in merged) && key in liveData) {
+            merged[key] = liveData[key];
+            changed = true;
+        }
+    }
+    if (!changed)
+        return proposedRaw;
+    const newFrontmatter = yamlStringify(merged).trimEnd();
+    const separator = proposedBlock.content.startsWith("\n") ? "" : "\n";
+    return `---\n${newFrontmatter}\n---\n${separator}${proposedBlock.content}`;
+}
 // ── Minimum score delta to trigger a frontmatter salience rewrite ─────────────
 const SALIENCE_WRITE_DELTA_THRESHOLD = 0.05;
 /**

package/dist/core/asset/resolve-ref.js

@@ -89,7 +89,7 @@ function notFound(conceptId, triedForms, ctx) {
  *
  * Exported (Chunk-8 WI-8.5c) as the ONE conceptId derivation the improve
  * correlation sites (`eligibility.ts` candidate refs, `salience.ts`
- * last-use lookup, `collapse-detector.ts` canary mint/score) share with the
+ * last-use lookup) share with the
  * display rule — the permanent successor to the retired transient
  * `legacyConceptId`.
  */

package/dist/core/bundle-id.js

@@ -4,18 +4,55 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import { isBundleSlug } from "./asset/asset-ref.js";
+import { UsageError } from "./errors.js";
 /** Deterministic, filesystem-safe bundle slug from a source path. */
 export function slugForPath(sourcePath) {
     const resolved = path.resolve(sourcePath);
-    const base = path
-        .basename(resolved)
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
+    const base = slugify(path.basename(resolved));
     if (base.length > 0)
         return base;
     return `bundle-${shortHash(resolved)}`;
 }
+/**
+ * Bundle slug from the package/repo name a registry install id names
+ * (`npm:@scope/pkg` → `pkg`, `github:owner/repo` → `repo`,
+ * `git:https://host/owner/repo` → `repo`); empty when it names none.
+ */
+export function slugForRegistryId(registryId) {
+    const locator = registryId.slice(registryId.indexOf(":") + 1);
+    return slugify(locator.split(/[/:]/).filter(Boolean).pop() ?? "");
+}
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Enforce the `--name` contract on every add path (D6): an explicit name is
+ * not a silent hint that may fall back to a derived id — it is a request
+ * that either succeeds exactly or fails loudly, before anything is written.
+ *
+ * `existingKeyForThisInstall` is the bundle key this exact source (path/URL/
+ * registry id) is already configured under, if any. Re-adding that same
+ * source under a *different* explicit name is rejected in favor of
+ * `akm bundle rename`, which is the one command allowed to change a bundle's
+ * key. A caller with no existing install for this source (the common case)
+ * omits it.
+ */
+export function validateExplicitBundleName(bundles, name, existingKeyForThisInstall) {
+    if (!isBundleSlug(name)) {
+        throw new UsageError(`"${name}" is not a legal bundle name: it must not contain whitespace or the characters ":" "." "#" "/".`, "INVALID_FLAG_VALUE");
+    }
+    if (existingKeyForThisInstall !== undefined && name !== existingKeyForThisInstall) {
+        throw new UsageError(`This source is already installed as bundle "${existingKeyForThisInstall}". Re-adding it under a ` +
+            `different name is not supported — run \`akm bundle rename ${existingKeyForThisInstall} ${name}\` instead.`, "INVALID_FLAG_VALUE");
+    }
+    if (Object.hasOwn(bundles, name) && name !== existingKeyForThisInstall) {
+        throw new UsageError(`Bundle name "${name}" already exists. Choose another name, or run ` +
+            `\`akm bundle rename ${name} <new-name>\` first.`, "INVALID_FLAG_VALUE");
+    }
+}
 /** Derive one batch-unique bundle id. */
 export function deriveBundleId(registryId, sourcePath, usedIds) {
     const preferred = registryId && registryId.length > 0 && isBundleSlug(registryId) ? registryId : slugForPath(sourcePath);

package/dist/core/bundle-rename.js

@@ -0,0 +1,285 @@
+// 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 bundle rename <old> <new>` (D6) — the one command allowed to change a
+ * bundle's key. A bundle id is a mass identity prefix: every durable ref this
+ * tool minted (`entries.item_ref`/`bundle_id`, `proposals.ref`, a pending
+ * proposal's `proposedTarget.source`, a workflow task_history row's
+ * `target_ref`, `scheduler.enabled[].ref`) carries it, and a hand-edited
+ * `bundles` key strands all of it (see `src/indexer/bundle-identity-guard.ts`
+ * §11.5). This module is the rekey transaction that guard's docstring points
+ * to.
+ *
+ * Rewritten: the config `bundles` key, `defaultBundle`/`defaultWriteTarget`
+ * when they name the old id, every `scheduler.enabled[].ref` with the old
+ * `//` prefix, the lockfile entry id, and the index/state rows above.
+ *
+ * Reported, never rewritten: refs inside bundle CONTENT (xrefs,
+ * `supersededBy`, task `uses:`) — rewriting a bundle's own files is
+ * `akm mv`/editing territory, not a config-identity rename. `--dry-run`
+ * (and every real run) lists the indexed files that still spell the old
+ * `<old>//` prefix so the operator can follow up.
+ *
+ * Left behind on purpose: `usage_events`/`asset_salience`/`asset_outcome`
+ * keyed by the old bundle prefix (learned utility/outcome history) — outside
+ * this item's scope; `warnOnBundleRenameDrift` already documents this class
+ * of gap and `akm index --full` re-mints under the new id.
+ */
+import fs from "node:fs";
+import { readLockfile, renameLockEntry } from "../integrations/lockfile.js";
+import { closeDatabase, openIndexDatabase, openReadonlyExistingDatabase, } from "../storage/repositories/index-connection.js";
+import { getFilePathsByBundle, renameEntriesBundleId } from "../storage/repositories/index-entries-repository.js";
+import { countProposalsForBundleRename, renameProposalsBundleRef } from "../storage/repositories/proposals-repository.js";
+import { countTaskHistoryTargetRefs, renameTaskHistoryTargetRefs, } from "../storage/repositories/task-history-repository.js";
+import { selectBackend } from "../tasks/backends/index.js";
+import { bundleRefToString, parseBundleRef } from "./asset/asset-ref.js";
+import { validateExplicitBundleName } from "./bundle-id.js";
+import { loadConfig, mutateConfig } from "./config/config.js";
+import { NotFoundError, UsageError } from "./errors.js";
+import { getDbPath } from "./paths.js";
+import { getStateDbPath, withStateDb } from "./state-db.js";
+/** Throws if `newId` cannot become `oldId`'s new key. Re-run under the config lock at apply time. */
+function validateRename(config, oldId, newId) {
+    if (!config.bundles?.[oldId]) {
+        throw new NotFoundError(`No configured bundle named "${oldId}".`, "SOURCE_NOT_FOUND");
+    }
+    if (oldId === newId) {
+        throw new UsageError(`"${oldId}" and "${newId}" are the same bundle name.`, "INVALID_FLAG_VALUE");
+    }
+    const withoutOld = { ...(config.bundles ?? {}) };
+    delete withoutOld[oldId];
+    validateExplicitBundleName(withoutOld, newId);
+}
+function bundleOfRef(ref) {
+    try {
+        return parseBundleRef(ref).bundle;
+    }
+    catch {
+        return undefined;
+    }
+}
+function schedulerRefsToRewrite(config, oldId) {
+    return (config.scheduler?.enabled ?? []).filter((ref) => bundleOfRef(ref) === oldId);
+}
+function renameBundleInConfig(config, oldId, newId) {
+    validateRename(config, oldId, newId);
+    const bundles = {};
+    for (const [key, entry] of Object.entries(config.bundles ?? {})) {
+        bundles[key === oldId ? newId : key] = entry;
+    }
+    const enabled = config.scheduler?.enabled;
+    const scheduler = enabled === undefined
+        ? config.scheduler
+        : {
+            ...config.scheduler,
+            enabled: enabled.map((ref) => bundleOfRef(ref) === oldId ? bundleRefToString({ ...parseBundleRef(ref), bundle: newId }) : ref),
+        };
+    return {
+        ...config,
+        bundles,
+        ...(config.defaultBundle === oldId ? { defaultBundle: newId } : {}),
+        ...(config.defaultWriteTarget === oldId ? { defaultWriteTarget: newId } : {}),
+        ...(scheduler ? { scheduler } : {}),
+    };
+}
+/** Indexed files (already read into `filePaths`) whose content still spells `<oldId>//`, best-effort. */
+function filesStillMentioning(filePaths, oldId) {
+    const needle = `${oldId}//`;
+    const hits = [];
+    for (const filePath of filePaths) {
+        try {
+            if (fs.readFileSync(filePath, "utf8").includes(needle))
+                hits.push(filePath);
+        }
+        catch {
+            // Best-effort: a since-removed or unreadable file is skipped, not fatal —
+            // this scan is a report, not a correctness requirement.
+        }
+    }
+    return hits;
+}
+/** True when an installed binding's invocation names `bundleId` — either as a `task run` entry's `--bundle <id>` argument, or as a `workflow run <id>//…` ref. */
+function invocationNamesBundle(invocation, bundleId) {
+    if (!invocation)
+        return false;
+    for (let i = 0; i < invocation.length; i++) {
+        const token = invocation[i];
+        if (token === bundleId && invocation[i - 1] === "--bundle")
+            return true;
+        if (token?.startsWith(`${bundleId}//`))
+            return true;
+    }
+    return false;
+}
+/**
+ * Installed native scheduler rows whose invocation names `oldId`, best-effort
+ * (a backend whose listing throws reports none — this is a preview, not a
+ * correctness requirement).
+ */
+async function nativeSchedulerRowsNamingBundle(sched, oldId) {
+    try {
+        return (await sched.list())
+            .filter((entry) => invocationNamesBundle(entry.invocation, oldId))
+            .map((entry) => entry.invocation?.join(" ") ?? entry.id);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Build the rename plan — every count and ref this rename would touch — by
+ * reading, never writing. Shared by `--dry-run` and a real run so the two
+ * can never disagree about what was reported vs. what happened.
+ */
+async function buildPlan(config, oldId, newId, sched) {
+    const schedulerRefs = schedulerRefsToRewrite(config, oldId);
+    const lockPresent = readLockfile().some((entry) => entry.id === oldId);
+    const nativeSchedulerRows = await nativeSchedulerRowsNamingBundle(sched, oldId);
+    let indexEntries = 0;
+    let contentRefs = [];
+    const readIndexDb = openReadonlyExistingDatabase(getDbPath());
+    if (readIndexDb) {
+        try {
+            const filePaths = getFilePathsByBundle(readIndexDb, oldId);
+            indexEntries = filePaths.length;
+            contentRefs = filesStillMentioning(filePaths, oldId);
+        }
+        finally {
+            closeDatabase(readIndexDb);
+        }
+    }
+    let proposalRefs = 0;
+    let proposalTargets = 0;
+    let taskHistoryRefs = 0;
+    if (fs.existsSync(getStateDbPath())) {
+        withStateDb((db) => {
+            const counts = countProposalsForBundleRename(db, oldId);
+            proposalRefs = counts.refs;
+            proposalTargets = counts.targets;
+            taskHistoryRefs = countTaskHistoryTargetRefs(db, oldId);
+        });
+    }
+    return {
+        oldId,
+        newId,
+        config: {
+            defaultBundleChanges: config.defaultBundle === oldId,
+            defaultWriteTargetChanges: config.defaultWriteTarget === oldId,
+            schedulerRefs,
+        },
+        lock: { present: lockPresent },
+        index: { entries: indexEntries },
+        state: { proposalRefs, proposalTargets, taskHistoryRefs },
+        contentRefs,
+        nativeSchedulerRows,
+    };
+}
+function taskSyncErrorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+/**
+ * Remove every installed native row still naming `oldId`, best-effort,
+ * before the sync below installs the new-named ones. Without this, a plain
+ * `akmTasksSync(deps, newId)` alone cannot clean the old rows up: a task
+ * binding's native id depends only on the task id, so the OLD row and the
+ * new one it should become collide on that id, and `installedRowScope`
+ * (scheduler-sync.ts) attributes a row by the bundle NAME it was installed
+ * under — the physical-path check only confirms a name match, it never
+ * substitutes for one — so the sync reports the old row as another bundle's
+ * and leaves the new binding out instead of replacing it. A workflow binding's native id
+ * depends on its fully-qualified ref instead, so old and new never collide
+ * at all and the old row would otherwise be left installed forever. Both
+ * fail the same way this function fixes: uninstall the exact native rows
+ * `nativeSchedulerRowsNamingBundle` already found, by their native id, so
+ * the sync that follows starts from a clean slate.
+ */
+async function removeStaleNativeSchedulerRows(sched, oldId) {
+    let installed;
+    try {
+        installed = await sched.list();
+    }
+    catch {
+        return;
+    }
+    for (const entry of installed) {
+        if (!invocationNamesBundle(entry.invocation, oldId))
+            continue;
+        try {
+            await sched.uninstall(entry.nativeId ?? entry.id);
+        }
+        catch {
+            // Best-effort: a row this process can't remove is left for the
+            // operator's own `akm task sync` to reconcile, same as every other
+            // per-item failure the sync itself reports rather than throws.
+        }
+    }
+}
+/**
+ * Rename a configured bundle's key everywhere akm itself persists it. With
+ * `dryRun: true`, only {@link buildPlan} runs — nothing is written, matching
+ * a `applied: false` result the caller renders as the plan. `deps.backend`
+ * lets a caller (tests) inject a fake scheduler backend instead of the real
+ * OS one `selectBackend()` would otherwise pick. `deps.syncTasks` is how the
+ * caller runs the post-rename `akmTasksSync` — `src/core` sits below
+ * `src/commands` (see `src/core/improve-types.ts`'s note on the same
+ * direction), so this module never imports `akmTasksSync` itself; the real
+ * caller (`akm bundle rename`'s command handler) always supplies it, and is
+ * required so a missing wire-up is a type error, not a silently skipped sync.
+ */
+export async function renameBundle(oldId, newId, options = {}, deps) {
+    const config = loadConfig();
+    validateRename(config, oldId, newId);
+    const sched = deps.backend ?? selectBackend();
+    const plan = await buildPlan(config, oldId, newId, sched);
+    if (options.dryRun)
+        return { ...plan, applied: false };
+    // Config: the bundles key, defaultBundle/defaultWriteTarget, and every
+    // scheduler.enabled[].ref with the old `//` prefix — all under one write
+    // (validated again inside the config lock).
+    mutateConfig((current) => renameBundleInConfig(current, oldId, newId));
+    // Lockfile: the resolved-install entry id (no-op for a bundle with none,
+    // e.g. a plain filesystem bundle).
+    await renameLockEntry(oldId, newId);
+    // Index: bundle_id/item_ref on every entry row (see index-entries-repository's
+    // renameEntriesBundleId docstring for why no FTS/vector rebuild is needed).
+    const readIndexDb = openReadonlyExistingDatabase(getDbPath());
+    if (readIndexDb) {
+        closeDatabase(readIndexDb);
+        const writeIndexDb = openIndexDatabase(getDbPath());
+        try {
+            renameEntriesBundleId(writeIndexDb, oldId, newId);
+        }
+        finally {
+            closeDatabase(writeIndexDb);
+        }
+    }
+    // State: proposals.ref, a pending proposal's proposedTarget.source, and
+    // workflow task_history.target_ref.
+    if (fs.existsSync(getStateDbPath())) {
+        withStateDb((db) => {
+            renameProposalsBundleRef(db, oldId, newId);
+            renameTaskHistoryTargetRefs(db, oldId, newId);
+        });
+    }
+    // Scheduler: remove native rows still naming `<old>//` (see
+    // removeStaleNativeSchedulerRows for why a plain sync alone can't do
+    // this), then re-sync so a scheduled run's invocation stops naming the
+    // old bundle the moment the rename applies, instead of waiting on the
+    // operator to run `akm task sync` by hand. Reported, never thrown:
+    // config/index/state above are already renamed by this point, so a sync
+    // problem must not make the rename itself look like it failed. `ok` is
+    // false both when the sync call throws and when it comes back with
+    // `result.failures` — a binding that failed to prepare has already lost
+    // its old native row above and is not scheduled until a retry.
+    let taskSync;
+    try {
+        await removeStaleNativeSchedulerRows(sched, oldId);
+        const result = await deps.syncTasks(newId, sched);
+        taskSync = { ok: result.failures.length === 0, result };
+    }
+    catch (cause) {
+        taskSync = { ok: false, error: taskSyncErrorMessage(cause) };
+    }
+    return { ...plan, applied: true, taskSync };
+}

package/dist/core/config/config-io.js

@@ -124,8 +124,7 @@ function isTimestampedConfigBackup(name) {
  * Keep the `keep` most-recently-modified entries of `dir` that `select`
  * admits and remove the rest. Best-effort: an unreadable dir is a no-op, an
  * unreadable entry sorts oldest (pruned first), and a failed removal is
- * retried by the next call. Shared by the config backups above and the task
- * migration snapshots (#897).
+ * retried by the next call.
  */
 export function pruneToNewest(dir, keep, select) {
     let entries;

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

@@ -39,8 +39,6 @@
  *   enforced at save time via `superRefine` on the top-level schema.
  */
 import { z } from "zod";
-import { bundleRefToString, parseBundleRef } from "../asset/asset-ref.js";
-import { warnOnce } from "../warn.js";
 import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_PROCESS_ENGINE_CAPABILITIES } from "./engine-semantics.js";
 import { EmbeddingConnectionConfigSchema } from "./schema/embedding.js";
 import { EnginesSchema } from "./schema/engines.js";
@@ -62,11 +60,11 @@ export { EngineConfigSchema, EnginesSchema, LlmConnectionConfigSchema, LlmProfil
 export { ExperimentalConfigSchema } from "./schema/experimental.js";
 export { FEEDBACK_FAILURE_MODES, FeedbackConfigSchema } from "./schema/feedback.js";
 export { ImproveConfigSchema } from "./schema/improve.js";
-export { ConsolidateProcessConfigSchema, DistillProcessConfigSchema, ExtractProcessConfigSchema, GraphExtractionProcessConfigSchema, ImproveProcessConfigSchema, ImproveProfileConfigSchema, MemoryInferenceProcessConfigSchema, ProactiveMaintenanceProcessConfigSchema, ReflectProcessConfigSchema, TriageProcessConfigSchema, ValidationProcessConfigSchema, } from "./schema/improve-processes.js";
+export { ConsolidateProcessConfigSchema, DistillProcessConfigSchema, ExtractProcessConfigSchema, ImproveProcessConfigSchema, ImproveProfileConfigSchema, MemoryInferenceProcessConfigSchema, ProactiveMaintenanceProcessConfigSchema, ReflectProcessConfigSchema, TriageProcessConfigSchema, ValidationProcessConfigSchema, } from "./schema/improve-processes.js";
 export { IndexConfigSchema, IndexPassConfigSchema } from "./schema/index-config.js";
 export { OutputConfigSchema } from "./schema/output.js";
 export { CURRENT_CONFIG_VERSION, LlmInvocationOverridesSchema } from "./schema/primitives.js";
-export { SchedulerActivationSchema, SchedulerConfigSchema } from "./schema/scheduler.js";
+export { SchedulerConfigSchema } from "./schema/scheduler.js";
 export { SearchConfigSchema } from "./schema/search.js";
 export { SetupConfigSchema } from "./schema/setup.js";
 export { BundleConfigEntrySchema, BundlesConfigSchema, RegistryConfigEntrySchema, SourceConfigEntrySchema, } from "./schema/sources-bundles.js";
@@ -143,11 +141,6 @@ const RETIRED_SOURCE_SHAPE_KEY_MESSAGES = {
 };
 export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) => {
     const raw = config;
-    for (const key of ["profiles", "llm", "agent", "features", "stashes", "modelAliases", "bindings", "writable"]) {
-        if (key in raw) {
-            warnOnce(`config:retired-key:${key}`, `Config key "${key}" is retired in 0.9 and is ignored; configure engines/improve.strategies/bundles.<id> instead.`);
-        }
-    }
     // Only the current source shape enters the runtime. There is no config
     // compatibility path; `bundles` + `defaultBundle` fully supersede these keys.
     for (const key of ["stashDir", "sources", "installed"]) {
@@ -200,31 +193,6 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
             });
         }
     }
-    const activationKeys = new Set();
-    for (const [index, activation] of (config.scheduler?.enabled ?? []).entries()) {
-        try {
-            const parsed = parseBundleRef(activation.ref);
-            if (!parsed.bundle || parsed.fragment !== undefined || bundleRefToString(parsed) !== activation.ref) {
-                throw new Error("not canonical");
-            }
-            const key = `${activation.kind}\0${activation.ref}`;
-            if (activationKeys.has(key)) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ["scheduler", "enabled", index],
-                    message: "duplicates an earlier scheduler activation",
-                });
-            }
-            activationKeys.add(key);
-        }
-        catch {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ["scheduler", "enabled", index, "ref"],
-                message: "must be one canonical fully-qualified ref without a fragment",
-            });
-        }
-    }
     for (const key of ["llm", "agent", "improve"]) {
         if (config.defaults && key in config.defaults) {
             ctx.addIssue({
@@ -272,6 +240,13 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
     }
     const defaultStrategy = config.defaults?.improveStrategy;
     if (defaultStrategy &&
+        // graph-refresh is exempt from this eager, config-load-time check: unlike
+        // a plain typo, it is a specific, known retirement, and refusing it here
+        // would fail every command's config load (including `akm migrate apply`,
+        // the one that fixes this). `resolveImproveStrategy`
+        // (src/commands/improve/improve-strategies.ts) refuses it lazily, at
+        // improve-invocation time, with the same message either way.
+        defaultStrategy !== "graph-refresh" &&
         !BUILTIN_IMPROVE_STRATEGY_NAMES.includes(defaultStrategy) &&
         !config.improve?.strategies?.[defaultStrategy]) {
         ctx.addIssue({

package/dist/core/config/config-walker.js

@@ -78,7 +78,7 @@ function unwrap(schema) {
  * AkmConfig schema. Returns `undefined` if any path segment doesn't match a
  * known schema field.
  */
-function resolveSchemaAt(path, config, raw) {
+export function resolveSchemaAt(path, config, raw) {
     let schema = AkmConfigBaseSchema;
     let existing = config;
     for (const [index, segment] of path.entries()) {