akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/core/fs-txn.js

@@ -59,6 +59,10 @@ function requireKind(kind) {
         throw new Error(`No transaction handler registered for kind "${kind}".`);
     return handler;
 }
+/** True when `kind` has a registered handler (see {@link recoverTxnsForRoot}). */
+function hasKind(kind) {
+    return kinds.has(kind);
+}
 // ── Test seam ────────────────────────────────────────────────────────────────
 let mutationHookForTests;
 /** TEST-ONLY crash-window hook used by subprocess recovery tests. */
@@ -187,13 +191,24 @@ export function cleanupTxn(dir) {
     }
 }
 /**
- * Sweep a transaction directory that has NO journal — but only when it is
- * demonstrably stale. All kinds share one namespace per root, so a scanner
- * may encounter a SIBLING transaction inside `beginTxn`'s mkdir→journal
- * window; a grace period keeps the sweep from racing it. Returns true when
- * the directory was removed.
+ * Grace period (ms) before a transaction directory/journal with no other
+ * evidence of activity is treated as stale rather than possibly belonging to
+ * a still-running operation. Shared by {@link sweepJournallessTxnDir} (racing
+ * a sibling's mkdir→journal window, and the unknown-kind sweep in
+ * {@link recoverTxnsForRoot}) and by read-only reporting such as `akm
+ * health`'s stale-journal advisory (see {@link listTxnJournalsTolerant}).
+ */
+export const TXN_SWEEP_GRACE_MS = 300_000;
+/**
+ * Sweep a transaction directory that cannot be recovered — it has NO journal,
+ * or (from {@link recoverTxnsForRoot}) a journal whose kind has no registered
+ * handler — but only when it is demonstrably stale. All kinds share one
+ * namespace per root, so a scanner may encounter a SIBLING transaction inside
+ * `beginTxn`'s mkdir→journal window, or one whose registrar this process
+ * simply has not imported yet; a grace period keeps the sweep from racing
+ * either. Returns true when the directory was removed.
  */
