akm-cli 0.9.16-alpha.1 → 0.9.16-alpha.2

package/dist/llm/embedders/remote.js

@@ -17,18 +17,16 @@ 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 `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).
+ * 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).
  */
 export const DEFAULT_REMOTE_BATCH_SIZE = 100;
 /**
- * Conservative default token budget per HTTP request when no better number
- * is known (`packing.tokenBudget`, sourced from `probeProviderLimits` —
- * see {@link EmbeddingRequestPacking}). #874's measurements:
+ * 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:
  * 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
@@ -47,6 +45,38 @@ 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
@@ -164,10 +194,9 @@ 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: 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)
+ * 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)
  * 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.
@@ -178,22 +207,15 @@ export function resolveEmbeddingConcurrency(config) {
     return defaultConcurrencyForEndpoint(config.endpoint);
 }
 /**
- * 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.
+ * 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).
  *
- * 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.
+ * 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.
  */
-export function buildTokenBoundedBatches(texts, tokenBudget, maxCount, tokenCounts) {
+export function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
     const batches = [];
     let current = [];
     let currentTokens = 0;
@@ -205,7 +227,7 @@ export function buildTokenBoundedBatches(texts, tokenBudget, maxCount, tokenCoun
         }
     };
     for (let i = 0; i < texts.length; i++) {
-        const tokens = tokenCounts?.[i] ?? estimateTokenCount(texts[i]);
+        const tokens = estimateTokenCount(texts[i]);
         if (tokens > tokenBudget) {
             flush();
             batches.push({ indices: [i], oversized: true });
@@ -225,20 +247,16 @@ export function buildTokenBoundedBatches(texts, tokenBudget, maxCount, tokenCoun
  * 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}. Only fires at all when the run's window
- * is not already authoritative (`packing.windowIsKnown` false) — see
- * {@link EmbeddingRequestPacking}.
+ * {@link RemoteEmbedder.embedBatch}.
  */
 const ADAPTIVE_BUDGET_SHRINK_FACTOR = 0.75;
 /**
- * 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.
+ * 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.
  */
-const ADAPTIVE_BUDGET_FLOOR_TOKENS = 1024;
+const ADAPTIVE_BUDGET_FLOOR_MULTIPLIER = 2;
 export class RemoteEmbedder {
     config;
     endpoint;
@@ -264,9 +282,6 @@ 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
@@ -347,47 +362,40 @@ 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; 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.
+     * 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.
      */
-    async embedBatch(texts, signal, onSkip, onBatch, packing) {
+    async embedBatch(texts, signal, onSkip, onBatch) {
         if (texts.length === 0)
             return [];
         const results = new Array(texts.length).fill(undefined);
         const headers = this.buildHeaders();
-        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
+        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
         // `concurrentMap` pool below (which reads this same array by reference)
         // picks up the re-planned tail without restarting.
-        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);
+        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);
         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
@@ -396,28 +404,24 @@ 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. Also true
-        // (so the shrink never fires at all) when the window is already known —
-        // see the method's doc comment.
-        let budgetShrunk = windowIsKnown;
+        // (#954) — guards `maybeShrinkBudget` so it never fires twice.
+        let budgetShrunk = false;
         // 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`) or when the window is
