akm-cli 0.9.15-beta.3 → 0.9.15-beta.5

package/dist/indexer/materialize-embeddings.js

@@ -12,6 +12,7 @@ import { purgeEmbeddingSalvage, relabelEmbeddingSalvageFingerprint, reuseSalvage
 import { getEmbeddableEntryCount } from "../storage/repositories/index-entries-repository.js";
 import { deleteMeta, getMeta, setMeta } from "../storage/repositories/index-meta-repository.js";
 import { getAllEntriesForEmbedding, getEmbeddingCount, isVecFastPathComplete, isVecFastPathReady, purgeEmbeddings, sampleEmbeddedEntriesForCanary, setVecFastPathReady, upsertEmbedding, } from "../storage/repositories/index-vec-repository.js";
+import { reclassifyIndexDbContention } from "./index-db-contention.js";
 /** Identifies the embedding provider+model+dimension a stored vector was generated with. */
 export function deriveSemanticProviderFingerprint(embedding) {
     if (isDeterministicEmbedEnabled()) {
@@ -732,7 +733,20 @@ export async function generateEmbeddingsForDb(db, config, onProgress, signal, en
         }
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+        // Field follow-up to #956 (dev-team field review 2026-09-10): a
+        // contention-shaped error (another akm process writing index.db right
+        // now) used to escape this catch as a raw driver string ("database is
+        // locked"), reaching this user-facing message unclassified even though
+        // the acquisition-time path (`akmIndex`'s outer catch) already
+        // reclassifies the same shape into `TransientError("INDEX_DB_CONTENDED")`.
+        // Reuses that ONE shared classifier rather than a second one — see
+        // `index-db-contention.ts`. This catch stays non-fatal (a caller sees
+        // `success: false` and a message, never a thrown error): the run
+        // continues through the remaining index phases exactly as it did
+        // before, only the message is now classified when the error is
+        // contention-shaped.
+        const reclassified = reclassifyIndexDbContention(error);
+        const message = reclassified instanceof Error ? reclassified.message : String(reclassified);
         warn("Embedding generation failed, continuing without:", message);
         onProgress({ phase: "embeddings", message: `Embedding generation failed: ${message}` });
         return {

package/dist/integrations/agent/model-map.js

@@ -26,6 +26,18 @@ let standaloneInstalledModelMapText;
 const ENGINE_KEY_PATTERN = new RegExp(ENGINE_NAME_PATTERN_SOURCE);
 const ALIAS_KEY_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 const RESERVED_MAP_KEYS = new Set(["__proto__", "constructor", "prototype", "tostring"]);
+/**
+ * A profile's own field names (#946). When one of these appears directly
+ * under an alias — e.g. `"fast": { "engine": "local-fast" }` — it is not a
+ * per-platform column named `model`/`inference`/`engine`; it is a wildcard
+ * default profile applied to every platform column of that alias, exactly
+ * the flat shorthand the original proposal asked for. A nested per-platform
+ * entry in the same alias (`"fast": { "claude": { ... } }`) still overrides
+ * the wildcard for that one column, so both forms compose.
+ */
+const PROFILE_FIELD_KEYS = new Set(["model", "inference", "engine"]);
+/** Internal key the wildcard default profile is stored under (never user-writable directly). */
+export const WILDCARD_ENGINE_KEY = "*";
 function assertSafeMapKey(key, source, jsonPath) {
     if (RESERVED_MAP_KEYS.has(key.toLowerCase())) {
         invalid(source, jsonPath, "reserved prototype-like key is not allowed");
@@ -137,7 +149,18 @@ export function parseModelMapLayer(text, source) {
         }
         const engines = [];
         const enginesSeen = new Map();
-        for (const [rawEngine, rawProfile] of Object.entries(engineRecord)) {
+        const wildcardFields = {};
+        const platformEntries = [];
+        for (const [rawKey, rawValue] of Object.entries(engineRecord)) {
+            if (PROFILE_FIELD_KEYS.has(rawKey))
+                wildcardFields[rawKey] = rawValue;
+            else
+                platformEntries.push([rawKey, rawValue]);
+        }
+        if (Object.keys(wildcardFields).length > 0) {
+            engines.push([WILDCARD_ENGINE_KEY, parseProfileLayer(wildcardFields, source, `$.aliases.${rawAlias}`)]);
+        }
+        for (const [rawEngine, rawProfile] of platformEntries) {
             const engine = rawEngine.toLowerCase();
             assertSafeMapKey(engine, source, `$.aliases.${rawAlias}.${rawEngine}`);
             if (!ENGINE_KEY_PATTERN.test(engine)) {
@@ -238,6 +261,18 @@ function mergeRawProfileLayers(installed, user) {
     const apply = (layer) => {
         for (const [alias, layerEngines] of Object.entries(layer.aliases)) {
             const mergedEngines = aliases.get(alias) ?? new Map();
+            const wildcard = ownValue(layerEngines, WILDCARD_ENGINE_KEY);
+            if (wildcard !== undefined) {
+                // This layer's wildcard default (#946) overlays every platform column
+                // already accumulated from earlier layers, before this layer's own
+                // explicit per-platform entries (applied below) get a chance to
+                // override it for their one column.
+                for (const [engineKey, profile] of mergedEngines) {
+                    if (engineKey === WILDCARD_ENGINE_KEY)
+                        continue;
+                    mergedEngines.set(engineKey, mergeProfiles(profile, wildcard));
+                }
+            }
             for (const [engineKey, profile] of Object.entries(layerEngines)) {
                 mergedEngines.set(engineKey, mergeProfiles(mergedEngines.get(engineKey), profile));
             }
@@ -316,7 +351,9 @@ export function resolveModelMapAlias(input, engine, map) {
     const alias = input.toLowerCase();
     const selectedEngine = engine.toLowerCase();
     const tier = ownValue(map.aliases, alias);
-    const profile = ownValue(tier, selectedEngine);
+    // A specific platform column always wins; the alias-level wildcard default
+    // (#946) is only a fallback for a column no layer ever set explicitly.
+    const profile = ownValue(tier, selectedEngine) ?? ownValue(tier, WILDCARD_ENGINE_KEY);
     if (profile !== undefined)
         return selectionFromProfile(input, profile);
     const knownAliasUnmappedForEngine = tier !== undefined;

package/dist/llm/client.js

@@ -472,3 +472,21 @@ export async function probeLlmEndpoint(config, timeoutMs = 3_000) {
         return { reachable: false, error: err instanceof Error ? err.message : String(err) };
     }
 }
+/**
+ * Endpoint-keyed probe memoization (#957): every caller that probes several
+ * engine connections in one pass (`akm health`'s engine checks, `akm
+ * improve --require-engines`) shares one in-flight probe per distinct
+ * endpoint (trailing slashes normalized) instead of firing a duplicate probe
+ * when two engines point at the same server. `cache` must be scoped to one
+ * invocation and never shared across calls — a stale "reachable" surviving
+ * past the run that produced it is the failure mode this exists to avoid.
+ */
+export function probeEndpointOnce(connection, cache, probe) {
+    const key = connection.endpoint.replace(/\/+$/, "");
+    let pending = cache.get(key);
+    if (!pending) {
+        pending = probe(connection);
+        cache.set(key, pending);
+    }
+    return pending;
+}

package/dist/llm/feature-gate.js

@@ -9,6 +9,10 @@ const FEATURE_LOCATION = {
     memory_inference: (cfg) => cfg.index?.memory?.enabled ?? true,
     graph_extraction: (cfg) => cfg.index?.graph?.enabled ?? true,
     metadata_enhance: (cfg) => cfg.index?.metadataEnhance?.enabled ?? false,
+    // #951: a real implementation of the dead `curate_rerank` key removed in
+    // 0.8.0. Off by default — it requires a `search.curateRerank.endpoint` a
+    // caller must explicitly configure.
+    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

@@ -0,0 +1,113 @@
+// 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/.
+/**
+ * HTTP client for a standalone cross-encoder rerank endpoint (#951).
+ *
+ * `curate_rerank` was a dead `llm.features.*` key removed in 0.8.0 — no wire
+ * call was ever implemented under it. This is the first real implementation:
+ * a small, dedicated client (NOT routed through `llm/client.ts`'s chat-
+ * completions transport, since a reranker speaks a different, much smaller
+ * contract) for the request/response shape a TEI/Cohere-style `/rerank`
+ * endpoint accepts:
+ *
+ *   POST <endpoint>
+ *   { "model": "<name>", "query": "<text>", "documents": ["<text>", ...] }
+ *
+ *   200 OK
+ *   { "results": [ { "index": 0, "relevance_score": 0.83 }, ... ] }
+ *
+ * `results` need not be sorted or complete — {@link rerankDocuments} sorts by
+ * `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
+ * `core/config/schema/search.ts` for why.
+ */
+import { fetchWithTimeout, readBodyWithByteCap } from "../core/common.js";
+import { resolveSecret } from "../core/config/config.js";
+import { isApiKeyReference } from "../core/config/schema/primitives.js";
+import { redactErrorBody, redactSensitiveText } from "../core/redaction.js";
+import { resolveSecretFromStore } from "../sources/snapshot-fetchers/secret-seam.js";
+const DEFAULT_RERANK_TIMEOUT_MS = 10_000;
+export class RerankCallError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "RerankCallError";
+        this.code = code;
+    }
+}
+/**
+ * Call a configured rerank endpoint and return documents ordered by
+ * relevance to `query`, most relevant first. Any document the endpoint
+ * didn't return a score for keeps its original relative order, appended
+ * 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", ...)`
+ * (`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");
+    }
+    if (documents.length === 0)
+        return [];
+    const resolvedKey = config.apiKey && isApiKeyReference(config.apiKey)
+        ? resolveSecret(config.apiKey, resolveSecretFromStore)
+        : config.apiKey;
+    const headers = { "Content-Type": "application/json" };
+    if (resolvedKey)
+        headers.Authorization = `Bearer ${resolvedKey}`;
+    const timeoutMs = config.timeoutMs ?? DEFAULT_RERANK_TIMEOUT_MS;
+    const requestBody = JSON.stringify({
+        ...(config.model ? { model: config.model } : {}),
+        query,
+        documents,
+    });
+    let response;
+    try {
+        response = await fetchWithTimeout(config.endpoint, { method: "POST", headers, body: requestBody }, timeoutMs);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("timed out")) {
+            throw new RerankCallError(`Rerank request timed out after ${timeoutMs}ms`, "timeout");
+        }
+        throw new RerankCallError(`Rerank network error: ${msg}`, "network_error");
+    }
+    if (!response.ok) {
+        const rawBody = await readBodyWithByteCap(response).catch(() => "");
+        const safeBody = redactSensitiveText(redactErrorBody(rawBody), resolvedKey ? [resolvedKey] : []);
+        throw new RerankCallError(`Rerank request failed (${response.status}) ${config.endpoint}: ${safeBody}`, "provider_error");
+    }
+    const rawBody = await readBodyWithByteCap(response);
+    let json;
+    try {
+        json = JSON.parse(rawBody);
+    }
+    catch {
+        throw new RerankCallError(`Rerank response was not valid JSON ${config.endpoint}: ${redactSensitiveText(redactErrorBody(rawBody), resolvedKey ? [resolvedKey] : [])}`, "parse_error");
+    }
+    if (!Array.isArray(json.results)) {
+        throw new RerankCallError(`Rerank response from ${config.endpoint} has no "results" array.`, "parse_error");
+    }
+    const scored = new Map();
+    for (const entry of json.results) {
+        if (typeof entry.index !== "number")
+            continue;
+        const score = typeof entry.relevance_score === "number" ? entry.relevance_score : entry.score;
+        if (typeof score === "number")
+            scored.set(entry.index, score);
+    }
+    const rankedScored = [...scored.entries()]
+        .map(([index, score]) => ({ index, score }))
+        .sort((a, b) => b.score - a.score);
+    const unscored = documents
+        .map((_, index) => index)
+        .filter((index) => !scored.has(index))
+        .map((index) => ({ index, score: Number.NEGATIVE_INFINITY }));
+    return [...rankedScored, ...unscored];
+}

package/dist/llm/usage-persist.js

@@ -67,12 +67,18 @@ function toEventMetadata(record) {
  * opened for its other events. A getter is resolved for every append so a
  * caller can replace its context binding without replacing this owning sink.
  * When omitted, `appendEvent` falls back to its default open-insert-close path.
+ *
+ * `onRecord`, when supplied, runs synchronously for every terminal record
+ * BEFORE persistence — improve's first-engine-response heartbeat (#957) uses
+ * it to know the run is no longer silent, without this module taking on any
+ * dependency of its own on improve's lifecycle.
  */
-export function installLlmUsagePersistence(ctx) {
+export function installLlmUsagePersistence(ctx, onRecord) {
     let expectedTerminalRecords = 0;
     let disposed = false;
     setLlmUsageSink((record) => {
         expectedTerminalRecords += 1;
+        onRecord?.(record);
         appendEvent({ eventType: LLM_USAGE_EVENT, metadata: toEventMetadata(record) }, typeof ctx === "function" ? ctx() : ctx);
     });
     return () => {

package/dist/scripts/akm-migrate-node.js

@@ -7071,7 +7071,9 @@ var init_errors = __esm(() => {
   TRANSIENT_HINTS = {
     RUN_LEASE_HELD: "Wait for the named engine invocation to finish or for the lease to expire, then retry. `akm workflow status <id>` shows the current lease.",
     STATE_DB_CONTENDED: "Another akm process is writing state.db right now. Wait a few seconds and retry; commands that support --skip-if-locked can skip instead of failing.",
-    INDEX_DB_CONTENDED: "Another akm process is writing index.db; retry shortly, or pass --skip-if-locked on scheduled runs."
+    INDEX_DB_CONTENDED: "Another akm process is writing index.db; retry shortly, or pass --skip-if-locked on scheduled runs.",
+    MAINTENANCE_BARRIER_BUSY: "Another akm process is registering a lock or lease right now. Retry shortly, or pass --skip-if-locked on scheduled index/improve/workflow runs.",
+    IMPROVE_LOCK_HELD: "Another akm improve run holds the whole-run lock right now. Wait for it to finish and retry, or pass --skip-if-locked on scheduled runs."
   };
   NOT_FOUND_HINTS = {
     ASSET_NOT_FOUND: "Run `akm search <query>` or `akm index` to refresh the index.",
@@ -76377,10 +76379,19 @@ var SearchGraphBoostSchema = exports_external.object({
   confidenceMode: exports_external.enum(["blend"]).default("blend").optional(),
   confidenceWeight: exports_external.number().finite().min(0).max(1).default(0.2).optional()
 }).passthrough();
+var CurateRerankConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
+  endpoint: httpUrl.optional(),
+  model: nonEmptyString.optional(),
+  apiKey: symbolicOrWarnApiKey("search.curateRerank.apiKey").optional(),
+  timeoutMs: positiveInt.optional(),
+  topN: positiveInt.max(50).optional()
+}).passthrough();
 var SearchConfigSchema = exports_external.object({
   minScore: nonNegativeNumber.optional(),
   defaultExcludeTypes: exports_external.array(nonEmptyString).optional(),
-  graphBoost: SearchGraphBoostSchema.optional()
+  graphBoost: SearchGraphBoostSchema.optional(),
+  curateRerank: CurateRerankConfigSchema.optional()
 }).passthrough();
 
 // src/core/config/schema/setup.ts
@@ -77923,10 +77934,13 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs7 from "node:fs";
 import path12 from "node:path";
+init_common();
 init_errors();
 init_paths();
 var heldBarrierContext = new AsyncLocalStorage;
 var MAINTENANCE_BARRIER_STALE_AFTER_MS = 5 * 60 * 1000;
+var MAINTENANCE_BARRIER_BUSY_RETRY_BOUND_MS = 1500;
+var busyRetryBoundMsForTests;
 function tryAcquireMaintenanceBarrier() {
   const lockPath = getMaintenanceBarrierPath();
   fs7.mkdirSync(path12.dirname(lockPath), { recursive: true });
@@ -77942,10 +77956,18 @@ function tryAcquireMaintenanceBarrier() {
   return;
 }
 function acquireMaintenanceBarrier() {
-  const release = tryAcquireMaintenanceBarrier();
-  if (release)
-    return release;
-  throw new ConfigError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry after it completes. ` + `A sentinel older than ${MAINTENANCE_BARRIER_STALE_AFTER_MS / 60000} minute(s) is reclaimed automatically on the next attempt.`, "INVALID_CONFIG_FILE");
+  const boundMs = busyRetryBoundMsForTests ?? MAINTENANCE_BARRIER_BUSY_RETRY_BOUND_MS;
+  const deadline = Date.now() + boundMs;
+  for (let attempt = 0;; attempt += 1) {
+    const release = tryAcquireMaintenanceBarrier();
+    if (release)
+      return release;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0)
+      break;
+    sleepSync(Math.min(backoffDelay(attempt), remainingMs));
+  }
+  throw new TransientError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry shortly. ` + `A sentinel older than ${MAINTENANCE_BARRIER_STALE_AFTER_MS / 60000} minute(s) is reclaimed automatically on the next attempt.`, "MAINTENANCE_BARRIER_BUSY");
 }
 function withMaintenanceStartBarrier(run) {
   if (heldBarrierContext.getStore()?.active)
@@ -93471,6 +93493,7 @@ init_warn();
 var MODEL_MAP_VERSION = 1;
 var ENGINE_KEY_PATTERN = new RegExp(ENGINE_NAME_PATTERN_SOURCE);
 var RESERVED_MAP_KEYS = new Set(["__proto__", "constructor", "prototype", "tostring"]);
+var PROFILE_FIELD_KEYS = new Set(["model", "inference", "engine"]);
 
 // src/integrations/harnesses/opencode-sdk/sdk-runner.ts
 var _servers = new Map;
@@ -97460,6 +97483,34 @@ async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch) {
   return results;
 }
 
+// src/indexer/index-db-contention.ts
+init_errors();
+
+// src/indexer/index-rebuild-lock.ts
+init_paths();
+init_warn();
+function indexRebuildLockPath() {
+  return getIndexRebuildLockPath();
+}
+
+// src/indexer/index-db-contention.ts
+function describeIndexRebuildLockHolder() {
+  const probe = probeLock(indexRebuildLockPath());
+  if (probe.state !== "held")
+    return "";
+  return ` The rebuild lock is currently held by pid ${formatLockHolderPid({
+    pid: probe.holderPid,
+    launcherPid: probe.launcherPid ?? null
+  })}.`;
+}
+function reclassifyIndexDbContention(error2) {
+  if (error2 instanceof AkmError || !isSqliteContentionError(error2))
+    return error2;
+  const contended = new TransientError(`akm's index database is busy (another akm process is writing it); retry shortly.${describeIndexRebuildLockHolder()}`, "INDEX_DB_CONTENDED");
+  contended.cause = error2;
+  return contended;
+}
+
 // src/indexer/materialize-embeddings.ts
 function deriveSemanticProviderFingerprint(embedding) {
   if (isDeterministicEmbedEnabled()) {
@@ -97870,7 +97921,8 @@ ${listed}${more}` });
         clearInterval(heartbeatTimer);
     }
   } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
+    const reclassified = reclassifyIndexDbContention(error2);
+    const message = reclassified instanceof Error ? reclassified.message : String(reclassified);
     warn("Embedding generation failed, continuing without:", message);
     onProgress({ phase: "embeddings", message: `Embedding generation failed: ${message}` });
     return {

package/dist/scripts/akm-migrate.js

@@ -7070,7 +7070,9 @@ var init_errors = __esm(() => {
   TRANSIENT_HINTS = {
     RUN_LEASE_HELD: "Wait for the named engine invocation to finish or for the lease to expire, then retry. `akm workflow status <id>` shows the current lease.",
     STATE_DB_CONTENDED: "Another akm process is writing state.db right now. Wait a few seconds and retry; commands that support --skip-if-locked can skip instead of failing.",
-    INDEX_DB_CONTENDED: "Another akm process is writing index.db; retry shortly, or pass --skip-if-locked on scheduled runs."
+    INDEX_DB_CONTENDED: "Another akm process is writing index.db; retry shortly, or pass --skip-if-locked on scheduled runs.",
+    MAINTENANCE_BARRIER_BUSY: "Another akm process is registering a lock or lease right now. Retry shortly, or pass --skip-if-locked on scheduled index/improve/workflow runs.",
+    IMPROVE_LOCK_HELD: "Another akm improve run holds the whole-run lock right now. Wait for it to finish and retry, or pass --skip-if-locked on scheduled runs."
   };
   NOT_FOUND_HINTS = {
     ASSET_NOT_FOUND: "Run `akm search <query>` or `akm index` to refresh the index.",
@@ -75705,10 +75707,19 @@ var SearchGraphBoostSchema = exports_external.object({
   confidenceMode: exports_external.enum(["blend"]).default("blend").optional(),
   confidenceWeight: exports_external.number().finite().min(0).max(1).default(0.2).optional()
 }).passthrough();
+var CurateRerankConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
+  endpoint: httpUrl.optional(),
+  model: nonEmptyString.optional(),
+  apiKey: symbolicOrWarnApiKey("search.curateRerank.apiKey").optional(),
+  timeoutMs: positiveInt.optional(),
+  topN: positiveInt.max(50).optional()
+}).passthrough();
 var SearchConfigSchema = exports_external.object({
   minScore: nonNegativeNumber.optional(),
   defaultExcludeTypes: exports_external.array(nonEmptyString).optional(),
-  graphBoost: SearchGraphBoostSchema.optional()
+  graphBoost: SearchGraphBoostSchema.optional(),
+  curateRerank: CurateRerankConfigSchema.optional()
 }).passthrough();
 
 // src/core/config/schema/setup.ts
@@ -77251,10 +77262,13 @@ import { AsyncLocalStorage } from "async_hooks";
 import { randomUUID as randomUUID2 } from "crypto";
 import fs7 from "fs";
 import path12 from "path";
+init_common();
 init_errors();
 init_paths();
 var heldBarrierContext = new AsyncLocalStorage;
 var MAINTENANCE_BARRIER_STALE_AFTER_MS = 5 * 60 * 1000;
+var MAINTENANCE_BARRIER_BUSY_RETRY_BOUND_MS = 1500;
+var busyRetryBoundMsForTests;
 function tryAcquireMaintenanceBarrier() {
   const lockPath = getMaintenanceBarrierPath();
   fs7.mkdirSync(path12.dirname(lockPath), { recursive: true });
@@ -77270,10 +77284,18 @@ function tryAcquireMaintenanceBarrier() {
   return;
 }
 function acquireMaintenanceBarrier() {
-  const release = tryAcquireMaintenanceBarrier();
-  if (release)
-    return release;
-  throw new ConfigError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry after it completes. ` + `A sentinel older than ${MAINTENANCE_BARRIER_STALE_AFTER_MS / 60000} minute(s) is reclaimed automatically on the next attempt.`, "INVALID_CONFIG_FILE");
+  const boundMs = busyRetryBoundMsForTests ?? MAINTENANCE_BARRIER_BUSY_RETRY_BOUND_MS;
+  const deadline = Date.now() + boundMs;
+  for (let attempt = 0;; attempt += 1) {
+    const release = tryAcquireMaintenanceBarrier();
+    if (release)
+      return release;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0)
+      break;
+    sleepSync(Math.min(backoffDelay(attempt), remainingMs));
+  }
+  throw new TransientError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry shortly. ` + `A sentinel older than ${MAINTENANCE_BARRIER_STALE_AFTER_MS / 60000} minute(s) is reclaimed automatically on the next attempt.`, "MAINTENANCE_BARRIER_BUSY");
 }
 function withMaintenanceStartBarrier(run) {
   if (heldBarrierContext.getStore()?.active)
@@ -93466,6 +93488,7 @@ init_warn();
 var MODEL_MAP_VERSION = 1;
 var ENGINE_KEY_PATTERN = new RegExp(ENGINE_NAME_PATTERN_SOURCE);
 var RESERVED_MAP_KEYS = new Set(["__proto__", "constructor", "prototype", "tostring"]);
+var PROFILE_FIELD_KEYS = new Set(["model", "inference", "engine"]);
 
 // src/integrations/harnesses/opencode-sdk/sdk-runner.ts
 var _servers = new Map;
@@ -97416,6 +97439,34 @@ async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch) {
   return results;
 }
 
+// src/indexer/index-db-contention.ts
+init_errors();
+
+// src/indexer/index-rebuild-lock.ts
+init_paths();
+init_warn();
+function indexRebuildLockPath() {
+  return getIndexRebuildLockPath();
+}
+
+// src/indexer/index-db-contention.ts
+function describeIndexRebuildLockHolder() {
+  const probe = probeLock(indexRebuildLockPath());
+  if (probe.state !== "held")
+    return "";
+  return ` The rebuild lock is currently held by pid ${formatLockHolderPid({
+    pid: probe.holderPid,
+    launcherPid: probe.launcherPid ?? null
+  })}.`;
+}
+function reclassifyIndexDbContention(error2) {
+  if (error2 instanceof AkmError || !isSqliteContentionError(error2))
+    return error2;
+  const contended = new TransientError(`akm's index database is busy (another akm process is writing it); retry shortly.${describeIndexRebuildLockHolder()}`, "INDEX_DB_CONTENDED");
+  contended.cause = error2;
+  return contended;
+}
+
 // src/indexer/materialize-embeddings.ts
 function deriveSemanticProviderFingerprint(embedding) {
   if (isDeterministicEmbedEnabled()) {
@@ -97826,7 +97877,8 @@ ${listed}${more}` });
         clearInterval(heartbeatTimer);
     }
   } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
+    const reclassified = reclassifyIndexDbContention(error2);
+    const message = reclassified instanceof Error ? reclassified.message : String(reclassified);
     warn("Embedding generation failed, continuing without:", message);
     onProgress({ phase: "embeddings", message: `Embedding generation failed: ${message}` });
     return {

package/dist/tasks/run/task-log.js

@@ -36,6 +36,65 @@ export function resolveTaskLogPath(logDir, taskId, startedAtIso) {
         return "";
     }
 }
+/**
+ * Delete per-run flat log files (`<logDir>/<taskId>/<timestamp>.log`) older
+ * than `retentionDays` (#951). These files are a transitional human-readable
+ * tail only — the durable record lives in logs.db, already purged by
+ * {@link purgeOldTaskLogs} in ../../core/logs-db — so deleting an old file
+ * here loses nothing that isn't already retained (and separately purged)
+ * there.
+ *
+ * Bounded by construction: only ever reads/deletes inside `logDir` (defaults
+ * to {@link getTaskLogDir}), one level of `<taskId>` subdirectories, `.log`
+ * files only. A missing/unreadable directory is a no-op, not an error —
+ * mirrors the best-effort contract the rest of this module holds for log
+ * persistence.
+ */
+export function purgeOldTaskLogFiles(logDir, retentionDays = 90) {
+    if (!Number.isFinite(retentionDays) || retentionDays <= 0)
+        return 0;
+    const dir = logDir ?? getTaskLogDir();
+    const cutoffMs = Date.now() - retentionDays * 86_400_000;
+    let deleted = 0;
+    let taskDirs;
+    try {
+        taskDirs = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        rethrowIfTestIsolationError(error);
+        return 0;
+    }
+    for (const taskDirEntry of taskDirs) {
+        if (!taskDirEntry.isDirectory())
+            continue;
+        const taskDirPath = path.join(dir, taskDirEntry.name);
+        let logFiles;
+        try {
+            logFiles = fs.readdirSync(taskDirPath, { withFileTypes: true });
+        }
+        catch (error) {
+            rethrowIfTestIsolationError(error);
+            continue;
+        }
+        for (const logFile of logFiles) {
+            if (!logFile.isFile() || !logFile.name.endsWith(".log"))
+                continue;
+            const logFilePath = path.join(taskDirPath, logFile.name);
+            try {
+                const stat = fs.statSync(logFilePath);
+                if (stat.mtimeMs < cutoffMs) {
+                    fs.unlinkSync(logFilePath);
+                    deleted++;
+                }
+            }
+            catch (error) {
+                rethrowIfTestIsolationError(error);
+                // Best-effort: a file that vanished or can't be stat'd/removed is skipped.
+            }
+        }
+    }
+    return deleted;
+}
 /**
  * Redact logs.db rows against the SAME contiguous text the file sink sees.
  *