akm-cli 0.9.15-beta.1 → 0.9.15-beta.2

package/dist/scripts/akm-migrate.js

@@ -35703,7 +35703,7 @@ var require_libvips = __commonJS((exports, module) => {
     SPDX-License-Identifier: Apache-2.0
   */
   var { spawnSync: spawnSync6 } = __require("child_process");
-  var { createHash: createHash10 } = __require("crypto");
+  var { createHash: createHash11 } = __require("crypto");
   var semverCoerce = require_coerce2();
   var semverGreaterThanOrEqualTo = require_gte2();
   var semverSatisfies = require_satisfies2();
@@ -35791,7 +35791,7 @@ var require_libvips = __commonJS((exports, module) => {
     }
     return false;
   };
-  var sha512 = (s) => createHash10("sha512").update(s).digest("hex");
+  var sha512 = (s) => createHash11("sha512").update(s).digest("hex");
   var yarnLocator = () => {
     try {
       const identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`);
@@ -75245,11 +75245,14 @@ var EmbeddingConnectionConfigSchema = exports_external.object({
   apiKey: symbolicOrWarnApiKey("embedding.apiKey").optional(),
   dimension: positiveInt.max(4096).optional(),
   localModel: exports_external.string().min(1).optional(),
+  maxInputTokens: positiveInt.optional(),
   maxTokens: positiveInt.optional(),
   batchSize: positiveInt.optional(),
   chunkSize: positiveInt.optional(),
   contextLength: positiveInt.optional(),
-  ollamaOptions: EmbeddingOllamaOptionsSchema.optional()
+  ollamaOptions: EmbeddingOllamaOptionsSchema.optional(),
+  timeoutMs: positiveInt.optional(),
+  concurrency: positiveInt.max(16).optional()
 }).passthrough();
 
 // src/integrations/harnesses/ids.ts
@@ -76322,8 +76325,21 @@ function releaseLockRaw(lockPath) {
 function tryAcquireLockSync(lockPath, payload) {
   return withLockOperationMutex(lockPath, () => tryAcquireLockRaw(lockPath, payload));
 }
+function launcherPidFromEnv() {
+  const raw = process.env.AKM_LAUNCHER_PID;
+  if (!raw)
+    return;
+  const pid = Number.parseInt(raw, 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
 function createLockPayload(metadata = {}) {
-  return JSON.stringify({ ...metadata, pid: process.pid, lockId: randomUUID() });
+  const launcherPid = launcherPidFromEnv();
+  return JSON.stringify({
+    ...metadata,
+    pid: process.pid,
+    ...launcherPid !== undefined ? { launcherPid } : {},
+    lockId: randomUUID()
+  });
 }
 function probeLock(lockPath, opts) {
   let snapshot;
@@ -76339,17 +76355,17 @@ function probeLock(lockPath, opts) {
     return { state: "absent" };
   const { rawContent, identity: identity3 } = snapshot;
   const ageMs = Date.now() - identity3.mtimeMs;
-  const holderPid = extractHolderPid(rawContent);
+  const { holderPid, launcherPid } = extractLockIdentity(rawContent);
   if (holderPid === undefined) {
     return { state: "stale", reason: "invalid_pid", ageMs, rawContent, identity: identity3 };
   }
   if (!isProcessAlive(holderPid)) {
-    return { state: "stale", reason: "pid_dead", holderPid, ageMs, rawContent, identity: identity3 };
+    return { state: "stale", reason: "pid_dead", holderPid, launcherPid, ageMs, rawContent, identity: identity3 };
   }
   if (opts?.staleAfterMs !== undefined && ageMs > opts.staleAfterMs) {
-    return { state: "stale", reason: "age_exceeded", holderPid, ageMs, rawContent, identity: identity3 };
+    return { state: "stale", reason: "age_exceeded", holderPid, launcherPid, ageMs, rawContent, identity: identity3 };
   }
-  return { state: "held", holderPid, ageMs, rawContent, identity: identity3 };
+  return { state: "held", holderPid, launcherPid, ageMs, rawContent, identity: identity3 };
 }
 function reclaimStaleLock(lockPath, probe, options) {
   if (probe.rawContent === undefined || probe.identity === undefined)
@@ -76417,21 +76433,25 @@ function releaseLock(ownership) {
     }
   });
 }
-function extractHolderPid(content) {
+function extractLockIdentity(content) {
   const trimmed = content.trim();
   if (!trimmed)
-    return;
+    return {};
   if (trimmed.startsWith("{")) {
     try {
       const parsed = JSON.parse(trimmed);
       const pid2 = typeof parsed.pid === "number" ? parsed.pid : Number.NaN;
-      return Number.isInteger(pid2) && pid2 > 0 ? pid2 : undefined;
+      const rawLauncherPid = typeof parsed.launcherPid === "number" ? parsed.launcherPid : Number.NaN;
+      return {
+        holderPid: Number.isInteger(pid2) && pid2 > 0 ? pid2 : undefined,
+        launcherPid: Number.isInteger(rawLauncherPid) && rawLauncherPid > 0 ? rawLauncherPid : undefined
+      };
     } catch {
-      return;
+      return {};
     }
   }
   const pid = Number.parseInt(trimmed, 10);
-  return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+  return { holderPid: Number.isInteger(pid) && pid > 0 ? pid : undefined };
 }
 
 // src/core/config/config-io.ts
@@ -95693,7 +95713,7 @@ function listTxnJournalsTolerant(predicate) {
 }
 
 // src/commands/proposal/repository.ts
-import { createHash as createHash10, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash11, randomUUID as randomUUID6 } from "crypto";
 import fs55 from "fs";
 init_dist();
 import path66 from "path";
@@ -95759,6 +95779,16 @@ import fs53 from "fs";
 import path64 from "path";
 init_errors();
 init_paths();
+
+// src/core/run-lock.ts
+init_errors();
+function formatLockHolderPid(holder) {
+  if (holder.pid === null)
+    return "unknown";
+  return holder.launcherPid !== null ? `${holder.pid} (launcher ${holder.launcherPid})` : String(holder.pid);
+}
+
+// src/indexer/index-written-assets.ts
 init_warn();
 
 // src/storage/repositories/index-connection.ts
@@ -96013,6 +96043,15 @@ function isCanonicalIndexGeneration(db) {
 init_errors();
 init_warn();
 
+// src/storage/repositories/embedding-salvage-repository.ts
+import { createHash as createHash9 } from "crypto";
+
+// src/storage/repositories/embeddings-repository.ts
+function blobToEmbedding(blob) {
+  const f32 = new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+  return Array.from(f32);
+}
+
 // src/storage/repositories/index-meta-repository.ts
 function getMeta(db, key) {
   const row = db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key);
@@ -96025,6 +96064,64 @@ function deleteMeta(db, key) {
   db.prepare("DELETE FROM index_meta WHERE key = ?").run(key);
 }
 
+// src/storage/repositories/index-sql.ts
+var SQLITE_CHUNK_SIZE = 500;
+
+// src/storage/repositories/embedding-salvage-repository.ts
+function hashEmbeddableText(searchText) {
+  return createHash9("sha256").update(searchText, "utf8").digest("hex");
+}
+function purgeEmbeddingSalvage(db) {
+  db.exec("DELETE FROM embedding_salvage");
+}
+function relabelEmbeddingSalvageFingerprint(db, fromFingerprint, toFingerprint) {
+  db.prepare("UPDATE embedding_salvage SET fingerprint = ? WHERE fingerprint = ?").run(toFingerprint, fromFingerprint);
+}
+function reuseSalvagedEmbeddings(db, entries, fingerprint, writeReused) {
+  if (entries.length === 0)
+    return { reusedCount: 0, remaining: [] };
+  const anySalvageForFingerprint = db.prepare("SELECT 1 FROM embedding_salvage WHERE fingerprint = ? LIMIT 1").get(fingerprint);
+  if (!anySalvageForFingerprint)
+    return { reusedCount: 0, remaining: [...entries] };
+  const hashes = entries.map((entry) => hashEmbeddableText(entry.searchText));
+  const salvageByHash = new Map;
+  const uniqueHashes = [...new Set(hashes)];
+  for (let offset = 0;offset < uniqueHashes.length; offset += SQLITE_CHUNK_SIZE) {
+    const chunk = uniqueHashes.slice(offset, offset + SQLITE_CHUNK_SIZE);
+    const placeholders = chunk.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT content_hash AS contentHash, embedding FROM embedding_salvage WHERE fingerprint = ? AND content_hash IN (${placeholders})`).all(fingerprint, ...chunk);
+    for (const row of rows)
+      salvageByHash.set(row.contentHash, row.embedding);
+  }
+  if (salvageByHash.size === 0)
+    return { reusedCount: 0, remaining: [...entries] };
+  let reusedCount = 0;
+  const remaining = [];
+  for (let offset = 0;offset < entries.length; offset += SQLITE_CHUNK_SIZE) {
+    const end = Math.min(offset + SQLITE_CHUNK_SIZE, entries.length);
+    const chunkMatches = [];
+    for (let i = offset;i < end; i++) {
+      const entry = entries[i];
+      const blob = salvageByHash.get(hashes[i]);
+      if (blob)
+        chunkMatches.push({ entry, blob });
+      else
+        remaining.push(entry);
+    }
+    if (chunkMatches.length === 0)
+      continue;
+    db.transaction(() => {
+      for (const { entry, blob } of chunkMatches) {
+        if (writeReused(entry, blobToEmbedding(blob)))
+          reusedCount++;
+        else
+          remaining.push(entry);
+      }
+    })();
+  }
+  return { reusedCount, remaining };
+}
+
 // src/storage/repositories/index-vec-repository.ts
 import { createRequire as createRequire3 } from "module";
 
@@ -96066,9 +96163,6 @@ function cosineSimilarity(a, b) {
   return denom === 0 ? 0 : dot / denom;
 }
 
-// src/storage/repositories/index-sql.ts
-var SQLITE_CHUNK_SIZE = 500;
-
 // src/storage/repositories/index-vec-repository.ts
 var vecStatus = new WeakMap;
 function loadVecExtension(db) {
@@ -96328,11 +96422,11 @@ init_warn();
 
 // src/core/asset/markdown-fragments.ts
 init_markdown();
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 var MARKDOWN_FRAGMENT_MAX_CHARS = 1600;
 var MARKDOWN_FRAGMENT_PREFIX = "akm-fragment-";
 function hash3(text) {
-  return createHash9("sha256").update(text).digest("hex");
+  return createHash10("sha256").update(text).digest("hex");
 }
 function uniqueSlugs(body) {
   const out = new Map;
@@ -96613,6 +96707,7 @@ function getEmbeddableEntryCount(db) {
 }
 
 // src/indexer/materialize-embeddings.ts
+init_paths();
 init_warn();
 
 // src/llm/embedders/cache.ts
@@ -96852,6 +96947,39 @@ var DEFAULT_TOKEN_BUDGET = 8000;
 function estimateTokenCount(text) {
   return Math.round(text.length / 4);
 }
+var DEFAULT_MAX_INPUT_TOKENS = 512;
+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);
+    if (code >= 56320 && code <= 57343)
+      cut -= 1;
+  }
+  return { text: text.slice(0, cut), truncated: true };
+}
+var DEFAULT_EMBEDDING_TIMEOUT_MS = 120000;
+function resolveEmbeddingTimeoutMs(config) {
+  return config.timeoutMs ?? DEFAULT_EMBEDDING_TIMEOUT_MS;
+}
+function scaleEmbeddingTimeoutMs(timeoutMs, requestTokens, tokenBudget) {
+  const scaled = tokenBudget > 0 ? timeoutMs * (requestTokens / tokenBudget) : timeoutMs;
+  return Math.min(Math.max(scaled, 30000), timeoutMs);
+}
+function isEmbeddingTimeoutError(err) {
+  if (!(err instanceof Error))
+    return false;
+  if (err.name === "BodyReadTimeoutError")
+    return true;
+  return err.message.startsWith("Request timed out after ");
+}
+var embeddingTimeoutBackoffOverrideForTests;
+function embeddingTimeoutRetryBackoffMs(timeoutAttempt = 0) {
+  const { baseMs, maxMs } = embeddingTimeoutBackoffOverrideForTests ?? { baseMs: 5000, maxMs: 60000 };
+  return backoffDelay(timeoutAttempt, baseMs, maxMs);
+}
 
 class ContextExceededError extends Error {
   constructor(message) {
@@ -96859,13 +96987,15 @@ class ContextExceededError extends Error {
     this.name = "ContextExceededError";
   }
 }
-var CONTEXT_EXCEEDED_PATTERN = /exceed_context_size_error|context size|context length|too many tokens/i;
+var CONTEXT_EXCEEDED_PATTERN = /exceed_context_size_error|context size|context length|too many tokens|input is too large to process|physical batch size|ubatch/i;
 function isContextExceededResponse(status, body) {
   if (status === 413)
     return true;
   return CONTEXT_EXCEEDED_PATTERN.test(body);
 }
 function resolveEmbeddingConcurrency(config) {
+  if (typeof config.concurrency === "number")
+    return config.concurrency;
   return defaultConcurrencyForEndpoint(config.endpoint);
 }
 function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
@@ -96921,20 +97051,21 @@ class RemoteEmbedder {
     if (ollamaOpts) {
       body.options = ollamaOpts;
     }
+    const timeoutMs = resolveEmbeddingTimeoutMs(this.config);
     const response = await fetchWithTimeout(normalizeEmbeddingEndpoint(this.endpoint), {
       method: "POST",
       headers,
       body: JSON.stringify(body)
-    }, 30000, signal);
+    }, timeoutMs, signal);
     if (!response.ok) {
-      const errBody = await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: 30000, signal }).catch((err) => {
+      const errBody = await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: timeoutMs, signal }).catch((err) => {
         if (signal?.aborted)
           throw err;
         return "";
       });
       throw new Error(`Embedding request failed (${response.status}): ${this.safeErrorBody(errBody)}`);
     }
