akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/integrations/lockfile.js

@@ -4,9 +4,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { writeFileAtomic } from "../core/common.js";
-import { ConfigError, rethrowIfTestIsolationError } from "../core/errors.js";
+import { ConfigError, rethrowIfTestIsolationError, TransientError } from "../core/errors.js";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "../core/file-lock.js";
-import { acquireMaintenanceBarrier } from "../core/maintenance-barrier.js";
 import { classifyPathAccess, describeInaccessiblePath } from "../core/path-access.js";
 import { getDataDir, getLockfileLockPath, getLockfilePath } from "../core/paths.js";
 import { warn } from "../core/warn.js";
@@ -27,23 +26,18 @@ async function acquireLockSentinel() {
     let delayMs = LOCK_RETRY_INITIAL_DELAY_MS;
     let announced = false;
     for (;;) {
-        const releaseBarrier = acquireMaintenanceBarrier();
-        try {
-            const ownership = tryAcquireLockSync(sentinelPath, createLockPayload());
-            if (ownership) {
-                return () => releaseLock(ownership);
-            }
-            const probe = probeLock(sentinelPath);
-            if (probe.state === "stale" && reclaimStaleLock(sentinelPath, probe)) {
-                continue; // Reclaimed — retry immediately.
-            }
+        const ownership = tryAcquireLockSync(sentinelPath, createLockPayload());
+        if (ownership) {
+            return () => releaseLock(ownership);
         }
-        finally {
-            releaseBarrier();
+        const probe = probeLock(sentinelPath);
+        if (probe.state === "stale" && reclaimStaleLock(sentinelPath, probe)) {
+            continue; // Reclaimed — retry immediately.
         }
-        // Another process holds the lock.
+        // Another process holds the lock: ordinary contention, exit 75, not a
+        // config error a supervisor should stop retrying on.
         if (Date.now() >= deadline) {
-            throw new ConfigError(`Could not acquire lockfile sentinel at ${sentinelPath} after ${(timeoutMs / 1000).toFixed(1)}s; refusing to write without exclusive ownership.`, "INVALID_CONFIG_FILE");
+            throw new TransientError(`Could not acquire lockfile sentinel at ${sentinelPath} after ${(timeoutMs / 1000).toFixed(1)}s; refusing to write without exclusive ownership.`, "LOCKFILE_CONTENDED");
         }
         if (!announced) {
             announced = true;
@@ -93,37 +87,33 @@ function assertLockfilePathReadable(target) {
         "records, and writing over them would destroy every bundle they track. Fix the ownership or mode of that " +
         "path (or point AKM_DATA_DIR / XDG_DATA_HOME somewhere this user owns) and retry.", "DATA_DIR_UNREADABLE");
 }
-function readLockfileSnapshotOrThrow() {
+/**
+ * Like {@link readLockfile}, but THROWS instead of silently degrading to `[]`
+ * when the on-disk lockfile exists yet cannot be read or parsed (R-012, #791).
+ *
+ * `readLockfile`'s fail-open contract is intentional for READ paths — a
+ * corrupt lock degrades a managed bundle to "unmanaged" rather than erroring
+ * every read-only command. But every writer below reads the current entries
+ * and writes the whole array back; if that read silently returned `[]` for a
+ * corrupt or unreadable file, the write would replace it with only the one
+ * entry being changed — permanently destroying every other lock record (a
+ * corrupt lockfile once wiped every entry this way). A missing file is NOT
+ * corruption: there is nothing to preserve, so that case returns `[]`.
+ */
+function readLockfileOrThrow() {
     const lockfilePath = getLockfilePath();
-    let fd;
     let raw;
-    let mode;
     try {
-        // One descriptor owns both byte and metadata observation so a rename or
-        // chmod between separate path-based calls cannot synthesize a generation
-        // that never existed on disk.
-        fd = fs.openSync(lockfilePath, "r");
-        raw = fs.readFileSync(fd, "utf8");
-        mode = fs.fstatSync(fd).mode & 0o777;
+        raw = fs.readFileSync(lockfilePath, "utf8");
     }
     catch (err) {
         rethrowIfTestIsolationError(err);
-        if (err.code === "ENOENT") {
-            return { entries: [], raw: null, mode: 0o600 };
-        }
-        // "Missing file" is the only failure with nothing to preserve. An
-        // UNREADABLE lockfile has everything to preserve and we cannot see it —
-        // degrading it to `[]` here is precisely the destructive overwrite this
-        // function was written to prevent, only triggered by a permission fault
-        // instead of a corrupt file (#791). Classify AFTER the failed read so the
-        // happy path costs no extra syscall and the answer describes the failure
-        // we actually got.
+        if (err.code === "ENOENT")
+            return [];
+        // An UNREADABLE lockfile has everything to preserve and we cannot see it.
+        // Classify AFTER the failed read so the happy path costs no extra syscall.
         assertLockfilePathReadable(lockfilePath);
-        return { entries: [], raw: null, mode: 0o600 };
-    }
-    finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
+        return [];
     }
     let parsed;
     try {
@@ -145,23 +135,7 @@ function readLockfileSnapshotOrThrow() {
         throw new ConfigError(`Refusing to modify lockfile ${lockfilePath}: ${invalid.length} existing entr${invalid.length === 1 ? "y is" : "ies are"} malformed. ` +
             "Fix or remove the file by hand before retrying — those entries would otherwise be lost.", "INVALID_CONFIG_FILE");
     }
-    return {
-        entries: parsed.filter(isValidLockfileEntry),
-        raw,
-        mode,
-    };
-}
-function readLockfileOrThrow() {
-    return readLockfileSnapshotOrThrow().entries;
-}
-/**
- * Read the exact lock generation that a source-lifecycle transaction may
- * replace. Unlike {@link readLockfile}, this refuses corrupt, malformed, or
- * unreadable state so an update can never treat state it could not snapshot as
- * an empty generation.
- */
-export function readLockfileForUpdate() {
-    return readLockfileSnapshotOrThrow();
+    return parsed;
 }
 /**
  * The materialized content root recorded in the lock for a managed (git/npm)
@@ -201,66 +175,44 @@ export async function writeLockfile(entries) {
         release();
     }
 }
-/**
- * Publish an update from one exact raw + parsed lockfile generation and return
- * the exact bytes that were written. Formatting-only concurrent edits are a
- * generation change here: rollback must never overwrite bytes it did not
- * publish merely because they parse to an equivalent array.
- */
-export async function publishLockfileUpdate(expected, desired) {
+export async function upsertLockEntry(entry) {
     const release = await acquireLockSentinel();
     try {
-        const current = readLockfileSnapshotOrThrow();
-        if (JSON.stringify(current.entries) !== JSON.stringify(expected.entries) ||
-            current.raw !== expected.raw ||
-            current.mode !== expected.mode) {
-            return null;
-        }
-        writeLockfileUnlocked(desired);
-        return readLockfileSnapshotOrThrow();
+        // R-012: readLockfileOrThrow (not readLockfile) — a corrupt/malformed
+        // lockfile must abort the upsert loudly rather than read as `[]` and get
+        // silently overwritten with just this one entry.
+        const entries = readLockfileOrThrow();
+        const withoutExisting = entries.filter((e) => e.id !== entry.id);
+        writeLockfileUnlocked([...withoutExisting, entry]);
     }
     finally {
         release();
     }
 }
-/** Restore an exact raw snapshot after verifying the exact generation we published. */
-export async function compareAndSwapLockfileSnapshot(expected, desired) {
+/**
+ * Rename a lock entry's id in place (D6 — `akm bundle rename`), keeping every
+ * other resolved field (`localRoot`, `resolvedVersion`, …) unchanged. Returns
+ * `true` when an entry for `oldId` existed and was renamed, `false` when
+ * there was nothing to rename (e.g. a filesystem bundle, which has no lock
+ * entry).
+ */
+export async function renameLockEntry(oldId, newId) {
     const release = await acquireLockSentinel();
     try {
-        const current = readLockfileSnapshotOrThrow();
-        if (JSON.stringify(current.entries) !== JSON.stringify(expected.entries) ||
-            current.raw !== expected.raw ||
-            current.mode !== expected.mode) {
+        // R-012: see upsertLockEntry — a corrupt lockfile must abort loudly
+        // rather than read as `[]` and get silently overwritten.
+        const entries = readLockfileOrThrow();
+        const existing = entries.find((e) => e.id === oldId);
+        if (!existing)
             return false;
-        }
-        const lockfilePath = getLockfilePath();
-        if (desired.raw === null) {
-            fs.rmSync(lockfilePath, { force: true });
-        }
-        else {
-            fs.mkdirSync(path.dirname(lockfilePath), { recursive: true });
-            writeFileAtomic(lockfilePath, desired.raw, desired.mode);
-        }
+        const renamed = entries.map((e) => (e.id === oldId ? { ...e, id: newId } : e));
+        writeLockfileUnlocked(renamed);
         return true;
     }
     finally {
         release();
     }
 }
-export async function upsertLockEntry(entry) {
-    const release = await acquireLockSentinel();
-    try {
-        // R-012: readLockfileOrThrow (not readLockfile) — a corrupt/malformed
-        // lockfile must abort the upsert loudly rather than read as `[]` and get
-        // silently overwritten with just this one entry.
-        const entries = readLockfileOrThrow();
-        const withoutExisting = entries.filter((e) => e.id !== entry.id);
-        writeLockfileUnlocked([...withoutExisting, entry]);
-    }
-    finally {
-        release();
-    }
-}
 export async function removeLockEntry(id) {
     // Returning early says "there is no lock record to remove", and the uninstall
     // that called us reports success on that basis. Only an absent data dir earns

package/dist/llm/client.js

@@ -101,10 +101,9 @@ function retryBackoffMs() {
  * narrating about a document) does not get misclassified as a provider
  * context-limit error (#496).
  *
- * Canonical home: `graph-extract.ts` re-exports this so the index-pass
- * graph extractor and the retry classifier (`isRetryable`) share one
- * definition — retrying a context overflow cannot shrink the input, so it
- * must never be retried.
+ * Canonical home: `structured-call.ts`'s failure classifier and the retry
+ * classifier (`isRetryable`) here share one definition — retrying a context
+ * overflow cannot shrink the input, so it must never be retried.
  */
 export function isContextSizeError(message) {
     const lower = message.toLowerCase();
@@ -117,12 +116,23 @@ export function isContextSizeError(message) {
         /exceeded|over.*limit|too.*long/.test(lower);
     return evidence;
 }
+/**
+ * Codes describing a failure to reach or get a usable response from the
+ * provider transport itself, as opposed to a malformed-but-received response
+ * (`parse_error`) or a request-shape rejection (`rate_limited`). Used by
+ * {@link isRetryable}, which additionally requires evidence the failure is
+ * transient. Not exported — its one external caller (batched LLM
+ * entity-graph extraction) was retired in 0.9.17-alpha.9.
+ */
+function isTransportFailure(err) {
+    return err.code === "provider_error" || err.code === "network_error" || err.code === "provider_html_error";
+}
 /**
  * Decide whether a first-attempt {@link LlmCallError} is eligible for a single
  * retry. Retryable: HTTP 5xx (`provider_error` with statusCode >= 500) and
  * `network_error` whose message looks like a transient connection drop.
- * NOT retryable: 4xx, `rate_limited` (429), `timeout`, `parse_error`, and
- * context-overflow-classified errors.
+ * NOT retryable: 4xx, `rate_limited` (429), `timeout`, `parse_error`,
+ * `provider_html_error`, and context-overflow-classified errors.
  *
  * The connection-drop heuristic covers the substrings emitted across runtimes
  * for a mid-flight socket close:
@@ -141,6 +151,8 @@ export function isContextSizeError(message) {
 function isRetryable(err) {
     if (isContextSizeError(err.message))
         return false;
+    if (!isTransportFailure(err))
+        return false;
     if (err.code === "provider_error") {
         return typeof err.statusCode === "number" && err.statusCode >= 500;
     }

package/dist/llm/embedders/deterministic.js

@@ -4,9 +4,8 @@
 /** Env var that switches the whole embedding facade into deterministic mode. */
 export const DETERMINISTIC_EMBED_ENV = "AKM_EMBED_DETERMINISTIC";
 /**
- * Vector width. Matches the default local model (`bge-small`, 384 dims) so the
- * index DB's embedding column and sqlite-vec table dimensions line up without
- * any extra config.
+ * Vector width. Matches the default local model (`bge-small`, 384 dims), so a
+ * deterministic index is the same shape as a default local one.
  */
 export const DETERMINISTIC_EMBED_DIM = 384;
 /**

package/dist/llm/embedders/profile.js

@@ -0,0 +1,71 @@
+// 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/.
+/**
+ * Embedding profile: the text an embedding model expects around a query and
+ * around a document. Retrieval models are trained with these prompts, and
+ * sending raw text costs recall — Qwen3-Embedding without its query
+ * instruction lost 0.096 nDCG@10 on the retrieval suite.
+ *
+ * Presets are matched on the model name; `embedding.queryTemplate` and
+ * `embedding.documentTemplate` override them (an empty string means none).
+ * `{text}` marks where the text goes; a template without it is a prefix.
+ */
+import { createHash } from "node:crypto";
+import { isDeterministicEmbedEnabled } from "./deterministic.js";
+import { DEFAULT_LOCAL_MODEL } from "./local.js";
+const RETRIEVAL_QUERY_PREFIX = "Represent this sentence for searching relevant passages: {text}";
+const PRESETS = [
+    {
+        model: /qwen3-embedding/i,
+        profile: {
+            queryTemplate: "Instruct: Given a question or task, retrieve the knowledge asset that helps with it\nQuery:{text}",
+        },
+    },
+    {
+        model: /nomic-embed/i,
+        profile: { queryTemplate: "search_query: {text}", documentTemplate: "search_document: {text}" },
+    },
+    {
+        model: /bge-(?:small|base|large)-en|mxbai-embed|arctic-embed/i,
+        profile: { queryTemplate: RETRIEVAL_QUERY_PREFIX },
+    },
+    {
+        model: /(?:^|[^a-z0-9])e5-(?:small|base|large)(?!.*instruct)/i,
+        profile: { queryTemplate: "query: {text}", documentTemplate: "passage: {text}" },
+    },
+];
+/** The model a config embeds with, as the presets match it. */
+function embeddingModelName(config) {
+    if (config?.endpoint)
+        return config.model ?? "";
+    return config?.localModel ?? DEFAULT_LOCAL_MODEL;
+}
+/** The configured model's templates: its preset, with each side replaced by an explicit config value. */
+export function resolveEmbeddingProfile(config) {
+    const model = embeddingModelName(config);
+    const preset = isDeterministicEmbedEnabled() ? {} : (PRESETS.find((entry) => entry.model.test(model))?.profile ?? {});
+    const queryTemplate = config?.queryTemplate ?? preset.queryTemplate;
+    const documentTemplate = config?.documentTemplate ?? preset.documentTemplate;
+    return {
+        ...(queryTemplate ? { queryTemplate } : {}),
+        ...(documentTemplate ? { documentTemplate } : {}),
+    };
+}
+/** Put `text` into `template`; no template returns the text unchanged. */
+export function applyEmbeddingTemplate(template, text) {
+    if (!template)
+        return text;
+    // A replacer function keeps `$&`-style sequences in the text literal.
+    return template.includes("{text}") ? template.replaceAll("{text}", () => text) : `${template}${text}`;
+}
+/**
+ * The document template's part of the embedding fingerprint: empty without a
+ * template, so vectors embedded without one stay current.
+ */
+export function documentTemplateFingerprint(config) {
+    const template = resolveEmbeddingProfile(config).documentTemplate;
+    if (!template)
+        return "";
+    return `|doc:${createHash("sha256").update(template).digest("hex").slice(0, 12)}`;
+}

package/dist/llm/embedders/remote.js

@@ -187,8 +187,7 @@ export function isContextExceededResponse(status, body) {
  * Resolve the effective in-flight request window for `RemoteEmbedder.embedBatch`.
  * Default (unset `embedding.concurrency`): 1 for a loopback endpoint, 2 for a
  * remote one, via the shared `defaultConcurrencyForEndpoint`
- * (`src/core/loopback.ts`), the same lowest-common-denominator rule
- * `getDefaultLlmConcurrency` (`src/indexer/indexer.ts`) uses.
+ * (`src/core/loopback.ts`).
  *
  * `embedding.concurrency` (#954) overrides this default in
  * either direction, bounded 1-16 at the config schema — added after field
@@ -428,7 +427,7 @@ export class RemoteEmbedder {
                 textBatches.splice(dispatchedBatchCount, textBatches.length - dispatchedBatchCount, ...replanned);
             }
             warnVerbose(`[embed] provider rejected a ${rejectedRequestTokens}-token request as over its context; request budget lowered to ${effectiveTokenBudget.toLocaleString()} for the rest of this run`);
-            commitBatch(rejectedIndices, rejectedIndices.map(() => undefined), undefined, {
+            commitBatch(rejectedIndices, rejectedIndices.map(() => undefined), {
                 batchIndex: rejectedBatchIndex,
                 batchCount: textBatches.length,
                 docCount: rejectedIndices.length,
@@ -471,7 +470,7 @@ export class RemoteEmbedder {
         // fabricated "batch-request-failed" skip (#954). Checked (and rethrown)
         // once the pool drains, the same way `signal?.aborted` is today.
         let firstOnBatchError;
-        const commitBatch = (indices, embeddings, model, outcome) => {
+        const commitBatch = (indices, embeddings, outcome) => {
             if (!onBatch)
                 return;
             // Once persistence has failed once, an already in-flight batch that
@@ -481,7 +480,7 @@ export class RemoteEmbedder {
             if (firstOnBatchError !== undefined)
                 return;
             try {
-                onBatch(indices, embeddings, model, outcome);
+                onBatch(indices, embeddings, outcome);
             }
             catch (err) {
                 firstOnBatchError = err;
@@ -523,16 +522,14 @@ export class RemoteEmbedder {
             const requestTimeoutMs = scaleEmbeddingTimeoutMs(configuredTimeoutMs, requestTokens, effectiveTokenBudget);
             const requestStart = Date.now();
             let batchEmbeddings;
-            let responseModel;
             let outcome;
             let failureReason;
             try {
-                const { vectors, model } = await this.requestBatch(batch, headers, ollamaOpts, requestTimeoutMs, signal);
+                const vectors = await this.requestBatch(batch, headers, ollamaOpts, requestTimeoutMs, signal);
                 for (let k = 0; k < indices.length; k++) {
                     results[indices[k]] = vectors[k];
                 }
                 batchEmbeddings = indices.map((i) => results[i]);
-                responseModel = model;
                 outcome = "stored";
             }
             catch (err) {
@@ -571,7 +568,7 @@ export class RemoteEmbedder {
                     // failed or succeeded yet, so there is nothing to persist:
                     // `embeddings` are all `undefined` and the materializer's onBatch
                     // must not touch storage for this event.
-                    commitBatch(indices, indices.map(() => undefined), undefined, {
+                    commitBatch(indices, indices.map(() => undefined), {
                         batchIndex,
                         batchCount: textBatches.length,
                         docCount: indices.length,
@@ -635,7 +632,7 @@ export class RemoteEmbedder {
                 outcome = "failed";
                 failureReason = message;
             }
-            commitBatch(indices, batchEmbeddings, responseModel, {
+            commitBatch(indices, batchEmbeddings, {
                 batchIndex,
                 batchCount: textBatches.length,
                 docCount: indices.length,
@@ -665,7 +662,7 @@ export class RemoteEmbedder {
                 // Never made a request — excluded from the default-level per-batch
                 // line (there is no request outcome to report), but still counted
                 // in the run's oversized-skip total via `onSkip` above.
-                commitBatch([idx], [undefined], undefined, {
+                commitBatch([idx], [undefined], {
                     batchIndex,
                     batchCount: textBatches.length,
                     docCount: 1,
@@ -701,11 +698,8 @@ export class RemoteEmbedder {
         return results;
     }
     /**
-     * Send one batch request and return its embeddings in input order, plus the
-     * server-reported `model` id when the response body carried one (#955) —
-     * used by the embedding-fingerprint canary to verify a config-string
-     * rename against what the endpoint actually served, not just re-assert the
-     * configured string. Throws on any failure.
+     * Send one batch request and return its embeddings in input order. Throws
+     * on any failure.
      *
      * `timeoutMs` is the caller's ALREADY-SCALED per-request timeout (#954
      * — see {@link scaleEmbeddingTimeoutMs}), not re-resolved here:
@@ -756,7 +750,7 @@ export class RemoteEmbedder {
             }
             results.push(l2Normalize(d.embedding));
         }
-        return { vectors: results, model: typeof json.model === "string" && json.model ? json.model : undefined };
+        return results;
     }
     buildHeaders() {
         const headers = { "Content-Type": "application/json" };

package/dist/llm/feature-gate.js

@@ -7,8 +7,6 @@
  */
 const FEATURE_LOCATION = {
     memory_inference: (cfg) => cfg.index?.memory?.enabled ?? true,
-    graph_extraction: (cfg) => cfg.index?.graph?.enabled ?? true,
-    metadata_enhance: (cfg) => cfg.index?.metadataEnhance?.enabled ?? false,
     // #951: a real implementation of the dead `curate_rerank` key removed in
     // 0.8.0. Off by default — it requires a `search.curateRerank.endpoint` a
     // caller must explicitly configure.
@@ -79,15 +77,9 @@ export function isProcessEnabled(section, processName, config) {
         return false;
     // Index passes are first-class 0.9 entries.
     if (section === "index") {
-        if (processName === "metadata_enhance" || processName === "metadataEnhance") {
-            return config.index?.metadataEnhance?.enabled ?? true;
-        }
         if (processName === "memory_inference" || processName === "memoryInference") {
             return isLlmFeatureEnabled(config, "memory_inference");
         }
-        if (processName === "graph_extraction" || processName === "graphExtraction") {
-            return isLlmFeatureEnabled(config, "graph_extraction");
-        }
     }
     return false;
 }

package/dist/llm/index-passes.js

@@ -3,8 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { warn } from "../core/warn.js";
 import { cloneExecutionJsonObject } from "../execution/json.js";
-import { lowerResolvedExecutionRequest } from "../integrations/agent/execution-lowering.js";
-import { prepareInlineExecution } from "../integrations/agent/inline-execution.js";
+import { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
 const NO_LOWERING_NOTICES = Object.freeze([]);
 function own(value, key) {
     return value !== undefined && Object.hasOwn(value, key);
@@ -39,14 +38,13 @@ export function resolveIndexPassExecution(passName, config) {
         ...indexExecutionDefaults(defaults),
         ...(!own(defaults, "engine") && fallbackLlmEngine ? { engine: fallbackLlmEngine } : {}),
     };
-    const prepared = prepareInlineExecution({
+    const prepared = resolveExecution({
         content: "",
         config,
-        invocationKind: "direct",
         invocationDefaults,
         current: indexExecutionDefaults(pass),
     });
-    const lowered = lowerResolvedExecutionRequest(prepared.request, prepared.config);
+    const lowered = buildExecution(prepared.request, prepared.runner);
     if (lowered.runner.kind !== "llm") {
         warn("[akm] Index pass %s requires an LLM engine; %s is not one. Skipping this pass.", passName, selectedEngine);
         return Object.freeze({ runner: undefined, notices: NO_LOWERING_NOTICES });

package/dist/llm/memory-infer.js

@@ -68,7 +68,7 @@ const DERIVED_MEMORY_JSON_SCHEMA = {
  * feature gate, error classification, and onFallback hook are honoured uniformly
  * (Fix C5).
  */
-export async function compressMemoryToDerivedMemory(llmRunner, body, signal, akmConfig, onFallback, telemetry, onRetryAttempt, onNotices, lease) {
+export async function compressMemoryToDerivedMemory(llmRunner, body, signal, akmConfig, onFallback, telemetry, onRetryAttempt, onNotices) {
     const trimmedBody = body.trim();
     if (!trimmedBody)
         return undefined;
@@ -83,7 +83,6 @@ export async function compressMemoryToDerivedMemory(llmRunner, body, signal, akm
         feature: "memory_inference",
         akmConfig,
         runner: llmRunner,
-        ...(lease ? { lease } : {}),
         messages: [
             { role: "system", content: SYSTEM_PROMPT },
             { role: "user", content: userPrompt },

package/dist/llm/structured-call.js

@@ -2,8 +2,8 @@
 // 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 } from "../core/errors.js";
-import { acquireLoweredExecutionDispatchLease, dispatchLoweredExecutionRequest, lowerResolvedExecutionRequestWithRunner, } from "../integrations/agent/execution-lowering.js";
-import { prepareInlineExecutionWithRunner } from "../integrations/agent/inline-execution.js";
+import { buildExecution, resolveExecution } from "../integrations/agent/execution.js";
+import { runExecution } from "../integrations/agent/runner-dispatch.js";
 import { isContextSizeError, LlmCallError } from "./client.js";
 import { isLlmFeatureEnabled, tryLlmFeature, } from "./feature-gate.js";
 /**
@@ -62,22 +62,6 @@ function dispatchFailure(result) {
     const message = result.error ?? result.stderr ?? result.reason ?? "LLM dispatch failed";
     return result.llmErrorCode ? new LlmCallError(message, result.llmErrorCode) : new Error(message);
 }
-/**
- * Validate one already-selected symbolic LLM runner before an operation makes
- * any durable mutation. Callers must apply their feature/authorization gates
- * first. Acquisition crosses the canonical prepare -> lower -> lease boundary,
- * so required credentials are snapshotted by the same central authority as a
- * real call without contacting the provider.
- */
-export async function preflightStructuredLlmRunner(runner) {
-    const prepared = prepareInlineExecutionWithRunner({
-        content: "Validate the selected LLM runner before operation dispatch.",
-        runner,
-        invocationKind: "direct",
-    });
-    const lowered = lowerResolvedExecutionRequestWithRunner(prepared.request, prepared.runner);
-    return acquireLoweredExecutionDispatchLease(lowered);
-}
 export async function callStructured(opts) {
     const { feature, akmConfig, enabled, messages, request, parse, onError, fallback, onFallback } = opts;
     // A disabled feature owns a true no-work path: it does not need a runner,
@@ -97,19 +81,16 @@ export async function callStructured(opts) {
     const terminal = requireTerminalUserMessage(messages);
     const prepareInvocation = () => {
         const current = resolveStructuredCurrent(opts.current, request);
-        const prepared = prepareInlineExecutionWithRunner({
+        const prepared = resolveExecution({
             content: terminal.content,
             conversation: terminal.conversation,
             runner,
-            invocationKind: "direct",
             ...(current ? { current } : {}),
-            ...(opts.authorizeTools ? { authorizeTools: opts.authorizeTools } : {}),
         });
-        const lowered = lowerResolvedExecutionRequestWithRunner(prepared.request, prepared.runner);
+        const lowered = buildExecution(prepared.request, prepared.runner);
         opts.onNotices?.(lowered.notices);
         return async () => {
-            const result = await dispatchLoweredExecutionRequest(lowered, {
-                ...(opts.lease ? { lease: opts.lease } : {}),
+            const result = await runExecution(lowered, {
                 ...(request?.chat ? { chat: request.chat } : {}),
                 ...(request?.onRetryAttempt ? { onRetryAttempt: request.onRetryAttempt } : {}),
                 ...(own(request, "signal") ? { runOptions: { signal: request?.signal } } : {}),

package/dist/output/generic-render.js

@@ -1,6 +1,29 @@
 // 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/.
+/**
+ * Generic `md` / `html` / `text` rendering of a shaped output envelope (D7).
+ *
+ * Every command gets `json`, `jsonl`, and `yaml` for free because those are
+ * serializations of the envelope rather than renderings of it. `md`, `html`,
+ * and `text` are renderings, and before D7 only `akm health` had `md`/`html`:
+ * `md` silently emitted the JSON envelope everywhere else and `html` threw.
+ * `text` had the same silent-JSON gap for any command with no registered
+ * text formatter, closed later than `md`/`html` — see `renderGenericText`
+ * below for why it is its own function rather than a reuse of
+ * `renderGenericMarkdown`.
+ *
+ * These functions close that gap structurally rather than per command. A
+ * command that registers a bespoke renderer (`akm health`) still wins; every
+ * other command falls back to a real rendering derived from whatever its
+ * envelope happens to contain. The shape is discovered, not declared, so a new
+ * command is covered the day it is added.
+ *
+ * Deliberately dependency-free apart from the shared detail types and
+ * `escapeHtml`: this module sits underneath the per-command renderer
+ * registries and must not import them.
+ */
+import { escapeHtml } from "./html-render.js";
 /**
  * True when `value` is a non-empty array of plain objects — the shape worth
  * rendering as a table rather than as a nested list. Uniformity is judged on
@@ -106,17 +129,6 @@ export function renderGenericMarkdown(command, value) {
     return `${rendered}\n`;
 }
 // ── HTML ─────────────────────────────────────────────────────────────────────
-const HTML_ESCAPES = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;",
-};
-/** Escape every value that reaches the document — this is untrusted content. */
-function escapeHtml(text) {
-    return text.replace(/[&<>"']/g, (char) => HTML_ESCAPES[char] ?? char);
-}
 function htmlTable(rows) {
     const columns = tableColumns(rows);
     if (columns.length === 0)