akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/core/adapter/execution-source.js

@@ -0,0 +1,308 @@
+// 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 { createHash } from "node:crypto";
+import { isMap, isScalar, parseDocument, visit } from "yaml";
+import { cloneExecutionJson, cloneExecutionJsonObject, } from "../../execution/json.js";
+import { assertSnapshotKeys, snapshotStrictRecord } from "../../execution/record.js";
+import { cloneToolSelection, createAdapterRenderedExecutionSource, } from "../../execution/source.js";
+function nextLine(text, start) {
+    const lf = text.indexOf("\n", start);
+    if (lf < 0)
+        return { line: text.slice(start), next: text.length };
+    const end = lf > start && text[lf - 1] === "\r" ? lf - 1 : lf;
+    return { line: text.slice(start, end), next: lf + 1 };
+}
+/** Strict execution-only frontmatter parser; indexing's tolerant parser is deliberately not reused. */
+export function parseExecutionMarkdown(raw) {
+    if (typeof raw !== "string")
+        throw new TypeError("execution source raw content must be a string");
+    const withoutBom = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+    const opening = nextLine(withoutBom, 0);
+    if (opening.line !== "---")
+        return { content: withoutBom, data: Object.freeze({}) };
+    if (opening.next === withoutBom.length) {
+        throw new TypeError("execution source has unterminated frontmatter");
+    }
+    let cursor = opening.next;
+    let frontmatterEnd = -1;
+    let bodyStart = -1;
+    while (cursor <= withoutBom.length) {
+        const lineStart = cursor;
+        const current = nextLine(withoutBom, cursor);
+        if (current.line === "---") {
+            frontmatterEnd = lineStart;
+            bodyStart = current.next;
+            break;
+        }
+        if (current.next === cursor || current.next === withoutBom.length)
+            break;
+        cursor = current.next;
+    }
+    if (frontmatterEnd < 0 || bodyStart < 0) {
+        throw new TypeError("execution source has unterminated frontmatter");
+    }
+    const yaml = withoutBom.slice(opening.next, frontmatterEnd);
+    const document = parseDocument(yaml, { uniqueKeys: true });
+    if (document.errors.length > 0) {
+        throw new TypeError(`execution source has invalid YAML frontmatter: ${document.errors[0]?.message ?? "parse error"}`);
+    }
+    if (document.warnings.length > 0) {
+        throw new TypeError(`execution source YAML frontmatter uses an unsupported tag or construct: ${document.warnings[0]?.message}`);
+    }
+    if (!isMap(document.contents)) {
+        throw new TypeError("execution source YAML frontmatter must be a mapping");
+    }
+    let unsupported;
+    visit(document, {
+        Alias: () => {
+            unsupported ??= "aliases";
+        },
+        Node: (_key, node) => {
+            if (node.tag)
+                unsupported ??= "custom or explicit tags";
+            if (node.anchor !== undefined)
+                unsupported ??= "anchors";
+        },
+        Pair: (_key, pair) => {
+            if (!isScalar(pair.key) || typeof pair.key.value !== "string")
+                unsupported ??= "non-string mapping keys";
+        },
+    });
+    if (unsupported)
+        throw new TypeError(`execution source YAML frontmatter does not support ${unsupported}`);
+    let root;
+    try {
+        root = document.toJS({ maxAliasCount: 0 });
+    }
+    catch (cause) {
+        throw new TypeError("execution source YAML frontmatter could not be converted safely", { cause });
+    }
+    const data = cloneExecutionJsonObject(root, "execution source YAML frontmatter");
+    return { content: withoutBom.slice(bodyStart), data: Object.freeze(data) };
+}
+function own(data, key) {
+    return Object.hasOwn(data, key);
+}
+function requireMetadataMapping(value, path) {
+    try {
+        return snapshotStrictRecord(value, path);
+    }
+    catch (cause) {
+        throw new TypeError(`${path} must be a mapping with enumerable data fields`, { cause });
+    }
+}
+function nullableString(value, path) {
+    if (value !== null && typeof value !== "string")
+        throw new TypeError(`${path} must be a string or null`);
+    return value;
+}
+function nullableObject(value, path) {
+    return value === null ? null : cloneExecutionJsonObject(value, path);
+}
+function nullableEnvironment(value, path) {
+    if (value === null)
+        return null;
+    const environment = cloneExecutionJsonObject(value, path);
+    if (Object.values(environment).some((entry) => typeof entry !== "string")) {
+        throw new TypeError(`${path} values must be strings`);
+    }
+    return environment;
+}
+function nullableTimeout(value, path) {
+    const timeout = cloneExecutionJson(value, path);
+    if (timeout !== null && typeof timeout !== "string" && typeof timeout !== "number") {
+        throw new TypeError(`${path} must be a string, number, or null`);
+    }
+    return timeout;
+}
+/** Adapter helper for the common frontmatter fields fixed by the 0.9.2 design. */
+export function executionDefaultsFromFrontmatter(data, options) {
+    const frontmatter = snapshotStrictRecord(data, "frontmatter");
+    const optionRecord = snapshotStrictRecord(options, "execution frontmatter projection options");
+    assertSnapshotKeys(optionRecord, ["kind", "allowTopLevelEngine", "toolsKeys"], "execution frontmatter projection options");
+    const kind = optionRecord.kind;
+    if (kind !== "command" && kind !== "persona") {
+        throw new TypeError("execution frontmatter projection options.kind is invalid");
+    }
+    const allowTopLevelEngine = Object.hasOwn(optionRecord, "allowTopLevelEngine")
+        ? optionRecord.allowTopLevelEngine
+        : false;
+    if (typeof allowTopLevelEngine !== "boolean") {
+        throw new TypeError("execution frontmatter projection options.allowTopLevelEngine must be a boolean");
+    }
+    const configuredToolsKeys = Object.hasOwn(optionRecord, "toolsKeys")
+        ? cloneExecutionJson(optionRecord.toolsKeys, "execution frontmatter projection options.toolsKeys")
+        : ["tools"];
+    if (!Array.isArray(configuredToolsKeys) || configuredToolsKeys.some((key) => typeof key !== "string" || !key)) {
+        throw new TypeError("execution frontmatter projection options.toolsKeys must be an array of non-empty strings");
+    }
+    const namespace = own(frontmatter, "akm")
+        ? requireMetadataMapping(frontmatter.akm, "frontmatter.akm")
+        : snapshotStrictRecord({}, "frontmatter.akm");
+    const out = Object.create(null);
+    if (kind === "command" && own(frontmatter, "agent")) {
+        out.agent = nullableString(frontmatter.agent, "frontmatter.agent");
+    }
+    const namespacedEngine = own(namespace, "engine")
+        ? nullableString(namespace.engine, "frontmatter.akm.engine")
+        : undefined;
+    const topLevelEngine = allowTopLevelEngine && own(frontmatter, "engine")
+        ? nullableString(frontmatter.engine, "frontmatter.engine")
+        : undefined;
+    if (topLevelEngine !== undefined)
+        out.engine = topLevelEngine;
+    else if (namespacedEngine !== undefined)
+        out.engine = namespacedEngine;
+    if (own(frontmatter, "model")) {
+        out.model = nullableString(frontmatter.model, "frontmatter.model");
+    }
+    let toolsSelected = false;
+    for (const key of configuredToolsKeys) {
+        if (!own(frontmatter, key))
+            continue;
+        const selection = cloneToolSelection(frontmatter[key], `frontmatter.${key}`);
+        if (!toolsSelected) {
+            out.tools = selection;
+            toolsSelected = true;
+        }
+    }
+    let inferenceEntries;
+    if (own(namespace, "inference")) {
+        if (namespace.inference === null)
+            inferenceEntries = null;
+        else {
+            inferenceEntries = new Map();
+            for (const [key, value] of Object.entries(cloneExecutionJsonObject(namespace.inference, "frontmatter.akm.inference"))) {
+                inferenceEntries.set(key, value);
+            }
+        }
+    }
+    for (const key of ["temperature", "effort"]) {
+        if (!own(frontmatter, key))
+            continue;
+        if (inferenceEntries === null) {
+            throw new TypeError(`frontmatter.${key} conflicts with explicit null frontmatter.akm.inference`);
+        }
+        inferenceEntries ??= new Map();
+        const value = frontmatter[key];
+        if (key === "temperature") {
+            if (value !== null && typeof value !== "number") {
+                throw new TypeError("frontmatter.temperature must be a number or null");
+            }
+        }
+        else if (value !== null && typeof value !== "string") {
+            throw new TypeError("frontmatter.effort must be a string or null");
+        }
+        inferenceEntries.set(key, cloneExecutionJson(value, `frontmatter.${key}`));
+    }
+    if (inferenceEntries === null)
+        out.inference = null;
+    else if (inferenceEntries !== undefined)
+        out.inference = Object.fromEntries(inferenceEntries);
+    const namespacedSchema = own(namespace, "schema")
+        ? nullableObject(namespace.schema, "frontmatter.akm.schema")
+        : undefined;
+    const topLevelSchema = own(frontmatter, "schema")
+        ? nullableObject(frontmatter.schema, "frontmatter.schema")
+        : undefined;
+    if (topLevelSchema !== undefined)
+        out.outputSchema = topLevelSchema;
+    else if (namespacedSchema !== undefined)
+        out.outputSchema = namespacedSchema;
+    const namespacedTimeouts = new Map();
+    for (const key of ["timeoutMs", "timeout"]) {
+        if (own(namespace, key)) {
+            namespacedTimeouts.set(key, nullableTimeout(namespace[key], `frontmatter.akm.${key}`));
+        }
+    }
+    const topLevelTimeouts = new Map();
+    if (allowTopLevelEngine) {
+        for (const key of ["timeoutMs", "timeout"]) {
+            if (own(frontmatter, key)) {
+                topLevelTimeouts.set(key, nullableTimeout(frontmatter[key], `frontmatter.${key}`));
+            }
+        }
+    }
+    const timeoutKey = namespacedTimeouts.has("timeoutMs")
+        ? "timeoutMs"
+        : namespacedTimeouts.has("timeout")
+            ? "timeout"
+            : undefined;
+    const topLevelTimeoutKey = allowTopLevelEngine
+        ? topLevelTimeouts.has("timeoutMs")
+            ? "timeoutMs"
+            : topLevelTimeouts.has("timeout")
+                ? "timeout"
+                : undefined
+        : undefined;
+    const selectedTimeoutKey = topLevelTimeoutKey ?? timeoutKey;
+    if (selectedTimeoutKey) {
+        out.timeout = topLevelTimeoutKey
+            ? topLevelTimeouts.get(selectedTimeoutKey)
+            : namespacedTimeouts.get(selectedTimeoutKey);
+    }
+    for (const key of ["workspace", "environment", "runtime"]) {
+        const namespaced = own(namespace, key)
+            ? key === "workspace"
+                ? nullableString(namespace[key], `frontmatter.akm.${key}`)
+                : key === "environment"
+                    ? nullableEnvironment(namespace[key], `frontmatter.akm.${key}`)
+                    : nullableObject(namespace[key], `frontmatter.akm.${key}`)
+            : undefined;
+        const topLevel = allowTopLevelEngine && own(frontmatter, key)
+            ? key === "workspace"
+                ? nullableString(frontmatter[key], `frontmatter.${key}`)
+                : key === "environment"
+                    ? nullableEnvironment(frontmatter[key], `frontmatter.${key}`)
+                    : nullableObject(frontmatter[key], `frontmatter.${key}`)
+            : undefined;
+        if (topLevel !== undefined)
+            out[key] = topLevel;
+        else if (namespaced !== undefined)
+            out[key] = namespaced;
+    }
+    return out;
+}
+function snapshotRendererInput(input) {
+    const inputSnapshot = snapshotStrictRecord(input, "adapter execution source");
+    assertSnapshotKeys(inputSnapshot, ["kind", "raw", "identity", "defaults", "extensions"], "adapter execution source");
+    const identity = snapshotStrictRecord(inputSnapshot.identity, "adapter execution source identity");
+    assertSnapshotKeys(identity, ["ref", "bundle", "adapter", "file"], "adapter execution source identity");
+    return { input: inputSnapshot, identity };
+}
+export function renderMarkdownExecutionSource(input) {
+    const snapshots = snapshotRendererInput(input);
+    const raw = snapshots.input.raw;
+    if (typeof raw !== "string")
+        throw new TypeError("adapter execution source.raw must be a string");
+    const kind = snapshots.input.kind;
+    if (kind !== "command" && kind !== "persona")
+        throw new TypeError("adapter execution source.kind is invalid");
+    const parsed = parseExecutionMarkdown(raw);
+    const hasDefaults = Object.hasOwn(snapshots.input, "defaults");
+    const defaultsProjection = snapshots.input.defaults;
+    const defaults = typeof defaultsProjection === "function" ? defaultsProjection(parsed.data) : defaultsProjection;
+    if (hasDefaults && defaults === undefined) {
+        throw new TypeError("adapter execution source defaults must be omitted or resolve to an object");
+    }
+    const extensionsProjection = snapshots.input.extensions;
+    const extensionsAreProjected = typeof extensionsProjection === "function";
+    const extensions = extensionsAreProjected ? extensionsProjection(parsed.data) : extensionsProjection;
+    if (Object.hasOwn(snapshots.input, "extensions") && !extensionsAreProjected && extensions === undefined) {
+        throw new TypeError("adapter execution source extensions must be omitted or be an adapter-owned extension object");
+    }
+    return createAdapterRenderedExecutionSource({
+        kind,
+        content: parsed.content,
+        identity: {
+            ref: snapshots.identity.ref,
+            bundle: snapshots.identity.bundle,
+            adapter: snapshots.identity.adapter,
+            file: snapshots.identity.file,
+            hash: createHash("sha256").update(raw, "utf8").digest("hex"),
+        },
+        ...(hasDefaults ? { defaults } : {}),
+        ...(extensions === undefined ? {} : { extensions }),
+    });
+}

