akm-cli 0.9.15 → 0.9.16-alpha.1

package/dist/llm/embedders/remote.js

@@ -17,16 +17,18 @@ import { warnVerbose } from "../../core/warn.js";
 import { resolveSecretFromStore } from "../../sources/snapshot-fetchers/secret-seam.js";
 /**
  * Upper bound on the number of documents in one HTTP request, independent of
- * the token budget below. Overridable via `config.batchSize`. Purely a
- * safety cap (very many tiny documents could otherwise pack one request) —
- * the token budget is what actually keeps a request inside the endpoint's
- * context window and inside the timeout (#874).
+ * the token budget below. Overridable via `packing.maxCount` (index
+ * redesign, B5 — the retired `embedding.batchSize` config key's replacement,
+ * sourced by `drain.ts` from the provider's own probed limits rather than
+ * config). Purely a safety cap (very many tiny documents could otherwise
+ * pack one request) — the token budget is what actually keeps a request
+ * inside the endpoint's context window and inside the timeout (#874).
  */
 export const DEFAULT_REMOTE_BATCH_SIZE = 100;
 /**
- * Conservative default token budget per HTTP request when the config gives
- * no better number (`maxTokens` — see #956 for why `contextLength`
- * no longer feeds this). #874's measurements:
+ * Conservative default token budget per HTTP request when no better number
+ * is known (`packing.tokenBudget`, sourced from `probeProviderLimits` —
+ * see {@link EmbeddingRequestPacking}). #874's measurements:
  * a batch of 100 small docs (~400 KB, ~100K tokens) took 14.8s against a
  * healthy local endpoint — half the 30s request timeout — and a single
  * 128 KB (~24K token) document alone was rejected by the endpoint as
@@ -45,38 +47,6 @@ export const DEFAULT_TOKEN_BUDGET = 6000;
 export function estimateTokenCount(text) {
     return Math.round(text.length / 4);
 }
-/**
- * Default per-document embedding cap (`embedding.maxInputTokens`, #956)
- * — the materializer truncates a document's embedded text to
- * this cap (head only) instead of skipping it outright, so one oversized
- * entry can no longer fail a whole batch. Fragments are not embedded at all
- * (only the entry's own search text is), so this is the only lever on how
- * much of a large document contributes to its vector.
- */
-export const DEFAULT_MAX_INPUT_TOKENS = 512;
-/**
- * Truncate `text` to at most `maxTokens` (estimated via
- * {@link estimateTokenCount}, the same 4-chars≈1-token rule the batching
- * budget uses), keeping only its head. The cut never splits a UTF-16
- * surrogate pair. Text already at or under the cap is returned unchanged
- * (`truncated: false`) — including empty text, which is never itself
- * "truncated".
- */
-export function capEmbeddingText(text, maxTokens) {
-    if (estimateTokenCount(text) <= maxTokens)
-        return { text, truncated: false };
-    const charBudget = Math.max(0, maxTokens * 4);
-    let cut = Math.min(charBudget, text.length);
-    if (cut > 0 && cut < text.length) {
-        const code = text.charCodeAt(cut);
-        // A low surrogate (0xDC00-0xDFFF) at the cut point means its high
-        // surrogate is the character just before it — back off one position so
-        // the pair stays together rather than yielding a lone surrogate.
-        if (code >= 0xdc00 && code <= 0xdfff)
-            cut -= 1;
-    }
-    return { text: text.slice(0, cut), truncated: true };
-}
 /**
  * Default per-request timeout when `embedding.timeoutMs` is unset (#954).
  * The prior fixed 30s cut off exactly the field-report case: a
@@ -194,9 +164,10 @@ export function isContextExceededResponse(status, body) {
  * either direction, bounded 1-16 at the config schema — added after field
  * evidence that a multi-slot local server (llama.cpp `--parallel N`, vLLM)
  * genuinely serves parallel requests and was left idle by the fixed default.
- * Request SIZE remains the first throughput lever regardless:
- * `embedding.batchSize` (document cap) and `embedding.maxTokens` (request
- * token budget — see #956; `contextLength` no longer feeds it)
+ * Request SIZE remains the first throughput lever regardless: the packed
+ * request's document count and token budget (`EmbeddingRequestPacking`,
+ * sourced from `probeProviderLimits` — the retired `embedding.batchSize`/
+ * `maxTokens`/`contextLength` config keys' replacement, index redesign B5)
  * reach a larger batch per request, which is where most of the win is for a
  * single-slot server — a 32-input batch takes about the same wall time as
  * one input against a healthy endpoint.
@@ -207,15 +178,22 @@ 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
- * silently blow the batch past the endpoint's context window (#874).
+ * Group `texts` into request-sized batches bounded by BOTH a token budget and
+ * a document-count cap, so one large document does not silently blow the
+ * batch past the endpoint's context window (#874).
+ *
+ * `tokenCounts[i]`, when given, is the count to use for `texts[i]` instead of
+ * {@link estimateTokenCount}'s fixed 4-chars≈1-token guess — `embedBatch`
+ * passes the calibrated `charsPerToken` estimate for every text
+ * (`EmbeddingRequestPacking.charsPerToken`, sourced from the provider's own
+ * probed limits). Omitted (or shorter than `texts`, e.g. a caller with no
+ * packing at all) falls back to the estimate for the texts it does not cover.
  *
- * A single document whose own estimate exceeds `tokenBudget` can never fit
- * any batch — it is reported as its own oversized "batch" so the caller can
- * skip it without ever making an HTTP request for it.
+ * A single document whose own count exceeds `tokenBudget` can never fit any
+ * batch — it is reported as its own oversized "batch" so the caller can skip
+ * it without ever making an HTTP request for it.
  */
