akm-cli 0.9.17-alpha.1 → 0.9.17-alpha.10

package/dist/assets/prompts/retrieval-relevance-judge.md

@@ -0,0 +1,6 @@
+You are grading search-and-retrieval results for an AI coding agent's knowledge base (the akm tool). For the given query and ONE candidate asset, grade how useful loading this asset would be, on this scale:
+3 = exactly the asset an agent should load for this query or task; it directly answers or performs the request.
+2 = relevant and clearly useful, though not the single best asset for the query.
+1 = same general topic as the query, but would not actually help complete this specific query or task.
+0 = unrelated to the query.
+Reply with ONLY a JSON object: {"grade": <integer 0-3>, "reason": "<=25 words"}.

package/dist/assets/stash-skeleton/facts/conventions/backlinks.md

@@ -3,25 +3,26 @@ type: fact
 category: convention
 description: How to cross-link assets so retrieval compounds — a provenance xref when derived, sparse real associative xrefs, corrections as new assets, and canonical entity naming.
 when_to_use: Surfaced to authoring agents when they create or revise any asset that derives from, corrects, or relates to another asset.
-updated: 2026-07-28
+updated: 2026-09-28
 ---
 
 <!--
   SOFT guidance only — advice, not a contract. Back-linking here is a RETRIEVAL