-        // already known (`windowIsKnown`, folded into `budgetShrunk`'s initial
-        // value above).
+        // a no-op after the first call (`budgetShrunk`).
         const maybeShrinkBudget = (rejectedIndices, rejectedBatchIndex, rejectedRequestTokens) => {
             if (budgetShrunk)
                 return;
             budgetShrunk = true;
-            effectiveTokenBudget = Math.max(Math.round(effectiveTokenBudget * ADAPTIVE_BUDGET_SHRINK_FACTOR), ADAPTIVE_BUDGET_FLOOR_TOKENS);
+            const floor = ADAPTIVE_BUDGET_FLOOR_MULTIPLIER * maxInputTokens;
+            effectiveTokenBudget = Math.max(Math.round(effectiveTokenBudget * ADAPTIVE_BUDGET_SHRINK_FACTOR), floor);
             const notYetDispatched = textBatches.slice(dispatchedBatchCount);
             const remainingIndices = notYetDispatched.flatMap((batch) => batch.indices);
             if (remainingIndices.length > 0) {
                 const remainingTexts = remainingIndices.map((i) => texts[i]);
-                const remainingCounts = remainingIndices.map((i) => tokenCounts[i]);
-                const replanned = buildTokenBoundedBatches(remainingTexts, effectiveTokenBudget, maxCount, remainingCounts).map((batch) => ({
+                const replanned = buildTokenBoundedBatches(remainingTexts, effectiveTokenBudget, maxCount).map((batch) => ({
                     indices: batch.indices.map((localIndex) => remainingIndices[localIndex]),
                     oversized: batch.oversized,
                 }));
@@ -435,7 +439,7 @@ export class RemoteEmbedder {
             });
         };
         // Stops the pool from claiming any FURTHER provider batch once the
-        // caller's onBatch has failed once (the caller's transaction
+        // 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`,
@@ -459,7 +463,7 @@ export class RemoteEmbedder {
             }
         }
         // First error thrown BY the caller's onBatch callback (e.g. a real
-        // competing-process SQLITE_BUSY from the caller's own db.transaction())
+        // 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
@@ -515,7 +519,7 @@ export class RemoteEmbedder {
             if (dispatchAbort.signal.aborted)
                 return;
             const batch = indices.map((i) => texts[i]);
-            const requestTokens = indices.reduce((sum, i) => sum + tokenCounts[i], 0);
+            const requestTokens = batch.reduce((sum, text) => sum + estimateTokenCount(text), 0);
             const requestTimeoutMs = scaleEmbeddingTimeoutMs(configuredTimeoutMs, requestTokens, effectiveTokenBudget);
             const requestStart = Date.now();
             let batchEmbeddings;
@@ -565,8 +569,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 caller's onBatch must
-                    // not touch storage for this event.
+                    // `embeddings` are all `undefined` and the materializer's onBatch
+                    // must not touch storage for this event.
                     commitBatch(indices, indices.map(() => undefined), undefined, {
                         batchIndex,
                         batchCount: textBatches.length,
@@ -601,12 +605,13 @@ 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 the caller's (`drain.ts`) per-batch line
+                // through `onBatch`, and materialize-embeddings.ts's 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 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).
+                // 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).
                 let stopRequested = false;
                 for (const [k, idx] of indices.entries()) {
                     if (onSkip?.({
@@ -649,7 +654,7 @@ export class RemoteEmbedder {
             dispatchedBatchCount = batchIndex;
             if (textBatch.oversized) {
                 const idx = textBatch.indices[0];
-                const estTokens = tokenCounts[idx];
+                const estTokens = estimateTokenCount(texts[idx]);
                 onSkip?.({
                     index: idx,
                     reason: "context-window-exceeded",
@@ -719,9 +724,6 @@ 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), {
@@ -814,34 +816,6 @@ 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) {
@@ -854,22 +828,19 @@ function embeddingEndpointPathHint(endpoint) {
  *
  * Resolution order:
  *   1. `ollamaOptions` — forwarded verbatim (explicit opt-in, takes precedence).
- *   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 }`.
+ *   2. `contextLength` — wrapped as `{ num_ctx: contextLength }`.
  *   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, ollamaNumCtx) {
+function resolveOllamaOptions(config) {
     if (config.ollamaOptions && Object.keys(config.ollamaOptions).length > 0) {
         return config.ollamaOptions;
     }
-    if (ollamaNumCtx) {
-        return { num_ctx: ollamaNumCtx };
+    if (config.contextLength) {
+        return { num_ctx: config.contextLength };
     }
     return undefined;
 }

package/dist/llm/feature-gate.js

@@ -10,11 +10,9 @@ 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, 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
+    // 0.8.0. Off by default — it requires a `search.curateRerank.endpoint` a
     // caller must explicitly configure.
-    search_rerank: (cfg) => Boolean(cfg.search?.rerank?.enabled),
+    curate_rerank: (cfg) => Boolean(cfg.search?.curateRerank?.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 `SearchRerankConfigSchema` in
+ * kinds — see the comment on `CurateRerankConfigSchema` 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("search_rerank", ...)`
+ * that want a graceful fallback should use `tryLlmFeature("curate_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.rerank.endpoint is not configured.", "provider_error");
+        throw new RerankCallError("search.curateRerank.endpoint is not configured.", "provider_error");
     }
     if (documents.length === 0)
         return [];

package/dist/output/shapes/passthrough.js

@@ -54,7 +54,6 @@ const PASSTHROUGH_COMMANDS = [
     "improve-report",
     "import",
     "index",
-    "index-status",
     "info",
     "lint",
     "list",
@@ -72,7 +71,9 @@ const PASSTHROUGH_COMMANDS = [
     "setup",
     "sync",
     "task-add",
+    "task-disable",
     "task-doctor",
+    "task-enable",
     "task-explain",
     "task-history",
     "task-prune",

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

@@ -422,13 +422,21 @@ export function formatInitPlain(r) {
 }
 export function formatIndexPlain(r) {
     const indexResult = r;
-    let out = `Indexed ${indexResult.totalEntries ?? 0} entries from ${indexResult.sourcesScanned ?? 0} source${indexResult.sourcesScanned === 1 ? "" : "s"} (mode: ${indexResult.mode ?? "unknown"})`;
+    let out = `Indexed ${indexResult.totalEntries ?? 0} entries from ${indexResult.directoriesScanned ?? 0} directories (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)}`;
@@ -438,30 +446,16 @@ export function formatIndexPlain(r) {
         out +=
             `\nTiming: total ${timing.totalMs}ms` +
                 `, preflight ${timing.preflightMs}ms` +
-                `, source cache ${timing.sourceCacheMs}ms` +
-                `, reconcile ${timing.reconcileMs}ms` +
+                `, walk ${timing.walkMs}ms` +
+                `, llm ${timing.llmMs}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, formatIndexStatusPlain, 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, 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,8 +1,5 @@
 // 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, formatIndexStatusPlain } from "./helpers.js";
-export const indexFormatters = [
-    { command: "index", handler: (r) => formatIndexPlain(r) },
-    { command: "index-status", handler: (r) => formatIndexStatusPlain(r) },
-];
+import { formatIndexPlain } from "./helpers.js";
+export const indexFormatters = [{ command: "index", handler: (r) => formatIndexPlain(r) }];