-    const json = JSON.parse(await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: 30000, signal }));
+    const json = JSON.parse(await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: timeoutMs, signal }));
     if (!json.data?.[0]?.embedding) {
       throw new Error(`Unexpected embedding response format: missing data[0].embedding.${embeddingEndpointPathHint(this.endpoint)}`);
     }
@@ -96946,9 +97077,10 @@ class RemoteEmbedder {
     const results = new Array(texts.length).fill(undefined);
     const headers = this.buildHeaders();
     const ollamaOpts = resolveOllamaOptions(this.config);
-    const tokenBudget = this.config.maxTokens ?? this.config.contextLength ?? DEFAULT_TOKEN_BUDGET;
+    const tokenBudget = this.config.maxTokens ?? DEFAULT_TOKEN_BUDGET;
     const maxCount = this.config.batchSize ?? DEFAULT_REMOTE_BATCH_SIZE;
     const textBatches = buildTokenBoundedBatches(texts, tokenBudget, maxCount);
+    const configuredTimeoutMs = resolveEmbeddingTimeoutMs(this.config);
     const dispatchAbort = new AbortController;
     const stopDispatch = (reason) => {
       if (!dispatchAbort.signal.aborted)
@@ -96964,66 +97096,132 @@ class RemoteEmbedder {
       }
     }
     let firstOnBatchError;
-    const commitBatch = (indices, embeddings, model) => {
+    const commitBatch = (indices, embeddings, model, outcome) => {
       if (!onBatch)
         return;
       if (firstOnBatchError !== undefined)
         return;
       try {
-        onBatch(indices, embeddings, model);
+        onBatch(indices, embeddings, model, outcome);
       } catch (err) {
         firstOnBatchError = err;
         stopDispatch(err);
       }
     };
-    const requestAndCommit = async (indices) => {
+    const requestAndCommit = async (indices, batchIndex, isTimeoutRetry = false, timeoutAttempt = 0) => {
+      if (dispatchAbort.signal.aborted)
+        return;
       const batch = indices.map((i) => texts[i]);
+      const requestTokens = batch.reduce((sum, text) => sum + estimateTokenCount(text), 0);
+      const requestTimeoutMs = scaleEmbeddingTimeoutMs(configuredTimeoutMs, requestTokens, tokenBudget);
+      const requestStart = Date.now();
       let batchEmbeddings;
       let responseModel;
+      let outcome;
+      let failureReason;
       try {
-        const { vectors, model } = await this.requestBatch(batch, headers, ollamaOpts, signal);
+        const { vectors, model } = await this.requestBatch(batch, headers, ollamaOpts, requestTimeoutMs, signal);
         for (let k2 = 0;k2 < indices.length; k2++) {
           results[indices[k2]] = vectors[k2];
         }
         batchEmbeddings = indices.map((i) => results[i]);
         responseModel = model;
+        outcome = "stored";
       } catch (err) {
         if (signal?.aborted)
           throw err;
         if (err instanceof ContextExceededError && indices.length > 1) {
           const mid = Math.ceil(indices.length / 2);
-          await requestAndCommit(indices.slice(0, mid));
-          await requestAndCommit(indices.slice(mid));
+          await requestAndCommit(indices.slice(0, mid), batchIndex, false, timeoutAttempt);
+          await requestAndCommit(indices.slice(mid), batchIndex, false, timeoutAttempt);
+          return;
+        }
+        const timedOut = isEmbeddingTimeoutError(err);
+        if (timedOut && !isTimeoutRetry) {
+          const backoffMs = embeddingTimeoutRetryBackoffMs(timeoutAttempt);
+          warnVerbose(`[embed] batch of ${batch.length} document(s) timed out after ${requestTimeoutMs}ms; retrying once after a ${Math.round(backoffMs)}ms backoff`);
+          commitBatch(indices, indices.map(() => {
+            return;
+          }), undefined, {
+            batchIndex,
+            batchCount: textBatches.length,
+            docCount: indices.length,
+            requestTokens,
+            elapsedMs: backoffMs,
+            outcome: "retrying",
+            reason: "timed out"
+          });
+          await abortableDelay(backoffMs, signal, "embedding interrupted during retry backoff");
+          if (!dispatchAbort.signal.aborted) {
+            return requestAndCommit(indices, batchIndex, true, timeoutAttempt);
+          }
+        } else if (timedOut && indices.length > 1) {
+          const mid = Math.ceil(indices.length / 2);
+          await requestAndCommit(indices.slice(0, mid), batchIndex, false, timeoutAttempt + 1);
+          await requestAndCommit(indices.slice(mid), batchIndex, false, timeoutAttempt + 1);
           return;
         }
         const message = err instanceof Error ? err.message : String(err);
         const reason = err instanceof ContextExceededError ? "context-window-exceeded" : "batch-request-failed";
-        warnVerbose(`[embed] batch of ${batch.length} document(s) failed and was skipped: ${message}`);
-        for (const idx of indices) {
-          onSkip?.({ index: idx, reason, message });
-        }
+        const failureKind = reason === "batch-request-failed" ? timedOut ? "timeout" : "network-error" : undefined;
+        let stopRequested = false;
+        for (const [k2, idx] of indices.entries()) {
+          if (onSkip?.({
+            index: idx,
+            reason,
+            message,
+            batchStart: k2 === 0,
+            batchSize: indices.length,
+            failureKind
+          }) === false)
+            stopRequested = true;
+        }
+        if (stopRequested)
+          stopDispatch();
         batchEmbeddings = indices.map(() => {
           return;
         });
-      }
-      commitBatch(indices, batchEmbeddings, responseModel);
+        outcome = "failed";
+        failureReason = message;
+      }
+      commitBatch(indices, batchEmbeddings, responseModel, {
+        batchIndex,
+        batchCount: textBatches.length,
+        docCount: indices.length,
+        requestTokens,
+        elapsedMs: Date.now() - requestStart,
+        outcome,
+        reason: failureReason
+      });
     };
-    const runProviderBatch = async (textBatch) => {
+    const runProviderBatch = async (textBatch, batchIndex) => {
       if (textBatch.oversized) {
         const idx = textBatch.indices[0];
         const estTokens = estimateTokenCount(texts[idx]);
         onSkip?.({
           index: idx,
           reason: "context-window-exceeded",
-          message: `Document estimated at ${estTokens} tokens exceeds the ${tokenBudget}-token embedding budget; skipped.`
+          message: `Document estimated at ${estTokens} tokens exceeds the ${tokenBudget}-token embedding budget; skipped.`,
+          batchStart: true,
+          batchSize: 1
+        });
+        commitBatch([idx], [undefined], undefined, {
+          batchIndex,
+          batchCount: textBatches.length,
+          docCount: 1,
+          requestTokens: estTokens,
+          elapsedMs: 0,
+          outcome: "failed",
+          reason: "oversized"
         });
-        commitBatch([idx], [undefined]);
         return;
       }
-      await requestAndCommit(textBatch.indices);
+      await requestAndCommit(textBatch.indices, batchIndex);
     };
     const concurrency = resolveEmbeddingConcurrency(this.config);
-    await concurrentMap(textBatches, runProviderBatch, concurrency, { signal: dispatchAbort.signal });
+    await concurrentMap(textBatches, (textBatch, i) => runProviderBatch(textBatch, i + 1), concurrency, {
+      signal: dispatchAbort.signal
+    });
     if (callerAbortListener)
       signal?.removeEventListener("abort", callerAbortListener);
     if (signal?.aborted) {
@@ -97034,7 +97232,7 @@ class RemoteEmbedder {
     }
     return results;
   }
-  async requestBatch(batch, headers, ollamaOpts, signal) {
+  async requestBatch(batch, headers, ollamaOpts, timeoutMs, signal) {
     const body = {
       input: batch,
       model: this.model
@@ -97049,9 +97247,9 @@ class RemoteEmbedder {
       method: "POST",
       headers,
       body: JSON.stringify(body)
-    }, 30000, signal);
+    }, timeoutMs, signal);
     if (!response.ok) {
-      const respBody = await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: 30000, signal }).catch((err) => {
+      const respBody = await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: timeoutMs, signal }).catch((err) => {
         if (signal?.aborted)
           throw err;
         return "";
@@ -97062,7 +97260,7 @@ class RemoteEmbedder {
       }
       throw new Error(message);
     }
-    const json = JSON.parse(await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: 30000, signal }));
+    const json = JSON.parse(await readBodyWithByteCap(response, undefined, { bodyTimeoutMs: timeoutMs, signal }));
     if (!json.data || json.data.length !== batch.length) {
       throw new Error(`Unexpected embedding batch response: expected ${batch.length} embeddings, got ${json.data?.length ?? 0}.${embeddingEndpointPathHint(this.endpoint)}`);
     }
@@ -97131,6 +97329,15 @@ function resolveOllamaOptions(config) {
 function hasRemoteEndpoint(config) {
   return isHttpUrl(config.endpoint);
 }
+function describeEmbeddingCredential(apiKey) {
+  if (!apiKey)
+    return "none configured";
+  if (SECRET_STORE_REFERENCE_PATTERN.test(apiKey))
+    return `${apiKey} (store)`;
+  if (ENV_REFERENCE_PATTERN.test(apiKey))
+    return `${apiKey} (env)`;
+  return "literal apiKey";
+}
 
 // src/llm/embedder.ts
 var embedderOverrides;
@@ -97181,9 +97388,12 @@ function deriveSemanticProviderFingerprint(embedding) {
   }
   return `local:${embedding?.localModel ?? DEFAULT_LOCAL_MODEL}`;
 }
-var PROGRESS_INTERVAL = 500;
+function formatEmbeddingHeartbeat(storedCount, total, failedCount) {
+  return `Still generating embeddings: ${storedCount}/${total} stored, ${failedCount} failed; waiting on embedding provider.`;
+}
 var CANARY_SAMPLE_SIZE = 8;
 var CANARY_SIMILARITY_THRESHOLD = 0.999;
+var CIRCUIT_BREAKER_THRESHOLD = 3;
 function decideEmbeddingCompatibility(pairs) {
   if (pairs.length === 0)
     return { outcome: "keep", medianSimilarity: undefined, verifiedSamples: 0 };
@@ -97271,11 +97481,24 @@ function throwIfAborted(signal) {
   }
 }
 async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds, opts) {
+  if (db.inTransaction) {
+    throw new Error("generateEmbeddingsForDb was called with an ambient transaction already open on `db`: per-batch commits " + "would become SAVEPOINTs inside it, losing the crash-durability contract per-batch commit exists for. " + "Run the embedding phase on a connection with no open transaction.");
+  }
   throwIfAborted(signal);
   if (config.semanticSearchMode === "off") {
+    purgeEmbeddingSalvage(db);
     onProgress({ phase: "embeddings", message: "Semantic search disabled; skipping embeddings." });
     return { success: false, message: "Semantic search is disabled." };
   }
+  if (hasRemoteEndpoint(config.embedding ?? {})) {
+    const endpoint = normalizeEmbeddingEndpoint(config.embedding?.endpoint ?? "");
+    const credential = describeEmbeddingCredential(config.embedding?.apiKey);
+    const configFileSuffix = isVerbose() ? `; config: ${getConfigPath()}` : "";
+    onProgress({
+      phase: "embeddings",
+      message: `[embed] endpoint ${endpoint}, model ${config.embedding?.model ?? "unknown"}; credential: ${credential}${configFileSuffix}`
+    });
+  }
   const vecFastPathWasReady = isVecFastPathReady(db);
   const currentFingerprint = deriveSemanticProviderFingerprint(config.embedding);
   const storedFingerprint = getMeta(db, "embeddingFingerprint");
@@ -97284,6 +97507,7 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
   if (opts?.forceReembed) {
     db.transaction(() => {
       purgeEmbeddings(db, { dropVecTable: true });
+      purgeEmbeddingSalvage(db);
       deleteMeta(db, "embeddingDim");
       setMeta(db, "embeddingFingerprint", currentFingerprint);
       deleteMeta(db, "embeddingIdentity");
@@ -97300,6 +97524,7 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
     if (decision.outcome === "rebuild") {
       db.transaction(() => {
         purgeEmbeddings(db, { dropVecTable: true });
+        purgeEmbeddingSalvage(db);
         deleteMeta(db, "embeddingDim");
         setMeta(db, "embeddingFingerprint", currentFingerprint);
         if (decision.identity)
@@ -97311,6 +97536,7 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
       rebuildReason = decision.reason;
     } else {
       setMeta(db, "embeddingFingerprint", currentFingerprint);
+      relabelEmbeddingSalvageFingerprint(db, storedFingerprint, currentFingerprint);
       if (decision.identity)
         setMeta(db, "embeddingIdentity", decision.identity);
       if (decision.verified) {
@@ -97321,28 +97547,66 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
         onProgress({ phase: "embeddings", message });
       }
     }
+  } else {
+    setMeta(db, "embeddingFingerprint", currentFingerprint);
   }
   try {
     throwIfAborted(signal);
     const allEntries = getAllEntriesForEmbedding(db, targetEntryIds);
-    if (allEntries.length === 0) {
+    let vecFailedCount = 0;
+    let vecUnavailableCount = 0;
+    const { reusedCount, remaining: candidateEntries } = reuseSalvagedEmbeddings(db, allEntries, currentFingerprint, (entry, embedding) => {
+      const result = upsertEmbedding(db, entry.id, embedding);
+      if (result.vec === "failed")
+        vecFailedCount++;
+      if (result.vec === "unavailable")
+        vecUnavailableCount++;
+      return result.stored;
+    });
+    if (reusedCount > 0) {
+      onProgress({
+        phase: "embeddings",
+        message: `Reused ${reusedCount} embedding${reusedCount === 1 ? "" : "s"} from the previous generation; embedding ${candidateEntries.length} new.`
+      });
+    }
+    if (candidateEntries.length === 0) {
       onProgress({ phase: "embeddings", message: "Embeddings already up to date." });
       setMeta(db, "embeddingFingerprint", currentFingerprint);
-      return { success: true };
+      if (reusedCount > 0) {
+        const vecGenerationComplete = targetEntryIds === undefined ? isVecFastPathComplete(db) : vecFastPathWasReady;
+        setVecFastPathReady(db, vecFailedCount === 0 && vecUnavailableCount === 0 && vecGenerationComplete);
+      }
+      purgeEmbeddingSalvage(db);
+      return reusedCount > 0 ? { success: true, vecInsertFailures: vecFailedCount } : { success: true };
+    }
+    const maxInputTokens = config.embedding?.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
+    let truncatedCount = 0;
+    const texts = [];
+    const pendingEntries = [];
+    for (const entry of candidateEntries) {
+      const capped = capEmbeddingText(entry.searchText, maxInputTokens);
+      if (capped.text.length === 0)
+        continue;
+      if (capped.truncated)
+        truncatedCount++;
+      pendingEntries.push(entry);
+      texts.push(capped.text);
+    }
+    if (truncatedCount > 0) {
+      const message = `[embed] ${truncatedCount} entr${truncatedCount === 1 ? "y" : "ies"} truncated to the ${maxInputTokens}-token embedding cap (embedding.maxInputTokens); rerun with a higher cap to embed the full text.`;
+      onProgress({ phase: "embeddings", message });
     }
     if (rebuildReason) {
-      const message = `[embed] Re-embedding ${allEntries.length} entr${allEntries.length === 1 ? "y" : "ies"} because ${rebuildReason}`;
-      warn(message);
+      const message = `[embed] Re-embedding ${pendingEntries.length} entr${pendingEntries.length === 1 ? "y" : "ies"} because ${rebuildReason}`;
       onProgress({ phase: "embeddings", message });
     }
     onProgress({
       phase: "embeddings",
-      message: `Generating embeddings for ${allEntries.length} entr${allEntries.length === 1 ? "y" : "ies"}.`
+      message: `Generating embeddings for ${pendingEntries.length} entr${pendingEntries.length === 1 ? "y" : "ies"}.`
     });
-    const texts = allEntries.map((entry) => entry.searchText);
     if (isVerbose()) {
       if (hasRemoteEndpoint(config.embedding ?? {})) {
-        const tokenBudget = config.embedding?.maxTokens ?? config.embedding?.contextLength ?? DEFAULT_TOKEN_BUDGET;
+        const tokenBudget = config.embedding?.maxTokens ?? DEFAULT_TOKEN_BUDGET;
         const maxCount = config.embedding?.batchSize ?? DEFAULT_REMOTE_BATCH_SIZE;
         const batches = buildTokenBoundedBatches(texts, tokenBudget, maxCount);
         const batchNumberByIndex = new Map;
@@ -97350,7 +97614,7 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
           for (const i of batch.indices)
             batchNumberByIndex.set(i, batchIdx + 1);
         });
-        for (const [i, entry] of allEntries.entries()) {
+        for (const [i, entry] of pendingEntries.entries()) {
           const chars = entry.searchText.length;
           const tokens = estimateTokenCount(entry.searchText);
           const batch = batches[batchNumberByIndex.get(i) - 1];
@@ -97358,7 +97622,7 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
           warnVerbose(`[embed] ${entry.itemRef} (${chars} chars, est. ${tokens} tokens) \u2192 ${label}`);
         }
       } else {
-        for (const entry of allEntries) {
+        for (const entry of pendingEntries) {
           warnVerbose(`[embed] ${entry.itemRef} (${entry.searchText.length} chars, est. ${estimateTokenCount(entry.searchText)} tokens)`);
         }
       }
@@ -97367,27 +97631,58 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
     let storedCount = 0;
     let skippedCount = 0;
     let embedFailedCount = 0;
-    let vecFailedCount = 0;
-    let vecUnavailableCount = 0;
     let storedTokens = 0;
-    let lastProgressBucket = 0;
     try {
       heartbeatTimer = setInterval(() => {
         onProgress({
           phase: "embeddings",
-          message: `Still generating embeddings: ${storedCount}/${allEntries.length} stored; waiting on embedding provider.`
+          message: formatEmbeddingHeartbeat(storedCount, pendingEntries.length, embedFailedCount)
         });
       }, 15000);
       const skips = [];
       const embedStart = Date.now();
+      let consecutiveSingleDocFailures = 0;
+      let consecutiveNetworkErrorFailures = 0;
+      let circuitBreakerReason;
+      const onSkip = (skip) => {
+        skips.push(skip);
+        if (!skip.batchStart)
+          return;
+        if (skip.reason === "context-window-exceeded") {
+          consecutiveSingleDocFailures = 0;
+          consecutiveNetworkErrorFailures = 0;
+          return;
+        }
+        consecutiveSingleDocFailures = skip.batchSize === 1 ? consecutiveSingleDocFailures + 1 : 0;
+        consecutiveNetworkErrorFailures = skip.failureKind === "network-error" ? consecutiveNetworkErrorFailures + 1 : 0;
+        if (consecutiveSingleDocFailures >= CIRCUIT_BREAKER_THRESHOLD || consecutiveNetworkErrorFailures >= CIRCUIT_BREAKER_THRESHOLD) {
+          circuitBreakerReason = skip.message;
+          return false;
+        }
+        return;
+      };
       let observedModel;
       let observedVectorLen;
-      const onBatch = (indices, batchEmbeddings, model) => {
+      const reportPerBatchLine = hasRemoteEndpoint(config.embedding ?? {});
+      const onBatch = (indices, batchEmbeddings, model, outcome) => {
+        if (outcome?.outcome === "retrying") {
+          if (reportPerBatchLine) {
+            onProgress({
+              phase: "embeddings",
+              message: `[embed] batch ${outcome.batchIndex}/${outcome.batchCount}: ${outcome.docCount} docs, ${outcome.requestTokens.toLocaleString()} tokens \u2192 retrying after ${(outcome.elapsedMs / 1000).toFixed(1)} s`
+            });
+          }
+          return;
+        }
         if (model)
           observedModel = model;
+        if (batchEmbeddings.some((embedding) => embedding !== undefined)) {
+          consecutiveSingleDocFailures = 0;
+          consecutiveNetworkErrorFailures = 0;
+        }
         db.transaction(() => {
           for (let k2 = 0;k2 < indices.length; k2++) {
-            const entry = allEntries[indices[k2]];
+            const entry = pendingEntries[indices[k2]];
             if (!entry)
               continue;
             const embedding = batchEmbeddings[k2];
@@ -97410,29 +97705,25 @@ async function generateEmbeddingsForDb(db, config, onProgress, signal, entryIds,
               vecUnavailableCount++;
           }
         })();
-        const bucket = Math.floor(storedCount / PROGRESS_INTERVAL);
-        if (bucket > lastProgressBucket) {
-          lastProgressBucket = bucket;
+        if (outcome && outcome.reason !== "oversized" && reportPerBatchLine) {
+          const elapsedSeconds2 = (outcome.elapsedMs / 1000).toFixed(1);
+          const outcomeLabel = outcome.outcome === "stored" ? `${outcome.docCount} stored (${elapsedSeconds2} s)` : `failed: ${outcome.reason}`;
           onProgress({
             phase: "embeddings",
-            message: `Embedded ${storedCount}/${allEntries.length} entries.`
+            message: `[embed] batch ${outcome.batchIndex}/${outcome.batchCount}: ${outcome.docCount} docs, ${outcome.requestTokens.toLocaleString()} tokens \u2192 ${outcomeLabel}`
           });
         }
+        onProgress({
+          phase: "embeddings",
+          message: `Embedded ${storedCount}/${pendingEntries.length} entries.`
+        });
       };
-      await embedBatch(texts, config.embedding, signal, (skip) => skips.push(skip), onBatch);
+      await embedBatch(texts, config.embedding, signal, onSkip, onBatch);
       throwIfAborted(signal);
       const elapsedSeconds = Math.max((Date.now() - embedStart) / 1000, 0.001);
       if (skippedCount > 0) {
         warn(`[embed] ${skippedCount} embedding${skippedCount === 1 ? "" : "s"} skipped (entry deleted between queue and write)`);
       }
-      if (embedFailedCount > 0) {
-        const detail = skips.slice(0, 20).map((skip) => `  - ${allEntries[skip.index]?.itemRef ?? skip.index} (${skip.reason}): ${skip.message}`).join(`
-`);
-        const more = skips.length > 20 ? `
-  ...and ${skips.length - 20} more` : "";
-        warn(`[embed] ${embedFailedCount} embedding${embedFailedCount === 1 ? "" : "s"} could not be generated and ${embedFailedCount === 1 ? "was" : "were"} skipped:
-${detail}${more}`);
-      }
       const vecGenerationComplete = targetEntryIds === undefined ? isVecFastPathComplete(db) : vecFastPathWasReady;
       setVecFastPathReady(db, vecFailedCount === 0 && vecUnavailableCount === 0 && vecGenerationComplete);
       if (vecFailedCount > 0) {
@@ -97440,14 +97731,39 @@ ${detail}${more}`);
       }
       const entriesPerSec = storedCount / elapsedSeconds;
       const tokensPerSec = storedTokens / elapsedSeconds;
+      const totalStored = storedCount + reusedCount;
+      const oversizedSkips = skips.filter((skip) => skip.reason === "context-window-exceeded");
+      const timedOutSkips = skips.filter((skip) => skip.reason === "batch-request-failed" && skip.failureKind === "timeout");
+      const failedSkips = skips.filter((skip) => skip.reason === "batch-request-failed" && skip.failureKind !== "timeout");
+      const throughputLine = reusedCount > 0 ? `Stored ${totalStored} embedding${totalStored === 1 ? "" : "s"} (${reusedCount} reused, ${storedCount} newly embedded) in ${elapsedSeconds.toFixed(1)}s (${entriesPerSec.toFixed(1)} entries/s, ~${Math.round(tokensPerSec)} tokens/s)` : `Stored ${storedCount} embedding${storedCount === 1 ? "" : "s"} in ${elapsedSeconds.toFixed(1)}s (${entriesPerSec.toFixed(1)} entries/s, ~${Math.round(tokensPerSec)} tokens/s)`;
       onProgress({
         phase: "embeddings",
-        message: `Stored ${storedCount} embedding${storedCount === 1 ? "" : "s"} in ${elapsedSeconds.toFixed(1)}s (${entriesPerSec.toFixed(1)} entries/s, ~${Math.round(tokensPerSec)} tokens/s).`
+        message: `${throughputLine}; ${oversizedSkips.length} oversized skipped, ${timedOutSkips.length} timed out, ${failedSkips.length} failed.`
       });
+      const printSkipList = (label, skipList) => {
+        if (skipList.length === 0)
+          return;
+        const limit = isVerbose() ? skipList.length : 20;
+        const listed = skipList.slice(0, limit).map((skip) => `  - ${pendingEntries[skip.index]?.itemRef ?? skip.index}: ${skip.message}`).join(`
+`);
+        const more = skipList.length > limit ? `
+  ...and ${skipList.length - limit} more` : "";
+        onProgress({ phase: "embeddings", message: `[embed] ${label} skipped:
+${listed}${more}` });
+      };
+      printSkipList("oversized documents", oversizedSkips);
+      printSkipList("timed-out documents", timedOutSkips);
+      printSkipList("failed documents", failedSkips);
       setMeta(db, "embeddingFingerprint", currentFingerprint);
       const observedIdentity = deriveObservedEmbeddingIdentity(config.embedding, observedModel, observedVectorLen);
       if (observedIdentity)
         setMeta(db, "embeddingIdentity", observedIdentity);
+      if (circuitBreakerReason !== undefined) {
+        const message = `embedding provider failed ${CIRCUIT_BREAKER_THRESHOLD} consecutive batches ` + `(last: ${circuitBreakerReason}); stopped after ${storedCount} embedding${storedCount === 1 ? "" : "s"} ` + "were stored \u2014 rerun akm index when the endpoint is healthy";
+        warn(`[embed] ${message}`);
+        onProgress({ phase: "embeddings", message });
+        return { success: false, message, vecInsertFailures: vecFailedCount };
+      }
       if (storedCount === 0 && embedFailedCount > 0) {
         const firstMessage = skips[0]?.message ?? "All embeddings failed.";
         return {
@@ -97455,6 +97771,7 @@ ${detail}${more}`);
           message: `All ${embedFailedCount} embedding batch(es) failed: ${firstMessage}`
         };
       }
+      purgeEmbeddingSalvage(db);
       return { success: true, vecInsertFailures: vecFailedCount };
     } finally {
       if (heartbeatTimer)
@@ -97871,7 +98188,11 @@ async function indexWrittenAssets(stashDir, filePaths, options = {}) {
     return await (async () => {
       const rebuildProbe = probeLock(getIndexRebuildLockPath());
       if (rebuildProbe.state === "held") {
-        warn(`index rebuild in progress (pid ${rebuildProbe.holderPid}); the next index pass will index ${filePaths.join(", ")}`);
+        const holderLabel = formatLockHolderPid({
+          pid: rebuildProbe.holderPid,
+          launcherPid: rebuildProbe.launcherPid ?? null
+        });
+        warn(`index rebuild in progress (pid ${holderLabel}); the next index pass will index ${filePaths.join(", ")}`);
         return true;
       }
       const dbPath = getDbPath();
@@ -98845,7 +99166,7 @@ var PROPOSAL_TXN_PHASES = [
   "committed"
 ];
 function proposalHash(content) {
-  return createHash10("sha256").update(content).digest("hex");
+  return createHash11("sha256").update(content).digest("hex");
 }
 function proposalFileHash(filePath) {
   return proposalHash(fs55.readFileSync(filePath));