akm-cli 0.9.14 → 0.9.15-beta.1

package/dist/llm/embedder.js

@@ -100,32 +100,44 @@ async function embedOnce(text, embeddingConfig, signal) {
  * skipped and why; the result array holds `undefined` at those indices.
  * Uses the LocalEmbedder.embedBatch path for the local transformer pipeline,
  * which processes texts in chunks of 32 for genuine batched inference.
+ *
+ * `onBatch`, when given, fires once per provider/local batch as it completes
+ * (#954) so a caller can commit each batch's rows durably as they land
+ * rather than buffering the whole call — see `EmbeddingBatchCommit`.
  */
-export async function embedBatch(texts, embeddingConfig, signal, onSkip) {
-    if (embedderOverrides?.embedBatch)
-        return embedderOverrides.embedBatch(texts, embeddingConfig, signal);
+export async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch) {
+    if (embedderOverrides?.embedBatch) {
+        return embedderOverrides.embedBatch(texts, embeddingConfig, signal, onSkip, onBatch);
+    }
     if (texts.length === 0)
         return [];
     // Deterministic mode (env-gated, test/bench only): model-free, stable.
     if (isDeterministicEmbedEnabled()) {
-        return texts.map((t) => deterministicEmbed(t));
+        const embeddings = texts.map((t) => deterministicEmbed(t));
+        // One onBatch commit for the whole call, like the local/remote batched
+        // paths — firing once per text opened one materializer transaction per
+        // entry in deterministic (test/bench) mode.
+        onBatch?.(embeddings.map((_embedding, i) => i), embeddings);
+        return embeddings;
     }
     if (embeddingConfig && hasRemoteEndpoint(embeddingConfig)) {
-        return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal, onSkip);
+        return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal, onSkip, onBatch);
     }
     // Local transformer: use the batched path (chunks of 32 via LocalEmbedder).
     // When a localModel override is set we cannot share the singleton (which uses
     // the default model), so fall back to per-text embedWithModel in that case.
     const localModel = embeddingConfig?.localModel;
     if (!localModel) {
-        return getLocalEmbedder().embedBatch(texts, signal);
+        return getLocalEmbedder().embedBatch(texts, signal, onBatch);
     }
     const results = [];
-    for (const text of texts) {
+    for (const [i, text] of texts.entries()) {
         if (signal?.aborted) {
             throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
         }
-        results.push(await getLocalEmbedder().embedWithModel(text, localModel));
+        const embedding = await getLocalEmbedder().embedWithModel(text, localModel);
+        results.push(embedding);
+        onBatch?.([i], [embedding]);
     }
     return results;
 }

package/dist/llm/embedders/local.js

@@ -81,8 +81,13 @@ export class LocalEmbedder {
      * Embed a batch of texts. Processes in chunks of `LOCAL_BATCH_SIZE` (32) so
      * the transformers pipeline can run genuine batched inference rather than one
      * call per text. Each chunk is checked against the AbortSignal between calls.
+     *
+     * `onBatch`, when given, fires once per chunk (indices into `texts` + the
+     * chunk's embeddings) as it completes (#954) — parity with
+     * `RemoteEmbedder.embedBatch`'s per-provider-batch commit callback, so a
+     * caller committing per batch does not need to special-case the local path.
      */
-    async embedBatch(texts, signal) {
+    async embedBatch(texts, signal, onBatch) {
         if (texts.length === 0)
             return [];
         if (signal?.aborted) {
@@ -109,9 +114,12 @@ export class LocalEmbedder {
             if (batch !== chunk.length || batchResult.data.length !== batch * dim) {
                 throw new Error("unexpected pipeline return shape for batch input");
             }
+            const chunkEmbeddings = [];
             for (let row = 0; row < chunk.length; row++) {
-                results.push(Array.from(batchResult.data.subarray(row * dim, (row + 1) * dim)));
+                chunkEmbeddings.push(Array.from(batchResult.data.subarray(row * dim, (row + 1) * dim)));
             }
+            results.push(...chunkEmbeddings);
+            onBatch?.(Array.from({ length: chunk.length }, (_, row) => i + row), chunkEmbeddings);
         }
         return results;
     }

package/dist/llm/embedders/remote.js

@@ -8,7 +8,9 @@
  * vectors so the scoring pipeline's L2-to-cosine conversion is correct.
  */
 import { fetchWithTimeout, isHttpUrl, readBodyWithByteCap } from "../../core/common.js";
+import { concurrentMap } from "../../core/concurrent.js";
 import { resolveSecret } from "../../core/config/config.js";
+import { defaultConcurrencyForEndpoint } from "../../core/loopback.js";
 import { redactErrorBody, redactSensitiveText } from "../../core/redaction.js";
 import { warnVerbose } from "../../core/warn.js";
 import { resolveSecretFromStore } from "../../sources/snapshot-fetchers/secret-seam.js";
@@ -34,6 +36,47 @@ export const DEFAULT_TOKEN_BUDGET = 8000;
 export function estimateTokenCount(text) {
     return Math.round(text.length / 4);
 }
+/**
+ * Distinguishes a batch rejected because it exceeded the endpoint's context
+ * window from every other failure mode (network error, 5xx, malformed
+ * response). Only this error class triggers the split-in-half retry in
+ * {@link RemoteEmbedder.embedBatch} (#954) — anything else keeps the
+ * original skip-the-whole-batch behavior pinned by
+ * tests/integration/embedding-batch-partial-failure.test.ts.
+ */
+export class ContextExceededError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ContextExceededError";
+    }
+}
+/** Patterns providers use to report a request too large for the model's context window. */
+const CONTEXT_EXCEEDED_PATTERN = /exceed_context_size_error|context size|context length|too many tokens/i;
+/**
+ * True when an HTTP failure means "this request's input is too large for the
+ * endpoint's context window" rather than some other failure. HTTP 413
+ * (Payload Too Large) is always treated this way regardless of body; other
+ * status codes are checked against known provider error-body phrasing.
+ */
+export function isContextExceededResponse(status, body) {
+    if (status === 413)
+        return true;
+    return CONTEXT_EXCEEDED_PATTERN.test(body);
+}
+/**
+ * Resolve the effective in-flight request window for `RemoteEmbedder.embedBatch`.
+ * FIXED — no config override: 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. The actual throughput knob is request
+ * SIZE, not request count: `embedding.batchSize` (document cap) and
+ * `embedding.maxTokens`/`contextLength` (token budget) reach a larger batch
+ * per request, which is where most of the win is — a 32-input batch takes
+ * about the same wall time as one input against a healthy endpoint.
+ */
+export function resolveEmbeddingConcurrency(config) {
+    return defaultConcurrencyForEndpoint(config.endpoint);
+}
 /**
  * Group `texts` into request-sized batches bounded by BOTH an estimated
  * token budget and a document-count cap, so one large document does not
@@ -130,8 +173,34 @@ export class RemoteEmbedder {
      * `onSkip` (index into `texts` + a named reason) rather than silently
      * dropped; the returned array holds `undefined` at every skipped index.
      * A caller abort (`signal.aborted`) still propagates as a rejection.
+     *
+     * Provider batches are dispatched through a bounded pool sized by
+     * `resolveEmbeddingConcurrency` (#954) instead of strictly sequentially, so
+     * request latency overlaps. `onBatch`, when given, fires once per provider
+     * batch (success or skip) as it completes, only after that batch's own
+     * outcome has already been classified — pass it to commit each batch's
+     * rows durably as they land rather than buffering the whole call.
+     * Completion order does not matter to `results` placement, which is always
+     * written by index regardless of dispatch order. A throw from `onBatch`
+     * itself (e.g. the caller's own commit failing) is never mistaken for a
+     * provider/network failure; it is captured and rethrown once every batch
+     * has been dispatched, alongside the `signal.aborted` check. The FIRST
+     * `onBatch` throw also stops the pool from dispatching any further
+     * provider request (#954 gap fix) — a persistence failure means every
+     * later batch's result can never be committed either, so there is no
+     * point paying for more HTTP requests; a batch already in flight when this
+     * happens is left to finish (never network-aborted) but its result is
+     * discarded rather than committed.
+     *
+     * A batch rejected specifically for exceeding the endpoint's context window
+     * (HTTP 413, or a recognised context-size error body — see
+     * {@link isContextExceededResponse}) is split in half and retried
+     * recursively rather than skipped outright, down to individual documents; a
+     * single document that still fails this way becomes a genuine
+     * `context-window-exceeded` skip. Every other failure (network error, 5xx,
+     * malformed response) keeps the original skip-the-whole-batch behavior.
      */
-    async embedBatch(texts, signal, onSkip) {
+    async embedBatch(texts, signal, onSkip, onBatch) {
         if (texts.length === 0)
             return [];
         const results = new Array(texts.length).fill(undefined);
@@ -139,40 +208,134 @@ export class RemoteEmbedder {
         const ollamaOpts = resolveOllamaOptions(this.config);
         const tokenBudget = this.config.maxTokens ?? this.config.contextLength ?? DEFAULT_TOKEN_BUDGET;
         const maxCount = this.config.batchSize ?? DEFAULT_REMOTE_BATCH_SIZE;
-        const batches = buildTokenBoundedBatches(texts, tokenBudget, maxCount);
-        for (const textBatch of batches) {
-            if (textBatch.oversized) {
-                const idx = textBatch.indices[0];
-                const estTokens = estimateTokenCount(texts[idx]);
-                onSkip?.({
-                    index: idx,
-                    reason: "context-window-exceeded",
-                    message: `Document estimated at ${estTokens} tokens exceeds the ${tokenBudget}-token embedding budget; skipped.`,
-                });
-                continue;
+        const textBatches = buildTokenBoundedBatches(texts, tokenBudget, maxCount);
+        // Stops the pool from claiming any FURTHER provider batch once the
+        // caller's onBatch has failed once (the materializer's transaction
+        // failed, so a subsequent commit would just fail again) — dispatching
+        // real HTTP requests whose results can never be persisted is pure waste.
+        // Deliberately a SEPARATE controller from the caller's own `signal`,
+        // chained one-way to it: aborting this one must never cancel an
+        // in-flight request's own network call (it is left to finish and its
+        // result is discarded, not persisted), and a genuine caller abort must
+        // still surface below as the caller's own abort reason, not this
+        // internal one.
+        const dispatchAbort = new AbortController();
+        const stopDispatch = (reason) => {
+            if (!dispatchAbort.signal.aborted)
+                dispatchAbort.abort(reason);
+        };
+        let callerAbortListener;
+        if (signal) {
+            if (signal.aborted)
+                stopDispatch(signal.reason);
+            else {
+                callerAbortListener = () => stopDispatch(signal.reason);
+                signal.addEventListener("abort", callerAbortListener, { once: true });
+            }
+        }
+        // First error thrown BY the caller's onBatch callback (e.g. a real
+        // competing-process SQLITE_BUSY from the materializer's db.transaction())
+        // rather than by requestBatch itself. Captured here instead of being left
+        // to reach requestAndCommit's try/catch below, which exists solely to
+        // classify requestBatch's own provider/network failures — a persistence
+        // failure must never be caught by that block and misreported as a
+        // 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) => {
+            if (!onBatch)
+                return;
+            // Once persistence has failed once, an already in-flight batch that
+            // finishes afterward has nowhere safe to land — its result is
+            // discarded rather than retried into a transaction that will fail
+            // again (see the dispatch-stop comment above).
+            if (firstOnBatchError !== undefined)
+                return;
+            try {
+                onBatch(indices, embeddings, model);
+            }
+            catch (err) {
+                firstOnBatchError = err;
+                stopDispatch(err);
             }
-            const batch = textBatch.indices.map((i) => texts[i]);
+        };
+        // Requests a single provider batch (by index list), recursing on a
+        // context-size rejection. Never throws except to propagate a genuine
+        // caller abort — every other outcome (success or a non-abort failure)
+        // resolves normally after reporting via onSkip/onBatch. `onBatch` fires
+        // only once this try/catch has already settled success vs. failure, so a
+        // throw from it is never caught and reclassified by this block.
+        const requestAndCommit = async (indices) => {
+            const batch = indices.map((i) => texts[i]);
+            let batchEmbeddings;
+            let responseModel;
             try {
-                const embeddings = await this.requestBatch(batch, headers, ollamaOpts, signal);
-                for (let k = 0; k < textBatch.indices.length; k++) {
-                    results[textBatch.indices[k]] = embeddings[k];
+                const { vectors, model } = await this.requestBatch(batch, headers, ollamaOpts, signal);
+                for (let k = 0; k < indices.length; k++) {
+                    results[indices[k]] = vectors[k];
                 }
+                batchEmbeddings = indices.map((i) => results[i]);
+                responseModel = model;
             }
             catch (err) {
                 // A caller abort must still propagate — it is not a "this batch
                 // failed" condition, it means stop entirely.
                 if (signal?.aborted)
                     throw err;
+                if (err instanceof ContextExceededError && indices.length > 1) {
+                    const mid = Math.ceil(indices.length / 2);
+                    await requestAndCommit(indices.slice(0, mid));
+                    await requestAndCommit(indices.slice(mid));
+                    return;
+                }
                 const message = err instanceof Error ? err.message : String(err);
+                const reason = err instanceof ContextExceededError ? "context-window-exceeded" : "batch-request-failed";
                 warnVerbose(`[embed] batch of ${batch.length} document(s) failed and was skipped: ${message}`);
-                for (const idx of textBatch.indices) {
-                    onSkip?.({ index: idx, reason: "batch-request-failed", message });
+                for (const idx of indices) {
+                    onSkip?.({ index: idx, reason, message });
                 }
+                batchEmbeddings = indices.map(() => undefined);
+            }
+            commitBatch(indices, batchEmbeddings, responseModel);
+        };
+        const runProviderBatch = async (textBatch) => {
+            if (textBatch.oversized) {
+                const idx = textBatch.indices[0];
+                const estTokens = estimateTokenCount(texts[idx]);
+                onSkip?.({
+                    index: idx,
+                    reason: "context-window-exceeded",
+                    message: `Document estimated at ${estTokens} tokens exceeds the ${tokenBudget}-token embedding budget; skipped.`,
+                });
+                commitBatch([idx], [undefined]);
+                return;
             }
+            await requestAndCommit(textBatch.indices);
+        };
+        const concurrency = resolveEmbeddingConcurrency(this.config);
+        // concurrentMap swallows a thrown fn (per-item, results discarded here —
+        // requestAndCommit only throws to signal a caller abort), so abort must
+        // be re-checked once the pool has drained rather than relying on the
+        // throw itself to escape. Dispatch is gated on `dispatchAbort`, not the
+        // caller's `signal` directly — see the comment above.
+        await concurrentMap(textBatches, runProviderBatch, concurrency, { signal: dispatchAbort.signal });
+        if (callerAbortListener)
+            signal?.removeEventListener("abort", callerAbortListener);
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+        }
+        if (firstOnBatchError !== undefined) {
+            throw firstOnBatchError instanceof Error ? firstOnBatchError : new Error(String(firstOnBatchError));
         }
         return results;
     }
-    /** Send one batch request and return its embeddings in input order. Throws on any failure. */
+    /**
+     * 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.
+     */
     async requestBatch(batch, headers, ollamaOpts, signal) {
         const body = {
             input: batch,
@@ -197,7 +360,11 @@ export class RemoteEmbedder {
                     throw err;
                 return "";
             });
-            throw new Error(`Embedding batch request failed (${response.status}): ${this.safeErrorBody(respBody)}`);
+            const message = `Embedding batch request failed (${response.status}): ${this.safeErrorBody(respBody)}`;
+            if (isContextExceededResponse(response.status, respBody)) {
+                throw new ContextExceededError(message);
+            }
+            throw new Error(message);
         }
         const json = JSON.parse(await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: 30_000, signal }));
         if (!json.data || json.data.length !== batch.length) {
@@ -212,7 +379,7 @@ export class RemoteEmbedder {
             }
             results.push(l2Normalize(d.embedding));
         }
-        return results;
+        return { vectors: results, model: typeof json.model === "string" && json.model ? json.model : undefined };
     }
     buildHeaders() {
         const headers = { "Content-Type": "application/json" };

package/dist/output/shapes/helpers.js

@@ -2,6 +2,21 @@
 // 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/.
 export const NORMAL_DESCRIPTION_LIMIT = 250;
+const FRAGMENT_PROVENANCE_FIELDS = [
+    "selectedRef",
+    "parentRef",
+    "fragmentOrdinal",
+    "fragmentCount",
+    "startLine",
+    "endLine",
+    "previousRef",
+    "nextRef",
+    "fragmentChars",
+    "fragmentEstimatedTokens",
+    "parentChars",
+    "parentEstimatedTokens",
+];
+const FRAGMENT_CONTEXT_FIELDS = ["contextMode", "contextMaxChars", "contextTruncated"];
 export function shapeProposalProducerOutput(result, detail) {
     if (result.ok === false) {
         const base = {
@@ -268,8 +283,21 @@ export function shapeSearchHit(hit, detail) {
     // Stash hit (local or remote)
     // `ref` is included at `brief` so agents can run `akm show <ref>` without
     // needing --detail full or --shape agent (REC-03).
-    if (detail === "brief")
-        return pickFields(hit, ["type", "name", "ref", "action", "estimatedTokens", "keys"]);
+    if (detail === "brief") {
+        return pickFields(hit, [
+            "type",
+            "name",
+            "ref",
+            "action",
+            "estimatedTokens",
+            "keys",
+            "selectedRef",
+            "parentRef",
+            "fragmentOrdinal",
+            "fragmentCount",
+            "parentEstimatedTokens",
+        ]);
+    }
     if (detail === "normal") {
         // `warnings` is projected at `normal` so non-fatal hit-level issues are
         // visible without forcing callers up to `--detail full`. Optional
@@ -288,6 +316,7 @@ export function shapeSearchHit(hit, detail) {
             "warnings",
             "quality",
             "matchStage",
+            ...FRAGMENT_PROVENANCE_FIELDS,
         ]), NORMAL_DESCRIPTION_LIMIT);
         if (Array.isArray(hit.keys) && hit.keys.length > 0)
             shaped.keys = hit.keys;
@@ -314,6 +343,7 @@ export function shapeSearchHitForAgent(hit) {
         // hit (a strict-AND match is stronger signal than an OR-fallback
         // recovery match) without going to `--detail full`.
         "matchStage",
+        ...FRAGMENT_PROVENANCE_FIELDS,
     ]);
     if (picked.editable !== false)
         delete picked.editHint;
@@ -360,6 +390,8 @@ export function shapeShowOutput(result, detail, shape = "human") {
             "steps",
             "keys",
             "related",
+            ...FRAGMENT_PROVENANCE_FIELDS,
+            ...FRAGMENT_CONTEXT_FIELDS,
         ]);
         if (shaped.editable !== false)
             delete shaped.editHint;
@@ -382,6 +414,8 @@ export function shapeShowOutput(result, detail, shape = "human") {
             "origin",
             "keys",
             "related",
+            ...FRAGMENT_PROVENANCE_FIELDS,
+            ...FRAGMENT_CONTEXT_FIELDS,
         ]);
     }
     const base = pickFields(result, [
@@ -409,6 +443,8 @@ export function shapeShowOutput(result, detail, shape = "human") {
         "activeRun",
         "keys",
         "related",
+        ...FRAGMENT_PROVENANCE_FIELDS,
+        ...FRAGMENT_CONTEXT_FIELDS,
         // ref, path, and editable are always projected — at every --detail level,
         // not just --detail full — so JSON consumers can locate and edit the
         // asset without needing --detail full (QA #7 / D-14).

package/dist/output/shapes/models-list.js

@@ -0,0 +1,16 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+export const modelsListShapes = [
+    {
+        command: "models-list",
+        handler: (result) => {
+            const r = result;
+            return {
+                ...r,
+                shape: r.shape ?? "models-list",
+                schemaVersion: r.schemaVersion ?? 1,
+            };
+        },
+    },
+];

package/dist/output/shapes/passthrough.js

@@ -43,6 +43,7 @@ const PASSTHROUGH_COMMANDS = [
     "clone",
     "command-dry-run",
     "config",
+    "config-diff",
     "env-create",
     "env-export",
     "env-remove",
@@ -50,6 +51,7 @@ const PASSTHROUGH_COMMANDS = [
     "extract",
     "health",
     "improve",
+    "improve-report",
     "import",
     "index",
     "info",

package/dist/output/shapes.js

@@ -22,6 +22,7 @@ import { curateShapes } from "./shapes/curate.js";
 import { envListShapes } from "./shapes/env-list.js";
 import { eventsShapes } from "./shapes/events.js";
 import { migrateShapes } from "./shapes/migrate.js";
+import { modelsListShapes } from "./shapes/models-list.js";
 import { passthroughShapes } from "./shapes/passthrough.js";
 import { proposalAcceptShapes } from "./shapes/proposal/accept.js";
 import { proposalDiffShapes } from "./shapes/proposal/diff.js";
@@ -55,6 +56,7 @@ const BUILT_IN_OUTPUT_SHAPES = [
     ...envListShapes,
     ...secretListShapes,
     ...migrateShapes,
+    ...modelsListShapes,
     // Passthrough commands are registered last so an explicit dedicated handler
     // above always wins over the identity-stamp fallback for the same name.
     ...passthroughShapes,
@@ -94,6 +96,8 @@ const LIST_RESULT_COLLECTION_KEYS = {
     "workflow-list": "runs",
     "task-history": "rows",
     "log-list": "events", // `akm log list`
+    "config-diff": "rows", // `akm config diff`
+    "models-list": "rows", // `akm models list`
 };
 function withResultsAlias(command, shaped) {
     const key = LIST_RESULT_COLLECTION_KEYS[command];

package/dist/output/text/command-format.js

@@ -478,6 +478,35 @@ export function formatListPlain(r) {
     lines.push("To search: akm search '<query>'  |  To view an asset: akm show <ref>");
     return lines.join("\n");
 }
+/** Render `akm models list`'s `{ rows }` as a column-aligned table (#946). */
+export function formatModelsListPlain(r) {
+    const rows = Array.isArray(r.rows) ? r.rows : [];
+    if (rows.length === 0)
+        return "No model aliases configured.";
+    const headers = ["ALIAS", "COLUMN", "MODEL", "SOURCE", "VIA", "ENGINE"];
+    const cells = rows.map((row) => [
+        String(row.alias ?? "?"),
+        String(row.column ?? "?"),
+        String(row.model ?? "?"),
+        String(row.source ?? "?"),
+        String(row.via ?? "?"),
+        row.engine !== undefined ? String(row.engine) : "-",
+    ]);
+    const widths = headers.map((header, i) => {
+        let width = header.length;
+        for (const cols of cells) {
+            const cell = cols[i];
+            if (cell !== undefined && cell.length > width)
+                width = cell.length;
+        }
+        return width;
+    });
+    const renderRow = (cols) => cols
+        .map((cell, i) => cell.padEnd(widths[i] ?? cell.length))
+        .join("  ")
+        .trimEnd();
+    return [renderRow(headers), ...cells.map(renderRow)].join("\n");
+}
 /** Render a single `SourceEntry` — `akm bundle show <name>`'s detail view of one `list` row. */
 export function formatBundleShowPlain(r) {
     const name = typeof r.name === "string" ? r.name : "unknown";

package/dist/output/text/helpers.js

@@ -15,7 +15,7 @@
  *
  * No registry imports — no circular dependencies.
  */
-export { formatAddPlain, formatBundleShowPlain, formatClonePlain, formatConfigPlain, formatCuratePlain, formatEnvCreatePlain, formatEnvExportPlain, formatEnvListPlain, formatEnvRemovePlain, formatEventLine, formatEventsPlain, formatFeedbackPlain, formatImportPlain, formatIndexPlain, formatInfoPlain, formatInitPlain, formatListPlain, formatRegistryAddPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, formatRememberPlain, formatRemovePlain, formatSearchPlain, formatSyncPlain, formatUpdatePlain, formatUpgradePlain, } from "./command-format.js";
+export { formatAddPlain, formatBundleShowPlain, formatClonePlain, formatConfigPlain, formatCuratePlain, formatEnvCreatePlain, formatEnvExportPlain, formatEnvListPlain, formatEnvRemovePlain, formatEventLine, formatEventsPlain, formatFeedbackPlain, formatImportPlain, formatIndexPlain, formatInfoPlain, formatInitPlain, formatListPlain, formatModelsListPlain, formatRegistryAddPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, formatRememberPlain, formatRemovePlain, formatSearchPlain, formatSyncPlain, formatUpdatePlain, formatUpgradePlain, } from "./command-format.js";
 export { formatHealthPlain } from "./health-format.js";
 export { formatLintPlain } from "./lint-format.js";
 export { formatGateDecisionSummary, formatProposalAcceptPlain, formatProposalDiffPlain, formatProposalDrainPlain, formatProposalListPlain, formatProposalProducerPlain, formatProposalRejectPlain, formatProposalShowPlain, } from "./proposal-format.js";

package/dist/output/text/improve-report.js

@@ -0,0 +1,27 @@
+// 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/.
+/**
+ * #944 — `akm improve report --format text`. Renders the SAME fixed-width
+ * table `formatUsageReportTable` produces for the end-of-run stderr summary
+ * (`improve-cli.ts`), prefixed with which run(s) it covers.
+ */
+import { formatUsageReportTable } from "../../commands/improve/improve-usage-report.js";
+function formatImproveReportPlain(result) {
+    const usageReport = result.usageReport;
+    if (!usageReport)
+        return null;
+    const lines = [];
+    if (result.mode === "since") {
+        const runIds = Array.isArray(result.runIds) ? result.runIds : [];
+        lines.push(`[improve] report since ${String(result.since ?? "?")} (${runIds.length} run${runIds.length === 1 ? "" : "s"})`);
+    }
+    else {
+        lines.push(`[improve] report for run ${String(result.runId ?? "?")}${result.strategy ? ` (strategy: ${result.strategy})` : ""}`);
+    }
+    lines.push(formatUsageReportTable(usageReport, result.notes));
+    return lines.join("\n");
+}
+export const improveReportFormatters = [
+    { command: "improve-report", handler: (r) => formatImproveReportPlain(r) },
+];

package/dist/{commands/env/marker-path.js → output/text/models.js}

@@ -1,6 +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/.
-export function sensitiveMarkerPath(assetPath, type) {
-    return type === "env" ? assetPath.replace(/\.env$/, ".sensitive") : `${assetPath}.sensitive`;
-}
+import { formatModelsListPlain } from "./helpers.js";
+export const modelsFormatters = [
+    { command: "models-list", handler: (r) => formatModelsListPlain(r) },
+];

package/dist/output/text/show-format.js

@@ -14,6 +14,10 @@ export function formatShowPlain(r, detail) {
         lines.push(`# origin: ${String(r.origin)}`);
     if (r.action)
         lines.push(`# ${String(r.action)}`);
+    if (Array.isArray(r.keys)) {
+        const keys = r.keys.map(String);
+        lines.push(keys.length > 0 ? `keys: ${keys.join(", ")}` : "(no keys)");
+    }
     if (r.description)
         lines.push(`description: ${String(r.description)}`);
     if (r.workflowTitle)

package/dist/output/text.js

@@ -12,11 +12,13 @@ import { eventsFormatters } from "./text/events.js";
 import { feedbackFormatters } from "./text/feedback.js";
 import { healthFormatters } from "./text/health.js";
 import { importFormatters } from "./text/import.js";
+import { improveReportFormatters } from "./text/improve-report.js";
 import { indexFormatters } from "./text/index.js";
 import { infoFormatters } from "./text/info.js";
 import { lintFormatters } from "./text/lint.js";
 import { listFormatters } from "./text/list.js";
 import { migrateFormatters } from "./text/migrate.js";
+import { modelsFormatters } from "./text/models.js";
 import { proposalProducerFormatters } from "./text/proposal/producer.js";
 import { proposalFormatters } from "./text/proposal/proposal.js";
 import { getTextFormatterHandler, registerTextFormatters } from "./text/registry.js";
@@ -54,6 +56,7 @@ const BUILT_IN_TEXT_FORMATTERS = [
     ...proposalProducerFormatters,
     ...infoFormatters,
     ...healthFormatters,
+    ...improveReportFormatters,
     ...lintFormatters,
     ...configFormatters,
     ...feedbackFormatters,
@@ -63,6 +66,7 @@ const BUILT_IN_TEXT_FORMATTERS = [
     ...registryCommandFormatters,
     ...envFormatters,
     ...migrateFormatters,
+    ...modelsFormatters,
 ];
 registerTextFormatters(BUILT_IN_TEXT_FORMATTERS);
 // ── JSONL output (unchanged — not part of the formatPlain dispatch) ───────────