-export function sweepJournallessTxnDir(dir, graceMs = 300_000) {
+export function sweepJournallessTxnDir(dir, graceMs = TXN_SWEEP_GRACE_MS) {
     try {
         const age = Date.now() - fs.statSync(dir).mtimeMs;
         if (age < graceMs)
@@ -250,7 +265,20 @@ export function isCommittedPhase(journal) {
  * the kind's `finalize`. Fully-finalized directories are swept. The domain
  * registrar (which registers the kinds) must be imported by the caller.
  *
- * `filter` optionally narrows recovery (e.g. one kind, one proposal id).
+ * A journal whose `kind` has NO registered handler is SWEPT (same stale-dir
+ * grace period as {@link sweepJournallessTxnDir}) rather than thrown on. A
+ * kind can disappear for good — 0.9.0 deleted `akm mv` and with it the
+ * `kind:"mv"` handler — and an unrecoverable leftover journal must never
+ * brick every later recovery scan (index refresh, proposal accept/reject) run
+ * against the same root. Kinds that ARE registered keep failing LOUDLY on any
+ * fence violation: those journals may fence an interrupted, irreversible
+ * mutation. The grace period also covers the transient case where the caller
+ * has not imported a live kind's registrar yet.
+ *
+ * `filter` optionally narrows recovery (e.g. one kind, one proposal id). The
+ * unknown-kind sweep runs BEFORE the filter: such a journal is garbage no
+ * matter what the caller asked to recover, and leaving it behind is what
+ * bricks the next scan.
  */
 export async function recoverTxnsForRoot(root, filter) {
     const nsDir = txnNamespaceDir(root);
@@ -267,6 +295,12 @@ export async function recoverTxnsForRoot(root, filter) {
             continue;
         }
         const journal = readJournal(journalPath);
+        if (!hasKind(journal.kind)) {
+            if (sweepJournallessTxnDir(dir)) {
+                warn(`[txn] swept unrecoverable journal of unregistered kind "${journal.kind}" at ${journalPath}.`);
+            }
+            continue;
+        }
         if (filter && !filter(journal))
             continue;
         fenceJournal(journal, dir, root, journalPath);
@@ -314,3 +348,45 @@ export function listTxnJournals(predicate) {
     }
     return matches;
 }
+/**
+ * Read-only, best-effort sibling of {@link listTxnJournals} for reporting
+ * (e.g. `akm health`'s stale-journal advisory): a corrupt `journal.json` is
+ * counted rather than thrown, so one damaged journal doesn't abort the whole
+ * scan. Recovery call sites (which must decide how to roll a journal forward
+ * or back) keep using {@link listTxnJournals} — it fails loudly on purpose,
+ * since silently skipping a damaged journal there could leave an interrupted,
+ * irreversible mutation unrecovered.
+ */
+export function listTxnJournalsTolerant(predicate) {
+    const home = path.join(getDataDir(), "txn");
+    const matches = [];
+    const unreadableMtimes = [];
+    if (!fs.existsSync(home))
+        return { matches, unreadableMtimes };
+    for (const ns of fs.readdirSync(home, { withFileTypes: true })) {
+        if (!ns.isDirectory())
+            continue;
+        const nsDir = path.join(home, ns.name);
+        for (const entry of fs.readdirSync(nsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const journalPath = path.join(nsDir, entry.name, "journal.json");
+            let mtimeMs;
+            try {
+                mtimeMs = fs.statSync(journalPath).mtimeMs;
+            }
+            catch {
+                continue; // no journal.json here, or it vanished mid-scan
+            }
+            try {
+                const journal = readJournal(journalPath);
+                if (predicate(journal))
+                    matches.push({ journal, mtimeMs });
+            }
+            catch {
+                unreadableMtimes.push(mtimeMs);
+            }
+        }
+    }
+    return { matches, unreadableMtimes };
+}

package/dist/core/git-message.js

@@ -10,8 +10,8 @@
  * barrel, by value) does not need to import back into `write-source.ts` just
  * for this helper — that back-edge was a 3-file static-graph cycle
  * (write-source.ts → git.ts → git-stash.ts → write-source.ts; chunk 9 WI-9.8
- * KILL 6 sever). `write-source.ts` re-exports `sanitizeCommitMessage` so
- * existing import sites are unaffected.
+ * KILL 6 sever). Callers import `sanitizeCommitMessage` directly so
+ * the dependency graph stays acyclic.
  */
 /**
  * Maximum length of a sanitized git commit message. Git itself imposes no

package/dist/core/improve-result.js

@@ -37,40 +37,12 @@ const COMMON_FIELDS = [
     "gateAutoAcceptFailedCount",
     "triage",
     "proactiveMaintenance",
-    // Retired producers still exist in the persisted 90-day improve-run ledger.
-    "recombination",
-    "proceduralCompilation",
     "cycleMetrics",
     "runId",
     "sync",
     "terminated",
 ];
-const V1_FIELDS = new Set([
-    ...COMMON_FIELDS,
-    "profile",
-    "profileFilteredRefs",
-    "stalenessDetection",
-    "executionLogCandidates",
-]);
 const V2_FIELDS = new Set([...COMMON_FIELDS, "strategy", "strategyFilteredRefs"]);
-const STALENESS_DETECTION_FIELDS = new Set([
-    "considered",
-    "deprecated",
-    "confirmed",
-    "skipped",
-    "durationMs",
-    "warnings",
-]);
-const INTERRUPTED_V1_FIELDS = new Set([
-    "schemaVersion",
-    "ok",
-    "profile",
-    "scope",
-    "dryRun",
-    "plannedRefs",
-    "actions",
-    "terminated",
-]);
 function fail(message) {
     throw new Error(`invalid improve-result envelope: ${message}`);
 }
@@ -82,33 +54,6 @@ function requireExactFields(value, allowed) {
     if (unknown.length > 0)
         fail(`unknown field${unknown.length === 1 ? "" : "s"}: ${unknown.sort().join(", ")}`);
 }
-function isKnownInterruptedV1Partial(value) {
-    if (Object.keys(value).some((key) => !INTERRUPTED_V1_FIELDS.has(key)))
-        return false;
-    if (value.ok !== false || typeof value.dryRun !== "boolean")
-        return false;
-    if (value.profile !== undefined && typeof value.profile !== "string")
-        return false;
-    if (!Array.isArray(value.plannedRefs) || value.plannedRefs.length !== 0)
-        return false;
-    if (!Array.isArray(value.actions) || value.actions.length !== 0)
-        return false;
-    if (!isRecord(value.scope))
-        return false;
-    if (Object.keys(value.scope).some((key) => key !== "mode" && key !== "value"))
-        return false;
-    if (value.scope.mode !== "all" && value.scope.mode !== "type" && value.scope.mode !== "ref")
-        return false;
-    if (value.scope.value !== undefined && typeof value.scope.value !== "string")
-        return false;
-    if (!isRecord(value.terminated))
-        return false;
-    if (Object.keys(value.terminated).some((key) => !["reason", "at", "errorMessage"].includes(key)))
-        return false;
-    if (typeof value.terminated.reason !== "string" || typeof value.terminated.at !== "string")
-        return false;
-    return value.terminated.errorMessage === undefined || typeof value.terminated.errorMessage === "string";
-}
 function validateCommon(value) {
     if (typeof value.ok !== "boolean")
         fail("ok must be a boolean");
@@ -138,7 +83,6 @@ function validateCommon(value) {
         "extract",
         "coverageGaps",
         "deadUrls",
-        "executionLogCandidates",
     ]) {
         if (value[field] !== undefined && !Array.isArray(value[field]))
             fail(`${field} must be an array`);
@@ -175,8 +119,6 @@ function validateCommon(value) {
         "graphExtraction",
         "triage",
         "proactiveMaintenance",
-        "recombination",
-        "proceduralCompilation",
         "cycleMetrics",
         "sync",
         "terminated",
@@ -194,24 +136,7 @@ function validateCommon(value) {
         }
     }
 }
-function validateV1StalenessDetection(value) {
-    if (value === undefined)
-        return;
-    if (!isRecord(value))
-        fail("stalenessDetection must be an object");
-    const unknown = Object.keys(value).filter((key) => !STALENESS_DETECTION_FIELDS.has(key));
-    if (unknown.length > 0) {
-        fail(`stalenessDetection has unknown field${unknown.length === 1 ? "" : "s"}: ${unknown.sort().join(", ")}`);
-    }
-    for (const field of ["considered", "deprecated", "confirmed", "skipped", "durationMs"]) {
-        if (typeof value[field] !== "number")
-            fail(`stalenessDetection.${field} must be a number`);
-    }
-    if (!Array.isArray(value.warnings) || value.warnings.some((warning) => typeof warning !== "string")) {
-        fail("stalenessDetection.warnings must be an array of strings");
-    }
-}
-/** Decode the persisted public v1/v2 contract without guessing across versions. */
+/** Decode the persisted public result contract. */
 export function decodeImproveResult(input) {
     let parsed = input;
     if (typeof input === "string") {
@@ -224,28 +149,6 @@ export function decodeImproveResult(input) {
     }
     if (!isRecord(parsed))
         fail("root must be an object");
-    if (parsed.schemaVersion === 1) {
-        let normalized = parsed;
-        let normalizedLegacyPartial = false;
-        if (normalized.memorySummary === undefined && isKnownInterruptedV1Partial(normalized)) {
-            normalized = { ...normalized, memorySummary: { eligible: 0, derived: 0 } };
-            normalizedLegacyPartial = true;
-        }
-        requireExactFields(normalized, V1_FIELDS);
-        validateCommon(normalized);
-        validateV1StalenessDetection(normalized.stalenessDetection);
-        if (normalized.profile !== undefined && typeof normalized.profile !== "string")
-            fail("profile must be a string");
-        if (normalized.profileFilteredRefs !== undefined && !Array.isArray(normalized.profileFilteredRefs)) {
-            fail("profileFilteredRefs must be an array");
-        }
-        return {
-            envelope: normalized,
-            strategy: null,
-            legacyProfile: typeof normalized.profile === "string" ? normalized.profile : null,
-            normalizedLegacyPartial,
-        };
-    }
     if (parsed.schemaVersion === 2) {
         requireExactFields(parsed, V2_FIELDS);
         validateCommon(parsed);
@@ -258,8 +161,6 @@ export function decodeImproveResult(input) {
         return {
             envelope: parsed,
             strategy: parsed.strategy,
-            legacyProfile: null,
-            normalizedLegacyPartial: false,
         };
     }
     fail(`unsupported schemaVersion: ${String(parsed.schemaVersion)}`);

package/dist/core/lesson-lint.js

@@ -13,9 +13,7 @@
  *
  * Lint produces structured findings rather than throwing so callers can
  * batch-validate (e.g. `akm proposal accept` over a queue) and surface every
- * violation in a single pass. A strict wrapper (`assertLessonValid`) throws
- * a `UsageError` for call sites that want a fail-fast contract — most
- * notably the proposal-accept path described in v1 spec §13.1.
+ * violation in a single pass.
  *
  * The lint is intentionally side-effect free and does not import the indexer
  * or filesystem walker; it operates on a single file path + raw string. This
@@ -24,7 +22,6 @@
  */
 import fs from "node:fs";
 import { parseFrontmatter } from "./asset/frontmatter.js";
-import { UsageError } from "./errors.js";
 function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
@@ -74,16 +71,3 @@ export function lintLessonFile(filePath) {
     const raw = fs.readFileSync(filePath, "utf8");
     return lintLessonContent(raw, filePath);
 }
-/**
- * Strict variant: throws a `UsageError` if any finding is present. The thrown
- * error carries the full set of findings on its message and a hint pointing
- * at v1 spec §13. The first finding's `field` becomes the error's primary
- * field for callers that want to highlight the first violation.
- */
-export function assertLessonValid(filePath) {
-    const report = lintLessonFile(filePath);
-    if (report.findings.length === 0)
-        return;
-    const message = report.findings.map((f) => f.message).join("\n");
-    throw new UsageError(message, "MISSING_REQUIRED_ARGUMENT", "Lessons require non-empty `description` and `when_to_use` frontmatter fields. See v1 spec §13.");
-}

package/dist/core/logs-db.js

@@ -38,7 +38,7 @@
  * @module logs-db
  */
 import path from "node:path";
-import { runMigrations as runSqliteMigrations } from "../storage/engines/sqlite-migrations.js";
+import { assertMigrationRegistry, runMigrations as runSqliteMigrations, } from "../storage/engines/sqlite-migrations.js";
 import { openManagedDatabase } from "../storage/managed-db.js";
 import { getDataDir } from "./paths.js";
 // ── Path helper ──────────────────────────────────────────────────────────────
@@ -130,6 +130,7 @@ const MIGRATIONS = [
     `,
     },
 ];
+assertMigrationRegistry(MIGRATIONS);
 /**
  * Apply every pending migration. Called automatically by
  * {@link openLogsDatabase}; exported for the same test seams state-db exposes.

package/dist/core/migration-operation.js

@@ -29,6 +29,22 @@ export function getMigrationRestoreJournalPath() {
 export function getMigrationApplyJournalPath() {
     return path.join(getMigrationOperationRoot(), "apply-active.json");
 }
+/**
+ * Predictable path for the config `akm migrate apply` auto-generates when no
+ * `--config` is given and the active config still carries the pre-cutover
+ * `stashDir`/`sources[]`/`installed[]` shape (see `config-migrate.ts`'s
+ * `buildMigrationPlan`/`writeGeneratedTargetConfig`). Deliberately NOT the
+ * live `config.json` — the live 0.8 file must stay byte-for-byte untouched
+ * until `publishConfigLast` performs its normal atomic install, so the
+ * generated draft lives here instead, next to the apply/restore sentinels.
+ * Stable across invocations (keyed only by installation id, not a run id) so
+ * a second `migrate apply`/`migrate status` with still no `--config` finds
+ * the same file an operator may have hand-edited (e.g. to add `engines`)
+ * after the first run generated it.
+ */
+export function getMigrationGeneratedConfigPath() {
+    return path.join(getMigrationOperationRoot(), "generated-config.json");
+}
 export function assertNoPendingMigrationOperation() {
     for (const [kind, journalPath] of [
         ["restore", getMigrationRestoreJournalPath()],

package/dist/core/mutation-target.js

@@ -0,0 +1,78 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import path from "node:path";
+import { deriveInstallations } from "../indexer/installations.js";
+import { resolveSourceEntries } from "../indexer/search/search-source.js";
+import { displayRef } from "./asset/resolve-ref.js";
+import { UsageError } from "./errors.js";
+import { prepareWriteTargetForMutation, resolveWorkingStashTarget, resolveWriteTarget, } from "./write-source.js";
+function canonicalSources(config) {
+    const sources = resolveSourceEntries(undefined, config);
+    const installations = deriveInstallations(sources);
+    return sources.flatMap((source, index) => {
+        const bundleId = installations[index]?.id;
+        return bundleId ? [{ bundleId, source }] : [];
+    });
+}
+function targetForCanonicalSource(config, canonical, options) {
+    const target = canonical.source.registryId
+        ? resolveWriteTarget(config, canonical.source.registryId, options)
+        : resolveWorkingStashTarget(config, options);
+    if (path.resolve(target.source.path) !== path.resolve(canonical.source.path)) {
+        throw new UsageError(`Bundle "${canonical.bundleId}" no longer resolves to its indexed source root.`);
+    }
+    return target;
+}
+/** Resolve the canonical bundle id currently assigned to a write target. */
+export function canonicalBundleIdForTarget(config, target) {
+    return (canonicalSources(config).find((candidate) => path.resolve(candidate.source.path) === path.resolve(target.source.path))?.bundleId ?? target.source.name);
+}
+/** Resolve a canonical bundle qualifier to its writable target without preparing a Git boundary. */
+export function resolveBundleWriteTarget(config, bundleId, options = {}) {
+    const canonical = canonicalSources(config).find((candidate) => candidate.bundleId === bundleId);
+    if (!canonical) {
+        throw new UsageError(`Bundle "${bundleId}" is not configured.`, "INVALID_FLAG_VALUE");
+    }
+    const target = targetForCanonicalSource(config, canonical, options);
+    return { ...target, source: { ...target.source, name: canonical.bundleId } };
+}
+function resolveExplicitMutationTarget(config, explicitTarget, options) {
+    try {
+        return resolveWriteTarget(config, explicitTarget, options);
+    }
+    catch (error) {
+        try {
+            return resolveBundleWriteTarget(config, explicitTarget, options);
+        }
+        catch {
+            throw error;
+        }
+    }
+}
+/** Reconcile a qualified mutation ref with `--target`, then resolve the write destination. */
+export function resolveMutationTarget(config, ref, explicitTarget, options = {}) {
+    const writeOptions = { requireWritable: options.requireWritable };
+    const qualifiedTarget = ref.origin ? resolveBundleWriteTarget(config, ref.origin, writeOptions) : undefined;
+    const explicitResolved = explicitTarget
+        ? resolveExplicitMutationTarget(config, explicitTarget, writeOptions)
+        : undefined;
+    if (qualifiedTarget &&
+        explicitResolved &&
+        path.resolve(qualifiedTarget.source.path) !== path.resolve(explicitResolved.source.path)) {
+        throw new UsageError(`Qualified ref bundle "${ref.origin}" conflicts with --target "${explicitTarget}".`, "INVALID_FLAG_VALUE", `Drop --target or select the same bundle.`);
+    }
+    let target = qualifiedTarget ?? explicitResolved ?? resolveWriteTarget(config, undefined, writeOptions);
+    const bundleId = ref.origin ?? canonicalBundleIdForTarget(config, target);
+    target = prepareWriteTargetForMutation({ ...target, source: { ...target.source, name: bundleId } }, { allowedAdapters: options.allowedAdapters });
+    const stableRef = { ...ref, origin: bundleId };
+    const defaultBundle = defaultBundleForTarget(config);
+    return {
+        target,
+        ref: stableRef,
+        displayRef: displayRef({ type: stableRef.type, name: stableRef.name, bundleId: stableRef.origin }, defaultBundle),
+    };
+}
+export function defaultBundleForTarget(config) {
+    return config.defaultBundle;
+}

package/dist/core/parse.js

@@ -23,7 +23,10 @@
  * models). Also strips leading/trailing whitespace.
  */
 export function stripThinkBlocks(raw) {
-    return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+    return raw
+        .replace(/<think>[\s\S]*?<\/think>/gi, "")
+        .replace(/^[\s\S]*?<\/think>/i, "")
+        .trim();
 }
 /**
  * Strips markdown code fences (``` or ~~~, with optional language tag).

package/dist/core/paths.js

@@ -30,7 +30,7 @@ function isUnderBunTest(env) {
  * Returns true when the given path is in a directory family the OS may
  * reap (or that the user has clearly designated as a sandbox by virtue
  * of placing it under `/tmp` or a macOS per-user temp dir). Used to
- * decide whether `AKM_STASH_DIR=$tmpdir` should also isolate config +
+ * decide whether `AKM_BUNDLE_DIR=$tmpdir` should also isolate config +
  * cache writes (so a test harness's `akm setup --yes --dir .` cannot
  * silently clobber the user's `~/.config/akm/config.json`). See
  * the 2026-05-23 setup-clobbers-user-config incident
@@ -67,7 +67,7 @@ export function getConfigDir(env = process.env, platform = process.platform) {
         return override;
     // Explicit XDG override wins next — tests and operators that pre-arrange
     // an isolated config dir via XDG_CONFIG_HOME (or %APPDATA% on Windows)
-    // must be honored as set, so the AKM_STASH_DIR transient-isolation rule
+    // must be honored as set, so the AKM_BUNDLE_DIR transient-isolation rule
     // below does not silently move config away from where they pointed it.
     if (platform === "win32") {
         const appData = env.APPDATA?.trim();
@@ -79,16 +79,16 @@ export function getConfigDir(env = process.env, platform = process.platform) {
         if (xdgConfigHome)
             return path.join(xdgConfigHome, "akm");
     }
-    // Isolation safety: when AKM_STASH_DIR points at a transient/sandbox path
+    // Isolation safety: when AKM_BUNDLE_DIR points at a transient/sandbox path
     // (/tmp, /var/tmp, /private/var/folders) AND no explicit config dir
-    // override is set, route config writes into `${AKM_STASH_DIR}/.akm`
+    // override is set, route config writes into `${AKM_BUNDLE_DIR}/.akm`
     // instead of the user's host ~/.config/akm. This prevents the documented
     // isolation pattern
-    //   AKM_DATA_DIR=/tmp/x AKM_STASH_DIR=/tmp/x akm setup --yes --dir .
+    //   AKM_DATA_DIR=/tmp/x AKM_BUNDLE_DIR=/tmp/x akm setup --yes --dir .
     // from silently clobbering the host config. See
     // the 2026-05-23 setup-clobbers-user-config incident.
-    // Daily users with a persistent AKM_STASH_DIR=~/my-stash are unaffected.
-    const stashOverride = env.AKM_STASH_DIR?.trim();
+    // Daily users with a persistent AKM_BUNDLE_DIR=~/my-stash are unaffected.
+    const stashOverride = env.AKM_BUNDLE_DIR?.trim();
     if (stashOverride && isTransientStashPath(stashOverride)) {
         return path.join(stashOverride, ".akm");
     }
@@ -122,7 +122,7 @@ export function getCacheDir(env = process.env) {
     // Explicit XDG/platform overrides win before the transient-stash isolation
     // rule below — tests and operators that pre-arrange XDG_CACHE_HOME (or
     // %LOCALAPPDATA% / %USERPROFILE% / %APPDATA% on Windows) must be honored
-    // as set, so the AKM_STASH_DIR transient rule does not silently move cache
+    // as set, so the AKM_BUNDLE_DIR transient rule does not silently move cache
     // writes away from where they pointed them.
     if (IS_WINDOWS) {
         const localAppData = env.LOCALAPPDATA?.trim();
@@ -145,12 +145,12 @@ export function getCacheDir(env = process.env) {
         if (xdgCacheHome)
             return path.join(xdgCacheHome, "akm");
     }
-    // Isolation safety (mirrors getConfigDir): when AKM_STASH_DIR points at a
+    // Isolation safety (mirrors getConfigDir): when AKM_BUNDLE_DIR points at a
     // transient path AND no explicit cache override is set, route cache writes
-    // into `${AKM_STASH_DIR}/.akm/cache` so that config backups, registry-index
+    // into `${AKM_BUNDLE_DIR}/.akm/cache` so that config backups, registry-index
     // cache, and other regenerable artifacts do not pollute the user's host
     // ~/.cache/akm directory.
-    const stashOverride = env.AKM_STASH_DIR?.trim();
+    const stashOverride = env.AKM_BUNDLE_DIR?.trim();
     if (stashOverride && isTransientStashPath(stashOverride)) {
         return path.join(stashOverride, ".akm", "cache");
     }
@@ -184,7 +184,7 @@ export function getDataDir(env = process.env, platform = process.platform) {
     // user's real $XDG_DATA_HOME / ~/.local/share/akm under any condition.
     // Any test that needs a data dir must point it at a mktemp-d directory
     // via XDG_DATA_HOME (or AKM_DATA_DIR). The previous carve-out that only
-    // fired when AKM_STASH_DIR was set was a loophole: tests calling
+    // fired when AKM_BUNDLE_DIR was set was a loophole: tests calling
     // openDatabase() or getDbPath() without overriding any env var silently
     // wrote into ~/.local/share/akm/index.db (observed: 4,183-row
     // registry-cache pollution). Item 5 of the 0.8.x critical-review plan.
@@ -225,9 +225,9 @@ export function getMaintenanceBarrierPath() {
 export function getStateDbPathInDataDir() {
     return path.join(getDataDir(), "state.db");
 }
-/** Path for the task history directory in $DATA. */
-export function getTaskHistoryStateDir() {
-    return path.join(getDataDir(), "tasks", "history");
+/** Content-addressed scheduler runtime descriptors. */
+export function getTaskContextDir(env = process.env) {
+    return path.join(getDataDir(env), "tasks", "context");
 }
 /** Path to the akm.lock file in $DATA. */
 export function getLockfilePath() {
@@ -246,9 +246,6 @@ export function getRegistryCacheDir() {
 export function getRegistryIndexCacheDir() {
     return path.join(getCacheDir(), "registry-index");
 }
-export function getBinDir() {
-    return path.join(getCacheDir(), "bin");
-}
 // ── Scheduled-task runtime directories (logs + history) ──────────────────────
 export function getTaskLogDir() {
     return path.join(getCacheDir(), "tasks", "logs");
@@ -258,7 +255,7 @@ export function getTaskHistoryDir() {
 }
 // ── Default stash directory ──────────────────────────────────────────────────
 export function getDefaultStashDir(env = process.env) {
-    const override = env.AKM_STASH_DIR?.trim();
+    const override = env.AKM_BUNDLE_DIR?.trim();
     if (override)
         return override;
     if (IS_WINDOWS) {
@@ -269,7 +266,7 @@ export function getDefaultStashDir(env = process.env) {
     }
     const home = env.HOME?.trim();
     if (!home) {
-        throw new ConfigError("Unable to determine default stash directory. Set HOME.", "STASH_DIR_NOT_FOUND");
+        throw new ConfigError("Unable to determine default bundle directory. Set HOME.", "STASH_DIR_NOT_FOUND");
     }
     return path.join(home, "akm");
 }

package/dist/core/recognition-util.js

@@ -34,22 +34,20 @@ export const SCRIPT_EXTENSIONS = new Set([
     ".kts",
 ]);
 /**
- * Recognized workflow asset extensions, in resolution-priority order.
- * `.md` (classic linear markdown workflows — the stable contract) stays
- * FIRST for back-compat; `.yaml`/`.yml` hold YAML workflow *programs*
- * (redesign addendum, R1). `workflows/<name>` refs resolve against this list.
+ * Recognized workflow asset extensions. One format now (workflow-format-
+ * unification): orchestration graph in frontmatter, prose in the body.
+ * `workflows/<name>` refs resolve against this list.
  */
-export const WORKFLOW_EXTENSIONS = [".md", ".yaml", ".yml"];
+export const WORKFLOW_EXTENSIONS = [".md"];
 /**
- * Strip a recognized workflow extension (`.md`/`.yaml`/`.yml`) from a workflow
- * asset *name* so `foo`, `foo.yaml`, `foo.yml`, and `foo.md` collapse to one
- * canonical identity — the same collapse `workflowSpec.toCanonicalName`
- * performs on a resolved file path. Callers that turn a `workflows/<name>` ref
- * into run identity (the active-run guard, list/status filters) MUST route the
- * name through this so an aliased spelling (`workflows/foo.yaml`) and the
- * canonical `workflows/foo` cannot start or hide parallel runs of the same
- * workflow. Names without a recognized workflow extension pass through
- * unchanged.
+ * Strip the recognized workflow extension (`.md`) from a workflow asset
+ * *name* so `foo` and `foo.md` collapse to one canonical identity — the same
+ * collapse `workflowSpec.toCanonicalName` performs on a resolved file path.
+ * Callers that turn a `workflows/<name>` ref into run identity (the
+ * active-run guard, list/status filters) MUST route the name through this so
+ * an aliased spelling (`workflows/foo.md`) and the canonical `workflows/foo`
+ * cannot start or hide parallel runs of the same workflow. Names without the
+ * extension pass through unchanged.
  */
 export function canonicalizeWorkflowName(name) {
     const lower = name.toLowerCase();

package/dist/core/redaction.js

@@ -297,6 +297,40 @@ function addMappedMatches(coverageDelta, haystack, needle) {
         offset = match + Math.max(needle.length, 1);
     }
 }
+/**
+ * Redact credential-shaped substrings from arbitrary text by pattern alone —
+ * unlike {@link redactSensitiveText}, which requires the exact secret value
+ * up front, this catches credentials no caller ever knew to list. No
+ * truncation is applied; callers that need a length cap (e.g.
+ * {@link redactErrorBody} in src/llm/client.ts) apply it themselves.
+ *
+ * Targets:
+ *  - `Bearer <token>` headers echoed back by a provider
+ *  - `sk-…` / `sk_…` style API keys (OpenAI / Anthropic-shaped)
+ *  - `key-…` / `key_…` shorthand keys
+ *  - `"api_key": "…"` / `"apiKey": "…"` JSON fields
+ *  - Discord webhook URLs (`discord.com/api/webhooks/<id>/<token>`) — the id
+ *    is kept, only the token segment is redacted
+ *  - Slack incoming-webhook URLs (`hooks.slack.com/services/<team>/<channel>/<token>`)
+ *    — the team/channel ids are kept, only the trailing token is redacted
+ */
+export function redactCredentialPatterns(input) {
+    if (!input)
+        return "";
+    return (input
+        // Bearer tokens (case-insensitive)
+        .replace(/\bBearer\s+[A-Za-z0-9._\-+/=]+/gi, "Bearer [REDACTED]")
+        // sk-/sk_ style keys
+        .replace(/\bsk[-_][A-Za-z0-9._-]{6,}/g, "[REDACTED]")
+        // key-/key_ shorthand keys
+        .replace(/\bkey[-_][A-Za-z0-9._-]{6,}/g, "[REDACTED]")
+        // JSON-style "api_key": "...", "apiKey": "...", "api-key": "..."
+        .replace(/("(?:api[_-]?key|apiKey|authorization|token)"\s*:\s*")([^"]*)(")/gi, "$1[REDACTED]$3")
+        // Discord webhook URLs: keep the webhook id, redact the token segment.
+        .replace(/(discord(?:app)?\.com\/api\/webhooks\/\d+\/)[A-Za-z0-9_-]+/gi, "$1[REDACTED]")
+        // Slack incoming-webhook URLs: keep the team/channel ids, redact the token.
+        .replace(/(hooks\.slack\.com\/services\/[A-Za-z0-9]+\/[A-Za-z0-9]+\/)[A-Za-z0-9]+/gi, "$1[REDACTED]"));
+}
 /**
  * Replace exact sensitive values in text. Longer values are replaced first so
  * an overlapping prefix cannot expose the suffix of a longer credential.