akm-cli 0.9.0-rc.4 → 0.9.0-rc.6

package/dist/workflows/renderer.js

@@ -16,13 +16,11 @@
  *     `program/project.ts`, including a compact orchestration summary per
  *     step (runner/model, `fanOut.over` expression, route table).
  */
-import { makeAssetRef } from "../core/asset/asset-ref.js";
+import { displayRef } from "../core/asset/resolve-ref.js";
 import { UsageError } from "../core/errors.js";
-import { registerMetadataContributor } from "../indexer/passes/metadata-contributors.js";
 import { parseWorkflow } from "./parser.js";
 import { parseWorkflowProgram } from "./program/parser.js";
 import { programStepInstructions, projectProgramParameters, summarizeProgramStepOrchestration, WORKFLOW_PROGRAM_RENDERER_NAME, } from "./program/project.js";
-import { cacheWorkflowDocument } from "./runtime/document-cache.js";
 export { WORKFLOW_PROGRAM_RENDERER_NAME };
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -49,7 +47,12 @@ export const workflowMdRenderer = {
     buildShowResponse(ctx) {
         const name = deriveName(ctx);
         const doc = loadDocument(ctx);
-        const ref = makeAssetRef("workflow", name, ctx.origin);
+        // WI-8.5b (display flip): the `akm workflow next <ref>` action is DISPLAY
+        // output — its spelling follows the D-R5 display rule (`displayRef`). A
+        // primary/default-bundle workflow renders the SHORT conceptId
+        // (`workflows/<name>`); a named source qualifies it as
+        // (`<bundle>//workflows/<name>`).
+        const ref = displayRef({ type: "workflow", name, bundleId: ctx.origin });
         return {
             type: "workflow",
             name,
@@ -82,7 +85,10 @@ export const workflowProgramRenderer = {
     buildShowResponse(ctx) {
         const name = deriveName(ctx);
         const program = loadProgram(ctx);
-        const ref = makeAssetRef("workflow", name, ctx.origin);
+        // WI-8.5b (display flip): the `akm workflow next <ref>` action is DISPLAY
+        // output — its spelling follows the D-R5 display rule (`displayRef`), mirroring
+        // workflowMdRenderer above.
+        const ref = displayRef({ type: "workflow", name, bundleId: ctx.origin });
         const parameters = projectProgramParameters(program);
         return {
             type: "workflow",
@@ -106,58 +112,3 @@ export const workflowProgramRenderer = {
         };
     },
 };
-registerMetadataContributor({
-    name: "workflow-document-metadata",
-    appliesTo: ({ rendererName }) => rendererName === "workflow-md",
-    contribute(entry, { renderContext }) {
-        const doc = loadDocument(renderContext);
-        const hints = new Set(entry.searchHints ?? []);
-        hints.add(doc.title);
-        for (const step of doc.steps) {
-            hints.add(step.title);
-            hints.add(step.id);
-            hints.add(step.instructions.text);
-            for (const criterion of step.completionCriteria ?? []) {
-                hints.add(criterion.text);
-            }
-        }
-        entry.searchHints = Array.from(hints).filter(Boolean);
-        if (doc.parameters?.length) {
-            entry.parameters = doc.parameters.map((p) => ({
-                name: p.name,
-                ...(p.description ? { description: p.description } : {}),
-            }));
-        }
-        cacheWorkflowDocument(entry, doc);
-    },
-});
-registerMetadataContributor({
-    name: "workflow-program-metadata",
-    appliesTo: ({ rendererName }) => rendererName === WORKFLOW_PROGRAM_RENDERER_NAME,
-    contribute(entry, { renderContext }) {
-        // Parse failures throw, which the metadata pass turns into a
-        // skip-with-warning — broken programs never land in the index, mirroring
-        // markdown workflows. No workflow_documents cache row is written: YAML
-        // programs are re-parsed from disk by the runtime loader.
-        const program = loadProgram(renderContext);
-        const hints = new Set(entry.searchHints ?? []);
-        hints.add(program.name);
-        for (const step of program.steps) {
-            hints.add(step.id);
-            if (step.title)
-                hints.add(step.title);
-            hints.add(programStepInstructions(step));
-            for (const criterion of step.gate?.criteria ?? []) {
-                hints.add(criterion);
-            }
-        }
-        entry.searchHints = Array.from(hints).filter(Boolean);
-        if (!entry.description && program.description) {
-            entry.description = program.description;
-        }
-        const parameters = projectProgramParameters(program);
-        if (parameters?.length) {
-            entry.parameters = parameters;
-        }
-    },
-});

package/dist/workflows/runtime/checkin.js

@@ -5,7 +5,7 @@
  * Agent check-in: a no-background-thread "continue" nudge for stalled workflow
  * runs (#506).
  *
- * The design decision (see docs/technical/workflow-agent-checkin-adr.md)
+ * The design decision (the workflow-agent check-in ADR)
  * reconciles #506 (file/command-loop signal) with #501 (background thread) in
  * favour of the former. There is intentionally NO timer or resident process
  * here. Arming a check-in writes a timestamp (`checkin_armed_at`) on the run

package/dist/workflows/runtime/plan-classifier.js

@@ -133,9 +133,12 @@ export function assertWorkflowSpineMatchesPlan(plan, run, rows) {
     for (let index = 0; index < expected.length; index++) {
         const actual = rows[index];
         const planned = expected[index];
-        if (!actual ||
-            !planned ||
-            actual.step_id !== planned.stepId ||
+        // The length check above (corruptSpine returns `never`) guarantees both are
+        // present; the guard narrows them and preserves the "missing row" message.
+        if (!actual || !planned) {
+            corruptSpine(run.id, `step row ${index} differs from the frozen plan (missing row)`);
+        }
+        if (actual.step_id !== planned.stepId ||
             actual.step_title !== planned.stepTitle ||
             actual.instructions !== planned.instructions ||
             actual.completion_json !== planned.completionJson ||
@@ -147,7 +150,7 @@ export function assertWorkflowSpineMatchesPlan(plan, run, rows) {
                 actual.completion_json !== planned.completionJson ? "completion_json" : "",
                 actual.sequence_index !== planned.sequenceIndex ? "sequence_index" : "",
             ].filter(Boolean);
-            corruptSpine(run.id, `step row ${index} differs from the frozen plan (${fields.join(", ") || "missing row"})`);
+            corruptSpine(run.id, `step row ${index} differs from the frozen plan (${fields.join(", ")})`);
         }
     }
     if (run.current_step_id !== null && !expected.some((step) => step.stepId === run.current_step_id))

package/dist/workflows/runtime/runs.js

@@ -2,11 +2,10 @@
 // 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 { randomUUID } from "node:crypto";
-import { parseAssetRef } from "../../core/asset/asset-ref.js";
-import { canonicalizeWorkflowName } from "../../core/asset/asset-spec.js";
 import { loadConfig } from "../../core/config/config.js";
 import { NotFoundError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
+import { canonicalizeWorkflowName } from "../../core/recognition-util.js";
 import { warn } from "../../core/warn.js";
 import { withWorkflowRunsRepo, } from "../../storage/repositories/workflow-runs-repository.js";
 import { getCurrentWorkflowScopeKey } from "../authoring/scope-key.js";
@@ -22,7 +21,7 @@ import { resolveAgentIdentity } from "./agent-identity.js";
 import { evaluateCheckin } from "./checkin.js";
 import { assertWorkflowSpineMatchesPlan, classifyWorkflowRunPlan, frozenStepRows, requireAbandonableWorkflowPlan, requireExecutableWorkflowPlan, } from "./plan-classifier.js";
 import { evaluateStaleUnits } from "./unit-checkin.js";
-import { loadWorkflowAsset, resolveWorkflowEntryId } from "./workflow-asset-loader.js";
+import { canonicalWorkflowRunRef, loadWorkflowAsset, parseWorkflowRefInput, resolveWorkflowEntryId, } from "./workflow-asset-loader.js";
 /** Clip bound for a unit's `result_json` on the `--units` diagnostic surface. */
 const UNIT_DIAGNOSTIC_CLIP = 2000;
 function toUnitDiagnostic(row, stale, plannedEngine) {
@@ -118,7 +117,7 @@ export async function startWorkflowRun(ref, params = {}, options) {
             }
         }
         // #506: arm a file-signal check-in (a timestamp, NOT a background thread —
-        // see docs/technical/workflow-agent-checkin-adr.md) so a stalled run can be
+        // per the workflow-agent check-in ADR) so a stalled run can be
         // re-targeted with a `continue` directive. The agent harness + session id
         // are already resolved above (agentHarness/agentSessionId, from #501).
         repo.transaction(() => {
@@ -199,11 +198,11 @@ export async function listWorkflowRuns(input) {
         const scopeKey = getCurrentWorkflowScopeKey();
         let workflowRef;
         if (input?.workflowRef) {
-            const parsed = parseAssetRef(input.workflowRef);
+            const parsed = parseWorkflowRefInput(input.workflowRef);
             if (parsed.type !== "workflow") {
-                throw new UsageError(`Expected a workflow ref (workflow:<name>), got "${input.workflowRef}".`);
+                throw new UsageError(`Expected a workflow ref (workflows/<name>), got "${input.workflowRef}".`);
             }
-            workflowRef = `${parsed.origin ? `${parsed.origin}//` : ""}workflow:${canonicalizeWorkflowName(parsed.name)}`;
+            workflowRef = canonicalWorkflowRunRef(parsed.origin, canonicalizeWorkflowName(parsed.name));
         }
         const rows = repo.listRuns({
             scopeKey,
@@ -481,14 +480,16 @@ async function resolveRunSpecifier(repo, specifier, params) {
         }
         return { run: explicitRun, autoStarted: false };
     }
-    if (!specifier.includes(":")) {
+    // Run-id vs workflow-ref disambiguation: a run id is a bare token, while a
+    // canonical `workflows/name` ref carries a `/`.
+    if (!specifier.includes(":") && !specifier.includes("/")) {
         throw new NotFoundError(`Workflow run "${specifier}" not found.`, "WORKFLOW_NOT_FOUND");
     }
-    const parsed = parseAssetRef(specifier);
+    const parsed = parseWorkflowRefInput(specifier);
     if (parsed.type !== "workflow") {
         throw new UsageError(`Expected a workflow ref or workflow run id, got "${specifier}".`);
     }
-    const ref = `${parsed.origin ? `${parsed.origin}//` : ""}workflow:${canonicalizeWorkflowName(parsed.name)}`;
+    const ref = canonicalWorkflowRunRef(parsed.origin, canonicalizeWorkflowName(parsed.name));
     const scopeKey = getCurrentWorkflowScopeKey();
     const active = repo.getActiveRunRowForScope(ref, scopeKey);
     if (active) {

package/dist/workflows/runtime/unit-checkin.js

@@ -1,7 +1,7 @@
 // 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 { GATE_EVALUATION_PHASE } from "../exec/step-work.js";
+import { GATE_EVALUATION_PHASE } from "./unit-phases.js";
 /**
  * Default staleness window. A unit claimed `running` whose last heartbeat (or,
  * absent any heartbeat, its first claim) is older than this is surfaced as

package/dist/workflows/runtime/unit-phases.js

@@ -0,0 +1,20 @@
+// 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/.
+/**
+ * Unit-row phase markers — a leaf module (imports nothing) so both the exec
+ * drivers (step-work, brief, run-workflow) and the runtime (unit-checkin) can
+ * key on the phase discriminator without an exec ↔ runtime import cycle.
+ * Extracting {@link GATE_EVALUATION_PHASE} here broke the last workflows-
+ * runtime knot (step-work → runs → unit-checkin → step-work; chunk-8 WI-8.6,
+ * DoD 11).
+ */
+/**
+ * `phase` marker stamped on gate-evaluation unit rows. Step ids cannot contain
+ * dots (`PROGRAM_STEP_ID_PATTERN`), so a step can never be NAMED `x.gate` and
+ * the synthetic `<stepId>.gate` node id is collision-free against user step
+ * ids. The phase column is nonetheless the discriminator we key on — an
+ * explicit marker, not a `node_id` suffix match, so recovery stays robust even
+ * if the id scheme evolves. Dispatch rows always journal `phase: null`.
+ */
+export const GATE_EVALUATION_PHASE = "gate";

package/dist/workflows/runtime/workflow-asset-loader.js

@@ -2,11 +2,12 @@
 // 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 fs from "node:fs";
-import { parseAssetRef } from "../../core/asset/asset-ref.js";
-import { canonicalizeWorkflowName } from "../../core/asset/asset-spec.js";
+import { parseRefInput } from "../../core/asset/resolve-ref.js";
+import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { NotFoundError, UsageError } from "../../core/errors.js";
 import { getDbPath } from "../../core/paths.js";
+import { canonicalizeWorkflowName } from "../../core/recognition-util.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
@@ -16,17 +17,27 @@ import { parseWorkflow } from "../parser.js";
 import { parseWorkflowProgram } from "../program/parser.js";
 import { isWorkflowProgramPath, projectProgramParameters, projectProgramStepDefinitions } from "../program/project.js";
 /**
- * Resolve a `workflow:<name>` ref to a fully-projected {@link WorkflowAsset}.
- *
- * Prefers the parsed document cached in `index.db` (fast path) and falls back to
- * reading + parsing the source file from disk. Pure loading/parsing concern —
- * extracted from the run repository so run orchestration no longer owns asset
- * resolution.
+ * The canonical durable `workflow_runs.workflow_ref` run-key:
+ * `[origin//]workflows/<canonical-name>` (normative §11.4 — the chunk-8
+ * cutover re-keys pre-existing legacy rows onto this spelling; every mint
+ * site MUST build the key through this one helper).
+ */
+export function canonicalWorkflowRunRef(origin, canonicalName) {
+    return `${origin ? `${origin}//` : ""}workflows/${canonicalName}`;
+}
+/** Parse a workflow ref using the canonical `[bundle//]workflows/<name>` grammar. */
+export function parseWorkflowRefInput(ref) {
+    return parseRefInput(ref.trim());
+}
+/**
+ * Resolve a workflow ref to a fully-projected {@link WorkflowAsset}. Prefers the
+ * parsed document cached in `index.db` (fast path) and falls back to reading +
+ * parsing the source file from disk.
  */
 export async function loadWorkflowAsset(ref) {
-    const parsed = parseAssetRef(ref);
+    const parsed = parseWorkflowRefInput(ref);
     if (parsed.type !== "workflow") {
-        throw new UsageError(`Expected a workflow ref (workflow:<name>), got "${ref}".`);
+        throw new UsageError(`Expected a workflow ref (workflows/<name>), got "${ref}".`);
     }
     const config = loadConfig();
     const allSources = resolveSourceEntries(undefined, config);
@@ -44,16 +55,16 @@ export async function loadWorkflowAsset(ref) {
         }
     }
     if (!assetPath) {
-        throw new NotFoundError(`Workflow not found for ref: workflow:${parsed.name}`);
+        throw new NotFoundError(`Workflow not found for ref: workflows/${parsed.name}`);
     }
-    const resolvedSourcePath = sourcePath ?? config.stashDir ?? assetPath;
-    // Canonicalize the stored ref: `workflow:foo.yaml` and `workflow:foo`
+    const resolvedSourcePath = sourcePath ?? resolveStashDir() ?? assetPath;
+    // Canonicalize the stored ref: `workflows/foo.yaml` and `workflows/foo`
     // resolve to the same file, so they MUST share one run identity. The raw
     // `parsed.name` (with any extension) is what drives file resolution above;
     // only the persisted/queried ref is collapsed (matches the index entry key,
     // which is keyed by the extension-stripped canonical name).
     const canonicalName = canonicalizeWorkflowName(parsed.name);
-    const fullRef = `${parsed.origin ? `${parsed.origin}//` : ""}workflow:${canonicalName}`;
+    const fullRef = canonicalWorkflowRunRef(parsed.origin, canonicalName);
     // Format detection by extension: `.yaml`/`.yml` is a YAML workflow program
     // (redesign addendum, R1); everything else is the markdown document format.
     if (isWorkflowProgramPath(assetPath)) {
@@ -71,7 +82,7 @@ export async function loadWorkflowAsset(ref) {
 export function resolveWorkflowEntryId(sourcePath, ref) {
     if (!fs.existsSync(getDbPath()))
         return null;
-    const parsed = parseAssetRef(ref);
+    const parsed = parseWorkflowRefInput(ref);
     const entryKey = `${sourcePath}:${parsed.type}:${parsed.name}`;
     return withIndexDb((db) => {
         const row = db
@@ -103,7 +114,7 @@ function loadWorkflowDocumentFromDisk(assetPath) {
 function readWorkflowDocumentFromIndex(sourcePath, ref) {
     if (!fs.existsSync(getDbPath()))
         return null;
-    const parsed = parseAssetRef(ref);
+    const parsed = parseWorkflowRefInput(ref);
     const entryKey = `${sourcePath}:${parsed.type}:${parsed.name}`;
     return withIndexDb((db) => {
         const row = db

package/dist/workflows/validate-summary.js

@@ -11,8 +11,8 @@
  *
  * The LLM call is injected (`judge`) so the gate is unit-testable without a
  * live endpoint, and the whole gate is fail-open: when no criteria exist or no
- * judge is available the step completes as before. See
- * docs/technical/workflow-agent-checkin-adr.md.
+ * judge is available the step completes as before (per the workflow-agent
+ * check-in ADR).
  *
  * @module workflows/validate-summary
  */

package/dist/workflows/validator.js

@@ -8,7 +8,8 @@
  * the whole document or the raw frontmatter at once: duplicate step IDs,
  * step-id format, and the frontmatter key whitelist.
  */
-import { parseAssetRef, refToString } from "../core/asset/asset-ref.js";
+import { isBundleSlug } from "../core/asset/asset-ref.js";
+import { conceptIdFromTypeName, parseRefInput } from "../core/asset/resolve-ref.js";
 import { utf8Bytes, WORKFLOW_MAX_INSTRUCTION_BYTES, WORKFLOW_MAX_PARAMS, WORKFLOW_MAX_STEPS } from "./resource-limits.js";
 const STEP_ID_REGEX = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const ALLOWED_FRONTMATTER_KEYS = new Set(["description", "tags", "params", "name", "updated", "when_to_use", "xrefs"]);
@@ -28,7 +29,22 @@ function checkXrefs(value, line, errors) {
     }
     for (const ref of value) {
         try {
-            if (typeof ref !== "string" || refToString(parseAssetRef(ref)) !== ref)
+            if (typeof ref !== "string")
+                throw new Error("non-canonical ref");
+            // Canonicity accepts BOTH grammars during the transition (WI-8.5a flipped
+            // the content writers to the new grammar; existing content still carries
+            // legacy xrefs — the dual-reader arm stays alive until WI-8.5b): the new
+            // bare `conceptId` (or slug-clean `bundle//conceptId`) that lint/mv now
+            // recognize, OR the legacy `[origin//]type:name` round-trip.
+            const p = parseRefInput(ref);
+            const conceptId = conceptIdFromTypeName(p.type, p.name);
+            const newCanonical = p.origin !== undefined && p.origin !== "local" && p.origin !== "stash"
+                ? isBundleSlug(p.origin)
+                    ? `${p.origin}//${conceptId}`
+                    : `${p.origin}//${p.type}:${p.name}`
+                : conceptId;
+            const legacyCanonical = p.origin ? `${p.origin}//${p.type}:${p.name}` : `${p.type}:${p.name}`;
+            if (ref !== newCanonical && ref !== legacyCanonical)
                 throw new Error("non-canonical ref");
         }
         catch {

package/docs/migration/release-notes/0.9.0.md

@@ -5,21 +5,57 @@ were already running a 0.9.0 beta, align scripts, prompts, and stash layout
 with the current command surface and verify every durable artifact before
 normal use.
 
+Heads-up: 0.9.x is a refactoring and clean-up release series. Patch
+releases may include breaking changes (each called out in the CHANGELOG with
+a migration note) until the remaining technical debt is paid off; the 0.10.x
+series returns to bug fixes and tuning with breaking changes only in major
+and minor releases. See STABILITY.md for the full policy.
+
 Key operator-facing changes:
 
-- The published npm package requires Node.js >= 20.12 as its cross-platform
+- **This release is the format-neutral bundle-adapter refactor.** The flat
+  asset-type registry is replaced by per-format adapters, and refs move from the
+  old `type:name` grammar to `[bundle//]conceptId` — a subdir-qualified concept
+  id such as `skills/code-review`, `memories/vpn-note`, or `env/prod`, with an
+  optional `bundle//` installation prefix and an optional `#fragment`. Durable
+  state is stored fully-qualified; the short bundle-omitted form is input sugar
+  (resolved against `defaultBundle`, then installation-priority order).
+  `akm migrate apply` re-keys all durable state, folds the former `workflow.db`
+  into `state.db` (three databases: `state.db` / `index.db` / a separate
+  `logs.db`, down from four), and migrates config from the flat `stashDir` /
+  `sources` / `installed` / `wikiName` keys to `bundles` / `defaultBundle`.
+  `index.md` / `log.md` are reserved structural files — never indexed as
+  concepts and never valid write targets.
+- **Installed non-akm bundles reclassify on your next `akm index`.** The
+  indexer now dispatches each installed bundle's *detected* adapter instead of
+  recognizing everything with the akm-stash adapter. No action needed — the
+  index is a regenerable cache — but searches/saved refs into those bundles may
+  resolve to new ref spellings afterwards.
+- The published npm package requires Node.js >= 22 as its cross-platform
   bootstrap. When a working Bun >= 1.0 is also on `PATH`, the launcher prefers
   Bun after bootstrap; old, unusable, or absent Bun installations fall back to
   Node.js. The standalone binaries are runtime-free.
 - The legacy `vault` asset type and `akm vault ...` command family are gone.
-  Use `env:` for whole `.env` groups and `secret:` for a single sensitive
-  value.
+  Use `env/<name>` for whole `.env` groups and `secrets/<name>` for a single
+  sensitive value.
+- `akm save` is replaced by `akm sync` for writable-stash persistence and
+  pushes, and `akm events` is replaced by `akm log`.
+- The entire `akm wiki ...` command family and the `wiki` asset type are gone.
+  The Karpathy-style LLM wiki structure (`schema.md` + `pages/`) is now a
+  first-class **bundle format** recognized directly by `akm index`/`akm
+  search`/`akm lint` — no dedicated verb surface needed.
 - `akm-migrate-storage` still ships and still performs the non-destructive
   `vaults/` -> `env/` copy for older stashes. Run it before indexing if you are
   upgrading from a stash that still stores `.env` files only under `vaults/`.
 - Proposal workflow is fully consolidated around `akm improve`, `akm propose`,
   and `akm proposal ...`. Update any old `akm reflect`, `akm distill`,
   `akm accept`, `akm reject`, or `akm proposals` usage.
+- LLM-backed sustaining work is opt-in in the shipped presets: improve-stage
+  extract is off in `default` and `frequent`, and `proactiveMaintenance` is off
+  in `default` and `reflect-distill`. The dedicated `proactive-maintenance`
+  strategy remains enabled as an explicit opt-in. Presets that omit these
+  fields inherit the `default` off values, while an explicit user
+  `enabled: true` override still wins.
 - Config, `state.db`, and `workflow.db` are now classified independently by the
   explicit `akm migrate` coordinator. Normal commands refuse old, future, or
   divergent durable schemas instead of attempting migration as a side effect.
@@ -54,5 +90,11 @@ Required upgrade checks:
   `current`; indexing does not migrate config or durable schemas.
 - Review agent instructions and docs for old `vault`, `reflect`, and `distill`
   examples.
+- Review scheduled improve invocations if they relied on inherited extract or
+  proactive-maintenance enablement. Standalone extraction remains available,
+  but every command must select `--type <harness>` or `--auto`; bare
+  `akm extract` is invalid. Update any installed bare extract task to
+  `akm extract --auto` for all-harness discovery. The bundled template remains
+  an unselected opt-in and now uses that valid command.
 
 Full changelog: https://github.com/itlackey/akm/blob/main/CHANGELOG.md