-export function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
+export function buildTokenBoundedBatches(texts, tokenBudget, maxCount, tokenCounts) {
     const batches = [];
     let current = [];
     let currentTokens = 0;
@@ -227,7 +205,7 @@ export function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
         }
     };
     for (let i = 0; i < texts.length; i++) {
-        const tokens = estimateTokenCount(texts[i]);
+        const tokens = tokenCounts?.[i] ?? estimateTokenCount(texts[i]);
         if (tokens > tokenBudget) {
             flush();
             batches.push({ indices: [i], oversized: true });
@@ -247,16 +225,20 @@ export function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
  * context-size rejection of an `embedBatch` run (#954, field report on
  * beta.1): one 25% cut absorbs the estimator's measured undercount without
  * repeatedly re-shrinking mid-run — see the "shrink at most once" rule on
- * {@link RemoteEmbedder.embedBatch}.
+ * {@link RemoteEmbedder.embedBatch}. Only fires at all when the run's window
+ * is not already authoritative (`packing.windowIsKnown` false) — see
+ * {@link EmbeddingRequestPacking}.
  */
 const ADAPTIVE_BUDGET_SHRINK_FACTOR = 0.75;
 /**
- * Floor on the adaptive-budget shrink above, as a multiple of
- * `maxInputTokens` (#954): a request budget below twice the per-document cap
- * could no longer batch more than one document per request, defeating the
- * point of batching at all.
+ * Floor on the adaptive-budget shrink above (#954, revised by the index
+ * redesign's B5 — the retired `embedding.maxInputTokens` per-document cap no
+ * longer bounds a single document's size, so the floor is a fixed token
+ * count rather than a multiple of that cap): a request budget below this
+ * could no longer batch more than a couple of average-sized units per
+ * request, defeating the point of batching at all.
  */
-const ADAPTIVE_BUDGET_FLOOR_MULTIPLIER = 2;
+const ADAPTIVE_BUDGET_FLOOR_TOKENS = 1024;
 export class RemoteEmbedder {
     config;
     endpoint;
@@ -282,6 +264,9 @@ export class RemoteEmbedder {
         if (ollamaOpts) {
             body.options = ollamaOpts;
         }
+        if (isOllamaNativeEmbedEndpoint(this.endpoint)) {
+            body.truncate = false;
+        }
         const timeoutMs = resolveEmbeddingTimeoutMs(this.config);
         // `signal` MUST go through fetchWithTimeout's dedicated 4th parameter, not
         // the RequestInit: fetchWithTimeout replaces `opts.signal` with its own
@@ -362,40 +347,47 @@ export class RemoteEmbedder {
      * on a small batch rather than always waiting out the full configured
      * `embedding.timeoutMs`.
      *
-     * Run-scoped adaptive budget (#954, field report on beta.1): the FIRST
-     * context-size rejection of the run shrinks the effective request budget
-     * by {@link ADAPTIVE_BUDGET_SHRINK_FACTOR} (floored at
-     * {@link ADAPTIVE_BUDGET_FLOOR_MULTIPLIER} times `maxInputTokens`) for
-     * every batch not yet dispatched — the still-planned tail of `texts` is
-     * re-batched with `buildTokenBoundedBatches` at the smaller budget, and a
-     * `budget-lowered` `onBatch` event reports it once. This never touches the
-     * split-and-retry of the rejected batch itself (above), and never fires a
-     * second time in the same run even if a later batch is also rejected — a
-     * static configured budget that is simply too big for the endpoint should
-     * self-correct once, not ratchet down forever.
+     * Run-scoped adaptive budget (#954, field report on beta.1; gated by
+     * `packing.windowIsKnown` per the index redesign's B5): on the FIRST
+     * context-size rejection of the run, when the request window is NOT
+     * already an observed provider value (`packing.windowIsKnown` false/unset
+     * — the generic {@link DEFAULT_TOKEN_BUDGET}/8192-token default, or a
+     * caller with no packing at all), this shrinks the effective request
+     * budget by {@link ADAPTIVE_BUDGET_SHRINK_FACTOR} (floored at
+     * {@link ADAPTIVE_BUDGET_FLOOR_TOKENS}) for every batch not yet
+     * dispatched — the still-planned tail of `texts` is re-batched with
+     * `buildTokenBoundedBatches` at the smaller budget, and a
+     * `budget-lowered` `onBatch` event reports it once. A KNOWN window
+     * (llama.cpp/Ollama, probed via `probeProviderLimits`) is already
+     * authoritative, so a rejection against it is unexpected — split-and-retry
+     * (above) still recovers that one batch, but the run-wide budget is left
+     * alone rather than second-guessing a real number. This never touches the
+     * split-and-retry of the rejected batch itself, and never fires a second
+     * time in the same run even if a later batch is also rejected — a budget
+     * that is simply too big for the endpoint should self-correct once, not
+     * ratchet down forever.
      */
-    async embedBatch(texts, signal, onSkip, onBatch) {
+    async embedBatch(texts, signal, onSkip, onBatch, packing) {
         if (texts.length === 0)
             return [];
         const results = new Array(texts.length).fill(undefined);
         const headers = this.buildHeaders();
-        const ollamaOpts = resolveOllamaOptions(this.config);
-        // #956: `contextLength` is Ollama's `num_ctx` ONLY (see
-        // resolveOllamaOptions below) — it used to double as this client-side
-        // request budget too, so a config author setting it for one purpose
-        // silently changed the other. `maxTokens` is the sole knob for the
-        // request budget now; unset falls back to DEFAULT_TOKEN_BUDGET.
-        //
-        // `effectiveTokenBudget` (#954) starts at the configured/default value
-        // and MAY shrink once, on the run's first context-size rejection — see
-        // `maybeShrinkBudget` below. `textBatches` is mutated in place (spliced)
-        // by that shrink rather than reassigned, so the in-flight
+        const ollamaOpts = resolveOllamaOptions(this.config, packing?.ollamaNumCtx);
+        // Per-text counts from the calibrated chars-per-token ratio
+        // (`packing.charsPerToken`, sourced from the provider's own probed
+        // limits) rather than a per-text HTTP tokenize call — synchronous, so
+        // planning a corpus of any size costs no requests at all.
+        const tokenCounts = texts.map((text) => Math.ceil(text.length / (packing?.charsPerToken ?? 4)));
+        // `effectiveTokenBudget` (#954) starts at the probed/configured/default
+        // value and MAY shrink once, on the run's first context-size rejection —
+        // see `maybeShrinkBudget` below. `textBatches` is mutated in place
+        // (spliced) by that shrink rather than reassigned, so the in-flight
         // `concurrentMap` pool below (which reads this same array by reference)
         // picks up the re-planned tail without restarting.
-        let effectiveTokenBudget = this.config.maxTokens ?? DEFAULT_TOKEN_BUDGET;
-        const maxCount = this.config.batchSize ?? DEFAULT_REMOTE_BATCH_SIZE;
-        const maxInputTokens = this.config.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
-        const textBatches = buildTokenBoundedBatches(texts, effectiveTokenBudget, maxCount);
+        let effectiveTokenBudget = packing?.tokenBudget ?? DEFAULT_TOKEN_BUDGET;
+        const maxCount = packing?.maxCount ?? DEFAULT_REMOTE_BATCH_SIZE;
+        const windowIsKnown = packing?.windowIsKnown ?? false;
+        const textBatches = buildTokenBoundedBatches(texts, effectiveTokenBudget, maxCount, tokenCounts);
         const configuredTimeoutMs = resolveEmbeddingTimeoutMs(this.config);
         // How many of `textBatches` concurrentMap has already claimed (its own
         // `nextIndex`, mirrored here so a budget shrink knows where the
@@ -404,24 +396,28 @@ export class RemoteEmbedder {
         // order, so the highest `batchIndex` seen so far IS the claimed count.
         let dispatchedBatchCount = 0;
         // Set once the run's first context-size rejection has shrunk the budget
-        // (#954) — guards `maybeShrinkBudget` so it never fires twice.
-        let budgetShrunk = false;
+        // (#954) — guards `maybeShrinkBudget` so it never fires twice. Also true
+        // (so the shrink never fires at all) when the window is already known —
+        // see the method's doc comment.
+        let budgetShrunk = windowIsKnown;
         // On the FIRST context-size rejection of this `embedBatch` call, shrink
         // `effectiveTokenBudget` and re-plan every batch `concurrentMap` has not
         // yet claimed from the smaller budget. Never touches `rejectedIndices`
         // itself — the caller's own split-and-retry handles that batch — and is
-        // a no-op after the first call (`budgetShrunk`).
+        // a no-op after the first call (`budgetShrunk`) or when the window is
+        // already known (`windowIsKnown`, folded into `budgetShrunk`'s initial
+        // value above).
         const maybeShrinkBudget = (rejectedIndices, rejectedBatchIndex, rejectedRequestTokens) => {
             if (budgetShrunk)
                 return;
             budgetShrunk = true;
-            const floor = ADAPTIVE_BUDGET_FLOOR_MULTIPLIER * maxInputTokens;
-            effectiveTokenBudget = Math.max(Math.round(effectiveTokenBudget * ADAPTIVE_BUDGET_SHRINK_FACTOR), floor);
+            effectiveTokenBudget = Math.max(Math.round(effectiveTokenBudget * ADAPTIVE_BUDGET_SHRINK_FACTOR), ADAPTIVE_BUDGET_FLOOR_TOKENS);
             const notYetDispatched = textBatches.slice(dispatchedBatchCount);
             const remainingIndices = notYetDispatched.flatMap((batch) => batch.indices);
             if (remainingIndices.length > 0) {
                 const remainingTexts = remainingIndices.map((i) => texts[i]);
-                const replanned = buildTokenBoundedBatches(remainingTexts, effectiveTokenBudget, maxCount).map((batch) => ({
+                const remainingCounts = remainingIndices.map((i) => tokenCounts[i]);
+                const replanned = buildTokenBoundedBatches(remainingTexts, effectiveTokenBudget, maxCount, remainingCounts).map((batch) => ({
                     indices: batch.indices.map((localIndex) => remainingIndices[localIndex]),
                     oversized: batch.oversized,
                 }));
@@ -439,7 +435,7 @@ export class RemoteEmbedder {
             });
         };
         // Stops the pool from claiming any FURTHER provider batch once the
-        // caller's onBatch has failed once (the materializer's transaction
+        // caller's onBatch has failed once (the caller'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`,
@@ -463,7 +459,7 @@ export class RemoteEmbedder {
             }
         }
         // First error thrown BY the caller's onBatch callback (e.g. a real
-        // competing-process SQLITE_BUSY from the materializer's db.transaction())
+        // competing-process SQLITE_BUSY from the caller's own 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
@@ -519,7 +515,7 @@ export class RemoteEmbedder {
             if (dispatchAbort.signal.aborted)
                 return;
             const batch = indices.map((i) => texts[i]);
-            const requestTokens = batch.reduce((sum, text) => sum + estimateTokenCount(text), 0);
+            const requestTokens = indices.reduce((sum, i) => sum + tokenCounts[i], 0);
             const requestTimeoutMs = scaleEmbeddingTimeoutMs(configuredTimeoutMs, requestTokens, effectiveTokenBudget);
             const requestStart = Date.now();
             let batchEmbeddings;
@@ -569,8 +565,8 @@ export class RemoteEmbedder {
                     // verbose line above — a run silently waiting out a multi-minute
                     // back-off looked identical to a hang otherwise. Nothing has
                     // 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.
+                    // `embeddings` are all `undefined` and the caller's onBatch must
+                    // not touch storage for this event.
                     commitBatch(indices, indices.map(() => undefined), undefined, {
                         batchIndex,
                         batchCount: textBatches.length,
@@ -605,13 +601,12 @@ export class RemoteEmbedder {
                 // Default-level visibility for a failed batch (not verbose-only) is
                 // still guaranteed here — just not via warn(). The `commitBatch` call
                 // below carries `outcome: "failed"` and this `message` as `reason`
-                // through `onBatch`, and materialize-embeddings.ts's per-batch line
+                // through `onBatch`, and the caller's (`drain.ts`) per-batch line
                 // (also default-level) prints it from there. A warn() call here used
                 // to print the identical event a second time on stderr — the same
-                // class of double-print bug fixed for the truncation/re-embed-reason
-                // lines in materialize-embeddings.ts (#954, field-report follow-up).
-                // Per-entry batch-mapping detail stays verbose-only
-                // (materialize-embeddings.ts).
+                // class of double-print bug this once guarded against in the retired
+                // materialize-embeddings.ts (#954, field-report follow-up).
+                // Per-entry batch-mapping detail stays verbose-only (the caller).
                 let stopRequested = false;
                 for (const [k, idx] of indices.entries()) {
                     if (onSkip?.({
@@ -654,7 +649,7 @@ export class RemoteEmbedder {
             dispatchedBatchCount = batchIndex;
             if (textBatch.oversized) {
                 const idx = textBatch.indices[0];
-                const estTokens = estimateTokenCount(texts[idx]);
+                const estTokens = tokenCounts[idx];
                 onSkip?.({
                     index: idx,
                     reason: "context-window-exceeded",
@@ -724,6 +719,9 @@ export class RemoteEmbedder {
         if (ollamaOpts) {
             body.options = ollamaOpts;
         }
+        if (isOllamaNativeEmbedEndpoint(this.endpoint)) {
+            body.truncate = false;
+        }
         // See embed(): `signal` goes through the 4th parameter, not the
         // RequestInit, or fetchWithTimeout drops it.
         const response = await fetchWithTimeout(normalizeEmbeddingEndpoint(this.endpoint), {
@@ -816,6 +814,34 @@ export function normalizeEmbeddingEndpoint(endpoint) {
     parsed.pathname = normalizedPath ? `${normalizedPath}/embeddings` : "/embeddings";
     return parsed.toString();
 }
+/**
+ * True when `endpoint`'s normalized path is Ollama's native `/api/embed`
+ * route (see {@link normalizeEmbeddingEndpoint}) rather than an
+ * OpenAI-compatible `/embeddings` route. Gates `truncate: false` on the
+ * request body (round-2 field finding): akm never sent `truncate` at all, so
+ * Ollama's default — silently truncate an over-budget input and still return
+ * 200 — meant a unit denser than the calibrated chars-per-token ratio was
+ * embedded from a truncated prefix and stored as a complete, correct-looking
+ * vector: never counted `failed` or `skipped`, coverage reporting it done,
+ * that content's search quality silently degraded forever. `truncate: false`
+ * makes an over-budget request fail loudly instead, so it flows into the
+ * existing context-window handling (split-and-retry, ultimately a genuine
+ * `skipped` unit) rather than a silent truncation. Scoped to the native
+ * route specifically because that is the one shape this field evidence is
+ * about — an OpenAI-compatible endpoint ignores the unknown field either
+ * way, so this is not a safety boundary, just not sending an option that
+ * does nothing elsewhere.
+ */
+function isOllamaNativeEmbedEndpoint(endpoint) {
+    let parsed;
+    try {
+        parsed = new URL(normalizeEmbeddingEndpoint(endpoint));
+    }
+    catch {
+        return false;
+    }
+    return parsed.pathname.replace(/\/+$/, "").endsWith("/embed");
+}
 function embeddingEndpointPathHint(endpoint) {
     const normalizedEndpoint = normalizeEmbeddingEndpoint(endpoint);
     if (normalizedEndpoint !== endpoint) {
@@ -828,19 +854,22 @@ function embeddingEndpointPathHint(endpoint) {
  *
  * Resolution order:
  *   1. `ollamaOptions` — forwarded verbatim (explicit opt-in, takes precedence).
- *   2. `contextLength` — wrapped as `{ num_ctx: contextLength }`.
+ *   2. `ollamaNumCtx` — the caller-supplied, provider-probed native context
+ *      window (`ProviderLimits.ollamaNumCtx`, sourced from
+ *      `probeProviderLimits`, NOT the retired `embedding.contextLength`
+ *      config key), wrapped as `{ num_ctx: ollamaNumCtx }`.
  *   3. Neither set → returns `undefined` (no `options` field in the request body).
  *
  * These options are only meaningful for Ollama's native `/api/embed` endpoint.
  * OpenAI-compatible endpoints ignore unknown request fields, so passing them to
  * other providers is harmless but has no effect.
  */
-function resolveOllamaOptions(config) {
+function resolveOllamaOptions(config, ollamaNumCtx) {
     if (config.ollamaOptions && Object.keys(config.ollamaOptions).length > 0) {
         return config.ollamaOptions;
     }
-    if (config.contextLength) {
-        return { num_ctx: config.contextLength };
+    if (ollamaNumCtx) {
+        return { num_ctx: ollamaNumCtx };
     }
     return undefined;
 }

package/dist/llm/feature-gate.js

@@ -10,9 +10,11 @@ const FEATURE_LOCATION = {
     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
+    // 0.8.0, shipped in 0.9.15 wired to curate, then moved to search in 0.9.16
+    // (renamed `curate_rerank` → `search_rerank`; the pass was always meant for
+    // search). Off by default — it requires a `search.rerank.endpoint` a
     // caller must explicitly configure.
-    curate_rerank: (cfg) => Boolean(cfg.search?.curateRerank?.enabled),
+    search_rerank: (cfg) => Boolean(cfg.search?.rerank?.enabled),
     // Always on at the LLM-wrapper level. Enablement is decided ONCE at the
     // extract entry point (`akmExtract`): the `extract.enabled` process toggle
     // gates extract as a STAGE of `akm improve` (the active improve strategy, per

package/dist/llm/rerank-client.js

@@ -21,7 +21,7 @@
  * `relevance_score` descending and callers treat a missing index as
  * "unscored" (kept in its original relative position, after every scored
  * document). Deliberately independent of `EngineConfigSchema`'s "llm"/"agent"
- * kinds — see the comment on `CurateRerankConfigSchema` in
+ * kinds — see the comment on `SearchRerankConfigSchema` in
  * `core/config/schema/search.ts` for why.
  */
 import { fetchWithTimeout, readBodyWithByteCap } from "../core/common.js";
@@ -45,13 +45,13 @@ export class RerankCallError extends Error {
  * after every scored document (never dropped).
  *
  * Throws {@link RerankCallError} on any transport/parse failure — callers
- * that want a graceful fallback should use `tryLlmFeature("curate_rerank", ...)`
+ * that want a graceful fallback should use `tryLlmFeature("search_rerank", ...)`
  * (`llm/feature-gate.ts`), matching every other bounded in-tree LLM/rerank
  * call site.
  */
 export async function rerankDocuments(config, query, documents) {
     if (!config.endpoint) {
-        throw new RerankCallError("search.curateRerank.endpoint is not configured.", "provider_error");
+        throw new RerankCallError("search.rerank.endpoint is not configured.", "provider_error");
     }
     if (documents.length === 0)
         return [];

package/dist/output/shapes/passthrough.js

@@ -54,6 +54,7 @@ const PASSTHROUGH_COMMANDS = [
     "improve-report",
     "import",
     "index",
+    "index-status",
     "info",
     "lint",
     "list",

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

@@ -422,21 +422,13 @@ export function formatInitPlain(r) {
 }
 export function formatIndexPlain(r) {
     const indexResult = r;
-    let out = `Indexed ${indexResult.totalEntries ?? 0} entries from ${indexResult.directoriesScanned ?? 0} directories (mode: ${indexResult.mode ?? "unknown"})`;
+    let out = `Indexed ${indexResult.totalEntries ?? 0} entries from ${indexResult.sourcesScanned ?? 0} source${indexResult.sourcesScanned === 1 ? "" : "s"} (mode: ${indexResult.mode ?? "unknown"})`;
     const warnings = indexResult.warnings;
     if (Array.isArray(warnings) && warnings.length > 0) {
         out += `\nWarnings (${warnings.length}):`;
         for (const message of warnings)
             out += `\n  - ${String(message)}`;
     }
-    const notices = Array.isArray(indexResult.notices) ? indexResult.notices : [];
-    for (const notice of notices) {
-        const severity = notice.severity === "info" ? "info" : "warning";
-        const field = typeof notice.field === "string" ? ` field=${notice.field}` : "";
-        out +=
-            `\n  notice[${severity}] ${notice.code} adapter=${notice.adapter}${field}` +
-                (notice.message ? `: ${notice.message}` : "");
-    }
     const verification = indexResult.verification;
     if (verification?.ok === false && verification.message) {
         out += `\nVerification: ${String(verification.message)}`;
@@ -446,16 +438,30 @@ export function formatIndexPlain(r) {
         out +=
             `\nTiming: total ${timing.totalMs}ms` +
                 `, preflight ${timing.preflightMs}ms` +
-                `, walk ${timing.walkMs}ms` +
-                `, llm ${timing.llmMs}ms` +
+                `, source cache ${timing.sourceCacheMs}ms` +
+                `, reconcile ${timing.reconcileMs}ms` +
                 `, embeddings ${timing.embedMs}ms` +
-                `, fts ${timing.ftsMs}ms` +
                 `, finalize ${timing.finalizeMs}ms` +
-                `, clean ${timing.cleanMs}ms` +
                 `, end-to-end ${timing.endToEndMs}ms`;
     }
     return out;
 }
+/** Render `akm index status`'s `IndexStatusResponse` (src/commands/sources/index-status.ts). */
+export function formatIndexStatusPlain(r) {
+    const units = (r.units ?? {});
+    const lines = [
+        `Index: ${String(r.indexPath ?? "unknown")}`,
+        `Files: ${Number(r.files ?? 0)}`,
+        `Entries: ${Number(r.entries ?? 0)}`,
+        `Units: ${Number(units.total ?? 0)} total, ${Number(units.withVector ?? 0)} with a vector, ${Number(units.pending ?? 0)} pending`,
+        `Active identity: ${typeof r.activeIdentity === "string" ? r.activeIdentity : "none yet"}`,
+        `Last reconcile: ${typeof r.lastReconcileAt === "string" ? r.lastReconcileAt : "never"}`,
+        `Built at: ${typeof r.builtAt === "string" ? r.builtAt : "never"}`,
+    ];
+    if (typeof r.unreadable === "string")
+        lines.push(`Unreadable: ${r.unreadable}`);
+    return lines.join("\n");
+}
 export function formatListPlain(r) {
     const sources = Array.isArray(r.sources) ? r.sources : [];
     if (sources.length === 0)

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, formatModelsListPlain, 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, formatIndexStatusPlain, 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/index.js

@@ -1,5 +1,8 @@
 // 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 { formatIndexPlain } from "./helpers.js";
-export const indexFormatters = [{ command: "index", handler: (r) => formatIndexPlain(r) }];
+import { formatIndexPlain, formatIndexStatusPlain } from "./helpers.js";
+export const indexFormatters = [
+    { command: "index", handler: (r) => formatIndexPlain(r) },
+    { command: "index-status", handler: (r) => formatIndexStatusPlain(r) },
+];