package/dist/core/adapter/recognize-match.js

@@ -1,15 +1,16 @@
 // 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 { directoryMatcher, extensionMatcher, parentDirHintMatcher, smartMdMatcher } from "../../indexer/walk/matchers.js";
+import { directoryMatcher, extensionMatcher, parentDirHintMatcher, smartMdMatcher, smartMdPathCandidates, } from "../../indexer/walk/matchers.js";
 /**
  * The four builtin matchers, in registration order. The array index IS the
  * registration index `runMatchers` uses for tie-breaking. (The `wiki` matcher
  * was removed in chunk 4 — the wiki asset-type is retired; LLM Wiki content is
- * served by the first-class `llm-wiki` adapter, not the akm adapter. The YAML
- * workflow-program matcher was removed by workflow-format-unification — one
- * workflow format now, recognized by frontmatter `type: workflow` or
- * residence under `workflows/`, both already covered by the remaining four.)
+ * served by the first-class `llm-wiki` adapter, not the akm adapter. The old
+ * YAML workflow-program matcher is also gone: peer Markdown and GitHub-shaped
+ * `.yml` workflow sources are both path-owned by residence under `workflows/`
+ * (with Markdown frontmatter as an additional signal), while source IR owns
+ * their distinct parse/compile semantics.)
  */
 const AKM_MATCHERS = [
     extensionMatcher,
@@ -17,6 +18,17 @@ const AKM_MATCHERS = [
     parentDirHintMatcher,
     smartMdMatcher,
 ];
+function winningMatch(hits) {
+    if (hits.length === 0)
+        return null;
+    hits.sort((a, b) => {
+        const specDiff = b.result.specificity - a.result.specificity;
+        if (specDiff !== 0)
+            return specDiff;
+        return b.index - a.index;
+    });
+    return hits[0].result;
+}
 /**
  * Synchronous reproduction of `file-context.ts#runMatchers`'s arbitration
  * (`:242-265`), minus its `ensureBuiltinsRegistered()` dynamic import. Runs
@@ -32,13 +44,24 @@ export function recognizeMatch(file) {
         if (result !== null)
             hits.push({ result, index: i });
     }
-    if (hits.length === 0)
-        return null;
-    hits.sort((a, b) => {
-        const specDiff = b.result.specificity - a.result.specificity;
-        if (specDiff !== 0)
-            return specDiff;
-        return b.index - a.index;
+    return winningMatch(hits);
+}
+/**
+ * Every AKM matcher winner possible from path fields alone. The three
+ * path-only matchers run exactly as production does; each possible result of
+ * the shared smart-Markdown fact table is then arbitrated at its real index.
+ */
+export function recognizePathCandidateMatches(file) {
+    const fileContext = file;
+    const pathHits = [extensionMatcher, directoryMatcher, parentDirHintMatcher].flatMap((matcher, index) => {
+        const result = matcher(fileContext);
+        return result ? [{ result, index }] : [];
     });
-    return hits[0].result;
+    const smartCandidates = smartMdPathCandidates(file);
+    const variants = smartCandidates.length > 0 ? smartCandidates : [undefined];
+    const winners = variants.flatMap((smart) => {
+        const winner = winningMatch(smart ? [...pathHits, { result: smart, index: 3 }] : [...pathHits]);
+        return winner ? [winner] : [];
+    });
+    return [...new Map(winners.map((winner) => [`${winner.type}\0${winner.renderer}`, winner])).values()];
 }

package/dist/core/adapter/registry.js

@@ -45,12 +45,3 @@ export function getAdapters() {
 export function adapterForId(id) {
     return BY_ID.get(id);
 }
-/**
- * DEPRECATED no-op retained for test back-compat only. The registry is a static
- * frozen map (normative §12.6) populated at module load, so there is nothing to
- * reset — `getAdapters()` / `adapterForId()` are always the full built-in set.
- * New code MUST NOT depend on this.
- */
-export function resetAdapterRegistryForTests() {
-    // intentionally empty — the registry is static; see the doc comment above.
-}

package/dist/core/asset/stash-meta.js

@@ -95,16 +95,106 @@ export function resolveMetaFilePath(sourceRoot, name) {
         if (resolved !== metaRoot && !resolved.startsWith(metaRoot + path.sep)) {
             throw new UsageError("Meta ref resolves outside the stash .meta directory.", "PATH_ESCAPE_VIOLATION");
         }
-        if (isRegularFile(resolved))
+        if (isSafeRegularMetaFile(sourceRoot, metaRoot, resolved))
             return resolved;
     }
     return null;
 }
-function isRegularFile(p) {
+/**
+ * Resolve and read a meta doc from one stable, no-follow file descriptor.
+ * The descriptor/path identity check closes the swap window between path
+ * validation and reading: even if a writable local bundle changes the path
+ * concurrently, bytes are returned only when the opened inode is still the
+ * validated file inside the bundle's real `.meta/` directory.
+ */
+export function readMetaFile(sourceRoot, name) {
+    const filePath = resolveMetaFilePath(sourceRoot, name);
+    if (!filePath)
+        return null;
+    let fd;
     try {
-        return fs.statSync(p).isFile();
+        fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile())
+            throw metaPathEscape();
+        const metaRoot = path.resolve(sourceRoot, META_DIR);
+        if (!isSafeRegularMetaFile(sourceRoot, metaRoot, filePath))
+            throw metaPathEscape();
+        const current = fs.statSync(filePath);
+        if (opened.dev !== current.dev || opened.ino !== current.ino)
+            throw metaPathEscape();
+        return { path: filePath, content: fs.readFileSync(fd, "utf8") };
     }
-    catch {
+    catch (error) {
+        if (error instanceof UsageError)
+            throw error;
+        const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return null;
+        if (code === "ELOOP")
+            throw metaPathEscape();
+        throw new UsageError("Meta doc could not be read safely.", "PATH_ESCAPE_VIOLATION");
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+function isSafeRegularMetaFile(sourceRoot, metaRoot, filePath) {
+    const sourceRootReal = realPathOrNull(sourceRoot);
+    if (!sourceRootReal)
+        return false;
+    const metaStat = lstatOrNull(metaRoot);
+    if (!metaStat)
+        return false;
+    if (metaStat.isSymbolicLink())
+        throw metaPathEscape();
+    if (!metaStat.isDirectory())
+        return false;
+    const relative = path.relative(metaRoot, filePath);
+    if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw metaPathEscape();
+    }
+    let current = metaRoot;
+    for (const segment of relative.split(path.sep)) {
+        current = path.join(current, segment);
+        const stat = lstatOrNull(current);
+        if (!stat)
+            return false;
+        if (stat.isSymbolicLink())
+            throw metaPathEscape();
+    }
+    const finalStat = lstatOrNull(filePath);
+    if (!finalStat?.isFile())
+        return false;
+    const metaRootReal = realPathOrNull(metaRoot);
+    const fileReal = realPathOrNull(filePath);
+    if (!metaRootReal || !fileReal)
         return false;
+    if (!isWithin(sourceRootReal, metaRootReal) || !isWithin(metaRootReal, fileReal))
+        throw metaPathEscape();
+    return true;
+}
+function lstatOrNull(filePath) {
+    try {
+        return fs.lstatSync(filePath);
     }
+    catch {
+        return null;
+    }
+}
+function realPathOrNull(filePath) {
+    try {
+        return fs.realpathSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+function metaPathEscape() {
+    return new UsageError("Meta doc must be a regular file inside the stash .meta directory; symlinks are refused.", "PATH_ESCAPE_VIOLATION");
 }

package/dist/core/common.js

@@ -284,12 +284,8 @@ function isValidDirectory(dir) {
  * Read the primary stash path directly from config.json without pulling in the
  * full config module, to avoid circular dependencies.
  *
- * Reads ONLY the 0.9.0 `bundles`/`defaultBundle` shape. A config still carrying
- * the retired `stashDir`/`sources`/`installed` keys (with no usable bundles
- * path) is an unmigrated config: this refuses it with the same `akm-migrate
- * apply` hint the schema hard-reject uses (config-schema.ts), rather than
- * silently honouring the retired key — so every `resolveStashDir` caller gets
- * the coherent migrate posture instead of split-brain success.
+ * Reads only the current `bundles`/`defaultBundle` shape. Unsupported older
+ * keys are never interpreted as a second config architecture.
  */
 function readStashDirFromConfig() {
     try {
@@ -340,17 +336,16 @@ function readStashDirFromConfig() {
             }
             return bundlePath;
         }
-        // Retired pre-cutover shape with no usable bundles path: refuse with the
-        // migrate hint (matches the schema's hard-reject, config-schema.ts) instead
-        // of silently resolving the old key.
+        // Retired pre-cutover shapes are not runtime inputs. Refuse them instead
+        // of silently resolving old keys.
         for (const key of ["stashDir", "sources", "installed"]) {
             if (key in raw && raw[key] !== undefined) {
-                throw new ConfigError(`${key} is the retired pre-cutover source shape; run \`akm-migrate apply\` to convert it to bundles`, "INVALID_CONFIG_FILE");
+                throw new ConfigError(`${key} is not supported; configure the current bundles shape`, "INVALID_CONFIG_FILE");
             }
         }
     }
     catch (err) {
-        // A retired-shape refusal must reach the caller; genuine missing/invalid
+        // An unsupported-shape refusal must reach the caller; genuine missing/invalid
         // config (read or JSON-parse failure) falls through to the platform default.
         if (err instanceof ConfigError)
             throw err;

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

@@ -5,12 +5,12 @@
  * Pure I/O helpers for AKM config files.
  *
  * No knowledge of the AkmConfig shape — these functions just read JSON(C) text
- * from disk and write JSON text back atomically. Validation and migration live
- * in `./config.ts` and `./config-migrate.ts`.
+ * from disk and write JSON text back atomically. Current-schema validation lives
+ * in `./config.ts`; older config shapes are rejected.
  *
  * Split out so the load path is testable without touching the filesystem
  * (`parseConfigText` is pure), and so a single atomic write path serves
- * `saveConfig`, the migrate command, and the setup wizard (#464.c).
+ * `saveConfig` and the setup wizard (#464.c).
  */
 import fs from "node:fs";
 import path from "node:path";