akm-cli 0.9.15 → 0.9.16-alpha.1

package/dist/scripts/akm-migrate.js

@@ -7043,7 +7043,8 @@ var init_errors = __esm(() => {
     UNSAFE_STASH_DIR: "Choose a path inside your home directory (e.g. ~/akm) or another empty workspace. The bundle directory cannot be the filesystem root, your home directory itself, or a sensitive system path like /etc, /var, ~/.config, or ~/.ssh.",
     UNKNOWN_IMPROVE_STRATEGY: "Pass one of the listed strategy names to `--strategy`, or define it under `improve.strategies`. Names are case-sensitive.",
     EXECUTION_NOT_AUTHORIZED: "Change the selected tools or update the machine/user execution policy, then retry.",
-    SECRET_REFERENCE_UNRESOLVED: "Check the secret exists (`akm secret list`) and the name after `secret://` matches, or run `akm secret set <name> <value>` to store it."
+    SECRET_REFERENCE_UNRESOLVED: "Check the secret exists (`akm secret list`) and the name after `secret://` matches, or run `akm secret set <name> <value>` to store it.",
+    EMBEDDING_VEC_UNAVAILABLE: "Install sqlite-vec for unit-level semantic search, or rely on lexical search until it is available."
   };
   COMPOSITION_INVALID_MULTI_JOB_HINT = "AKM workflows support exactly one job per source, with no needs: between jobs. Split the extra job(s) into " + "their own workflow file, and compose them with uses: workflows/<ref> instead.";
   USAGE_HINTS = {
@@ -7070,8 +7071,8 @@ 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.",
-    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.",
+    INDEX_DB_CONTENDED: "Another akm process is writing index.db right now. Wait a few seconds and retry \u2014 index runs take no rebuild " + "lock, so this clears quickly; a scheduled run left alone will simply run again next time.",
+    MAINTENANCE_BARRIER_BUSY: "Another akm process is registering a lock or lease right now. Retry shortly, or pass --skip-if-locked on " + "scheduled improve runs to skip gracefully instead \u2014 workflow run does not treat this code as skippable.",
     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 = {
@@ -7539,9 +7540,6 @@ function getDataDir(env = process.env, platform = process.platform) {
 function getDbPath(env = process.env) {
   return path3.join(getDataDir(env), "index.db");
 }
-function getIndexRebuildLockPath() {
-  return path3.join(getDataDir(), "index.rebuild.lock");
-}
 function getMaintenanceBarrierPath() {
   return path3.join(getDataDir(), "maintenance.barrier.lock");
 }
@@ -8173,14 +8171,6 @@ var init_common = __esm(() => {
 });
 
 // src/core/recognition-util.ts
-function canonicalizeWorkflowName(name) {
-  const lower = name.toLowerCase();
-  for (const ext of WORKFLOW_EXTENSIONS) {
-    if (lower.endsWith(ext))
-      return name.slice(0, -ext.length);
-  }
-  return name;
-}
 function isKnownType(type) {
   return KNOWN_TYPES.includes(type);
 }
@@ -8276,6 +8266,9 @@ function assetPathCandidatesForName(assetType, typeRoot, name) {
   const namedForm = path7.join(typeRoot, base, "default.env");
   return [...new Set([primary, dotForm, namedForm])];
 }
+function assetPathCandidatesAreOrderedByPreference(assetType) {
+  return assetType === "memory";
+}
 var workflowSpec, markdownSpec, scriptSpec, BUILTIN_PLACEMENT_SPECS, PLACEMENT_SPECS;
 var init_asset_placement = __esm(() => {
   init_common();
@@ -11389,7 +11382,8 @@ function applyPostContributorFields(entry, file, canonicalName, dirPath) {
   }
   entry.tags = [...entry.tags ?? [], ...extractDirTagsFromName(canonicalName)];
   entry.tags = normalizeTerms(entry.tags ?? []);
-  entry.aliases = mergeAliases(entry.aliases, buildAliases(canonicalName, entry.tags));
+  const aliasTagInput = entry.type === "memory" && canonicalName.toLowerCase().endsWith(".derived") ? entry.tags.filter((tag) => tag !== "derived") : entry.tags;
+  entry.aliases = mergeAliases(entry.aliases, buildAliases(canonicalName, aliasTagInput));
   entry.filename = path17.basename(file);
 }
 function buildMetadataSkipWarning(filePath, assetType, error) {
@@ -35706,7 +35700,7 @@ var require_libvips = __commonJS((exports, module) => {
     SPDX-License-Identifier: Apache-2.0
   */
   var { spawnSync: spawnSync6 } = __require("child_process");
-  var { createHash: createHash11 } = __require("crypto");
+  var { createHash: createHash10 } = __require("crypto");
   var semverCoerce = require_coerce2();
   var semverGreaterThanOrEqualTo = require_gte2();
   var semverSatisfies = require_satisfies2();
@@ -35794,7 +35788,7 @@ var require_libvips = __commonJS((exports, module) => {
     }
     return false;
   };
-  var sha512 = (s) => createHash11("sha512").update(s).digest("hex");
+  var sha512 = (s) => createHash10("sha512").update(s).digest("hex");
   var yarnLocator = () => {
     try {
       const identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`);
@@ -43246,8 +43240,8 @@ function cos_sim(arr1, arr2) {
   const dotProduct = dot(arr1, arr2);
   const magnitudeA = magnitude(arr1);
   const magnitudeB = magnitude(arr2);
-  const cosineSimilarity2 = dotProduct / (magnitudeA * magnitudeB);
-  return cosineSimilarity2;
+  const cosineSimilarity = dotProduct / (magnitudeA * magnitudeB);
+  return cosineSimilarity;
 }
 function magnitude(arr) {
   return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
@@ -68186,7 +68180,7 @@ ${this.boa_token}${this.audio_token.repeat(this._compute_audio_num_tokens(audio_
 });
 
 // src/indexer/walk/file-context.ts
-import fs51 from "fs";
+import fs49 from "fs";
 import path61 from "path";
 function buildFileContext(stashRoot, absPath) {
   const relPath = toPosix(path61.relative(stashRoot, absPath));
@@ -68211,7 +68205,7 @@ function buildFileContext(stashRoot, absPath) {
     stashRoot,
     content() {
       if (cachedContent === undefined) {
-        cachedContent = fs51.readFileSync(absPath, "utf8");
+        cachedContent = fs49.readFileSync(absPath, "utf8");
       }
       return cachedContent;
     },
@@ -68226,7 +68220,7 @@ function buildFileContext(stashRoot, absPath) {
     },
     stat() {
       if (cachedStat === undefined) {
-        cachedStat = fs51.statSync(absPath);
+        cachedStat = fs49.statSync(absPath);
       }
       return cachedStat;
     }
@@ -69024,6 +69018,7 @@ var PASSTHROUGH_COMMANDS = [
   "improve-report",
   "import",
   "index",
+  "index-status",
   "info",
   "lint",
   "list",
@@ -69968,7 +69963,7 @@ Config saved to ${r.configPath}`;
 }
 function formatIndexPlain(r) {
   const indexResult = r;
-  let out = `Indexed ${indexResult.totalEntries ?? 0} entries from ${indexResult.directoriesScanned ?? 0} directories (mode: ${indexResult.mode ?? "unknown"})`;
+  let out = `Indexed ${indexResult.totalEntries ?? 0} entries from ${indexResult.sourcesScanned ?? 0} source${indexResult.sourcesScanned === 1 ? "" : "s"} (mode: ${indexResult.mode ?? "unknown"})`;
   const warnings = indexResult.warnings;
   if (Array.isArray(warnings) && warnings.length > 0) {
     out += `
@@ -69977,13 +69972,6 @@ Warnings (${warnings.length}):`;
       out += `
   - ${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 += `
-  notice[${severity}] ${notice.code} adapter=${notice.adapter}${field}` + (notice.message ? `: ${notice.message}` : "");
-  }
   const verification = indexResult.verification;
   if (verification?.ok === false && verification.message) {
     out += `
@@ -69992,10 +69980,26 @@ Verification: ${String(verification.message)}`;
   const timing = indexResult.timing;
   if (timing) {
     out += `
-Timing: total ${timing.totalMs}ms` + `, preflight ${timing.preflightMs}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`;
+Timing: total ${timing.totalMs}ms` + `, preflight ${timing.preflightMs}ms` + `, source cache ${timing.sourceCacheMs}ms` + `, reconcile ${timing.reconcileMs}ms` + `, embeddings ${timing.embedMs}ms` + `, finalize ${timing.finalizeMs}ms` + `, end-to-end ${timing.endToEndMs}ms`;
   }
   return out;
 }
+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(`
+`);
+}
 function formatListPlain(r) {
   const sources = Array.isArray(r.sources) ? r.sources : [];
   if (sources.length === 0)
@@ -75248,10 +75252,6 @@ 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(),
-  contextLength: positiveInt.optional(),
   ollamaOptions: EmbeddingOllamaOptionsSchema.optional(),
   timeoutMs: positiveInt.optional(),
   concurrency: positiveInt.max(16).optional()
@@ -75707,19 +75707,18 @@ 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({
+var SearchRerankConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional(),
   endpoint: httpUrl.optional(),
   model: nonEmptyString.optional(),
-  apiKey: symbolicOrWarnApiKey("search.curateRerank.apiKey").optional(),
+  apiKey: symbolicOrWarnApiKey("search.rerank.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(),
-  curateRerank: CurateRerankConfigSchema.optional()
+  rerank: SearchRerankConfigSchema.optional()
 }).passthrough();
 
 // src/core/config/schema/setup.ts
@@ -82895,7 +82894,7 @@ function foldRecognizedMetadata(rendererName, file) {
         const fm = parseFrontmatter(file.content()).data;
         applyFrontmatterDescriptionAndTags(fm, out);
         const hints = new Set;
-        const source = nonEmptyString2(fm.source);
+        const source = fm.inferred === true ? undefined : nonEmptyString2(fm.source);
         if (source)
           hints.add(source);
         const fmObservedAt = nonEmptyString2(fm.observed_at);
@@ -83344,9 +83343,23 @@ var akmAdapter = {
       return [];
     const canonical = assetPathCandidatesForName(type, path24.join(c.root, head), rest);
     const loose = assetPathCandidatesForName(type, c.root, rest);
-    return [...new Set([...canonical, ...loose])].map((candidatePath) => ({
+    if (!assetPathCandidatesAreOrderedByPreference(type)) {
+      return [...new Set([...canonical, ...loose])].map((candidatePath) => ({
+        path: candidatePath,
+        conceptId: posix
+      }));
+    }
+    const priorityByPath = new Map;
+    for (const list of [canonical, loose]) {
+      list.forEach((candidatePath, rank) => {
+        if (!priorityByPath.has(candidatePath))
+          priorityByPath.set(candidatePath, rank);
+      });
+    }
+    return [...priorityByPath.keys()].map((candidatePath) => ({
       path: candidatePath,
-      conceptId: posix
+      conceptId: posix,
+      priority: priorityByPath.get(candidatePath)
     }));
   },
   placeNew(c, conceptId) {
@@ -93479,6 +93492,7 @@ import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 var attributionStorage = new AsyncLocalStorage3;
 // src/llm/client.ts
 var jsonSchemaUnsupportedConnections = new Set;
+var HEALTH_PROBE_TIMEOUT_MS = 3000;
 
 // src/integrations/agent/model-map.ts
 init_common();
@@ -93670,7 +93684,10 @@ var improveReportFormatters = [
 ];
 
 // src/output/text/index.ts
-var indexFormatters = [{ command: "index", handler: (r) => formatIndexPlain(r) }];
+var indexFormatters = [
+  { command: "index", handler: (r) => formatIndexPlain(r) },
+  { command: "index-status", handler: (r) => formatIndexStatusPlain(r) }
+];
 
 // src/output/text/info.ts
 var infoFormatters = [{ command: "info", handler: (r) => formatInfoPlain(r) }];
@@ -94940,6 +94957,9 @@ function runMigrations2(db, options) {
   const initialMigration = STATE_MIGRATIONS[0];
   if (!initialMigration)
     throw new Error("State migration registry has no initial migration.");
+  const finalMigration = STATE_MIGRATIONS[STATE_MIGRATIONS.length - 1];
+  if (!finalMigration)
+    throw new Error("State migration registry has no final migration.");
   let existingUnversionedSnapshotPrepared = false;
   const prepareExistingUnversionedState = (lockedDb) => {
     if (existingUnversionedSnapshotPrepared)
@@ -94961,7 +94981,7 @@ function runMigrations2(db, options) {
     existingUnversionedSnapshotPrepared = true;
   };
   runMigrations(db, STATE_MIGRATIONS, {
-    lockInitialMigrationPrefixThrough: options?.existingUnversionedDatabase ? "002-task-history-per-run" : undefined,
+    lockInitialMigrationPrefixThrough: options?.existingUnversionedDatabase ? "002-task-history-per-run" : options?.freshDatabase ? finalMigration.id : undefined,
     beforeLedgerInitializationLocked(lockedDb) {
       if (options?.freshDatabase)
         return;
@@ -95222,10 +95242,13 @@ function openStateDatabase(dbPath, options) {
       });
       try {
         preflight.exec("PRAGMA busy_timeout = 30000");
-        const ledger = assertMigrationLedger(preflight, STATE_MIGRATIONS);
+        const { ledger, hasNoOtherTables } = preflight.transaction(() => ({
+          ledger: assertMigrationLedger(preflight, STATE_MIGRATIONS),
+          hasNoOtherTables: unversionedDatabaseHasNoTables(preflight)
+        }))();
         warnNewerStateLedger(ledger);
         existingUnversionedDatabase = ledger.migrationIds.length === 0;
-        if (existingUnversionedDatabase && unversionedDatabaseHasNoTables(preflight)) {
+        if (existingUnversionedDatabase && hasNoOtherTables) {
           existingUnversionedDatabase = false;
           treatUnversionedAsFresh = true;
         }
@@ -95307,7 +95330,7 @@ function openStateDatabase(dbPath, options) {
     if (freshReservation)
       closeFileIdentity(freshReservation);
     releaseActivity?.();
-    throw error;
+    throwBeginFailure(error, "state");
   }
 }
 function listPendingStateMigrations(dbPath = getStateDbPath()) {
@@ -95361,15 +95384,15 @@ function sleepSyncMs2(ms) {
     return;
   sleepSync(ms);
 }
-function throwBeginFailure(err) {
+function throwBeginFailure(err, dbKind) {
   if (isSqliteContentionError(err)) {
-    const contended = new TransientError("akm's state database is busy (another akm process is writing it); retry shortly.", "STATE_DB_CONTENDED");
+    const contended = dbKind === "index" ? new TransientError("akm's index database is busy (another akm process is writing it); retry shortly.", "INDEX_DB_CONTENDED") : new TransientError("akm's state database is busy (another akm process is writing it); retry shortly.", "STATE_DB_CONTENDED");
     contended.cause = err;
     throw contended;
   }
   throw err;
 }
-function beginImmediateTransaction(db) {
+function beginImmediateTransaction(db, dbKind = "state") {
   if (db.inTransaction) {
     throw new Error("beginImmediateTransaction requires a connection with no active transaction");
   }
@@ -95392,16 +95415,16 @@ function beginImmediateTransaction(db) {
         sleepSyncMs2(2 ** (attempt - 1));
         continue;
       }
-      throwBeginFailure(err);
+      throwBeginFailure(err, dbKind);
     }
   }
-  throwBeginFailure(lastBeginErr);
+  throwBeginFailure(lastBeginErr, dbKind);
 }
-function withImmediateTransaction(db, fn) {
+function withImmediateTransaction(db, fn, dbKind = "state") {
   if (db.inTransaction) {
     return fn();
   }
-  beginImmediateTransaction(db);
+  beginImmediateTransaction(db, dbKind);
   try {
     const result = fn();
     if (!db.inTransaction) {
@@ -95737,9 +95760,9 @@ function listTxnJournalsTolerant(predicate) {
 
 // src/commands/proposal/repository.ts
 import { createHash as createHash11, randomUUID as randomUUID6 } from "crypto";
-import fs55 from "fs";
+import fs53 from "fs";
 init_dist();
-import path66 from "path";
+import path65 from "path";
 
 // src/core/adapter/validate-context.ts
 init_asset_placement();
@@ -95798,20 +95821,9 @@ init_warn();
 init_write_provenance();
 
 // src/indexer/index-written-assets.ts
-import fs53 from "fs";
-import path64 from "path";
+import path63 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
@@ -95820,7 +95832,7 @@ init_paths();
 init_warn();
 
 // src/storage/repositories/index-entry-schema.ts
-var CANONICAL_INDEX_DB_VERSION = 23;
+var CANONICAL_INDEX_DB_VERSION = 24;
 var CANONICAL_ENTRY_SCHEMA_FINGERPRINT = {
   tableSql: "CREATE TABLE entries ( id INTEGER PRIMARY KEY AUTOINCREMENT, item_ref TEXT NOT NULL UNIQUE, bundle_id TEXT NOT NULL, component_id TEXT NOT NULL, concept_id TEXT NOT NULL, adapter_id TEXT NOT NULL, type TEXT NOT NULL, file_path TEXT NOT NULL, content_hash TEXT, document_json TEXT NOT NULL, search_text TEXT NOT NULL, derived_from TEXT )",
   sqliteSequenceTable: true,
@@ -95972,9 +95984,7 @@ var CANONICAL_ENTRY_SCHEMA_FINGERPRINT = {
     }
   ],
   searchSurfaces: {
-    entriesFtsSql: "CREATE VIRTUAL TABLE entries_fts USING fts5( entry_id UNINDEXED, name, description, tags, hints, content, tokenize='porter unicode61' )",
-    fragmentSourceSql: "CREATE TABLE entry_fragments ( entry_id INTEGER PRIMARY KEY REFERENCES entries(id) ON DELETE CASCADE, safe_markdown TEXT NOT NULL )",
-    fragmentsFtsSql: "CREATE VIRTUAL TABLE entry_fragments_fts USING fts5( entry_id UNINDEXED, fragment_id UNINDEXED, fragment_ordinal UNINDEXED, content, tokenize='porter unicode61' )"
+    fragmentSourceSql: "CREATE TABLE entry_fragments ( entry_id INTEGER PRIMARY KEY REFERENCES entries(id) ON DELETE CASCADE, safe_markdown TEXT NOT NULL )"
   }
 };
 function sqlString(value) {
@@ -96024,9 +96034,7 @@ function readEntrySchemaFingerprint(db) {
     columns,
     indexes,
     searchSurfaces: {
-      entriesFtsSql: readNamedTableSql(db, "entries_fts"),
-      fragmentSourceSql: readNamedTableSql(db, "entry_fragments"),
-      fragmentsFtsSql: readNamedTableSql(db, "entry_fragments_fts")
+      fragmentSourceSql: readNamedTableSql(db, "entry_fragments")
     }
   };
 }
@@ -96066,13 +96074,66 @@ function isCanonicalIndexGeneration(db) {
 init_errors();
 init_warn();
 
-// src/storage/repositories/embedding-salvage-repository.ts
-import { createHash as createHash9 } from "crypto";
+// src/storage/repositories/index-sql.ts
+var SQLITE_CHUNK_SIZE = 500;
 
-// 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/files-repository.ts
+function rowToFileState(row) {
+  return {
+    path: row.path,
+    bundleId: row.bundle_id,
+    size: row.size,
+    mtimeMs: row.mtime_ms,
+    ctimeMs: row.ctime_ms,
+    blobHash: row.blob_hash,
+    adapterId: row.adapter_id
+  };
+}
+function getFileState(db, path58) {
+  const row = db.prepare("SELECT path, bundle_id, size, mtime_ms, ctime_ms, blob_hash, adapter_id FROM files WHERE path = ?").get(path58);
+  return row ? rowToFileState(row) : undefined;
+}
+function upsertFileState(db, row) {
+  db.prepare(`INSERT INTO files (path, bundle_id, size, mtime_ms, ctime_ms, blob_hash, adapter_id) VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(path) DO UPDATE SET bundle_id = excluded.bundle_id, size = excluded.size,
+         mtime_ms = excluded.mtime_ms, ctime_ms = excluded.ctime_ms, blob_hash = excluded.blob_hash,
+         adapter_id = excluded.adapter_id`).run(row.path, row.bundleId, row.size, row.mtimeMs, row.ctimeMs, row.blobHash, row.adapterId);
+}
+function deleteFileStates(db, paths) {
+  for (let offset = 0;offset < paths.length; offset += SQLITE_CHUNK_SIZE) {
+    const chunk = paths.slice(offset, offset + SQLITE_CHUNK_SIZE);
+    const placeholders = chunk.map(() => "?").join(",");
+    db.prepare(`DELETE FROM files WHERE path IN (${placeholders})`).run(...chunk);
+  }
+}
+function insertNewUnitTexts(db, units) {
+  if (units.length === 0)
+    return { inserted: 0 };
+  const insertText = db.prepare("INSERT OR IGNORE INTO unit_texts (unit_hash, kind, text) VALUES (?, ?, ?)");
+  const insertFts = db.prepare("INSERT INTO units_fts (unit_hash, text) VALUES (?, ?)");
+  let inserted = 0;
+  for (const unit of units) {
+    const result = insertText.run(unit.hash, unit.kind, unit.text);
+    if (Number(result.changes) > 0) {
+      insertFts.run(unit.hash, unit.text);
+      inserted++;
+    }
+  }
+  return { inserted };
+}
+function pruneOrphanUnitTextsForHashes(db, hashes) {
+  const unique = [...new Set(hashes)];
+  if (unique.length === 0)
+    return { removed: 0 };
+  let removed = 0;
+  for (let offset = 0;offset < unique.length; offset += SQLITE_CHUNK_SIZE) {
+    const chunk = unique.slice(offset, offset + SQLITE_CHUNK_SIZE);
+    const placeholders = chunk.map(() => "?").join(",");
+    db.prepare(`DELETE FROM units_fts WHERE unit_hash IN (${placeholders}) AND NOT EXISTS ` + `(SELECT 1 FROM entry_units WHERE entry_units.unit_hash = units_fts.unit_hash)`).run(...chunk);
+    const result = db.prepare(`DELETE FROM unit_texts WHERE unit_hash IN (${placeholders}) AND NOT EXISTS ` + `(SELECT 1 FROM entry_units WHERE entry_units.unit_hash = unit_texts.unit_hash)`).run(...chunk);
+    removed += Number(result.changes);
+  }
+  return { removed };
 }
 
 // src/storage/repositories/index-meta-repository.ts
@@ -96083,112 +96144,16 @@ function getMeta(db, key) {
 function setMeta(db, key, value) {
   db.prepare("INSERT OR REPLACE INTO index_meta (key, value) VALUES (?, ?)").run(key, value);
 }
-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";
-
-// src/core/best-effort.ts
-init_warn();
-function bestEffort(fn, context) {
-  try {
-    return fn();
-  } catch (err) {
-    if (isVerbose()) {
-      warnVerbose(`[akm:best-effort] ${context ? `${context}: ` : ""}swallowed error`, err);
-    }
-    return;
-  }
-}
-
-// src/storage/repositories/index-vec-repository.ts
-init_warn();
-
-// src/llm/embedders/types.ts
-init_warn();
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    warn("cosineSimilarity: vector dimension mismatch (%d vs %d) \u2014 re-index recommended", a.length, b.length);
-    return 0;
-  }
-  const len = a.length;
-  if (len === 0)
-    return 0;
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0;i < len; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(magA) * Math.sqrt(magB);
-  return denom === 0 ? 0 : dot / denom;
-}
-
-// src/storage/repositories/index-vec-repository.ts
 var vecStatus = new WeakMap;
+var forceVecUnavailableForTests = false;
 function loadVecExtension(db) {
+  if (forceVecUnavailableForTests) {
+    vecStatus.set(db, false);
+    return;
+  }
   try {
     const esmRequire = createRequire3(import.meta.url);
     const sqliteVec = esmRequire("sqlite-vec");
@@ -96201,135 +96166,135 @@ function loadVecExtension(db) {
 function isVecAvailable(db) {
   return vecStatus.get(db) ?? false;
 }
-var VEC_FAST_PATH_READY_META = "vecFastPathReady";
-function setVecFastPathReady(db, ready) {
-  setMeta(db, VEC_FAST_PATH_READY_META, ready ? "1" : "0");
+
+// src/storage/repositories/units-repository.ts
+init_errors();
+function createUnitsVecTable(db, dim) {
+  db.exec(`
+    CREATE VIRTUAL TABLE units_vec USING vec0(
+      unit_id   INTEGER PRIMARY KEY,
+      embedding FLOAT[${dim}],
+      +unit_hash TEXT,
+      +identity  TEXT
+    );
+  `);
 }
-function isVecFastPathReady(db) {
-  if (getMeta(db, VEC_FAST_PATH_READY_META) === "0")
-    return false;
-  return hasVecTable(db);
+function tableExists(db, name) {
+  return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(name) != null;
 }
-function isVecFastPathComplete(db) {
-  if (!isVecAvailable(db) || !hasVecTable(db))
-    return false;
-  try {
-    const missingVecRows = db.prepare(`
-        SELECT id FROM embeddings
-        EXCEPT
-        SELECT id FROM entries_vec
-        LIMIT 1
-      `).all();
-    if (missingVecRows.length > 0)
-      return false;
-    const orphanVecRows = db.prepare(`
-        SELECT id FROM entries_vec
-        EXCEPT
-        SELECT id FROM embeddings
-        LIMIT 1
-      `).all();
-    return orphanVecRows.length === 0;
-  } catch {
-    return false;
-  }
+function unitsVecDimension(db) {
+  const row = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'units_vec'").get();
+  const match = row?.sql.match(/FLOAT\[(\d+)\]/);
+  return match?.[1] === undefined ? undefined : Number(match[1]);
 }
-var vecTablePresent = new WeakMap;
-function hasVecTable(db) {
-  if (vecTablePresent.get(db) === true)
-    return true;
-  let present = false;
-  try {
-    present = db.prepare("SELECT 1 FROM sqlite_master WHERE type IN ('table','view') AND name = 'entries_vec'").get() !== undefined;
-  } catch {
-    present = false;
-  }
-  if (present)
-    vecTablePresent.set(db, true);
-  return present;
-}
-function deleteEntryVectors(db, id) {
-  db.prepare("DELETE FROM embeddings WHERE id = ?").run(id);
-  if (isVecAvailable(db))
-    db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id);
-}
-var vecInitWarnedDbs = new WeakSet;
-function purgeEmbeddings(db, opts) {
-  bestEffort(() => db.exec("DELETE FROM embeddings"), "purge embeddings");
-  if (isVecAvailable(db)) {
-    bestEffort(() => db.exec(opts?.dropVecTable ? "DROP TABLE IF EXISTS entries_vec" : "DELETE FROM entries_vec"), "purge entries_vec");
-  }
-  setMeta(db, "hasEmbeddings", "0");
-}
-function upsertEmbedding(db, entryId, embedding) {
-  const exists = db.prepare("SELECT 1 FROM entries WHERE id = ?").get(entryId);
-  if (!exists)
-    return { stored: false, vec: "unavailable" };
-  const buf = float32Buffer(embedding);
-  db.prepare("INSERT OR REPLACE INTO embeddings (id, embedding) VALUES (?, ?)").run(entryId, buf);
+function ensureUnitTables(db, dim) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS units (
+      unit_id   INTEGER PRIMARY KEY,
+      unit_hash TEXT NOT NULL,
+      identity  TEXT NOT NULL,
+      UNIQUE (unit_hash, identity)
+    );
+    CREATE TABLE IF NOT EXISTS entry_units (
+      entry_id    INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE,
+      ordinal     INTEGER NOT NULL,
+      fragment_id TEXT,
+      unit_hash   TEXT NOT NULL,
+      PRIMARY KEY (entry_id, ordinal)
+    );
+    CREATE INDEX IF NOT EXISTS entry_units_hash ON entry_units(unit_hash);
+  `);
   if (!isVecAvailable(db))
-    return { stored: true, vec: "unavailable" };
-  try {
-    db.transaction(() => {
-      db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId);
-      db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf);
-    })();
-    return { stored: true, vec: "ok" };
-  } catch {
-    return { stored: true, vec: "failed" };
+    return;
+  if (tableExists(db, "units_vec"))
+    return;
+  createUnitsVecTable(db, dim);
+}
+function float32Buffer(vector) {
+  return Buffer.from(new Float32Array(vector).buffer);
+}
+function upsertUnitVectors(db, rows) {
+  if (rows.length === 0 || !isVecAvailable(db))
+    return { inserted: 0, failed: 0 };
+  const insertUnit = db.prepare("INSERT INTO units (unit_hash, identity) VALUES (?, ?) ON CONFLICT(unit_hash, identity) DO NOTHING");
+  const selectUnitId = db.prepare("SELECT unit_id FROM units WHERE unit_hash = ? AND identity = ?");
+  const deleteVec = db.prepare("DELETE FROM units_vec WHERE unit_id = ?");
+  const insertVec = db.prepare("INSERT INTO units_vec (unit_id, embedding, unit_hash, identity) VALUES (?, ?, ?, ?)");
+  const deleteUnit = db.prepare("DELETE FROM units WHERE unit_id = ?");
+  const writeOne = (row) => withImmediateTransaction(db, () => {
+    const result = insertUnit.run(row.hash, row.identity);
+    const freshlyInserted = Number(result.changes) > 0;
+    const unitRow = selectUnitId.get(row.hash, row.identity);
+    if (!unitRow)
+      return false;
+    deleteVec.run(unitRow.unit_id);
+    try {
+      insertVec.run(unitRow.unit_id, float32Buffer(row.vector), row.hash, row.identity);
+    } catch (err) {
+      deleteUnit.run(unitRow.unit_id);
+      throw err;
+    }
+    return freshlyInserted;
+  }, "index");
+  let inserted = 0;
+  let failed = 0;
+  for (const row of rows) {
+    try {
+      if (writeOne(row))
+        inserted++;
+    } catch {
+      failed++;
+    }
   }
+  return { inserted, failed };
 }
-function float32Buffer(vec) {
-  const f32 = new Float32Array(vec);
-  return Buffer.from(f32.buffer);
-}
-function bufferToFloat32(buf, expectedDim) {
-  if (buf.byteLength !== expectedDim * 4) {
-    warn("[db] bufferToFloat32: skipping embedding row \u2014 expected %d bytes (%d dim x 4), got %d", expectedDim * 4, expectedDim, buf.byteLength);
-    return null;
-  }
-  const aligned = new ArrayBuffer(buf.byteLength);
-  new Uint8Array(aligned).set(buf);
-  const f32 = new Float32Array(aligned);
-  return Array.from(f32);
-}
-function getAllEntriesForEmbedding(db, entryIds) {
-  const select = `
-      SELECT e.id, e.search_text AS searchText, e.item_ref AS itemRef, e.file_path AS filePath FROM entries e
-    `;
-  const missing = "NOT EXISTS (SELECT 1 FROM embeddings b WHERE b.id = e.id)";
-  if (entryIds === undefined) {
-    return db.prepare(`${select} WHERE ${missing} ORDER BY e.id`).all();
-  }
-  const targets = [...new Set(entryIds)].sort((left, right) => left - right);
-  const rows = [];
-  for (let offset = 0;offset < targets.length; offset += SQLITE_CHUNK_SIZE) {
-    const chunk = targets.slice(offset, offset + SQLITE_CHUNK_SIZE);
-    if (chunk.length === 0)
-      continue;
+function listMissingHashes(db, hashes, identity3) {
+  const unique = [...new Set(hashes)];
+  if (unique.length === 0)
+    return [];
+  const present = new Set;
+  for (let offset = 0;offset < unique.length; offset += SQLITE_CHUNK_SIZE) {
+    const chunk = unique.slice(offset, offset + SQLITE_CHUNK_SIZE);
     const placeholders = chunk.map(() => "?").join(",");
-    rows.push(...db.prepare(`${select} WHERE e.id IN (${placeholders}) AND ${missing} ORDER BY e.id`).all(...chunk));
+    const rows = db.prepare(`SELECT unit_hash FROM units WHERE identity = ? AND unit_hash IN (${placeholders})`).all(identity3, ...chunk);
+    for (const row of rows)
+      present.add(row.unit_hash);
   }
-  return rows;
+  return unique.filter((hash3) => !present.has(hash3));
 }
-function getEmbeddingCount(db) {
-  const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
-  return row.cnt;
+function dropOtherIdentities(db, keep, dim) {
+  if (!isVecAvailable(db))
+    return { removed: 0 };
+  ensureUnitTables(db, dim);
+  const currentDim = unitsVecDimension(db);
+  const widthChanged = currentDim !== undefined && currentDim !== dim;
+  const staleCount = db.prepare("SELECT COUNT(*) AS n FROM units WHERE identity != ?").get(keep).n;
+  if (staleCount === 0 && !widthChanged)
+    return { removed: 0 };
+  withImmediateTransaction(db, () => {
+    if (widthChanged) {
+      db.exec("DROP TABLE IF EXISTS units_vec");
+      createUnitsVecTable(db, dim);
+    } else {
+      const staleIds = db.prepare("SELECT unit_id FROM units WHERE identity != ?").all(keep).map((row) => row.unit_id);
+      for (let offset = 0;offset < staleIds.length; offset += SQLITE_CHUNK_SIZE) {
+        const chunk = staleIds.slice(offset, offset + SQLITE_CHUNK_SIZE);
+        const placeholders = chunk.map(() => "?").join(",");
+        db.prepare(`DELETE FROM units_vec WHERE unit_id IN (${placeholders})`).run(...chunk);
+      }
+    }
+    db.prepare("DELETE FROM units WHERE identity != ?").run(keep);
+  }, "index");
+  return { removed: staleCount };
 }
-function sampleEmbeddedEntriesForCanary(db, limit) {
-  const rows = db.prepare(`
-      SELECT e.id, e.search_text AS searchText, em.embedding AS embedding
-      FROM entries e
-      JOIN embeddings em ON em.id = e.id
-      ORDER BY e.id
-      LIMIT ?
-    `).all(limit);
-  const samples = [];
-  for (const row of rows) {
-    const vector = bufferToFloat32(row.embedding, Math.floor(row.embedding.byteLength / 4));
-    if (vector)
-      samples.push({ id: row.id, searchText: row.searchText, vector });
-  }
-  return samples;
+function replaceEntryUnits(db, entryId, units) {
+  withImmediateTransaction(db, () => {
+    db.prepare("DELETE FROM entry_units WHERE entry_id = ?").run(entryId);
+    const insert = db.prepare("INSERT INTO entry_units (entry_id, ordinal, fragment_id, unit_hash) VALUES (?, ?, ?, ?)");
+    for (const unit of units) {
+      insert.run(entryId, unit.ordinal, unit.fragmentId, unit.hash);
+    }
+  }, "index");
 }
 
 // src/storage/repositories/index-connection.ts
@@ -96378,6 +96343,21 @@ function closeDatabase(db) {
 import fs46 from "fs";
 init_asset_ref();
 init_resolve_ref();
+
+// src/core/best-effort.ts
+init_warn();
+function bestEffort(fn, context) {
+  try {
+    return fn();
+  } catch (err) {
+    if (isVerbose()) {
+      warnVerbose(`[akm:best-effort] ${context ? `${context}: ` : ""}swallowed error`, err);
+    }
+    return;
+  }
+}
+
+// src/storage/repositories/index-entries-repository.ts
 init_warn();
 init_metadata();
 
@@ -96445,11 +96425,11 @@ init_warn();
 
 // src/core/asset/markdown-fragments.ts
 init_markdown();
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var MARKDOWN_FRAGMENT_MAX_CHARS = 1600;
 var MARKDOWN_FRAGMENT_PREFIX = "akm-fragment-";
 function hash3(text) {
-  return createHash10("sha256").update(text).digest("hex");
+  return createHash9("sha256").update(text).digest("hex");
 }
 function uniqueSlugs(body) {
   const out = new Map;
@@ -96563,48 +96543,30 @@ function splitMarkdownFragments(body, maxChars = MARKDOWN_FRAGMENT_MAX_CHARS) {
 }
 
 // src/storage/repositories/index-fts-repository.ts
-init_warn();
-var INSERT_FTS_SQL = "INSERT INTO entries_fts (entry_id, name, description, tags, hints, content) VALUES (?, ?, ?, ?, ?, ?)";
-var INSERT_FRAGMENT_SQL = "INSERT INTO entry_fragments_fts (entry_id, fragment_id, fragment_ordinal, content) VALUES (?, ?, ?, ?)";
-var ftsMutationStatementsByDb = new WeakMap;
-function getFtsMutationStatements(db) {
-  const existing = ftsMutationStatementsByDb.get(db);
+var fragmentSourceStatementsByDb = new WeakMap;
+function getFragmentSourceStatements(db) {
+  const existing = fragmentSourceStatementsByDb.get(db);
   if (existing)
     return existing;
   const statements = {
-    deleteOne: db.prepare("DELETE FROM entries_fts WHERE entry_id = ?"),
-    insert: db.prepare(INSERT_FTS_SQL),
-    deleteFragments: db.prepare("DELETE FROM entry_fragments_fts WHERE entry_id = ?"),
     upsertFragmentSource: db.prepare("INSERT INTO entry_fragments (entry_id, safe_markdown) VALUES (?, ?) ON CONFLICT(entry_id) DO UPDATE SET safe_markdown = excluded.safe_markdown"),
-    deleteFragmentSource: db.prepare("DELETE FROM entry_fragments WHERE entry_id = ?"),
-    insertFragment: db.prepare(INSERT_FRAGMENT_SQL)
+    deleteFragmentSource: db.prepare("DELETE FROM entry_fragments WHERE entry_id = ?")
   };
-  ftsMutationStatementsByDb.set(db, statements);
+  fragmentSourceStatementsByDb.set(db, statements);
   return statements;
 }
-function replaceFtsEntry(db, entryId, entry, fragmentContent) {
-  const fields = buildSearchFields(entry);
-  const statements = getFtsMutationStatements(db);
-  statements.deleteOne.run(entryId);
-  statements.insert.run(entryId, fields.name, fields.description, fields.tags, fields.hints, fields.content);
-  if (fragmentContent === undefined) {
+function replaceFragmentSource(db, entryId, fragmentContent) {
+  if (fragmentContent === undefined)
     return;
-  }
-  statements.deleteFragments.run(entryId);
+  const statements = getFragmentSourceStatements(db);
   statements.deleteFragmentSource.run(entryId);
-  if (!fragmentContent)
-    return;
-  statements.upsertFragmentSource.run(entryId, fragmentContent);
-  for (const fragment of splitMarkdownFragments(fragmentContent)) {
-    statements.insertFragment.run(entryId, fragment.fragmentId, fragment.ordinal, fragment.text.toLowerCase());
-  }
+  if (fragmentContent)
+    statements.upsertFragmentSource.run(entryId, fragmentContent);
 }
-function deleteFtsEntries(db, entryIds) {
+function deleteFragmentSource(db, entryIds) {
   for (let i = 0;i < entryIds.length; i += SQLITE_CHUNK_SIZE) {
     const chunk = entryIds.slice(i, i + SQLITE_CHUNK_SIZE);
     const placeholders = chunk.map(() => "?").join(",");
-    db.prepare(`DELETE FROM entries_fts WHERE entry_id IN (${placeholders})`).run(...chunk);
-    db.prepare(`DELETE FROM entry_fragments_fts WHERE entry_id IN (${placeholders})`).run(...chunk);
     db.prepare(`DELETE FROM entry_fragments WHERE entry_id IN (${placeholders})`).run(...chunk);
   }
 }
@@ -96614,16 +96576,13 @@ function upsertEntry(db, filePath, entry, searchText, provenance, contentHash) {
   const stmts = getUpsertStmts(db);
   const derivedFrom = typeof entry.derivedFrom === "string" && entry.derivedFrom.trim() ? entry.derivedFrom.trim() : null;
   const apply = () => {
-    const previous = stmts.findByItemRef.get(provenance.itemRef);
     const result = stmts.upsert.get(provenance.itemRef, provenance.bundleId, provenance.componentId, provenance.conceptId, provenance.adapterId, entry.type, filePath, contentHash ?? null, JSON.stringify(entry), searchText, derivedFrom);
     if (!result)
       throw new Error("upsertEntry: item_ref not found after upsert");
-    if (previous?.id === result.id && previous.search_text !== searchText)
-      deleteEntryVectors(db, result.id);
-    replaceFtsEntry(db, result.id, entry, hasMarkdownFragmentContent(entry) ? getMarkdownFragmentContent(entry) ?? null : undefined);
+    replaceFragmentSource(db, result.id, hasMarkdownFragmentContent(entry) ? getMarkdownFragmentContent(entry) ?? null : undefined);
     return result.id;
   };
-  return db.transaction(apply)();
+  return db.inTransaction ? db.transaction(apply)() : withImmediateTransaction(db, apply, "index");
 }
 var upsertStmtsByDb = new WeakMap;
 var UPSERT_SET_CLAUSE = `SET
@@ -96650,8 +96609,7 @@ function getUpsertStmts(db) {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(item_ref) DO UPDATE ${UPSERT_SET_CLAUSE}
       RETURNING id
-    `),
-    findByItemRef: db.prepare("SELECT id, search_text FROM entries WHERE item_ref = ?")
+    `)
   };
   upsertStmtsByDb.set(db, stmts);
   return stmts;
@@ -96660,15 +96618,10 @@ function deleteRelatedRows(db, ids, options = {}) {
   if (ids.length === 0)
     return;
   const numericIds = ids.map((r) => r.id);
-  const vecAvail = isVecAvailable(db);
-  deleteFtsEntries(db, numericIds);
+  deleteFragmentSource(db, numericIds);
   for (let i = 0;i < numericIds.length; i += SQLITE_CHUNK_SIZE) {
     const chunk = numericIds.slice(i, i + SQLITE_CHUNK_SIZE);
     const placeholders = chunk.map(() => "?").join(",");
-    bestEffort(() => db.prepare(`DELETE FROM embeddings WHERE id IN (${placeholders})`).run(...chunk), "delete embeddings for entries");
-    if (vecAvail) {
-      bestEffort(() => db.prepare(`DELETE FROM entries_vec WHERE id IN (${placeholders})`).run(...chunk), "delete entries_vec for entries");
-    }
     bestEffort(() => db.prepare(`DELETE FROM utility_scores WHERE entry_id IN (${placeholders})`).run(...chunk), "delete utility_scores for entries");
     bestEffort(() => db.prepare(`DELETE FROM utility_scores_scoped WHERE entry_id IN (${placeholders})`).run(...chunk), "delete utility_scores_scoped for entries");
   }
@@ -96711,7 +96664,7 @@ function deleteUsageEventsByEntryIds(entryIds) {
 function deleteEntriesByIds(db, ids) {
   if (ids.length === 0)
     return;
-  db.transaction(() => {
+  withImmediateTransaction(db, () => {
     const idObjs = ids.map((id) => ({ id }));
     deleteRelatedRows(db, idObjs);
     for (let i = 0;i < ids.length; i += SQLITE_CHUNK_SIZE) {
@@ -96719,17 +96672,14 @@ function deleteEntriesByIds(db, ids) {
       const placeholders = chunk.map(() => "?").join(",");
       db.prepare(`DELETE FROM entries WHERE id IN (${placeholders})`).run(...chunk);
     }
-  })();
+  }, "index");
 }
 function getEntryCount(db) {
   const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get();
   return row.cnt;
 }
-function getEmbeddableEntryCount(db) {
-  return getEntryCount(db);
-}
 
-// src/indexer/materialize-embeddings.ts
+// src/indexer/drain.ts
 init_paths();
 init_warn();
 
@@ -96970,19 +96920,6 @@ var DEFAULT_TOKEN_BUDGET = 6000;
 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;
@@ -97021,7 +96958,7 @@ function resolveEmbeddingConcurrency(config) {
     return config.concurrency;
   return defaultConcurrencyForEndpoint(config.endpoint);
 }
-function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
+function buildTokenBoundedBatches(texts, tokenBudget, maxCount, tokenCounts) {
   const batches = [];
   let current = [];
   let currentTokens = 0;
@@ -97033,7 +96970,7 @@ function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
     }
   };
   for (let i = 0;i < texts.length; i++) {
-    const tokens = estimateTokenCount(texts[i]);
+    const tokens = tokenCounts?.[i] ?? estimateTokenCount(texts[i]);
     if (tokens > tokenBudget) {
       flush();
       batches.push({ indices: [i], oversized: true });
@@ -97049,7 +96986,7 @@ function buildTokenBoundedBatches(texts, tokenBudget, maxCount) {
   return batches;
 }
 var ADAPTIVE_BUDGET_SHRINK_FACTOR = 0.75;
-var ADAPTIVE_BUDGET_FLOOR_MULTIPLIER = 2;
+var ADAPTIVE_BUDGET_FLOOR_TOKENS = 1024;
 
 class RemoteEmbedder {
   config;
@@ -97076,6 +97013,9 @@ class RemoteEmbedder {
     if (ollamaOpts) {
       body.options = ollamaOpts;
     }
+    if (isOllamaNativeEmbedEndpoint(this.endpoint)) {
+      body.truncate = false;
+    }
     const timeoutMs = resolveEmbeddingTimeoutMs(this.config);
     const response = await fetchWithTimeout(normalizeEmbeddingEndpoint(this.endpoint), {
       method: "POST",
@@ -97096,30 +97036,31 @@ class RemoteEmbedder {
     }
     return l2Normalize(json.data[0].embedding);
   }
-  async embedBatch(texts, signal, onSkip, onBatch) {
+  async embedBatch(texts, signal, onSkip, onBatch, packing) {
     if (texts.length === 0)
       return [];
     const results = new Array(texts.length).fill(undefined);
     const headers = this.buildHeaders();
-    const ollamaOpts = resolveOllamaOptions(this.config);
-    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 ollamaOpts = resolveOllamaOptions(this.config, packing?.ollamaNumCtx);
+    const tokenCounts = texts.map((text) => Math.ceil(text.length / (packing?.charsPerToken ?? 4)));
+    let effectiveTokenBudget = packing?.tokenBudget ?? DEFAULT_TOKEN_BUDGET;
+    const maxCount = packing?.maxCount ?? DEFAULT_REMOTE_BATCH_SIZE;
+    const windowIsKnown = packing?.windowIsKnown ?? false;
+    const textBatches = buildTokenBoundedBatches(texts, effectiveTokenBudget, maxCount, tokenCounts);
     const configuredTimeoutMs = resolveEmbeddingTimeoutMs(this.config);
     let dispatchedBatchCount = 0;
-    let budgetShrunk = false;
+    let budgetShrunk = windowIsKnown;
     const maybeShrinkBudget = (rejectedIndices, rejectedBatchIndex, rejectedRequestTokens) => {
       if (budgetShrunk)
         return;
       budgetShrunk = true;
-      const floor2 = ADAPTIVE_BUDGET_FLOOR_MULTIPLIER * maxInputTokens;
-      effectiveTokenBudget = Math.max(Math.round(effectiveTokenBudget * ADAPTIVE_BUDGET_SHRINK_FACTOR), floor2);
+      effectiveTokenBudget = Math.max(Math.round(effectiveTokenBudget * ADAPTIVE_BUDGET_SHRINK_FACTOR), ADAPTIVE_BUDGET_FLOOR_TOKENS);
       const notYetDispatched = textBatches.slice(dispatchedBatchCount);
       const remainingIndices = notYetDispatched.flatMap((batch) => batch.indices);
       if (remainingIndices.length > 0) {
         const remainingTexts = remainingIndices.map((i) => texts[i]);
-        const replanned = buildTokenBoundedBatches(remainingTexts, effectiveTokenBudget, maxCount).map((batch) => ({
+        const remainingCounts = remainingIndices.map((i) => tokenCounts[i]);
+        const replanned = buildTokenBoundedBatches(remainingTexts, effectiveTokenBudget, maxCount, remainingCounts).map((batch) => ({
           indices: batch.indices.map((localIndex) => remainingIndices[localIndex]),
           oversized: batch.oversized
         }));
@@ -97169,7 +97110,7 @@ class RemoteEmbedder {
       if (dispatchAbort.signal.aborted)
         return;
       const batch = indices.map((i) => texts[i]);
-      const requestTokens = batch.reduce((sum, text) => sum + estimateTokenCount(text), 0);
+      const requestTokens = indices.reduce((sum, i) => sum + tokenCounts[i], 0);
       const requestTimeoutMs = scaleEmbeddingTimeoutMs(configuredTimeoutMs, requestTokens, effectiveTokenBudget);
       const requestStart = Date.now();
       let batchEmbeddings;
@@ -97258,7 +97199,7 @@ class RemoteEmbedder {
       dispatchedBatchCount = batchIndex;
       if (textBatch.oversized) {
         const idx = textBatch.indices[0];
-        const estTokens = estimateTokenCount(texts[idx]);
+        const estTokens = tokenCounts[idx];
         onSkip?.({
           index: idx,
           reason: "context-window-exceeded",
@@ -97304,6 +97245,9 @@ class RemoteEmbedder {
     if (ollamaOpts) {
       body.options = ollamaOpts;
     }
+    if (isOllamaNativeEmbedEndpoint(this.endpoint)) {
+      body.truncate = false;
+    }
     const response = await fetchWithTimeout(normalizeEmbeddingEndpoint(this.endpoint), {
       method: "POST",
       headers,
@@ -97371,6 +97315,15 @@ function normalizeEmbeddingEndpoint(endpoint) {
   parsed.pathname = normalizedPath ? `${normalizedPath}/embeddings` : "/embeddings";
   return parsed.toString();
 }
+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) {
@@ -97378,12 +97331,12 @@ function embeddingEndpointPathHint(endpoint) {
   }
   return "";
 }
-function resolveOllamaOptions(config) {
+function resolveOllamaOptions(config, ollamaNumCtx) {
   if (config.ollamaOptions && Object.keys(config.ollamaOptions).length > 0) {
     return config.ollamaOptions;
   }
-  if (config.contextLength) {
-    return { num_ctx: config.contextLength };
+  if (ollamaNumCtx) {
+    return { num_ctx: ollamaNumCtx };
   }
   return;
 }
@@ -97399,6 +97352,8 @@ function describeEmbeddingCredential(apiKey) {
     return `${apiKey} (env)`;
   return "literal apiKey";
 }
+// src/llm/embedders/types.ts
+init_warn();
 
 // src/llm/embedder.ts
 var embedderOverrides;
@@ -97409,9 +97364,9 @@ function getLocalEmbedder() {
   }
   return _localEmbedder;
 }
-async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch) {
+async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch, packing) {
   if (embedderOverrides?.embedBatch) {
-    return embedderOverrides.embedBatch(texts, embeddingConfig, signal, onSkip, onBatch);
+    return embedderOverrides.embedBatch(texts, embeddingConfig, signal, onSkip, onBatch, packing);
   }
   if (texts.length === 0)
     return [];
@@ -97421,7 +97376,7 @@ async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch) {
     return embeddings;
   }
   if (embeddingConfig && hasRemoteEndpoint(embeddingConfig)) {
-    return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal, onSkip, onBatch);
+    return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal, onSkip, onBatch, packing);
   }
   const localModel = embeddingConfig?.localModel;
   if (!localModel) {
@@ -97439,70 +97394,185 @@ 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/llm/embedders/provider-limits.ts
+var DEFAULT_WINDOW_TOKENS = 8192;
+var CHARS_PER_TOKEN_TAIL = 2.6;
+var UNIT_HEADER_MARGIN_TOKENS = 64;
+var CALIBRATION_PERCENTILE = 0.01;
+var TOKENIZE_PRESENCE_PROBE_TEXT = "ping";
+var CALIBRATION_SHAPES = [
+  "This is a short sentence describing typical prose content used to calibrate the tokenizer.",
+  "```ts\nfunction add(a: number, b: number): number {\n  return a + b;\n}\n```",
+  `| Column A | Column B | Column C |
+| --- | --- | --- |
+| 1 | 2 | 3 |
+| 4 | 5 | 6 |`,
+  `- first item in a list
+- second item in a list
+- third item, a little longer than the rest`,
+  "See [the reference documentation](https://example.com/docs/reference) for more detail on this API.",
+  "\u65E5\u672C\u8A9E\u306E\u30C6\u30AD\u30B9\u30C8\u306F\u82F1\u8A9E\u3068\u6BD4\u3079\u3066\u30C8\u30FC\u30AF\u30F3\u3042\u305F\u308A\u306E\u6587\u5B57\u6570\u304C\u5927\u304D\u304F\u7570\u306A\u308B\u3053\u3068\u304C\u3042\u308A\u307E\u3059\u3002",
+  "SELECT id, name, description FROM entries WHERE tags LIKE '%embedding%' ORDER BY updated_at DESC LIMIT 50;",
+  "A longer paragraph mixing punctuation, numbers (like 42 and 3.14), and technical terms such as `tokenizer`, `embedding`, and `context window`."
+];
+function percentileIndex(length, percentile) {
+  if (length <= 1)
+    return 0;
+  return Math.max(0, Math.min(length - 1, Math.floor((length - 1) * percentile)));
 }
-
-// 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
-  })}.`;
+async function calibrateCharsPerToken(countTokens) {
+  const ratios = [];
+  for (const text of CALIBRATION_SHAPES) {
+    try {
+      const tokens = await countTokens(text);
+      if (tokens > 0)
+        ratios.push(text.length / tokens);
+    } catch {}
+  }
+  if (ratios.length === 0)
+    return CHARS_PER_TOKEN_TAIL;
+  ratios.sort((a, b) => a - b);
+  return ratios[percentileIndex(ratios.length, CALIBRATION_PERCENTILE)];
 }
-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;
+function timedFetch(fetchImpl, url2, init, timeoutMs, externalSignal) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const signal = externalSignal ? AbortSignal.any([externalSignal, timeoutSignal]) : timeoutSignal;
+  return fetchImpl(url2, { ...init, signal });
 }
-
-// src/indexer/materialize-embeddings.ts
-function deriveSemanticProviderFingerprint(embedding) {
-  if (isDeterministicEmbedEnabled()) {
-    return `deterministic:${DETERMINISTIC_EMBED_MODEL_ID}`;
+async function readJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return;
   }
-  if (embedding?.endpoint) {
-    return `remote:${embedding.model}|${embedding.dimension ?? "default"}`;
+}
+async function probeLlamaCppCountTokens(origin, fetchImpl, timeoutMs, probeSignal) {
+  const tokenizeOnce = (text, signal) => timedFetch(fetchImpl, `${origin}/tokenize`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ content: text }) }, timeoutMs, signal);
+  const presence = await tokenizeOnce(TOKENIZE_PRESENCE_PROBE_TEXT, probeSignal);
+  if (!presence.ok)
+    return;
+  const presenceBody = await readJson(presence);
+  if (!Array.isArray(presenceBody?.tokens))
+    return;
+  return async (text) => {
+    const res = await tokenizeOnce(text, undefined);
+    if (!res.ok)
+      throw new Error(`llama.cpp /tokenize request failed (${res.status})`);
+    const json = await readJson(res);
+    if (!Array.isArray(json?.tokens))
+      throw new Error("Unexpected /tokenize response: missing tokens array");
+    return json.tokens.length;
+  };
+}
+async function probeLlamaCpp(origin, config, fetchImpl, timeoutMs, signal) {
+  const res = await timedFetch(fetchImpl, `${origin}/props`, { method: "GET" }, timeoutMs, signal);
+  if (!res.ok)
+    return;
+  const body = await readJson(res);
+  const windowTokens = body?.default_generation_settings?.n_ctx;
+  if (typeof windowTokens !== "number" || !Number.isFinite(windowTokens) || windowTokens <= 0)
+    return;
+  const probedSlots = typeof body?.total_slots === "number" && body.total_slots > 0 ? body.total_slots : 1;
+  const slots = config.concurrency ?? probedSlots;
+  const countTokens = await probeLlamaCppCountTokens(origin, fetchImpl, timeoutMs, signal).catch(() => {
+    return;
+  });
+  const charsPerToken = countTokens ? await calibrateCharsPerToken(countTokens) : CHARS_PER_TOKEN_TAIL;
+  return { windowTokens, slots, source: "llama.cpp", charsPerToken };
+}
+var OLLAMA_DEFAULT_SLOTS = 1;
+function findOllamaContextLength(modelInfo) {
+  for (const [key, value] of Object.entries(modelInfo)) {
+    if (key.endsWith(".context_length") && typeof value === "number" && Number.isFinite(value) && value > 0) {
+      return value;
+    }
   }
-  return `local:${embedding?.localModel ?? DEFAULT_LOCAL_MODEL}`;
+  return;
 }
-function formatEmbeddingHeartbeat(storedCount, total, failedCount) {
-  return `Still generating embeddings: ${storedCount}/${total} stored, ${failedCount} failed; waiting on embedding provider.`;
+async function probeOllama(origin, config, fetchImpl, timeoutMs, signal) {
+  if (!config.model)
+    return;
+  const res = await timedFetch(fetchImpl, `${origin}/api/show`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ model: config.model }) }, timeoutMs, signal);
+  if (!res.ok)
+    return;
+  const body = await readJson(res);
+  if (!body?.model_info)
+    return;
+  const windowTokens = findOllamaContextLength(body.model_info);
+  if (windowTokens === undefined)
+    return;
+  return {
+    windowTokens,
+    slots: config.concurrency ?? OLLAMA_DEFAULT_SLOTS,
+    source: "ollama",
+    charsPerToken: CHARS_PER_TOKEN_TAIL
+  };
 }
-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 };
-  const verified = pairs.filter((pair) => pair.fresh !== undefined);
-  if (verified.length * 2 <= pairs.length) {
-    return { outcome: "unverifiable", medianSimilarity: undefined, verifiedSamples: verified.length };
+function resolveOrigin(endpoint) {
+  if (!endpoint)
+    return;
+  try {
+    const parsed = new URL(endpoint);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+      return;
+    return parsed.origin;
+  } catch {
+    return;
   }
-  const similarities = verified.map((pair) => cosineSimilarity(pair.stored, pair.fresh));
-  const medianSimilarity = medianOf(similarities);
+}
+function resolveProbeTimeoutMs(config) {
+  return config.timeoutMs ?? HEALTH_PROBE_TIMEOUT_MS;
+}
+function defaultLimits(config) {
   return {
-    outcome: medianSimilarity >= CANARY_SIMILARITY_THRESHOLD ? "keep" : "rebuild",
-    medianSimilarity,
-    verifiedSamples: verified.length
+    windowTokens: DEFAULT_WINDOW_TOKENS,
+    slots: config.concurrency ?? 1,
+    source: "default",
+    charsPerToken: CHARS_PER_TOKEN_TAIL
   };
 }
-function medianOf(values) {
-  const sorted = [...values].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+function isUsableWindow(limits) {
+  return unitMaxChars(limits) > 0;
 }
+async function probeProviderLimitsUncached(config, opts) {
+  const origin = resolveOrigin(config.endpoint);
+  if (!origin)
+    return defaultLimits(config);
+  const fetchImpl = opts?.fetch ?? fetch;
+  const timeoutMs = resolveProbeTimeoutMs(config);
+  const signal = opts?.signal;
+  const llamaCpp = await probeLlamaCpp(origin, config, fetchImpl, timeoutMs, signal).catch(() => {
+    return;
+  });
+  if (llamaCpp && isUsableWindow(llamaCpp))
+    return llamaCpp;
+  const ollama = await probeOllama(origin, config, fetchImpl, timeoutMs, signal).catch(() => {
+    return;
+  });
+  if (ollama && isUsableWindow(ollama))
+    return ollama;
+  return defaultLimits(config);
+}
+var providerLimitsCache = new Map;
+async function probeProviderLimits(config, opts) {
+  const cacheKey = JSON.stringify({
+    endpoint: config.endpoint,
+    model: config.model,
+    concurrency: config.concurrency,
+    timeoutMs: config.timeoutMs
+  });
+  const cached = providerLimitsCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const probe = probeProviderLimitsUncached(config, opts);
+  providerLimitsCache.set(cacheKey, probe);
+  return probe;
+}
+function unitMaxChars(limits) {
+  return Math.max(0, Math.floor((limits.windowTokens - UNIT_HEADER_MARGIN_TOKENS) * limits.charsPerToken));
+}
+
+// src/indexer/embedding-identity.ts
 function deriveObservedEmbeddingIdentity(embedding, observedModel, observedVectorLen) {
   if (isDeterministicEmbedEnabled()) {
     return `deterministic:${DETERMINISTIC_EMBED_MODEL_ID}`;
@@ -97514,600 +97584,315 @@ function deriveObservedEmbeddingIdentity(embedding, observedModel, observedVecto
   }
   return `local:${embedding?.localModel ?? DEFAULT_LOCAL_MODEL}|${observedVectorLen}`;
 }
-async function runEmbeddingCanary(db, config, signal, maxInputTokens) {
-  const samples = sampleEmbeddedEntriesForCanary(db, CANARY_SAMPLE_SIZE);
-  if (samples.length === 0) {
-    return { outcome: "keep", verified: false, viaIdentityMatch: false };
-  }
-  let observedModel;
-  const skips = [];
-  let canaryVectors;
-  try {
-    canaryVectors = await embedBatch(samples.map((sample) => capEmbeddingText(sample.searchText, maxInputTokens).text), config.embedding, signal, (skip) => skips.push(skip), (_indices, _embeddings, model) => {
-      if (model)
-        observedModel = model;
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return {
-      outcome: "unverifiable",
-      message: `could not verify embedding compatibility (${message}); keeping existing vectors \u2014 rerun akm index when the endpoint is reachable`
-    };
-  }
-  const observedVectorLen = canaryVectors.find((vector) => vector !== undefined)?.length;
-  const observedIdentity = deriveObservedEmbeddingIdentity(config.embedding, observedModel, observedVectorLen);
-  const storedIdentity = getMeta(db, "embeddingIdentity");
-  if (storedIdentity && observedIdentity && storedIdentity === observedIdentity) {
-    return { outcome: "keep", verified: true, identity: observedIdentity, viaIdentityMatch: true };
-  }
-  const pairs = samples.map((sample, i) => ({ stored: sample.vector, fresh: canaryVectors[i] }));
-  const decision = decideEmbeddingCompatibility(pairs);
-  if (decision.outcome === "unverifiable") {
-    const message = skips[0]?.message ?? "embedding provider returned no vectors for the canary sample";
-    return {
-      outcome: "unverifiable",
-      message: `could not verify embedding compatibility (${message}); keeping existing vectors \u2014 rerun akm index when the endpoint is reachable`
-    };
-  }
-  if (decision.outcome === "keep") {
-    return {
-      outcome: "keep",
-      verified: true,
-      identity: observedIdentity,
-      viaIdentityMatch: false,
-      medianSimilarity: decision.medianSimilarity
-    };
-  }
-  return {
-    outcome: "rebuild",
-    identity: observedIdentity,
-    reason: `vectors differ (median similarity ${decision.medianSimilarity?.toFixed(3)})`
-  };
+
+// src/indexer/drain.ts
+var CIRCUIT_BREAKER_THRESHOLD = 3;
+var CIRCUIT_BREAKER_WINDOW = CIRCUIT_BREAKER_THRESHOLD * 2;
+function pushBreakerOutcome(window2, isFailure) {
+  window2.push(isFailure);
+  if (window2.length > CIRCUIT_BREAKER_WINDOW)
+    window2.shift();
+}
+function breakerFailureCount(window2) {
+  return window2.reduce((n, isFailure) => n + (isFailure ? 1 : 0), 0);
 }
+var DRAIN_BATCH_PROGRESS_PREFIX = "[drain] batch ";
 function throwIfAborted(signal) {
   if (signal?.aborted) {
-    throw signal.reason instanceof Error ? signal.reason : new Error("index interrupted");
+    throw signal.reason instanceof Error ? signal.reason : new Error("drain interrupted");
   }
 }
-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.");
+function selectAllUnitHashes(db) {
+  return db.prepare("SELECT unit_hash FROM unit_texts ORDER BY unit_hash").all().map((row) => row.unit_hash);
+}
+function fetchUnitTexts(db, hashes) {
+  const texts = new Map;
+  for (let offset = 0;offset < hashes.length; offset += SQLITE_CHUNK_SIZE) {
+    const chunk2 = hashes.slice(offset, offset + SQLITE_CHUNK_SIZE);
+    const placeholders = chunk2.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT unit_hash, text FROM unit_texts WHERE unit_hash IN (${placeholders})`).all(...chunk2);
+    for (const row of rows)
+      texts.set(row.unit_hash, row.text);
   }
-  throwIfAborted(signal);
+  return texts;
+}
+async function resolveEmbeddingPacking(config, signal) {
+  const base3 = config.embedding ?? {};
+  const limits = await probeProviderLimits(base3, { signal });
+  return {
+    embeddingConfig: { ...base3, concurrency: base3.concurrency ?? limits.slots },
+    packing: {
+      tokenBudget: limits.windowTokens,
+      charsPerToken: limits.charsPerToken,
+      windowIsKnown: limits.source !== "default",
+      ollamaNumCtx: limits.source === "ollama" ? limits.windowTokens : undefined
+    }
+  };
+}
+function emitCredentialDiagnostic(config, onProgress) {
+  if (!onProgress || !hasRemoteEndpoint(config.embedding ?? {}))
+    return;
+  const endpoint = normalizeEmbeddingEndpoint(config.embedding?.endpoint ?? "");
+  const credential = describeEmbeddingCredential(config.embedding?.apiKey);
+  const configFileSuffix = isVerbose() ? `; config: ${getConfigPath()}` : "";
+  onProgress(`[embed] endpoint ${endpoint}, model ${config.embedding?.model ?? "unknown"}; credential: ${credential}${configFileSuffix}`);
+}
+function formatDoneLine(counts) {
+  return `[drain] done: ${counts.pending} pending, ${counts.embedded} embedded, ${counts.failed} failed, ` + `${counts.skipped} skipped (identity: ${counts.identity ?? "unknown"})`;
+}
+async function drainEmbeddingQueue(db, config, opts = {}) {
+  throwIfAborted(opts.signal);
+  let identity3 = getMeta(db, "embeddingIdentity") ?? null;
   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");
-  let targetEntryIds = entryIds;
-  let rebuildReason;
-  const maxInputTokens = config.embedding?.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
-  if (opts?.forceReembed) {
-    db.transaction(() => {
-      purgeEmbeddings(db, { dropVecTable: true });
-      purgeEmbeddingSalvage(db);
-      deleteMeta(db, "embeddingDim");
-      setMeta(db, "embeddingFingerprint", currentFingerprint);
-      deleteMeta(db, "embeddingIdentity");
-    })();
-    targetEntryIds = undefined;
-    rebuildReason = "forced by --reembed";
-  } else if (storedFingerprint && storedFingerprint !== currentFingerprint) {
-    const decision = await runEmbeddingCanary(db, config, signal, maxInputTokens);
-    if (decision.outcome === "unverifiable") {
-      warn(`[embed] ${decision.message}`);
-      onProgress({ phase: "embeddings", message: decision.message });
-      return { success: false, message: decision.message };
-    }
-    if (decision.outcome === "rebuild") {
-      db.transaction(() => {
-        purgeEmbeddings(db, { dropVecTable: true });
-        purgeEmbeddingSalvage(db);
-        deleteMeta(db, "embeddingDim");
-        setMeta(db, "embeddingFingerprint", currentFingerprint);
-        if (decision.identity)
-          setMeta(db, "embeddingIdentity", decision.identity);
-        else
-          deleteMeta(db, "embeddingIdentity");
-      })();
-      targetEntryIds = undefined;
-      rebuildReason = decision.reason;
-    } else {
-      setMeta(db, "embeddingFingerprint", currentFingerprint);
-      relabelEmbeddingSalvageFingerprint(db, storedFingerprint, currentFingerprint);
-      if (decision.identity)
-        setMeta(db, "embeddingIdentity", decision.identity);
-      if (decision.verified) {
-        const keptCount = getEmbeddingCount(db);
-        const detail = decision.viaIdentityMatch ? "server-reported model unchanged" : `stored vectors are compatible (median similarity ${decision.medianSimilarity?.toFixed(3)})`;
-        const message = `[embed] embedding model renamed (${storedFingerprint} \u2192 ${currentFingerprint}); ${detail}, keeping ${keptCount} embedding${keptCount === 1 ? "" : "s"}.`;
-        warn(message);
-        onProgress({ phase: "embeddings", message });
-      }
+    return { pending: 0, embedded: 0, failed: 0, skipped: 0, identity: identity3 };
+  }
+  const candidateHashes = opts.onlyHashes ? [...new Set(opts.onlyHashes)] : selectAllUnitHashes(db);
+  const missingHashes = identity3 ? listMissingHashes(db, candidateHashes, identity3) : candidateHashes;
+  const pending = missingHashes.length;
+  const emitDone = (counts) => {
+    opts.onProgress?.(formatDoneLine(counts));
+    return counts;
+  };
+  if (!isVecAvailable(db)) {
+    return emitDone({ pending, embedded: 0, failed: 0, skipped: pending, identity: identity3 });
+  }
+  if (pending === 0) {
+    return emitDone({ pending: 0, embedded: 0, failed: 0, skipped: 0, identity: identity3 });
+  }
+  const boundedHashes = opts.limit !== undefined ? missingHashes.slice(0, opts.limit) : missingHashes;
+  const textByHash = fetchUnitTexts(db, boundedHashes);
+  const orderedHashes = boundedHashes.filter((hash4) => textByHash.has(hash4));
+  const texts = orderedHashes.map((hash4) => textByHash.get(hash4));
+  if (texts.length === 0) {
+    return emitDone({ pending, embedded: 0, failed: 0, skipped: 0, identity: identity3 });
+  }
+  emitCredentialDiagnostic(config, opts.onProgress);
+  const { embeddingConfig, packing } = await resolveEmbeddingPacking(config, opts.signal);
+  let embedded = 0;
+  let failed = 0;
+  let batchNumber = 0;
+  const singleDocFailureWindow = [];
+  const networkErrorFailureWindow = [];
+  let identityDecidedThisCall = false;
+  const onSkip = (skip) => {
+    failed++;
+    if (!skip.batchStart)
+      return;
+    if (skip.reason === "context-window-exceeded") {
+      singleDocFailureWindow.length = 0;
+      networkErrorFailureWindow.length = 0;
+      return;
     }
-  } else {
-    setMeta(db, "embeddingFingerprint", currentFingerprint);
-  }
-  try {
-    throwIfAborted(signal);
-    const allEntries = getAllEntriesForEmbedding(db, targetEntryIds);
-    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.`
-      });
+    pushBreakerOutcome(singleDocFailureWindow, skip.batchSize === 1);
+    pushBreakerOutcome(networkErrorFailureWindow, skip.failureKind === "network-error");
+    if (breakerFailureCount(singleDocFailureWindow) >= CIRCUIT_BREAKER_THRESHOLD || breakerFailureCount(networkErrorFailureWindow) >= CIRCUIT_BREAKER_THRESHOLD) {
+      return false;
     }
-    if (candidateEntries.length === 0) {
-      onProgress({ phase: "embeddings", message: "Embeddings already up to date." });
-      setMeta(db, "embeddingFingerprint", currentFingerprint);
-      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 };
-    }
-    let truncatedCount = 0;
-    const texts = [];
-    const pendingEntries = [];
-    for (const entry of candidateEntries) {
-      const capped = capEmbeddingText(entry.searchText, maxInputTokens);
-      if (capped.text.length === 0)
+    return;
+  };
+  const onBatch = (indices, embeddings, model, outcome) => {
+    if (outcome?.outcome === "retrying" || outcome?.outcome === "budget-lowered")
+      return;
+    const rows = [];
+    for (let k2 = 0;k2 < indices.length; k2++) {
+      const embedding = embeddings[k2];
+      if (!embedding)
         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 ${pendingEntries.length} entr${pendingEntries.length === 1 ? "y" : "ies"} because ${rebuildReason}`;
-      onProgress({ phase: "embeddings", message });
-    }
-    onProgress({
-      phase: "embeddings",
-      message: `Generating embeddings for ${pendingEntries.length} entr${pendingEntries.length === 1 ? "y" : "ies"}.`
-    });
-    if (isVerbose()) {
-      if (hasRemoteEndpoint(config.embedding ?? {})) {
-        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;
-        batches.forEach((batch, batchIdx) => {
-          for (const i of batch.indices)
-            batchNumberByIndex.set(i, batchIdx + 1);
-        });
-        for (const [i, entry] of pendingEntries.entries()) {
-          const chars = entry.searchText.length;
-          const tokens = estimateTokenCount(entry.searchText);
-          const batch = batches[batchNumberByIndex.get(i) - 1];
-          const label = batch?.oversized ? "oversized (skipped)" : `batch ${batchNumberByIndex.get(i)}/${batches.length}`;
-          warnVerbose(`[embed] ${entry.itemRef} (${chars} chars, est. ${tokens} tokens) \u2192 ${label}`);
-        }
-      } else {
-        for (const entry of pendingEntries) {
-          warnVerbose(`[embed] ${entry.itemRef} (${entry.searchText.length} chars, est. ${estimateTokenCount(entry.searchText)} tokens)`);
+      const learned = deriveObservedEmbeddingIdentity(config.embedding, model, embedding.length);
+      if (!identityDecidedThisCall) {
+        identityDecidedThisCall = true;
+        if (learned && learned !== identity3) {
+          identity3 = learned;
+          setMeta(db, "embeddingIdentity", identity3);
+          dropOtherIdentities(db, identity3, embedding.length);
         }
       }
+      const currentIdentity = identity3;
+      if (currentIdentity === null || learned !== currentIdentity) {
+        continue;
+      }
+      const hash4 = orderedHashes[indices[k2]];
+      if (hash4)
+        rows.push({ hash: hash4, identity: currentIdentity, vector: embedding });
     }
-    let heartbeatTimer;
-    let storedCount = 0;
-    let skippedCount = 0;
-    let embedFailedCount = 0;
-    let storedTokens = 0;
-    try {
-      heartbeatTimer = setInterval(() => {
-        onProgress({
-          phase: "embeddings",
-          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 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 (outcome?.outcome === "budget-lowered") {
-          if (reportPerBatchLine) {
-            onProgress({
-              phase: "embeddings",
-              message: `[embed] batch ${outcome.batchIndex}/${outcome.batchCount}: ${outcome.docCount} docs, ${outcome.requestTokens.toLocaleString()} tokens \u2192 ${outcome.reason}`
-            });
-          }
-          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 index = indices[k2];
-            const entry = pendingEntries[index];
-            if (!entry)
-              continue;
-            const embedding = batchEmbeddings[k2];
-            if (!embedding) {
-              embedFailedCount++;
-              continue;
-            }
-            if (observedVectorLen === undefined)
-              observedVectorLen = embedding.length;
-            const result = upsertEmbedding(db, entry.id, embedding);
-            if (result.stored) {
-              storedCount++;
-              storedTokens += estimateTokenCount(texts[index]);
-            } else {
-              skippedCount++;
-            }
-            if (result.vec === "failed")
-              vecFailedCount++;
-            if (result.vec === "unavailable")
-              vecUnavailableCount++;
-          }
-        })();
-        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: `[embed] batch ${outcome.batchIndex}/${outcome.batchCount}: ${outcome.docCount} docs, ${outcome.requestTokens.toLocaleString()} tokens \u2192 ${outcomeLabel}`
-          });
+    let storageBreakerTripped = false;
+    if (rows.length > 0) {
+      const result = upsertUnitVectors(db, rows);
+      embedded += result.inserted;
+      failed += result.failed;
+      if (result.failed > 0) {
+        pushBreakerOutcome(singleDocFailureWindow, true);
+        pushBreakerOutcome(networkErrorFailureWindow, true);
+        if (breakerFailureCount(singleDocFailureWindow) >= CIRCUIT_BREAKER_THRESHOLD || breakerFailureCount(networkErrorFailureWindow) >= CIRCUIT_BREAKER_THRESHOLD) {
+          storageBreakerTripped = true;
         }
-        onProgress({
-          phase: "embeddings",
-          message: `Embedded ${storedCount}/${pendingEntries.length} entries.`
-        });
-      };
-      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)`);
-      }
-      const vecGenerationComplete = targetEntryIds === undefined ? isVecFastPathComplete(db) : vecFastPathWasReady;
-      setVecFastPathReady(db, vecFailedCount === 0 && vecUnavailableCount === 0 && vecGenerationComplete);
-      if (vecFailedCount > 0) {
-        warn(`[embed] ${vecFailedCount} sqlite-vec fast-path insert${vecFailedCount === 1 ? "" : "s"} failed \u2014 ` + "semantic search will use the slower JS-cosine fallback over stored embeddings. " + "Rebuild with 'akm index --full' after resolving the vec table (often a vector-dimension mismatch).");
-      }
-      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: `${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 {
-          success: false,
-          message: `All ${embedFailedCount} embedding batch(es) failed: ${firstMessage}`
-        };
       }
-      purgeEmbeddingSalvage(db);
-      return { success: true, vecInsertFailures: vecFailedCount };
-    } finally {
-      if (heartbeatTimer)
-        clearInterval(heartbeatTimer);
     }
-  } catch (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 {
-      success: false,
-      message: `Semantic search verification failed: ${message}`
-    };
-  }
-}
-function publishTargetedEmbeddingMeta(db, config) {
-  if (config.semanticSearchMode === "off") {
-    setMeta(db, "hasEmbeddings", "0");
-    return;
-  }
-  const entryCount = getEmbeddableEntryCount(db);
-  const embeddingCount = getEmbeddingCount(db);
-  const ready = entryCount > 0 && embeddingCount >= entryCount;
-  setMeta(db, "hasEmbeddings", ready ? "1" : "0");
+    if (embeddings.some((embedding) => embedding !== undefined)) {
+      pushBreakerOutcome(singleDocFailureWindow, false);
+      pushBreakerOutcome(networkErrorFailureWindow, false);
+    }
+    batchNumber++;
+    if (opts.onProgress) {
+      const docCount = outcome?.docCount ?? indices.length;
+      const label = outcome && outcome.outcome !== "stored" ? `failed: ${outcome.reason ?? "unknown"}` : `${rows.length} stored`;
+      opts.onProgress(`${DRAIN_BATCH_PROGRESS_PREFIX}${batchNumber}: ${docCount} docs \u2192 ${label}`);
+    }
+    if (storageBreakerTripped) {
+      throw new Error(`Circuit breaker: ${CIRCUIT_BREAKER_THRESHOLD} storage write failures while embedding; stopping further provider requests this call.`);
+    }
+  };
+  await embedBatch(texts, embeddingConfig, opts.signal, onSkip, onBatch, packing);
+  throwIfAborted(opts.signal);
+  const attempted = texts.length;
+  const skipped = Math.max(0, attempted - embedded - failed);
+  return emitDone({ pending, embedded, failed, skipped, identity: identity3 });
 }
 
-// src/indexer/index-written-assets.ts
-init_metadata();
-
-// src/indexer/scan/drain-dir.ts
-import path63 from "path";
+// src/indexer/reconcile.ts
+import fs51 from "fs";
+import path62 from "path";
 init_common();
 init_recognition_util();
+init_warn();
 
 // src/workflows/source-files.ts
 init_common();
 init_errors();
 init_recognition_util();
 init_warn();
-import fs49 from "fs";
-import path60 from "path";
 
-class WorkflowSourceRejectionError extends UsageError {
-  sourcePaths;
-  constructor(message, code, sourcePaths) {
-    super(message, code);
-    this.sourcePaths = [...sourcePaths].sort(compareCodePoints);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-class WorkflowSourceLinkIdentityError extends WorkflowSourceRejectionError {
-  constructor(sourcePath, targetPath) {
-    super(`Workflow source ${sourcePath} resolves through a symlink to ${targetPath} with a different source format. ` + "The authored workflow path and resolved source must use the same .md or .yml format.", "WORKFLOW_SOURCE_INVALID", [sourcePath]);
-    this.name = "WorkflowSourceLinkIdentityError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
+// src/indexer/enrich.ts
+init_errors();
+init_warn();
 
-class WorkflowSourceLinkResolutionError extends WorkflowSourceRejectionError {
-  constructor(sourcePath) {
-    super(`Workflow source symlink ${sourcePath} cannot be resolved to a regular file.`, "WORKFLOW_SOURCE_INVALID", [
-      sourcePath
-    ]);
-    this.name = "WorkflowSourceLinkResolutionError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
+// src/llm/index-passes.ts
+init_warn();
+var NO_LOWERING_NOTICES = Object.freeze([]);
+// src/llm/structured-call.ts
+init_errors();
 
-class WorkflowSourcePathIdentityError extends WorkflowSourceRejectionError {
-  constructor(sourcePath, targetPath) {
-    super(`Workflow source ${sourcePath} resolves outside the bundle root to ${targetPath}.`, "PATH_ESCAPE_VIOLATION", [
-      sourcePath
-    ]);
-    this.name = "WorkflowSourcePathIdentityError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
+// src/indexer/enrich.ts
+init_metadata();
+
+// src/indexer/units/unit.ts
+init_markdown();
+
+// src/core/hash.ts
+import { createHash as createHash10 } from "crypto";
+function hashEmbeddableText(text) {
+  return createHash10("sha256").update(text, "utf8").digest("hex");
 }
-function workflowNameForSourcePath(sourceRoot, adapterId, sourcePath) {
-  if (adapterId !== "akm" && adapterId !== "akm-workflow")
-    return;
-  const relativePath = toPosix(path60.relative(path60.resolve(sourceRoot), path60.resolve(sourcePath)));
-  if (!isSafeRelativeName(relativePath))
-    return;
-  const ownedPath = adapterId === "akm" ? relativePath.replace(/^workflows\//, "") : relativePath;
-  if (adapterId === "akm" && ownedPath === relativePath)
-    return;
-  const extension = path60.posix.extname(ownedPath);
-  if (!WORKFLOW_EXTENSIONS.includes(extension.toLowerCase()))
-    return;
-  return ownedPath;
+
+// src/indexer/units/unit.ts
+init_metadata();
+var UNIT_HEADER_SECTION_SEPARATOR = " \u203A ";
+function structuredFieldsText(source) {
+  const body = [source.description, source.tags, source.hints, source.parameters].filter((field) => field.length > 0).join(`
+`);
+  return `${source.name}
+${body}`;
 }
-function resolveWorkflowSourceDomains(sourceRoot, adapterId, sourcePaths) {
-  if (adapterId !== "akm" && adapterId !== "akm-workflow")
-    return [];
-  const authoredRoot = path60.resolve(sourceRoot);
-  let realRoot;
-  try {
-    realRoot = fs49.realpathSync(authoredRoot);
-  } catch {
-    return [];
-  }
-  const candidatesByName = new Map;
-  const seenAuthoredPaths = new Set;
-  for (const sourcePath of sourcePaths) {
-    const normalizedSourcePath = path60.resolve(sourcePath);
-    if (seenAuthoredPaths.has(normalizedSourcePath))
-      continue;
-    seenAuthoredPaths.add(normalizedSourcePath);
-    const authoredName = workflowNameForSourcePath(authoredRoot, adapterId, normalizedSourcePath);
-    if (authoredName === undefined)
-      continue;
-    const canonicalName = canonicalizeWorkflowName(authoredName);
-    if (!isSafeRelativeName(canonicalName))
-      continue;
-    const extension = path60.extname(normalizedSourcePath);
-    const lowerExtension = extension.toLowerCase();
-    if (!WORKFLOW_EXTENSIONS.includes(lowerExtension))
-      continue;
-    const candidate = {
-      path: normalizedSourcePath,
-      relativePath: toPosix(path60.relative(authoredRoot, normalizedSourcePath)),
-      lowerExtension,
-      extensionlessStem: path60.basename(normalizedSourcePath).slice(0, -extension.length)
-    };
-    const domain = candidatesByName.get(canonicalName) ?? [];
-    domain.push(candidate);
-    candidatesByName.set(canonicalName, domain);
-  }
-  const resolutions = [];
-  for (const canonicalName of [...candidatesByName.keys()].sort(compareCodePoints)) {
-    const candidates = candidatesByName.get(canonicalName) ?? [];
-    candidates.sort((left, right) => compareCodePoints(left.relativePath, right.relativePath));
-    const sources = inspectWorkflowSourceDomain(candidates, canonicalName, realRoot);
-    const sourcePaths2 = candidates.map((candidate) => candidate.relativePath);
-    resolutions.push({
-      canonicalName,
-      sourcePaths: sourcePaths2,
-      source: pickWorkflowSource(adapterId, canonicalName, sources)
-    });
-  }
-  return resolutions;
+function parametersText(parameters) {
+  if (!parameters || parameters.length === 0)
+    return "";
+  return parameters.map((param) => param.description ? `${param.name}: ${param.description}` : param.name).join(`
+`).toLowerCase();
+}
+function fragmentHeaderText(name, sectionTitle) {
+  return sectionTitle ? `${name}${UNIT_HEADER_SECTION_SEPARATOR}${sectionTitle}` : name;
+}
+function fragmentSectionTitles(safeMarkdown, fragments) {
+  const headings = parseMarkdownToc(safeMarkdown).headings;
+  let headingIndex = 0;
+  let current = null;
+  return fragments.map((fragment) => {
+    while (headingIndex < headings.length && headings[headingIndex].line <= fragment.startLine) {
+      current = headings[headingIndex].text;
+      headingIndex++;
+    }
+    return current;
+  });
 }
-function inspectWorkflowSourceDomain(candidates, canonicalName, realRoot) {
-  const sources = [];
-  for (const candidate of candidates) {
-    const inspection = inspectWorkflowSourceCandidate(candidate, canonicalName, realRoot);
-    if (inspection.source) {
-      sources.push(inspection.source);
+function splitOverflowingText(text, maxChars) {
+  const pieces = [];
+  let rest = text;
+  while (rest.length > maxChars) {
+    const window2 = rest.slice(0, maxChars);
+    const newlineCut = window2.lastIndexOf(`
+`);
+    if (newlineCut > 0) {
+      pieces.push(rest.slice(0, newlineCut));
+      rest = rest.slice(newlineCut + 1);
       continue;
     }
-    for (const issue of inspection.issues) {
-      warnOnce(`workflow-source-invalid:${issue.sourcePaths.join(",")}`, issue.message);
+    const spaceCut = window2.lastIndexOf(" ");
+    if (spaceCut > 0) {
+      pieces.push(rest.slice(0, spaceCut));
+      rest = rest.slice(spaceCut + 1);
+      continue;
     }
+    pieces.push(rest.slice(0, maxChars));
+    rest = rest.slice(maxChars);
+  }
+  if (rest.length > 0)
+    pieces.push(rest);
+  return pieces;
+}
+function deriveUnits(source, maxChars) {
+  if (!Number.isFinite(maxChars) || maxChars <= 0) {
+    throw new RangeError("deriveUnits: maxChars must be a positive finite number");
+  }
+  const units = [];
+  let ordinal = 0;
+  const pushUnit = (fragmentId, text) => {
+    units.push({ entryId: source.entryId, ordinal: ordinal++, fragmentId, hash: hashEmbeddableText(text), text });
+  };
+  for (const text of splitOverflowingText(structuredFieldsText(source), maxChars))
+    pushUnit(null, text);
+  if (source.safeMarkdown != null) {
+    const fragments = splitMarkdownFragments(source.safeMarkdown);
+    const sectionTitles = fragmentSectionTitles(source.safeMarkdown, fragments);
+    fragments.forEach((fragment, index) => {
+      const header = fragmentHeaderText(source.name, sectionTitles[index] ?? null);
+      const text = `${header}
+${fragment.text}`;
+      for (const piece of splitOverflowingText(text, maxChars))
+        pushUnit(fragment.fragmentId, piece);
+    });
   }
-  return sources;
-}
-function pickWorkflowSource(adapterId, canonicalName, sources) {
-  if (sources.length <= 1)
-    return sources[0];
-  const winner = [...sources].sort((left, right) => left.format === right.format ? 0 : left.format === "markdown" ? -1 : 1)[0];
-  const shadowed = sources.filter((source) => source !== winner);
-  const displayName = adapterId === "akm" ? `workflows/${canonicalName}` : canonicalName;
-  warnOnce(`workflow-source-collision:${displayName}`, `Workflow "${displayName}" has both a .md and .yml source (${shadowed.map((source) => source.relativePath).join(", ")} shadowed by ${winner?.relativePath}); using the .md source. Remove the shadowed sibling to ` + "silence this warning.");
-  return winner;
+  return units;
 }
-function inspectWorkflowSourceCandidate(candidate, canonicalName, realRoot) {
-  const issues = [];
-  let authoredStat;
-  try {
-    authoredStat = fs49.lstatSync(candidate.path);
-  } catch {
-    issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
-    return { issues };
-  }
-  const isLink = authoredStat.isSymbolicLink();
-  if (!isLink && !authoredStat.isFile()) {
-    issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
-    return { issues };
-  }
-  let realPath;
-  try {
-    realPath = fs49.realpathSync(candidate.path);
-  } catch {
-    issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
-    return { issues };
-  }
-  const targetPath = toPosix(path60.relative(realRoot, realPath));
-  const contained2 = isWithinResolved(realPath, realRoot);
-  if (!contained2)
-    issues.push(new WorkflowSourcePathIdentityError(candidate.relativePath, targetPath));
-  if (isLink && path60.extname(realPath).toLowerCase() !== candidate.lowerExtension) {
-    issues.push(new WorkflowSourceLinkIdentityError(candidate.relativePath, targetPath));
-  }
-  if (contained2) {
-    try {
-      if (!fs49.statSync(realPath).isFile())
-        issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
-    } catch {
-      issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
-    }
-  }
-  if (issues.length > 0)
-    return { issues };
+function toUnitSource(entryId, entry) {
+  const fields = buildSearchFields(entry);
+  const safeMarkdown = hasMarkdownFragmentContent(entry) ? getMarkdownFragmentContent(entry) ?? null : typeof entry.content === "string" && entry.content.trim() ? entry.content : null;
   return {
-    issues,
-    source: {
-      path: candidate.path,
-      realPath,
-      relativePath: candidate.relativePath,
-      canonicalName,
-      format: candidate.lowerExtension === ".md" ? "markdown" : "github-yaml"
-    }
+    entryId,
+    name: fields.name,
+    description: fields.description,
+    tags: fields.tags,
+    hints: fields.hints,
+    parameters: parametersText(entry.parameters),
+    safeMarkdown
   };
 }
-function isSafeRelativeName(name) {
-  return name.length > 0 && !path60.posix.isAbsolute(name) && name !== ".." && !name.startsWith("../") && path60.posix.normalize(name) === name;
-}
-function isWithinResolved(candidate, root2) {
-  const relative = path60.relative(root2, path60.resolve(candidate));
-  return relative === "" || !relative.startsWith("..") && !path60.isAbsolute(relative);
-}
 
-// src/indexer/scan/drain-dir.ts
+// src/indexer/reconcile.ts
+init_metadata();
+
+// src/indexer/scan/parse-file.ts
 init_compile();
 init_metadata();
-init_file_context();
 
 // src/indexer/scan/doc-to-entry.ts
 init_metadata();
-import path62 from "path";
+import path60 from "path";
 function indexDocumentToStashEntry(doc) {
   const dj = doc.documentJson ?? {};
   const entry = {
     name: doc.name,
     type: doc.type,
-    filename: path62.basename(doc.path ?? "")
+    filename: path60.basename(doc.path ?? "")
   };
   if (doc.description !== undefined)
     entry.description = doc.description;
@@ -98203,58 +97988,25 @@ function isIntent(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/indexer/scan/drain-dir.ts
+// src/indexer/scan/parse-file.ts
 var WORKFLOW_MD_RENDERER = "workflow-md";
-function drainDirDocuments(adapter, component, fileContexts) {
-  const entries = [];
-  const warnings = [];
-  const hashByFile = new Map;
-  const conceptIdByFile = new Map;
-  const rejectedPaths = new Set;
-  const rejectedConceptIds = new Set;
-  const workflowOwnerPathByCanonicalName = new Map(resolveWorkflowSourceDomains(component.root, adapter.id, fileContexts.map((file) => file.absPath)).filter((resolution) => resolution.source !== undefined).map((resolution) => [resolution.canonicalName, path63.resolve(resolution.source.path)]));
-  const invalidWorkflowOwnerNames = new Set;
-  const orderedFileContexts = [...fileContexts].sort((left, right) => {
-    const leftName = workflowNameForSourcePath(component.root, adapter.id, left.absPath);
-    const rightName = workflowNameForSourcePath(component.root, adapter.id, right.absPath);
-    const leftOwner = leftName !== undefined && workflowOwnerPathByCanonicalName.get(canonicalizeWorkflowName(leftName)) === path63.resolve(left.absPath);
-    const rightOwner = rightName !== undefined && workflowOwnerPathByCanonicalName.get(canonicalizeWorkflowName(rightName)) === path63.resolve(right.absPath);
-    if (leftOwner !== rightOwner)
-      return leftOwner ? -1 : 1;
-    return compareCodePoints(left.absPath, right.absPath);
-  });
-  for (const file of orderedFileContexts) {
-    if (rejectedPaths.has(file.absPath))
-      continue;
-    const workflowName = workflowNameForSourcePath(component.root, adapter.id, file.absPath);
-    if (workflowName !== undefined) {
-      const canonicalName = canonicalizeWorkflowName(workflowName);
-      const ownerPath = workflowOwnerPathByCanonicalName.get(canonicalName);
-      if (ownerPath !== undefined && ownerPath !== path63.resolve(file.absPath) && !invalidWorkflowOwnerNames.has(canonicalName)) {
-        continue;
-      }
-    }
-    const doc = adapter.recognize(component, file);
-    if (doc === null)
-      continue;
-    if (!doc.conceptId) {
-      warnings.push(`Skipped ${file.absPath}: adapter "${adapter.id}" returned no conceptId.`);
-      continue;
-    }
-    const entry = indexDocumentToStashEntry(doc);
-    const dropWarning = handleWorkflowDoc(doc, file, component.root);
-    if (dropWarning !== null) {
-      warnings.push(dropWarning);
-      if (workflowName !== undefined)
-        invalidWorkflowOwnerNames.add(canonicalizeWorkflowName(workflowName));
-      continue;
-    }
-    if (doc.hash !== undefined)
-      hashByFile.set(file.absPath, doc.hash);
-    conceptIdByFile.set(file.absPath, doc.conceptId);
-    entries.push(entry);
+function parseFileDocument(adapter, component, file) {
+  const doc = adapter.recognize(component, file);
+  if (doc === null)
+    return { parsed: null, warning: null, isWorkflowDrop: false };
+  if (!doc.conceptId) {
+    return {
+      parsed: null,
+      warning: `Skipped ${file.absPath}: adapter "${adapter.id}" returned no conceptId.`,
+      isWorkflowDrop: false
+    };
   }
-  return { entries, warnings, hashByFile, conceptIdByFile, rejectedPaths, rejectedConceptIds };
+  const entry = indexDocumentToStashEntry(doc);
+  const dropWarning = handleWorkflowDoc(doc, file, component.root);
+  if (dropWarning !== null) {
+    return { parsed: null, warning: dropWarning, isWorkflowDrop: true };
+  }
+  return { parsed: { entry, hash: doc.hash, conceptId: doc.conceptId }, warning: null, isWorkflowDrop: false };
 }
 function handleWorkflowDoc(doc, file, workspaceRoot) {
   if (doc.type !== "workflow" || doc.adapterId !== "akm" && doc.adapterId !== "akm-workflow" || docRenderer(doc) !== WORKFLOW_MD_RENDERER && doc.adapterId !== "akm-workflow") {
@@ -98280,114 +98032,265 @@ function workflowDropWarning(file, errors3) {
 ${summary}`);
 }
 
-// src/indexer/index-written-assets.ts
+// src/indexer/reconcile.ts
 init_file_context();
+
+// src/indexer/walk/walker.ts
+init_asset_placement();
+init_recognition_util();
+init_file_context();
+var ALWAYS_SKIP_DIRS = new Set([".git"]);
+var AKM_SKIP_DIRS = new Set(["node_modules", "bin", ".cache"]);
+
+// src/indexer/reconcile.ts
+async function reconcilePaths(db, paths, bundleId, opts) {
+  const counts = emptyCounts();
+  if (paths.length === 0)
+    return counts;
+  const config = loadConfig();
+  let rootPath;
+  let ctx;
+  if (opts?.root) {
+    const resolvedCtx = resolveRootContext(opts.root, bundleId);
+    if (!resolvedCtx)
+      return counts;
+    rootPath = opts.root;
+    ctx = resolvedCtx;
+  } else {
+    const resolvedRoot = resolveBundleRoot(bundleId, config);
+    if (!resolvedRoot)
+      return counts;
+    rootPath = resolvedRoot.rootPath;
+    ctx = { bundleId, component: resolvedRoot.component, adapter: resolvedRoot.adapter };
+  }
+  const maxChars = unitMaxChars(await probeProviderLimits(config.embedding ?? {}));
+  for (const rawPath of paths) {
+    counts.scanned++;
+    const absPath = path62.resolve(rawPath);
+    if (!fs51.existsSync(absPath)) {
+      if (deleteFileAndEntryByPath(db, absPath))
+        counts.removed++;
+      continue;
+    }
+    const file = buildFileContext(rootPath, absPath);
+    const classified = classifyFile(ctx, file, getFileState(db, absPath), (message) => counts.warnings.push(message));
+    if (classified === "unchanged")
+      counts.unchanged++;
+    else if (classified === "unindexable") {
+      if (deleteFileAndEntryByPath(db, absPath))
+        counts.removed++;
+    } else {
+      applyOutcome(counts, applyChange(db, ctx, classified, maxChars, undefined, true));
+    }
+  }
+  return counts;
+}
+function resolveRootContext(rootPath, bundleId) {
+  const component = deriveInstallations([
+    { path: rootPath, registryId: bundleId, writable: true, adapterId: configuredAdapterIdForBundle(bundleId) }
+  ])[0]?.components[0];
+  if (!component)
+    return;
+  const adapter = adapterForId(component.adapter);
+  if (!adapter)
+    return;
+  return { bundleId, component, adapter };
+}
+function configuredAdapterIdForBundle(bundleId) {
+  const bundle = loadConfig().bundles?.[bundleId];
+  if (!bundle)
+    return;
+  return Object.values(bundle.components ?? {})[0]?.adapter;
+}
+function resolveBundleRoot(bundleId, config) {
+  const sources = resolveSourceEntries(undefined, config);
+  const installations = deriveInstallations(sources);
+  const index = installations.findIndex((installation) => installation.id === bundleId);
+  const source = index === -1 ? undefined : sources[index];
+  const component = index === -1 ? undefined : installations[index]?.components[0];
+  if (!source || !component)
+    return;
+  const adapter = adapterForId(component.adapter);
+  if (!adapter)
+    return;
+  return { rootPath: source.path, component, adapter };
+}
+function classifyFile(ctx, file, storedHint, onWarning) {
+  let stat;
+  try {
+    stat = file.stat();
+  } catch {
+    const access = classifyPathAccess(file.absPath);
+    if (access.access === "inaccessible") {
+      if (!storedHint) {
+        onWarning?.(`New file akm cannot read, never indexed: ${describeInaccessiblePath(file.absPath, access.code)}`, false);
+      }
+      return "unchanged";
+    }
+    return "unindexable";
+  }
+  if (storedHint && storedHint.size === stat.size && storedHint.mtimeMs === stat.mtimeMs && storedHint.ctimeMs === stat.ctimeMs && storedHint.adapterId === ctx.adapter.id) {
+    return "unchanged";
+  }
+  const outcome = parseFileDocument(ctx.adapter, ctx.component, file);
+  if (outcome.parsed === null) {
+    if (outcome.warning !== null)
+      onWarning?.(outcome.warning, outcome.isWorkflowDrop);
+    return "unindexable";
+  }
+  const hash4 = outcome.parsed.hash ?? hashContent(file.content());
+  return { file, stat, entry: outcome.parsed.entry, conceptId: outcome.parsed.conceptId, hash: hash4 };
+}
+function applyChange(db, ctx, change, maxChars, renameSource, supersedeOtherBundles) {
+  const { file, stat, entry, conceptId, hash: hash4 } = change;
+  const searchText = buildSearchText(entry);
+  const provenance = deriveEntryProvenance({ bundleId: ctx.bundleId, componentId: ctx.component.id, adapterId: ctx.component.adapter }, entry.type, entry.name, conceptId);
+  const entryWithSize = { ...entry, fileSize: stat.size };
+  if (hasMarkdownFragmentContent(entry))
+    setMarkdownFragmentContent(entryWithSize, getMarkdownFragmentContent(entry));
+  let orphanedUnitHashes = [];
+  const result = withImmediateTransaction(db, () => {
+    if (supersedeOtherBundles)
+      supersedeOtherItemRefsAtPath(db, file.absPath, provenance.itemRef);
+    const written = renameSource ? repointOrInsert(db, renameSource.path, file.absPath, entryWithSize, searchText, provenance, hash4) : upsertOrInsert(db, file.absPath, entryWithSize, searchText, provenance, hash4);
+    if (renameSource)
+      deleteFileStates(db, [renameSource.path]);
+    upsertFileState(db, {
+      path: file.absPath,
+      bundleId: ctx.bundleId,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      ctimeMs: stat.ctimeMs,
+      blobHash: hash4,
+      adapterId: ctx.adapter.id
+    });
+    const units = deriveUnits(toUnitSource(written.entryId, entry), maxChars);
+    const { inserted } = insertNewUnitTexts(db, units.map((unit) => ({
+      hash: unit.hash,
+      kind: unit.fragmentId === null ? "card" : "fragment",
+      text: unit.text
+    })));
+    const previousHashes = db.prepare("SELECT unit_hash FROM entry_units WHERE entry_id = ?").all(written.entryId).map((row) => row.unit_hash);
+    replaceEntryUnits(db, written.entryId, units.map((unit) => ({ ordinal: unit.ordinal, fragmentId: unit.fragmentId, hash: unit.hash })));
+    const currentHashes = new Set(units.map((unit) => unit.hash));
+    orphanedUnitHashes = previousHashes.filter((oldHash) => !currentHashes.has(oldHash));
+    return {
+      outcome: written.outcome,
+      unitsAdded: inserted,
+      entryId: written.entryId,
+      entry: entryWithSize,
+      provenance
+    };
+  }, "index");
+  if (orphanedUnitHashes.length > 0)
+    pruneOrphanUnitTextsForHashes(db, orphanedUnitHashes);
+  return result;
+}
+function upsertOrInsert(db, filePath, entry, searchText, provenance, hash4) {
+  const existedBefore = getFileState(db, filePath) !== undefined;
+  const entryId = upsertEntry(db, filePath, entry, searchText, provenance, hash4);
+  return { entryId, outcome: existedBefore ? "changed" : "added" };
+}
+function repointOrInsert(db, oldPath, newPath, entry, searchText, provenance, hash4) {
+  const oldRow = db.prepare("SELECT id FROM entries WHERE file_path = ?").get(oldPath);
+  if (!oldRow)
+    return upsertOrInsert(db, newPath, entry, searchText, provenance, hash4);
+  const claimedByOther = db.prepare("SELECT 1 FROM entries WHERE item_ref = ? AND id <> ?").get(provenance.itemRef, oldRow.id);
+  if (claimedByOther)
+    return upsertOrInsert(db, newPath, entry, searchText, provenance, hash4);
+  repointEntry(db, oldRow.id, newPath, entry, searchText, provenance, hash4);
+  return { entryId: oldRow.id, outcome: "changed" };
+}
+function repointEntry(db, entryId, filePath, entry, searchText, provenance, contentHash) {
+  const derivedFrom = typeof entry.derivedFrom === "string" && entry.derivedFrom.trim() ? entry.derivedFrom.trim() : null;
+  db.prepare(`UPDATE entries SET item_ref = ?, bundle_id = ?, component_id = ?, concept_id = ?, adapter_id = ?, type = ?,
+       file_path = ?, content_hash = ?, document_json = ?, search_text = ?, derived_from = ?
+     WHERE id = ?`).run(provenance.itemRef, provenance.bundleId, provenance.componentId, provenance.conceptId, provenance.adapterId, entry.type, filePath, contentHash, JSON.stringify(entry), searchText, derivedFrom, entryId);
+  replaceFragmentSource(db, entryId, hasMarkdownFragmentContent(entry) ? getMarkdownFragmentContent(entry) ?? null : undefined);
+}
+function supersedeOtherItemRefsAtPath(db, filePath, keepItemRef) {
+  const staleIds = db.prepare("SELECT id FROM entries WHERE file_path = ? AND item_ref <> ?").all(filePath, keepItemRef).map((row) => row.id);
+  if (staleIds.length > 0)
+    deleteEntriesByIds(db, staleIds);
+}
+function deleteFileAndEntryByPath(db, filePath) {
+  return withImmediateTransaction(db, () => {
+    const entryIds = db.prepare("SELECT id FROM entries WHERE file_path = ?").all(filePath).map((row) => row.id);
+    if (entryIds.length > 0)
+      deleteEntriesByIds(db, entryIds);
+    const hadFileRow = getFileState(db, filePath) !== undefined;
+    if (hadFileRow)
+      deleteFileStates(db, [filePath]);
+    return entryIds.length > 0 || hadFileRow;
+  }, "index");
+}
+function emptyCounts() {
+  return { scanned: 0, unchanged: 0, added: 0, changed: 0, removed: 0, unitsAdded: 0, complete: true, warnings: [] };
+}
+function applyOutcome(counts, result) {
+  if (result.outcome === "added")
+    counts.added++;
+  else
+    counts.changed++;
+  counts.unitsAdded += result.unitsAdded;
+}
+
+// src/indexer/index-written-assets.ts
 var WRITE_PATH_INDEX_BUSY_TIMEOUT_MS = 5000;
+function unitHashesForFiles(db, files) {
+  const hashes = new Set;
+  for (let offset = 0;offset < files.length; offset += SQLITE_CHUNK_SIZE) {
+    const chunk2 = files.slice(offset, offset + SQLITE_CHUNK_SIZE);
+    const placeholders = chunk2.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT DISTINCT eu.unit_hash AS unitHash
+           FROM entries e
+           JOIN entry_units eu ON eu.entry_id = e.id
+          WHERE e.file_path IN (${placeholders})`).all(...chunk2);
+    for (const row of rows)
+      hashes.add(row.unitHash);
+  }
+  return [...hashes];
+}
+function resolveWrittenAssetBundleId(stashDir) {
+  const resolvedStashDir = path63.resolve(stashDir);
+  const sourceEntries = resolveSourceEntries();
+  const index = sourceEntries.findIndex((entry) => path63.resolve(entry.path) === resolvedStashDir);
+  if (index !== -1)
+    return deriveInstallations(sourceEntries)[index]?.id;
+  return deriveInstallations([{ path: stashDir, writable: true }])[0]?.id;
+}
 async function indexWrittenAssets(stashDir, filePaths, options = {}) {
   try {
     return await (async () => {
-      const rebuildProbe = probeLock(getIndexRebuildLockPath());
-      if (rebuildProbe.state === "held") {
-        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();
       if (isPathAbsent(dbPath))
         return true;
       const files = filePaths.filter((f) => {
-        const rel = path64.relative(stashDir, f);
+        const rel = path63.relative(stashDir, f);
         return !rel.split(/[\\/]+/).some((segment) => segment.startsWith("."));
       });
       if (files.length === 0)
         return true;
-      const component = deriveInstallations([
-        { path: stashDir, writable: true, ...options.bundleId ? { registryId: options.bundleId } : {} }
-      ])[0]?.components[0];
-      if (!component)
+      const bundleId = options.bundleId ?? resolveWrittenAssetBundleId(stashDir);
+      if (!bundleId)
         throw new Error(`Could not derive bundle provenance for ${stashDir}`);
-      const pairs = [];
-      const unindexable = new Set;
-      const rejectedConceptIds = new Set;
-      for (const file of files) {
-        if (!fs53.existsSync(file)) {
-          let authoredDanglingSymlink = false;
-          try {
-            authoredDanglingSymlink = fs53.lstatSync(file).isSymbolicLink();
-          } catch {}
-          if (!authoredDanglingSymlink) {
-            unindexable.add(file);
-            continue;
-          }
-        }
-        const ctx = buildFileContext(stashDir, file);
-        const drained = drainDirDocuments(akmAdapter, component, [ctx]);
-        for (const rejectedPath of drained.rejectedPaths)
-          unindexable.add(rejectedPath);
-        for (const conceptId2 of drained.rejectedConceptIds)
-          rejectedConceptIds.add(conceptId2);
-        const entry = drained.entries[0];
-        const conceptId = drained.conceptIdByFile.get(ctx.absPath);
-        if (entry && conceptId)
-          pairs.push({ file, entry, conceptId, contentHash: drained.hashByFile.get(ctx.absPath) });
-        else
-          unindexable.add(file);
-      }
       const db = openExistingDatabase(dbPath);
       try {
         db.exec(`PRAGMA busy_timeout = ${WRITE_PATH_INDEX_BUSY_TIMEOUT_MS}`);
         if (getEntryCount(db) === 0)
           return true;
-        const targetEntryIds = new Set;
-        let mutated = false;
-        db.transaction(() => {
-          const unindexableEntryIds = new Set;
-          for (const file of unindexable) {
-            const rows = db.prepare(`SELECT id FROM entries
-                  WHERE file_path = ?
-                    AND bundle_id = ?
-                    AND adapter_id = ?`).all(file, component.id, component.adapter);
-            for (const row of rows)
-              unindexableEntryIds.add(row.id);
-          }
-          for (const conceptId of rejectedConceptIds) {
-            const itemRef = `${component.id}//${conceptId}`;
-            const rows = db.prepare(`SELECT id FROM entries
-                  WHERE bundle_id = ? AND adapter_id = ?
-                    AND type = 'workflow'
-                    AND (concept_id = ? OR item_ref = ?)`).all(component.id, component.adapter, conceptId, itemRef);
-            for (const row of rows)
-              unindexableEntryIds.add(row.id);
-          }
-          deleteEntriesByIds(db, [...unindexableEntryIds]);
-          mutated ||= unindexableEntryIds.size > 0;
-          for (const { file, entry, conceptId, contentHash } of pairs) {
-            let entryWithSize = entry;
-            try {
-              entryWithSize = { ...entry, fileSize: fs53.statSync(file).size };
-              if (hasMarkdownFragmentContent(entry)) {
-                setMarkdownFragmentContent(entryWithSize, getMarkdownFragmentContent(entry));
-              }
-            } catch {}
-            const provenance = deriveEntryProvenance({ bundleId: component.id, componentId: component.id, adapterId: component.adapter }, entry.type, entry.name, conceptId);
-            const supersededIds = db.prepare("SELECT id FROM entries WHERE file_path = ? AND item_ref <> ?").all(file, provenance.itemRef);
-            deleteEntriesByIds(db, supersededIds.map((row) => row.id));
-            targetEntryIds.add(upsertEntry(db, file, entryWithSize, buildSearchText(entry), provenance, contentHash));
-            mutated = true;
-          }
-        })();
-        if (mutated) {
+        await reconcilePaths(db, files, bundleId, { root: stashDir });
+        try {
           const config = loadConfig();
-          await generateEmbeddingsForDb(db, config, () => {}, undefined, [...targetEntryIds]);
-          publishTargetedEmbeddingMeta(db, config);
+          const onlyHashes = unitHashesForFiles(db, files);
+          await drainEmbeddingQueue(db, config, { onlyHashes });
+        } catch (drainError) {
+          warnVerbose("Write-path embedding drain skipped (vectors appear after the next drain):", drainError instanceof Error ? drainError.message : String(drainError));
         }
+        return true;
       } finally {
         closeDatabase(db);
       }
-      return true;
     })();
   } catch (error2) {
     if (isDataDirUnreadableError(error2)) {
@@ -98403,7 +98306,7 @@ async function indexWrittenAssets(stashDir, filePaths, options = {}) {
 init_asset_placement();
 init_asset_ref();
 init_warn();
-import path65 from "path";
+import path64 from "path";
 function changesToStored(changes) {
   return changes.map((c, i) => ({
     path: c.path,
@@ -98456,10 +98359,10 @@ function currentProposalTarget(value) {
   if (typeof value !== "object" || value === null)
     throw new Error("Proposal metadata has an invalid proposedTarget.");
   const target = value;
-  if (typeof target.source !== "string" || !isBundleSlug(target.source) || typeof target.root !== "string" || !path65.isAbsolute(target.root)) {
+  if (typeof target.source !== "string" || !isBundleSlug(target.source) || typeof target.root !== "string" || !path64.isAbsolute(target.root)) {
     throw new Error("Proposal metadata has an invalid proposedTarget.");
   }
-  return { source: target.source, root: path65.resolve(target.root) };
+  return { source: target.source, root: path64.resolve(target.root) };
 }
 function invalidPresentField(name) {
   throw new Error(`Proposal metadata has an invalid ${name}.`);
@@ -98499,7 +98402,7 @@ function validatePresentMetadata(meta) {
   }
   if (Object.hasOwn(meta, "acceptedTarget")) {
     const target = meta.acceptedTarget;
-    if (typeof target !== "object" || target === null || typeof target.source !== "string" || !isBundleSlug(target.source) || typeof target.root !== "string" || !path65.isAbsolute(target.root) || typeof target.path !== "string" || !path65.isAbsolute(target.path) || typeof target.contentHash !== "string") {
+    if (typeof target !== "object" || target === null || typeof target.source !== "string" || !isBundleSlug(target.source) || typeof target.root !== "string" || !path64.isAbsolute(target.root) || typeof target.path !== "string" || !path64.isAbsolute(target.path) || typeof target.contentHash !== "string") {
       invalidPresentField("acceptedTarget");
     }
   }
@@ -99269,12 +99172,12 @@ function proposalHash(content) {
   return createHash11("sha256").update(content).digest("hex");
 }
 function proposalFileHash(filePath) {
-  return proposalHash(fs55.readFileSync(filePath));
+  return proposalHash(fs53.readFileSync(filePath));
 }
 function sameProposalFile(left, right) {
   try {
-    const leftStat = fs55.statSync(left);
-    const rightStat = fs55.statSync(right);
+    const leftStat = fs53.statSync(left);
+    const rightStat = fs53.statSync(right);
     return leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
   } catch {
     return false;
@@ -99283,20 +99186,20 @@ function sameProposalFile(left, right) {
 function cleanupProposalPublication(p) {
   for (const filePath of [p.publishPath, p.displacedPath]) {
     try {
-      fs55.rmSync(filePath, { force: true });
+      fs53.rmSync(filePath, { force: true });
     } catch (error2) {
       warn(`[proposals] transaction publication cleanup failed at ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
-  fsyncTxnDir(path66.dirname(p.assetPath));
+  fsyncTxnDir(path65.dirname(p.assetPath));
 }
 function rollbackPreparedProposalTransaction(txn) {
   const p = txn.journal.payload;
-  const currentHash = fs55.existsSync(p.assetPath) ? proposalFileHash(p.assetPath) : null;
-  if (!fs55.existsSync(p.displacedPath)) {
+  const currentHash = fs53.existsSync(p.assetPath) ? proposalFileHash(p.assetPath) : null;
+  if (!fs53.existsSync(p.displacedPath)) {
     if (p.originalHash === null) {
       if (currentHash === p.publishedHash && sameProposalFile(p.assetPath, p.publishPath)) {
-        fs55.unlinkSync(p.assetPath);
+        fs53.unlinkSync(p.assetPath);
         recordWrittenPath(p.assetPath);
       } else if (currentHash !== null) {
         throw new Error(`Cannot roll back proposal transaction: target was created externally.`);
@@ -99308,30 +99211,30 @@ function rollbackPreparedProposalTransaction(txn) {
     return;
   }
   if (currentHash === p.publishedHash) {
-    fs55.unlinkSync(p.assetPath);
+    fs53.unlinkSync(p.assetPath);
     recordWrittenPath(p.assetPath);
   } else if (currentHash !== null && currentHash !== p.originalHash) {
     throw new Error(`Cannot roll back proposal transaction: ${p.assetPath} diverged.`);
   }
-  if (fs55.existsSync(p.displacedPath)) {
-    if (fs55.existsSync(p.assetPath)) {
+  if (fs53.existsSync(p.displacedPath)) {
+    if (fs53.existsSync(p.assetPath)) {
       throw new Error(`Cannot restore proposal backup: ${p.assetPath} is occupied.`);
     }
-    fs55.linkSync(p.displacedPath, p.assetPath);
+    fs53.linkSync(p.displacedPath, p.assetPath);
     recordWrittenPath(p.assetPath);
   }
   cleanupProposalPublication(p);
 }
 function validatePublishedProposal(p) {
-  if (!fs55.existsSync(p.assetPath) || proposalFileHash(p.assetPath) !== p.publishedHash) {
+  if (!fs53.existsSync(p.assetPath) || proposalFileHash(p.assetPath) !== p.publishedHash) {
     throw new Error(`Cannot recover proposal ${p.proposalId}: published asset diverged.`);
   }
 }
 function persistProposalTransactionState(txn, proposal, ctx) {
   const p = txn.journal.payload;
   const decidedAt = txn.journal.decidedAt;
-  const backupContent = p.backupPath ? fs55.readFileSync(p.backupPath, "utf8") : undefined;
-  const publishedContent = fs55.readFileSync(p.contentPath, "utf8");
+  const backupContent = p.backupPath ? fs53.readFileSync(p.backupPath, "utf8") : undefined;
+  const publishedContent = fs53.readFileSync(p.contentPath, "utf8");
   return withProposalsDb(p.stashDir, ctx, (db) => withImmediateTransaction(db, () => {
     const current = requireProposal(db, p.stashDir, p.proposalId);
     if (p.operation === "accept") {
@@ -99349,7 +99252,7 @@ function persistProposalTransactionState(txn, proposal, ctx) {
         payload: { ...proposal.payload, content: publishedContent },
         changes: [
           {
-            path: path66.relative(txn.journal.root, p.assetPath),
+            path: path65.relative(txn.journal.root, p.assetPath),
             op: p.originalHash === null ? "create" : "update",
             after: publishedContent
           }
@@ -99420,7 +99323,7 @@ async function finalizeProposalTransaction(txn, target, proposal, ctx) {
   cleanupProposalPublication(p);
   if (txn.journal.phase === "asset-published") {
     const commitRoot = target.source.repoPath ?? target.source.path;
-    const commitPath = path66.relative(commitRoot, p.assetPath).replaceAll(path66.sep, "/");
+    const commitPath = path65.relative(commitRoot, p.assetPath).replaceAll(path65.sep, "/");
     publishWriteTargetTransaction(target, p.gitPublication, {
       transactionId: txn.journal.transactionId,
       message: `${p.operation === "accept" ? "Update" : "Revert"} ${p.ref}`,
@@ -99439,10 +99342,11 @@ async function finalizeProposalTransaction(txn, target, proposal, ctx) {
   }
   let accepted = getProposal(p.stashDir, p.proposalId, ctx);
   if (txn.journal.phase === "proposal-persisted") {
-    if (!await indexWrittenAssets(txn.journal.root, [p.assetPath], { bundleId: target.source.name })) {
-      throw new Error(`Proposal ${p.proposalId} index finalization failed.`);
+    if (await indexWrittenAssets(txn.journal.root, [p.assetPath], { bundleId: target.source.name })) {
+      advanceTxn(txn, "index-finalized");
+    } else {
+      warn(`${p.operation === "accept" ? "Accept" : "Revert"} of ${p.ref} succeeded, but its index update failed; run \`akm index\` to refresh it.`);
     }
-    advanceTxn(txn, "index-finalized");
   }
   if (txn.journal.phase === "index-finalized") {
     accepted = getProposal(p.stashDir, p.proposalId, ctx);
@@ -99457,8 +99361,8 @@ async function finalizeProposalTransaction(txn, target, proposal, ctx) {
 function fenceProposalTxnJournal(journal, txnDir, root2) {
   const p = journal.payload;
   const refIdentity = proposalRefIdentity(p.ref);
-  if (!["accept", "revert"].includes(p.operation) || !p.targetSource || !p.targetKind || refIdentity?.bundle === undefined || !isWithin(p.assetPath, root2) || ![p.contentPath, p.backupPath].filter((candidate) => candidate !== null).every((candidate) => isWithin(candidate, txnDir)) || ![p.publishPath, p.displacedPath].every((candidate) => isWithin(candidate, root2) && path66.dirname(candidate) === path66.dirname(p.assetPath))) {
-    throw new Error(`Refusing unsafe proposal transaction journal at ${path66.join(txnDir, "journal.json")}.`);
+  if (!["accept", "revert"].includes(p.operation) || !p.targetSource || !p.targetKind || refIdentity?.bundle === undefined || !isWithin(p.assetPath, root2) || ![p.contentPath, p.backupPath].filter((candidate) => candidate !== null).every((candidate) => isWithin(candidate, txnDir)) || ![p.publishPath, p.displacedPath].every((candidate) => isWithin(candidate, root2) && path65.dirname(candidate) === path65.dirname(p.assetPath))) {
+    throw new Error(`Refusing unsafe proposal transaction journal at ${path65.join(txnDir, "journal.json")}.`);
   }
 }
 function resolveProposalRecoveryTarget(config, journal) {
@@ -99558,8 +99462,8 @@ async function recoverStaleTxns(stashDir) {
 }
 
 // scripts/akm-migrate/migrate/writer-relocation.ts
-import fs56 from "fs";
-import path67 from "path";
+import fs55 from "fs";
+import path66 from "path";
 init_paths();
 function relocationSpecs(stashDir) {
   return [
@@ -99579,7 +99483,7 @@ function mutexSiblingName(lockName) {
 function fileCountIfExists(dir) {
   let entries;
   try {
-    entries = fs56.readdirSync(dir, { withFileTypes: true });
+    entries = fs55.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -99587,7 +99491,7 @@ function fileCountIfExists(dir) {
 }
 function statFileIfExists(filePath) {
   try {
-    const stat = fs56.statSync(filePath);
+    const stat = fs55.statSync(filePath);
     return stat.isFile() ? stat : undefined;
   } catch {
     return;
@@ -99597,8 +99501,8 @@ function classifyLockArtifacts(akmDir) {
   const removable = [];
   const skipped = [];
   for (const lockName of LOCK_NAMES) {
-    const lockPath = path67.join(akmDir, lockName);
-    const mutexPath = path67.join(akmDir, mutexSiblingName(lockName));
+    const lockPath = path66.join(akmDir, lockName);
+    const mutexPath = path66.join(akmDir, mutexSiblingName(lockName));
     const lockStat = statFileIfExists(lockPath);
     const mutexStat = statFileIfExists(mutexPath);
     if (!lockStat) {
@@ -99624,11 +99528,11 @@ function classifyLockArtifacts(akmDir) {
   return { removable, skipped };
 }
 function findWriterRelocationEntries(stashDir) {
-  const akmDir = path67.join(stashDir, ".akm");
+  const akmDir = path66.join(stashDir, ".akm");
   const directories = [];
   for (const spec of relocationSpecs(stashDir)) {
     const relativeParts = Array.isArray(spec.oldRelative) ? spec.oldRelative : [spec.oldRelative];
-    const oldPath = path67.join(akmDir, ...relativeParts);
+    const oldPath = path66.join(akmDir, ...relativeParts);
     const fileCount = fileCountIfExists(oldPath);
     if (fileCount === undefined || fileCount === 0)
       continue;
@@ -99639,36 +99543,36 @@ function findWriterRelocationEntries(stashDir) {
 }
 function moveFile(oldFilePath, newFilePath) {
   try {
-    fs56.renameSync(oldFilePath, newFilePath);
+    fs55.renameSync(oldFilePath, newFilePath);
   } catch (error2) {
     if (error2.code !== "EXDEV")
       throw error2;
-    fs56.copyFileSync(oldFilePath, newFilePath);
-    fs56.rmSync(oldFilePath, { force: true });
+    fs55.copyFileSync(oldFilePath, newFilePath);
+    fs55.rmSync(oldFilePath, { force: true });
   }
 }
 function moveDirectoryContents(entry) {
   const errors3 = [];
   let moved = 0;
-  fs56.mkdirSync(entry.newPath, { recursive: true });
+  fs55.mkdirSync(entry.newPath, { recursive: true });
   let names;
   try {
-    names = fs56.readdirSync(entry.oldPath).sort();
+    names = fs55.readdirSync(entry.oldPath).sort();
   } catch {
     return { key: entry.key, oldPath: entry.oldPath, newPath: entry.newPath, moved: 0, errors: [] };
   }
   for (const name of names) {
-    const oldFilePath = path67.join(entry.oldPath, name);
-    const newFilePath = path67.join(entry.newPath, name);
+    const oldFilePath = path66.join(entry.oldPath, name);
+    const newFilePath = path66.join(entry.newPath, name);
     let oldStat;
     try {
-      oldStat = fs56.lstatSync(oldFilePath);
+      oldStat = fs55.lstatSync(oldFilePath);
     } catch {
       continue;
     }
     if (!oldStat.isFile())
       continue;
-    if (fs56.existsSync(newFilePath))
+    if (fs55.existsSync(newFilePath))
       continue;
     try {
       moveFile(oldFilePath, newFilePath);
@@ -99681,13 +99585,13 @@ function moveDirectoryContents(entry) {
 }
 function removeIfEmptyDir(dir) {
   try {
-    if (fs56.readdirSync(dir).length === 0)
-      fs56.rmdirSync(dir);
+    if (fs55.readdirSync(dir).length === 0)
+      fs55.rmdirSync(dir);
   } catch {}
 }
 function removeLockArtifact(entry) {
   try {
-    fs56.rmSync(entry.path, { force: true });
+    fs55.rmSync(entry.path, { force: true });
     return { path: entry.path, removed: true };
   } catch (error2) {
     return { path: entry.path, removed: false, error: error2 instanceof Error ? error2.message : String(error2) };
@@ -99699,36 +99603,36 @@ function applyWriterRelocation(stashDir) {
   const lockResults = lockArtifacts.map(removeLockArtifact);
   for (const spec of relocationSpecs(stashDir)) {
     const relativeParts = Array.isArray(spec.oldRelative) ? spec.oldRelative : [spec.oldRelative];
-    removeIfEmptyDir(path67.join(stashDir, ".akm", ...relativeParts));
+    removeIfEmptyDir(path66.join(stashDir, ".akm", ...relativeParts));
   }
   return { directories: directoryResults, lockArtifacts: lockResults, skippedLocks };
 }
 
 // scripts/akm-migrate/task-migrate.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import fs60 from "fs";
+import fs59 from "fs";
 import os9 from "os";
-import path70 from "path";
+import path69 from "path";
 init_errors();
 init_paths();
 
 // scripts/akm-migrate/migrate/task-files-to-v3.ts
 init_errors();
 import crypto6 from "crypto";
-import fs58 from "fs";
-import path68 from "path";
+import fs57 from "fs";
+import path67 from "path";
 
 // scripts/akm-migrate/migrate/durable-fs.ts
-import fs57 from "fs";
+import fs56 from "fs";
 function fsyncDirectoryPortable(directory) {
   if (process.platform === "win32")
     return;
   try {
-    const fd = fs57.openSync(directory, "r");
+    const fd = fs56.openSync(directory, "r");
     try {
-      fs57.fsyncSync(fd);
+      fs56.fsyncSync(fd);
     } finally {
-      fs57.closeSync(fd);
+      fs56.closeSync(fd);
     }
   } catch (cause) {
     const code = cause.code;
@@ -99742,25 +99646,25 @@ function migrationError(detail) {
   return new ConfigError(`Task migration to v3 failed: ${detail}`, "INVALID_CONFIG_FILE");
 }
 function contained2(root2, candidate) {
-  const relative = path68.relative(root2, candidate);
-  return relative === "" || !relative.startsWith("..") && !path68.isAbsolute(relative);
+  const relative = path67.relative(root2, candidate);
+  return relative === "" || !relative.startsWith("..") && !path67.isAbsolute(relative);
 }
 function realDirectory(filePath) {
-  const stat = fs58.lstatSync(filePath);
+  const stat = fs57.lstatSync(filePath);
   if (stat.isSymbolicLink() || !stat.isDirectory())
     throw migrationError(`${filePath} must be a real directory.`);
-  return fs58.realpathSync(filePath);
+  return fs57.realpathSync(filePath);
 }
 function snapshot(filePath) {
-  const stat = fs58.lstatSync(filePath);
+  const stat = fs57.lstatSync(filePath);
   if (stat.isSymbolicLink() || !stat.isFile())
     throw migrationError(`${filePath} must be a real file.`);
-  const bytes = fs58.readFileSync(filePath);
+  const bytes = fs57.readFileSync(filePath);
   return Object.freeze({ bytes, mode: stat.mode & 511 });
 }
 function writable(filePath) {
   try {
-    fs58.accessSync(filePath, fs58.constants.W_OK);
+    fs57.accessSync(filePath, fs57.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -99773,12 +99677,12 @@ function walkTasks(root2, tasksDir, out) {
     throw migrationError(`${root2.root} resolves outside bundle ${root2.bundleId}.`);
   }
   const visit2 = (directory) => {
-    const physicalDirectory = fs58.realpathSync(directory);
+    const physicalDirectory = fs57.realpathSync(directory);
     if (!contained2(physicalRoot, physicalDirectory)) {
       throw migrationError(`${directory} resolves outside bundle ${root2.bundleId}.`);
     }
-    for (const entry of fs58.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const candidate = path68.join(directory, entry.name);
+    for (const entry of fs57.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const candidate = path67.join(directory, entry.name);
       if (entry.isSymbolicLink())
         throw migrationError(`task migration does not follow symbolic link ${candidate}.`);
       if (entry.isDirectory()) {
@@ -99788,7 +99692,7 @@ function walkTasks(root2, tasksDir, out) {
       if (!entry.isFile() || !entry.name.endsWith(".yml"))
         continue;
       const current = snapshot(candidate);
-      const parent = path68.dirname(candidate);
+      const parent = path67.dirname(candidate);
       out.push({
         filePath: candidate,
         bytes: current.bytes,
@@ -99804,9 +99708,9 @@ function walkTasks(root2, tasksDir, out) {
 function inspectTaskToV3Files(roots) {
   const files = [];
   for (const root2 of [...roots].sort((a, b) => a.bundleId.localeCompare(b.bundleId))) {
-    const tasksDir = root2.layout === "akm-task" ? root2.root : path68.join(root2.root, "tasks");
+    const tasksDir = root2.layout === "akm-task" ? root2.root : path67.join(root2.root, "tasks");
     try {
-      const stat = fs58.lstatSync(tasksDir);
+      const stat = fs57.lstatSync(tasksDir);
       if (stat.isSymbolicLink())
         throw migrationError(`task migration does not follow symbolic link ${tasksDir}.`);
       if (!stat.isDirectory())
@@ -99821,33 +99725,33 @@ function inspectTaskToV3Files(roots) {
   return files.sort((a, b) => a.filePath.localeCompare(b.filePath));
 }
 function hashPath(filePath) {
-  return crypto6.createHash("sha256").update(path68.resolve(filePath)).digest("hex").slice(0, 16);
+  return crypto6.createHash("sha256").update(path67.resolve(filePath)).digest("hex").slice(0, 16);
 }
 function taskMigrationBackupPath(backupRoot, filePath) {
-  return path68.join(backupRoot, "files", `${hashPath(filePath)}-${path68.basename(filePath)}`);
+  return path67.join(backupRoot, "files", `${hashPath(filePath)}-${path67.basename(filePath)}`);
 }
 function writeDurable(filePath, bytes, mode, exclusive = false) {
-  fs58.mkdirSync(path68.dirname(filePath), { recursive: true });
+  fs57.mkdirSync(path67.dirname(filePath), { recursive: true });
   const flags = exclusive ? "wx" : "w";
-  const fd = fs58.openSync(filePath, flags, mode);
+  const fd = fs57.openSync(filePath, flags, mode);
   try {
-    fs58.writeFileSync(fd, bytes);
-    fs58.fsyncSync(fd);
+    fs57.writeFileSync(fd, bytes);
+    fs57.fsyncSync(fd);
   } finally {
-    fs58.closeSync(fd);
+    fs57.closeSync(fd);
   }
-  fs58.chmodSync(filePath, mode);
-  fsyncDirectoryPortable(path68.dirname(filePath));
+  fs57.chmodSync(filePath, mode);
+  fsyncDirectoryPortable(path67.dirname(filePath));
 }
 function replaceAtomically(filePath, bytes, mode) {
-  const temporary = path68.join(path68.dirname(filePath), `.${path68.basename(filePath)}.migrate-${crypto6.randomUUID()}`);
+  const temporary = path67.join(path67.dirname(filePath), `.${path67.basename(filePath)}.migrate-${crypto6.randomUUID()}`);
   try {
     writeDurable(temporary, bytes, mode, true);
-    fs58.renameSync(temporary, filePath);
-    fsyncDirectoryPortable(path68.dirname(filePath));
+    fs57.renameSync(temporary, filePath);
+    fsyncDirectoryPortable(path67.dirname(filePath));
   } finally {
     try {
-      fs58.unlinkSync(temporary);
+      fs57.unlinkSync(temporary);
     } catch (cause) {
       if (cause.code !== "ENOENT")
         throw cause;
@@ -99886,7 +99790,7 @@ function applyTaskToV3MigrationPlan(plan, options) {
       const current = snapshot(change.filePath);
       if (!current.bytes.equals(change.after))
         continue;
-      replaceAtomically(change.filePath, fs58.readFileSync(taskMigrationBackupPath(options.backupRoot, change.filePath)), change.mode);
+      replaceAtomically(change.filePath, fs57.readFileSync(taskMigrationBackupPath(options.backupRoot, change.filePath)), change.mode);
     }
     throw cause;
   }
@@ -99896,31 +99800,31 @@ function applyTaskToV3MigrationPlan(plan, options) {
 // scripts/akm-migrate/migrate/task-files-to-v4.ts
 init_errors();
 import crypto7 from "crypto";
-import fs59 from "fs";
-import path69 from "path";
+import fs58 from "fs";
+import path68 from "path";
 function migrationError2(detail) {
   return new ConfigError(`Task migration to v4 failed: ${detail}`, "INVALID_CONFIG_FILE");
 }
 function contained3(root2, candidate) {
-  const relative = path69.relative(root2, candidate);
-  return relative === "" || !relative.startsWith("..") && !path69.isAbsolute(relative);
+  const relative = path68.relative(root2, candidate);
+  return relative === "" || !relative.startsWith("..") && !path68.isAbsolute(relative);
 }
 function realDirectory2(filePath) {
-  const stat = fs59.lstatSync(filePath);
+  const stat = fs58.lstatSync(filePath);
   if (stat.isSymbolicLink() || !stat.isDirectory())
     throw migrationError2(`${filePath} must be a real directory.`);
-  return fs59.realpathSync(filePath);
+  return fs58.realpathSync(filePath);
 }
 function snapshot2(filePath) {
-  const stat = fs59.lstatSync(filePath);
+  const stat = fs58.lstatSync(filePath);
   if (stat.isSymbolicLink() || !stat.isFile())
     throw migrationError2(`${filePath} must be a real file.`);
-  const bytes = fs59.readFileSync(filePath);
+  const bytes = fs58.readFileSync(filePath);
   return Object.freeze({ bytes, mode: stat.mode & 511 });
 }
 function writable2(filePath) {
   try {
-    fs59.accessSync(filePath, fs59.constants.W_OK);
+    fs58.accessSync(filePath, fs58.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -99933,12 +99837,12 @@ function walkTasks2(root2, tasksDir, out) {
     throw migrationError2(`${root2.root} resolves outside bundle ${root2.bundleId}.`);
   }
   const visit2 = (directory) => {
-    const physicalDirectory = fs59.realpathSync(directory);
+    const physicalDirectory = fs58.realpathSync(directory);
     if (!contained3(physicalRoot, physicalDirectory)) {
       throw migrationError2(`${directory} resolves outside bundle ${root2.bundleId}.`);
     }
-    for (const entry of fs59.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const candidate = path69.join(directory, entry.name);
+    for (const entry of fs58.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const candidate = path68.join(directory, entry.name);
       if (entry.isSymbolicLink())
         throw migrationError2(`task migration does not follow symbolic link ${candidate}.`);
       if (entry.isDirectory()) {
@@ -99948,7 +99852,7 @@ function walkTasks2(root2, tasksDir, out) {
       if (!entry.isFile() || !entry.name.endsWith(".yml"))
         continue;
       const current = snapshot2(candidate);
-      const parent = path69.dirname(candidate);
+      const parent = path68.dirname(candidate);
       out.push({
         filePath: candidate,
         bytes: current.bytes,
@@ -99964,9 +99868,9 @@ function walkTasks2(root2, tasksDir, out) {
 function inspectTaskToV4Files(roots) {
   const files = [];
   for (const root2 of [...roots].sort((a, b) => a.bundleId.localeCompare(b.bundleId))) {
-    const tasksDir = root2.layout === "akm-task" ? root2.root : path69.join(root2.root, "tasks");
+    const tasksDir = root2.layout === "akm-task" ? root2.root : path68.join(root2.root, "tasks");
     try {
-      const stat = fs59.lstatSync(tasksDir);
+      const stat = fs58.lstatSync(tasksDir);
       if (stat.isSymbolicLink())
         throw migrationError2(`task migration does not follow symbolic link ${tasksDir}.`);
       if (!stat.isDirectory())
@@ -99981,33 +99885,33 @@ function inspectTaskToV4Files(roots) {
   return files.sort((a, b) => a.filePath.localeCompare(b.filePath));
 }
 function hashPath2(filePath) {
-  return crypto7.createHash("sha256").update(path69.resolve(filePath)).digest("hex").slice(0, 16);
+  return crypto7.createHash("sha256").update(path68.resolve(filePath)).digest("hex").slice(0, 16);
 }
 function taskMigrationBackupPathV4(backupRoot, filePath) {
-  return path69.join(backupRoot, "files", `${hashPath2(filePath)}-${path69.basename(filePath)}`);
+  return path68.join(backupRoot, "files", `${hashPath2(filePath)}-${path68.basename(filePath)}`);
 }
 function writeDurable2(filePath, bytes, mode, exclusive = false) {
-  fs59.mkdirSync(path69.dirname(filePath), { recursive: true });
+  fs58.mkdirSync(path68.dirname(filePath), { recursive: true });
   const flags = exclusive ? "wx" : "w";
-  const fd = fs59.openSync(filePath, flags, mode);
+  const fd = fs58.openSync(filePath, flags, mode);
   try {
-    fs59.writeFileSync(fd, bytes);
-    fs59.fsyncSync(fd);
+    fs58.writeFileSync(fd, bytes);
+    fs58.fsyncSync(fd);
   } finally {
-    fs59.closeSync(fd);
+    fs58.closeSync(fd);
   }
-  fs59.chmodSync(filePath, mode);
-  fsyncDirectoryPortable(path69.dirname(filePath));
+  fs58.chmodSync(filePath, mode);
+  fsyncDirectoryPortable(path68.dirname(filePath));
 }
 function replaceAtomically2(filePath, bytes, mode) {
-  const temporary = path69.join(path69.dirname(filePath), `.${path69.basename(filePath)}.migrate-${crypto7.randomUUID()}`);
+  const temporary = path68.join(path68.dirname(filePath), `.${path68.basename(filePath)}.migrate-${crypto7.randomUUID()}`);
   try {
     writeDurable2(temporary, bytes, mode, true);
-    fs59.renameSync(temporary, filePath);
-    fsyncDirectoryPortable(path69.dirname(filePath));
+    fs58.renameSync(temporary, filePath);
+    fsyncDirectoryPortable(path68.dirname(filePath));
   } finally {
     try {
-      fs59.unlinkSync(temporary);
+      fs58.unlinkSync(temporary);
     } catch (cause) {
       if (cause.code !== "ENOENT")
         throw cause;
@@ -100046,7 +99950,7 @@ function applyTaskToV4MigrationPlan(plan, options) {
       const current = snapshot2(change.filePath);
       if (!current.bytes.equals(change.after))
         continue;
-      replaceAtomically2(change.filePath, fs59.readFileSync(taskMigrationBackupPathV4(options.backupRoot, change.filePath)), change.mode);
+      replaceAtomically2(change.filePath, fs58.readFileSync(taskMigrationBackupPathV4(options.backupRoot, change.filePath)), change.mode);
     }
     throw cause;
   }
@@ -100058,12 +99962,12 @@ function expandTilde(value) {
   if (value === "~")
     return os9.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\"))
-    return path70.join(os9.homedir(), value.slice(2));
+    return path69.join(os9.homedir(), value.slice(2));
   return value;
 }
 function existingDirectory(target) {
   try {
-    return fs60.statSync(target).isDirectory();
+    return fs59.statSync(target).isDirectory();
   } catch (cause) {
     if (cause.code === "ENOENT")
       return false;
@@ -100084,21 +99988,21 @@ function taskRoots(config, resolutionBase = process.cwd()) {
     const source = sources.get(bundleId);
     if (!source)
       continue;
-    const configuredRoot = source.type === "filesystem" && source.path ? path70.resolve(resolutionBase, expandTilde(source.path)) : lockContentRootFor(bundleId, source.type);
+    const configuredRoot = source.type === "filesystem" && source.path ? path69.resolve(resolutionBase, expandTilde(source.path)) : lockContentRootFor(bundleId, source.type);
     if (!configuredRoot || !existingDirectory(configuredRoot))
       continue;
-    const bundleRoot = path70.resolve(configuredRoot);
+    const bundleRoot = path69.resolve(configuredRoot);
     const component = bundleComponentConfig(bundle);
-    const componentRoot = path70.resolve(bundleRoot, component?.root ?? ".");
-    const relative = path70.relative(bundleRoot, componentRoot);
-    if (relative === ".." || relative.startsWith(`..${path70.sep}`) || path70.isAbsolute(relative)) {
+    const componentRoot = path69.resolve(bundleRoot, component?.root ?? ".");
+    const relative = path69.relative(bundleRoot, componentRoot);
+    if (relative === ".." || relative.startsWith(`..${path69.sep}`) || path69.isAbsolute(relative)) {
       throw new ConfigError(`Task migration component root ${componentRoot} escapes bundle ${bundleId} at ${bundleRoot}.`, "INVALID_CONFIG_FILE");
     }
     if (!existingDirectory(componentRoot))
       continue;
     const adapter = component?.adapter ?? detectAdapterId(componentRoot, "");
     if (!component?.adapter && adapter === "") {
-      const flatTasks = fs60.readdirSync(componentRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".yml")).map((entry) => entry.name).sort();
+      const flatTasks = fs59.readdirSync(componentRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".yml")).map((entry) => entry.name).sort();
       if (flatTasks.length > 0) {
         throw new ConfigError(`Task migration cannot classify top-level task file(s) ${flatTasks.join(", ")} in bundle ${bundleId}; configure adapter "akm-task" or move them under tasks/.`, "INVALID_CONFIG_FILE");
       }
@@ -100170,8 +100074,8 @@ function applyTaskV3Migration() {
     const before = inspectCurrentTaskPlan();
     if (before.result.taskV3Migration.changed === 0)
       return before.result;
-    const backupRoot = path70.join(getDataDir(), "backups", "task-v3");
-    const backupPath = path70.join(backupRoot, `${Date.now()}-${randomUUID7()}`);
+    const backupRoot = path69.join(getDataDir(), "backups", "task-v3");
+    const backupPath = path69.join(backupRoot, `${Date.now()}-${randomUUID7()}`);
     const applied = applyTaskToV3MigrationPlan(before.plan, { backupRoot: backupPath });
     const after = inspectCurrentTaskPlan().result;
     if (after.taskV3Migration.changed > 0) {
@@ -100227,8 +100131,8 @@ function applyTaskV4Migration() {
     const before = inspectCurrentTaskV4Plan();
     if (before.result.taskV4Migration.changed === 0)
       return before.result;
-    const backupRoot = path70.join(getDataDir(), "backups", "task-v4");
-    const backupPath = path70.join(backupRoot, `${Date.now()}-${randomUUID7()}`);
+    const backupRoot = path69.join(getDataDir(), "backups", "task-v4");
+    const backupPath = path69.join(backupRoot, `${Date.now()}-${randomUUID7()}`);
     const applied = applyTaskToV4MigrationPlan(before.plan, { backupRoot: backupPath });
     const after = inspectCurrentTaskV4Plan().result;
     if (after.taskV4Migration.changed > 0) {