-  mechanism, not decoration: `xrefs:` frontmatter folds into the search index;
-  the entity/relation graph is extracted from BODY prose (memory + knowledge),
-  never from frontmatter. Over-linking degrades ranking, so these rules are
-  deliberately conservative. (LLM-wiki bundles carry their own xref system in
-  their pages' frontmatter — this convention is for in-stash assets.)
+  mechanism, not decoration: `xrefs:` frontmatter folds into the search index
+  and is stored as a declared link `akm show` lists on both assets.
+  Over-linking degrades ranking, so these rules are deliberately conservative.
+  (LLM-wiki bundles carry their own xref system in their pages' frontmatter —
+  this convention is for in-stash assets.)
 -->
 
 # Back-linking conventions
 
 Cross-references are how knowledge compounds instead of being re-derived every
 session. In AKM they are also **indexed**: the strings in an asset's `xrefs:`
-frontmatter fold into its search-hint text, and knowledge/memory bodies feed an
-LLM-extracted entity/relation graph that boosts ranking. So links are a retrieval
-lever — which means both too few and too many hurt.
+frontmatter fold into its search-hint text and are stored as links that
+`akm show` lists on both assets (with `supersededBy:`, `contradictedBy:` and a
+`.derived` memory's parent). So links are a retrieval lever — which means both
+too few and too many hurt.
 
 ```yaml
 ---
@@ -46,10 +47,8 @@ xrefs:
 - **Associative xrefs are discretionary — real relationships only.** Add one when
   you already know a genuine load-bearing connection. Do **not** hit a link
   quota by pointing at the topically-nearest sibling — a plausible-but-wrong
-  xref makes this asset a false search match for the other topic, and a wrong
-  relationship asserted in prose poisons the entity graph. A relationship you
-  want the graph to learn must be named in the body (e.g. open with "Corrects
-  knowledge/auth/oauth-refresh-races").
+  xref makes this asset a false search match for the other topic and a false
+  declared link on both assets' `akm show` output.
 - **Cap total xrefs at ~5 (a heuristic, not a measured threshold).** Each xref
   folds its ref tokens into THIS asset's search hints — past a handful, the
   asset matches queries about several other topics and its own ranking signal
@@ -78,19 +77,20 @@ prose is indexed in the lowest-weight `content` field, so
 `description:`/`when_to_use:` remain the primary orientation channel. Then
 open the body with a plain title plus a one-line
 orientation naming what it is, its scope/domain, and its key entities in
-canonical spelling (`Postgres`, `OAuth`, `TLS`, `Acme`) — the entity/relation
-graph is extracted from body prose, and readers land here from `akm show`.
-Keep the canonical-spelling list in `facts/conventions/domains` so agents don't
-fragment `postgres` / `postgresql` / `pg`.
+canonical spelling (`Postgres`, `OAuth`, `TLS`, `Acme`) — consistent spelling
+keeps search matches from fragmenting across variants, and readers land here
+from `akm show`. Keep the canonical-spelling list in `facts/conventions/domains`
+so agents don't fragment `postgres` / `postgresql` / `pg`.
 
 ## Hubs are optional, not per-namespace obligations
 
 A hub (a `knowledge/` overview page that xrefs the key assets in a domain) is
 worth authoring for a **few genuinely high-traffic domains**. Do **not**
 mandate a hub per namespace and do not edit a hub on every write: that is O(n)
-maintenance, a concurrent-write contention point, and it flattens the multi-hop
-graph into a namespace-wide star. Let the FTS index be the catalog; spend the
-effort on per-asset self-situating headers instead.
+maintenance, a concurrent-write contention point, and it flattens every linked
+asset's declared links into a namespace-wide star centered on the hub. Let the
+FTS index be the catalog; spend the effort on per-asset self-situating headers
+instead.
 
 ## Keep assets atomic
 

package/dist/assets/stash-skeleton/facts/conventions/domains.md

@@ -48,8 +48,8 @@ volume justifies it.
 ## Canonical entity spellings
 
 Pick ONE name per entity and use it everywhere in asset **bodies** — retrieval
-is case-insensitive but treats aliases as different entities, so alias variants
-fragment the entity graph. Extend as your stash grows.
+is case-insensitive but treats aliases as different terms, so alias variants
+fragment search matches. Extend as your stash grows.
 
 - Postgres (not postgresql / pg)
 - Kubernetes (not k8s)

package/dist/assets/templates/html/health.html

@@ -325,7 +325,7 @@
 
       <div class="chart-panel full-width">
         <h3>Per-Phase Wall Time Decomposition (stacked, min)</h3>
-        <div id="chartPhases" class="ec tall" role="img" aria-label="Stacked area chart decomposing wall time per run into consolidation, memory inference, graph extraction, and unattributed phases"></div>
+        <div id="chartPhases" class="ec tall" role="img" aria-label="Stacked area chart decomposing wall time per run into consolidation, memory inference, and unattributed phases"></div>
         <div class="empty-overlay" id="emptyPhases">No runs in the selected slice.</div>
       </div>
 
@@ -390,7 +390,7 @@
       <div class="table-wrap">
       <table>
         <thead>
-          <tr><th>Started</th><th>Task</th><th>Strategy</th><th>Wall</th><th>Promoted</th><th>Merged</th><th>Contradicted</th><th>MI Written</th><th>Entities</th><th>Lint Fixed</th><th>Status</th></tr>
+          <tr><th>Started</th><th>Task</th><th>Strategy</th><th>Wall</th><th>Promoted</th><th>Merged</th><th>Contradicted</th><th>MI Written</th><th>Lint Fixed</th><th>Status</th></tr>
         </thead>
         <tbody id="lastRunsTable"></tbody>
       </table>
@@ -539,7 +539,7 @@ mkChart('chartWallTime', {
 // ── 2. Per-phase wall time decomposition (stacked area) ──────────────────────
 mkChart('chartPhases', {
   tooltip: baseTooltip,
-  legend: { ...baseLegend, data: ['Consolidation', 'Memory inference', 'Graph extraction', 'Unattributed'] },
+  legend: { ...baseLegend, data: ['Consolidation', 'Memory inference', 'Unattributed'] },
   grid: denseGrid,
   dataZoom: denseZoom,
   xAxis: { type: 'category', data: xLabels, ...baseAxis },
@@ -547,7 +547,6 @@ mkChart('chartPhases', {
   series: [
     { name: 'Consolidation',    type: 'line', stack: 'p', areaStyle: { color: 'rgba(88,166,255,0.55)' },  lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.consDurationMs)) },
     { name: 'Memory inference', type: 'line', stack: 'p', areaStyle: { color: 'rgba(63,185,80,0.55)' },   lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.miDurationMs)) },
-    { name: 'Graph extraction', type: 'line', stack: 'p', areaStyle: { color: 'rgba(188,140,255,0.55)' }, lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.geDurationMs)) },
     { name: 'Unattributed',     type: 'line', stack: 'p', areaStyle: { color: 'rgba(210,153,34,0.45)' },  lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.otherMs)) },
   ],
 });
@@ -695,7 +694,6 @@ tbody.innerHTML = '';
     <td>${r.merged || 0}</td>
     <td style="color:${(r.contradicted||0)>5?'var(--yellow)':'var(--text)'};">${r.contradicted || 0}</td>
     <td style="color:var(--green);">${r.miWritten || 0}</td>
-    <td>${r.geEntities || 0}</td>
     <td>${r.lintFixed || 0}</td>
     <td>${badge}</td>
   `;

package/dist/cli/retired-commands.js

@@ -38,7 +38,7 @@ const RETIRED_COMMAND_HINTS = {
     events: "`akm events` moved in 0.9 — use `akm log`.",
     // Removed observability surfaces.
     history: "`akm history` was removed in 0.9 — use `akm log --ref <ref>` for an asset's event trail.",
-    graph: "`akm graph` was removed in 0.9 — graph counts appear in `akm health`; refresh extraction with `akm improve --strategy graph-refresh`.",
+    graph: "`akm graph` was removed in 0.9. The LLM entity graph it inspected was itself retired in 0.9.17-alpha.9 — use `akm show <ref>` for an asset's declared links.",
     lessons: "`akm lessons` was removed in 0.9 — lesson strength is indexed; use `akm search --type lesson`.",
     lesson: "`akm lesson` was removed in 0.9 — lesson strength is indexed; use `akm search --type lesson`.",
     // Relocated guidance / removed asset verbs.

package/dist/cli/shared.js

@@ -9,12 +9,13 @@
  */
 import { defineCommand } from "citty";
 import { stringify as yamlStringify } from "yaml";
+import { renderHealthHtml } from "../commands/health/renderers.js";
 import { assertNever } from "../core/assert.js";
 import { AkmError, UsageError } from "../core/errors.js";
 import { getOutputMode } from "../output/context.js";
 import { renderGenericHtml, renderGenericMarkdown, renderGenericText } from "../output/generic-render.js";
 import { deliverRendered } from "../output/html-render.js";
-import { getHtmlRendererHandler, getMdRendererHandler } from "../output/render-registry.js";
+import { getMdRendererHandler } from "../output/render-registry.js";
 import { shapeForCommand } from "../output/shapes.js";
 import { formatPlain, outputJsonl } from "../output/text.js";
 import { parseAllFlagValues } from "./invocation.js";
@@ -330,7 +331,10 @@ export function output(command, result) {
             return;
         }
         case "html": {
-            const rendered = getHtmlRendererHandler(command)?.(shaped, mode.detail);
+            // `akm health` is the only command with a bespoke HTML report, so it is
+            // called directly rather than through a registry with one possible
+            // registrant (see `output/render-registry.ts`).
+            const rendered = command === "health" ? renderHealthHtml(shaped) : null;
             deliverRendered(rendered ?? renderGenericHtml(command, shaped), mode.outputPath);
             return;
         }

package/dist/cli/unknown-flags.js

@@ -26,8 +26,17 @@
  * validation) — conservative by design.
  */
 import { UsageError } from "../core/errors.js";
+import { warn } from "../core/warn.js";
 import { cittyComparableName, findCittyTopLevelCommandIndex, toAliasArray, } from "./invocation.js";
 import { retiredFlagHint } from "./retired-commands.js";
+/**
+ * Commands that must never refuse on an unrecognized flag — `akm info` warns
+ * and continues instead of exiting 2, the same tolerance a bare `akm help
+ * --whatever` already gets for free from its group-command fallback (no
+ * resolved subcommand, so this gate stands down entirely). `info` is a leaf
+ * command, so it needs an explicit opt-in here instead.
+ */
+const UNKNOWN_FLAG_TOLERANT_COMMANDS = new Set(["info"]);
 /** Flags citty implements itself, which no command declares. */
 const IMPLICIT_FLAGS = ["help", "h", "version", "v"];
 /**
@@ -172,6 +181,10 @@ function throwUnknownFlag(shown, attempted, known) {
         ? `Did you mean \`${suggestion}\`? Run the command with \`--help\` to see its accepted flags.`
         : undefined);
 }
+/** The {@link UNKNOWN_FLAG_TOLERANT_COMMANDS} counterpart to {@link throwUnknownFlag}: report, don't refuse. */
+function warnUnknownFlag(shown, known) {
+    warn(`[akm ${known.path.join(" ")}] ignoring unknown flag "${shown}" — run with --help to see its accepted flags.`);
+}
 /**
  * Throw a {@link UsageError} naming the first flag the resolved command does
  * not declare. Returns silently when every flag is known.
@@ -195,6 +208,7 @@ export function assertKnownFlags(root, rawArgs) {
     const dynamicNamedFlagCommands = new Set(["workflow run", "task run", "task explain"]);
     const dynamicWorkflowParams = dynamicNamedFlagCommands.has(known.path.join(" "));
     const selfDiagnosed = SELF_DIAGNOSED_FLAGS.get(known.path.join(" "));
+    const tolerant = UNKNOWN_FLAG_TOLERANT_COMMANDS.has(known.path.join(" "));
     for (let i = 0; i < ownArgs.length; i += 1) {
         const token = ownArgs[i];
         // Not a flag: positional, a bare `-` (stdin), or a negative number.
@@ -209,8 +223,13 @@ export function assertKnownFlags(root, rawArgs) {
             for (let offset = 0; offset < shortFlags.length; offset += 1) {
                 const rawName = shortFlags[offset];
                 const candidate = cittyComparableName(rawName);
-                if (!known.names.has(candidate))
+                if (!known.names.has(candidate)) {
+                    if (tolerant) {
+                        warnUnknownFlag(token, known);
+                        break;
+                    }
                     throwUnknownFlag(token, `-${rawName}`, known);
+                }
                 if (known.valueFlags.has(candidate)) {
                     if (offset === shortFlags.length - 1)
                         i += 1;
@@ -239,6 +258,10 @@ export function assertKnownFlags(root, rawArgs) {
             // frozen plan before a run is inserted. Short flags remain strict.
             if (dynamicWorkflowParams)
                 continue;
+            if (tolerant) {
+                warnUnknownFlag(token.split("=")[0], known);
+                continue;
+            }
             throwUnknownFlag(token.split("=")[0], `--${rawName}`, known);
         }
         // Skip a declared value flag's value so `--reason "--x"` is not scanned.

package/dist/cli.js

@@ -177,7 +177,7 @@ const setupCommand = defineCommand({
         // the work, matching the `sync --push/--no-push` pattern. A flag
         // DECLARED as `no-init` can never be negated: `--no-init` parses as
         // "negate `init`", a name nothing declared, leaving the real key at its
-        // default forever — see `search --no-project-context`'s identical fix.
+        // default forever — see `search --no-track-usage`'s identical fix.
         init: {
             type: "boolean",
             default: true,
@@ -545,19 +545,32 @@ const helpCommand = defineGroupCommand({
         process.stdout.write(`${await renderSectionedRootHelp()}\n`);
     },
 });
+// Root `--help` text for the exit-code table. `EXIT_CODES` (src/cli/shared.ts)
+// is the single source of the numbers; this only supplies the prose next to
+// each one, so there is no third, independently-drifting copy of the table
+// (the other copy is errors.ts's doc comment, which documents by reference
+// instead of repeating the numbers).
+const EXIT_CODE_DESCRIPTIONS = [
+    [EXIT_CODES.SUCCESS, "success"],
+    [EXIT_CODES.GENERAL, "not found / command-reported failure"],
+    [EXIT_CODES.USAGE, "usage error"],
+    [EXIT_CODES.HEALTH_WARN, "health warn (akm health only)"],
+    [EXIT_CODES.INTERNAL, "internal / unclassified error"],
+    [
+        EXIT_CODES.TEMPFAIL,
+        "transient (retry shortly — another akm process holds a lock or is writing state.db or index.db)",
+    ],
+    [EXIT_CODES.CONFIG, "config error"],
+];
+function renderExitCodesHelp() {
+    return EXIT_CODE_DESCRIPTIONS.map(([code, description]) => `  ${String(code).padEnd(4)}${description}`).join("\n");
+}
 export const main = defineCommand({
     meta: {
         name: "akm",
         version: pkgVersion,
         description: "Agent Knowledge Manager — search, show, and manage assets from your bundle.\n\n" +
-            "Exit codes:\n" +
-            "  0   success\n" +
-            "  1   not found / command-reported failure\n" +
-            "  2   usage error\n" +
-            "  4   health warn (akm health only)\n" +
-            "  70  internal / unclassified error\n" +
-            "  75  transient (retry shortly — another akm process holds a lock or is writing state.db or index.db)\n" +
-            "  78  config error",
+            `Exit codes:\n${renderExitCodesHelp()}`,
     },
     args: {
         // Single-sourced from GLOBAL_OUTPUT_ARGS (src/cli/shared.ts) so root help
@@ -632,6 +645,24 @@ export function shouldBypassConfigStartup(argv) {
     const subcommand = args.slice(configIndex + 1).find((arg) => !arg.startsWith("-"));
     return subcommand === "path";
 }
+/**
+ * Whether `argv` resolves to the top-level `info` command — used by
+ * `runCli` (and mirrored in `tests/_helpers/cli.ts`) to scope the startup
+ * config read's best-effort fallback to `info` alone. `info` is NOT on
+ * {@link shouldBypassConfigStartup}'s allowlist: unlike a bare bypass, it
+ * still reads a valid config's `output.format`/`output.detail` like any
+ * other command, it just must not be aborted by one it cannot read (see
+ * `assembleInfo`'s doc comment, src/commands/sources/info.ts, for why).
+ * Every other command reads config exactly as before — a broken config
+ * throws here and the command never runs.
+ */
+export function isInfoCommand(argv) {
+    const userArgs = argv.slice(2);
+    const separator = userArgs.indexOf("--");
+    const args = separator === -1 ? userArgs : userArgs.slice(0, separator);
+    const commandIndex = findCittyTopLevelCommandIndex(args, MAIN_TOP_LEVEL_ARGS);
+    return (commandIndex >= 0 ? args[commandIndex] : undefined) === "info";
+}
 // ── Exit codes ──────────────────────────────────────────────────────────────
 // Canonical table lives in `src/cli/shared.ts` (EXIT_CODES). These aliases keep
 // the local call sites terse. EXIT_HEALTH_WARN (4) is the `akm health` "warn"
@@ -955,7 +986,34 @@ async function runCli() {
     try {
         applyEarlyStderrFlags(process.argv);
         const bypassConfig = shouldBypassConfigStartup(process.argv);
-        initOutputMode(process.argv, bypassConfig ? (DEFAULT_CONFIG.output ?? {}) : (loadConfig().output ?? {}));
+        // Off the bypass allowlist, every command reads config here exactly as
+        // it always has: an invalid config.json throws, `emitJsonError` reports
+        // it, and the command never runs — no side effect of its own body ever
+        // happens (a lock taken, a network call made, a database opened
+        // read-write). `akm info` is the ONE exception (see `assembleInfo`'s
+        // doc comment, src/commands/sources/info.ts): only ITS read is
+        // best-effort, falling back to `DEFAULT_CONFIG.output` instead of
+        // throwing. Scoped narrowly on purpose — an earlier version of this fix
+        // made the read best-effort for every command, which silently changed
+        // outcomes across the CLI (some commands that should refuse at exit 78
+        // ran anyway; `health`/`index`/`config set`/`feedback` still failed,
+        // but only after already taking a lock, opening a database read-write,
+        // or making a network call).
+        let outputDefaults = DEFAULT_CONFIG.output ?? {};
+        if (!bypassConfig) {
+            if (isInfoCommand(process.argv)) {
+                try {
+                    outputDefaults = loadConfig().output ?? {};
+                }
+                catch {
+                    outputDefaults = DEFAULT_CONFIG.output ?? {};
+                }
+            }
+            else {
+                outputDefaults = loadConfig().output ?? {};
+            }
+        }
+        initOutputMode(process.argv, outputDefaults);
     }
     catch (error) {
         emitJsonError(error);

package/dist/commands/agent/agent-dispatch.js

@@ -5,7 +5,7 @@ import { UsageError } from "../../core/errors.js";
 import { warn } from "../../core/warn.js";
 import { isPortableExecutionAgentSelector } from "../../execution/source.js";
 import { fallbackAnnouncement, NO_ENGINE_MESSAGE_SUFFIX, NO_ENGINE_REMEDY, withEngineFallback, } from "../../integrations/agent/engine-fallback.js";
-import { executeInteractiveAgentInvocation } from "../../integrations/agent/execution-lowering.js";
+import { executeInteractiveAgentInvocation } from "../../integrations/agent/runner-dispatch.js";
 import { executeCommandInvocation } from "../command/command-execution.js";
 function canonicalCurrent(options) {
     const current = {};

package/dist/commands/command/command-execution.js

@@ -1,31 +1,23 @@
 // 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 { ConfigError, UsageError } from "../../core/errors.js";
-import { cloneExecutionJsonObject } from "../../execution/json.js";
+import { UsageError } from "../../core/errors.js";
 import { createInlineResolvedCommand, createResolvedCommand, createResolvedPersona, } from "../../execution/resolved-request.js";
 import { isPortableExecutionAgentSelector, } from "../../execution/source.js";
 import { recordIndexedShowUsage } from "../../indexer/usage/show-usage.js";
 import { resolveUsageEventSource } from "../../indexer/usage/usage-events.js";
-import { fallbackAnnouncement, NO_ENGINE_MESSAGE_SUFFIX, NO_ENGINE_REMEDY, } from "../../integrations/agent/engine-fallback.js";
-import { requireAuthorizedExecutionPlan, } from "../../integrations/agent/execution-cascade.js";
-import { dispatchLoweredExecutionRequest, lowerResolvedExecutionRequest, } from "../../integrations/agent/execution-lowering.js";
-import { prepareResolvedExecution } from "../../integrations/agent/execution-preparation.js";
+import { fallbackAnnouncement } from "../../integrations/agent/engine-fallback.js";
+import { buildExecution, resolveExecution, } from "../../integrations/agent/execution.js";
+import { runExecution } from "../../integrations/agent/runner-dispatch.js";
 import { parseBuiltinCommandAction } from "./builtin-action.js";
 import { loadAdapterExecutionSource, } from "./execution-source-loader.js";
 import { applyPortableCommandArguments } from "./portable-template.js";
 /**
- * F-1 (spec §5.2 point 3): resolve the ambient-first provenance stamp
- * (matching the native arm's own `process.env.AKM_EVENT_SOURCE ?? …`) and
- * hand it to `dispatchLoweredExecutionRequest`'s dedicated, single-purpose
- * `eventSource` field — never through `runOptions`/`agentOptions`, which
- * stays exactly as untrusted for overriding resolved content as it was
- * before P1b (a caller-supplied `runOptions.env` still cannot replace frozen
- * request data, including a scheduler-restored directory value — see
- * `tests/integration/tasks-runner.test.ts`'s "forwards scheduled AKM
- * directory context … without trusting task or caller overrides").
+ * The ambient `AKM_EVENT_SOURCE` wins over the task runner's provenance; it
+ * rides `runExecution`'s single-purpose `eventSource`, never `runOptions.env`,
+ * so a caller cannot replace the request's own environment.
  */
-function loweredDispatchOptions(options) {
+function runOptionsFor(options) {
     const { eventSource, ...rest } = options;
     if (eventSource === undefined)
         return rest;
@@ -59,11 +51,7 @@ function qualifyCommandSelectedPersona(selector, command) {
         return selector;
     return `${command.identity.bundle}//${selector}`;
 }
-function snapshotCommandConfig(config, path = "command config") {
-    return cloneExecutionJsonObject(config, path);
-}
 export async function prepareCommandInvocation(options) {
-    const inputConfig = snapshotCommandConfig(options.config, "command input config");
     const action = parseBuiltinCommandAction(options.action);
     const sourceLoader = options.sourceLoader ?? defaultSourceLoader;
     let renderedCommand;
@@ -71,7 +59,7 @@ export async function prepareCommandInvocation(options) {
     let command;
     if (action.kind === "stored") {
         const rendered = await sourceLoader(action.ref, "command", {
-            config: inputConfig,
+            config: options.config,
             ...(options.sourceLookup ? { lookup: options.sourceLookup } : {}),
         });
         if (rendered.kind !== "command")
@@ -110,7 +98,7 @@ export async function prepareCommandInvocation(options) {
             ? qualifyCommandSelectedPersona(selectedAgent.value, renderedCommand)
             : selectedAgent.value;
         const rendered = await sourceLoader(lookupRef, "persona", {
-            config: inputConfig,
+            config: options.config,
             ...(options.sourceLookup ? { lookup: options.sourceLookup } : {}),
         });
         if (rendered.kind !== "persona")
@@ -118,10 +106,9 @@ export async function prepareCommandInvocation(options) {
         renderedPersona = rendered;
     }
     const persona = renderedPersona ? createResolvedPersona(renderedPersona) : selectedAgent.present ? null : undefined;
-    return prepareResolvedExecution({
+    return resolveExecution({
         command,
-        config: inputConfig,
-        invocationKind: options.invocationKind ?? "direct",
+        config: options.config,
         ...(persona !== undefined ? { persona } : {}),
         ...(renderedPersona ? { agentLayer: { id: renderedPersona.identity.ref, values: renderedPersona.defaults } } : {}),
         commandLayer: {
@@ -131,7 +118,6 @@ export async function prepareCommandInvocation(options) {
         ...(options.invocationDefaults ? { invocationDefaults: options.invocationDefaults } : {}),
         ...(options.current ? { current: options.current } : {}),
         ...(options.modelMap ? { modelMap: options.modelMap } : {}),
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
     });
 }
 function compareText(left, right) {
@@ -207,21 +193,6 @@ function safeDiagnosticNotice(notice) {
     if (!safeDiagnosticToken(notice.adapter))
         return undefined;
     switch (notice.code) {
-        case "engine-fallback":
-            return Object.freeze({
-                code: "engine-fallback",
-                severity: "info",
-                adapter: "akm",
-                field: "engine",
-                message: "No engine was selected; using the fixed opencode-sdk fallback.",
-            });
-        case "unrecognized-request-notice":
-            return Object.freeze({
-                code: "unrecognized-request-notice",
-                severity: "warning",
-                adapter: "akm",
-                message: "An unrecognized durable execution notice was omitted at the engine lowering boundary.",
-            });
         case "untranslated-field": {
             const field = canonicalDiagnosticNoticeField(notice.field);
             if (!field)
@@ -264,26 +235,20 @@ function diagnosticNotices(notices) {
     return Object.freeze([...canonical.values()].sort((left, right) => compareText(JSON.stringify(left), JSON.stringify(right))));
 }
 /**
- * Authorize and lower a prepared invocation, then project only safe structural
- * diagnostics. It never acquires a dispatch lease, materializes credentials,
- * records usage, or exposes request/plan values.
+ * Build a prepared invocation and project only safe structural diagnostics.
+ * Reads no credential, records no usage, and exposes no request values.
  */
 export function inspectPreparedCommandInvocation(prepared) {
-    const request = requireAuthorizedExecutionPlan(prepared.plan);
-    const lowered = lowerResolvedExecutionRequest(request, prepared.config);
-    const selectedEngine = request.engine.name;
-    if (!selectedEngine) {
-        throw new ConfigError(`command ${NO_ENGINE_MESSAGE_SUFFIX} ${NO_ENGINE_REMEDY}`, "INVALID_CONFIG_FILE");
-    }
-    return Object.freeze({
+    const built = buildExecution(prepared.request, prepared.runner);
+    return {
         schemaVersion: 1,
         shape: "command-dry-run",
         ok: true,
         dryRun: true,
-        engine: selectedEngine,
-        provenance: diagnosticProvenance(prepared.plan.provenance),
-        notices: diagnosticNotices(lowered.notices),
-    });
+        engine: prepared.request.engine.name,
+        provenance: diagnosticProvenance(prepared.provenance),
+        notices: diagnosticNotices(built.notices),
+    };
 }
 function resultEnvelope(result, engine, warnings, notices) {
     return {
@@ -302,13 +267,10 @@ function resultEnvelope(result, engine, warnings, notices) {
     };
 }
 export async function dispatchPreparedCommandInvocation(prepared, options = {}) {
-    const request = requireAuthorizedExecutionPlan(prepared.plan);
-    const lowered = lowerResolvedExecutionRequest(request, prepared.config);
+    const { request } = prepared;
+    const built = buildExecution(request, prepared.runner);
     const selectedEngine = request.engine.name;
-    if (!selectedEngine) {
-        throw new ConfigError(`command ${NO_ENGINE_MESSAGE_SUFFIX} ${NO_ENGINE_REMEDY}`, "INVALID_CONFIG_FILE");
-    }
-    const result = await dispatchLoweredExecutionRequest(lowered, loweredDispatchOptions(options));
+    const result = await runExecution(built, runOptionsFor(options));
     const consumedRefs = new Set();
     if (request.command.source)
         consumedRefs.add(request.command.source.ref);
@@ -322,7 +284,7 @@ export async function dispatchPreparedCommandInvocation(prepared, options = {})
     for (const ref of consumedRefs)
         recordIndexedShowUsage(ref, eventSource);
     const announcement = fallbackAnnouncement(prepared.fallbackEngineName, selectedEngine);
-    return resultEnvelope(result, selectedEngine, announcement ? [announcement] : [], lowered.notices);
+    return resultEnvelope(result, selectedEngine, announcement ? [announcement] : [], built.notices);
 }
 export async function executeCommandInvocation(options, dispatchOptions = {}) {
     return dispatchPreparedCommandInvocation(await prepareCommandInvocation(options), dispatchOptions);

package/dist/commands/feedback-cli.js

@@ -95,7 +95,6 @@ function appendLessonStrength(refInput, feedbackRef) {
     let mutationStarted = false;
     try {
         withWriteTargetMutation(resolved.target, [filePath], {
-            ignored: "reject",
             purpose: "feedback-lesson-credit",
             message: `Update ${makeBundleRef(bundleId, conceptId)}`,
         }, () => {

package/dist/commands/health/accept-rate.js

@@ -15,7 +15,7 @@
  * same read extended to the accepted/rejected archive.
  */
 import { resolveStashDir } from "../../core/common.js";
-import { isStaleTargetRejection } from "../proposal/proposal-types.js";
+import { isProceduralRejection } from "../proposal/proposal-types.js";
 import { listProposals } from "../proposal/repository.js";
 /**
  * Compute accept-rate-per-source metrics from the proposal store. Defaults to
@@ -32,7 +32,7 @@ export function computeAcceptRateBySource(stashDir) {
                 // A stale-target auto-reject (STALE, R20) is procedural, not a
                 // judgement on the content — counting it would understate the
                 // source's real accept rate for content the drain will re-propose.
-                if (status === "rejected" && isStaleTargetRejection(p))
+                if (status === "rejected" && isProceduralRejection(p))
                     continue;
                 const src = p.source || "(unknown)";
                 const entry = bySource.get(src) ?? { accepted: 0, rejected: 0, pending: 0 };