akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/indexer/bundle-identity-guard.js

@@ -86,6 +86,7 @@ export function warnOnBundleRenameDrift(config = loadConfig()) {
         `Configured bundle(s) with no indexed content: ${configuredMissingFromIndex.map((id) => `"${id}"`).join(", ")}; ` +
         `indexed content under unconfigured bundle id(s): ${indexedNotConfigured.map((id) => `"${id}"`).join(", ")}. ` +
         "This is the signature of a hand-renamed bundle id (spec §11.5). AKM will NOT silently re-mint fresh state " +
-        "under the new id. If you renamed a bundle, rekey it atomically via the bundle-rename command instead of " +
-        "editing the config key directly — otherwise the old index/state rows are stranded.");
+        "under the new id. There is no rekey command in 0.9.0: either restore the previous bundle id in config.json " +
+        "to reattach the existing rows, or keep the new id and run `akm index --full` to re-mint under it, accepting " +
+        "that learned state (utility, salience, outcomes, usage history) keyed to the old id is left behind.");
 }

package/dist/indexer/db/graph-db.js

@@ -215,13 +215,6 @@ export function drainExtractionQueue(db, stashRoot, limit) {
         return [];
     }
 }
-/**
- * Scoped loader — only the graph_meta row for a stash. Used by callers that
- * only need summary numbers (e.g. `akm graph summary`).
- */
-export function loadGraphMetaOnly(stashPath, db) {
-    return loadStoredGraphMeta(stashPath, db);
-}
 /**
  * Scoped loader — graph_files rows without entities/relations. Used for
  * orphan detection and entity overview commands.
@@ -256,23 +249,6 @@ export function loadGraphFilesOnly(stashPath, db) {
         return [];
     }
 }
-/**
- * Scoped loader — entities for a single file, keyed on the #624-P1 composite
- * (stash_root, file_path, body_hash). Used by per-asset show/curate lookups.
- */
-export function loadGraphEntitiesByPath(db, stashRoot, filePath, bodyHash) {
-    try {
-        const rows = db
-            .prepare(`SELECT entity FROM graph_file_entities
-          WHERE stash_root = ? AND file_path = ? AND body_hash = ?
-          ORDER BY entity_order`)
-            .all(stashRoot, filePath, bodyHash);
-        return rows.map((r) => r.entity);
-    }
-    catch {
-        return [];
-    }
-}
 export function loadStoredGraphMeta(stashPath, db) {
     try {
         return withReadableGraphDb(db, (readDb) => {

package/dist/indexer/ensure-index.js

@@ -185,6 +185,7 @@ async function runInlineReindex(stashDir, options = {}) {
         const { akmIndex } = await import("./indexer.js");
         await akmIndex({
             stashDir,
+            implicit: true,
             ...(options.signal ? { signal: options.signal } : {}),
             ...(options.hydrateSources === false ? { hydrateSources: false } : {}),
         });

package/dist/indexer/graph/graph-boost.js

@@ -249,12 +249,9 @@ export function collectGraphRelatedHit(context, filePath) {
  * NOT entries.id — so candidates are identified by file_path (the unique index
  * idx_graph_files_path guarantees one graph_files row per path).
  *
- * The returned `ref` field carries the CANONICAL asset ref resolved from the
- * durable identity columns (`entries.concept_id`, the bundle-less tail of
- * `item_ref`) when the file is indexed — NOT re-derived from the legacy
- * `entry_key`. Callers should fall back to formatting `path` when `ref` is
- * undefined (graph row with no matching entries row, or a NULL-provenance
- * write-back straggler healed on the next full index).
+ * The returned `ref` field carries the canonical indexed `concept_id`, never a
+ * value re-derived from presentation fields or `entry_key`. It is undefined
+ * when the graph row has no matching entry with current indexed provenance.
  */
 export function listRelatedPathsForFile(stashRoot, filePath, limit = 5, db) {
     if (!db) {
@@ -345,25 +342,17 @@ export function listRelatedPathsForFile(stashRoot, filePath, limit = 5, db) {
             relationCountByPath.set(row.file_path, (relationCountByPath.get(row.file_path) ?? 0) + 1);
         }
     }
-    // Ref lookup via the CANONICAL stored identity (spec §3.3): `item_ref` is THE
-    // durable ref (`<bundle>//<conceptId>`) and `concept_id` is its bundle-less
-    // tail — the exact spelling displayRef emits for a default-bundle item. This
-    // related list is always scoped to ONE stash root (every row shares a bundle),
-    // so the user-facing ref is that short conceptId. Resolve by (concept_id /
-    // item_ref, file_path) DIRECTLY — no entry_key→`type:name` string surgery.
-    // A NULL-provenance write-back straggler (item_ref/concept_id still NULL)
-    // simply carries no ref; the caller falls back to the path and the next full
-    // index heals the row.
+    // This related list is scoped to one source root, so the user-facing ref is
+    // the indexed bundle-less conceptId.
     const refByPath = new Map();
     try {
         const entryRows = db
-            .prepare(`SELECT file_path, concept_id, item_ref FROM entries
-          WHERE file_path IN (${placeholders}) AND stash_dir = ?`)
+            .prepare(`SELECT file_path, concept_id FROM entries
+          WHERE file_path IN (${placeholders}) AND stash_dir = ?
+            AND item_ref IS NOT NULL AND concept_id IS NOT NULL`)
             .all(...candidatePaths, stashRoot);
         for (const row of entryRows) {
-            const ref = row.concept_id ?? conceptIdFromItemRef(row.item_ref);
-            if (ref)
-                refByPath.set(row.file_path, ref);
+            refByPath.set(row.file_path, row.concept_id);
         }
     }
     catch {
@@ -382,20 +371,6 @@ export function listRelatedPathsForFile(stashRoot, filePath, limit = 5, db) {
         };
     });
 }
-/**
- * The bundle-less conceptId tail of a canonical `item_ref`
- * (`<bundle>//<conceptId>`), or `null` when the ref is absent. The graph-related
- * ref is scoped to a single stash root, so the short conceptId is the
- * user-facing spelling (matching displayRef's default-bundle output). The reader
- * prefers the stored `concept_id` column; this derives the same value from
- * `item_ref` when only that column is populated.
- */
-function conceptIdFromItemRef(itemRef) {
-    if (!itemRef)
-        return null;
-    const boundary = itemRef.indexOf("//");
-    return boundary >= 0 ? itemRef.slice(boundary + 2) : itemRef;
-}
 /**
  * Load and normalize graph data from SQLite once, then reuse it across all
  * per-entry boost lookups in the current query.

package/dist/indexer/graph/graph-extraction.js

@@ -8,7 +8,7 @@
  * configured LLM to extract entities and relations from each one, and
  * persists the result to stash-local SQLite graph tables keyed by stash root.
  * The artifact is consumed by the search
- * pipeline (see `src/indexer/graph-boost.ts`) as a single boost component
+ * pipeline (see `src/indexer/graph/graph-boost.ts`) as a single boost component
  * inside the existing FTS5+boosts loop — there is NO second SearchHit
  * scorer and no parallel ranking track.
  *
@@ -31,8 +31,11 @@
  *   - LLM access is exclusively via `resolveIndexPassLLM("graph", config)`.
  *   - The graph rows are an indexer artifact, NOT a user-visible
  *     asset. It does not have an asset ref, does not appear in search
- *     hits, and is not addressable via `akm show`. Direct `fs.writeFile`
- *     is therefore the correct primitive — `writeAssetToSource` is
+ *     hits, and is not addressable via `akm show`. The persisted artifact
+ *     lives in indexer-owned SQLite tables (`replaceStoredGraph` /
+ *     `loadStoredGraphSnapshot` in `../db/graph-db.ts`), NOT as a file on
+ *     disk (R-065 #3 — this comment previously described a retired
+ *     `fs.writeFile`-based storage layout) — `writeAssetToSource` is
  *     reserved for asset writes (CLAUDE.md / spec §10 step 5).
  */
 import fs from "node:fs";
@@ -470,8 +473,8 @@ export async function runGraphExtractionPass(ctx) {
             reportProgress(candidate.absPath, result);
             return result;
         }, 
-        // Default concurrency of 4 for cloud APIs. Set `llm.concurrency: 1`
-        // in config.json for local model servers (LM Studio, Ollama).
+        // Caller-set connection concurrency or 1: `resolveLlmEngineUse` does
+        // not forward `engines.<name>.concurrency`, so config cannot raise this.
         llmConfig.concurrency ?? 1);
     }
     else {

package/dist/indexer/index-writer-lock.js

@@ -41,6 +41,24 @@ function createLease(lockPath, ownership) {
         },
     };
 }
+function tryAcquireIndexWriterLease(lockPath, purpose) {
+    while (true) {
+        const releaseBarrier = tryAcquireMaintenanceBarrier();
+        if (!releaseBarrier)
+            return undefined;
+        try {
+            const ownership = tryAcquireLockSync(lockPath, buildPayload(purpose));
+            if (ownership)
+                return createLease(lockPath, ownership);
+            const probe = probeLock(lockPath, { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });
+            if (probe.state !== "stale" || !reclaimStaleLock(lockPath, probe))
+                return undefined;
+        }
+        finally {
+            releaseBarrier();
+        }
+    }
+}
 export async function acquireIndexWriterLease(options) {
     const mode = options.mode ?? "wait";
     const lockPath = getIndexWriterLockPath();
@@ -50,23 +68,10 @@ export async function acquireIndexWriterLease(options) {
     let lastWaitNoticeMs = 0;
     while (true) {
         throwIfAborted(options.signal);
-        const releaseBarrier = tryAcquireMaintenanceBarrier();
-        if (releaseBarrier) {
-            try {
-                const ownership = tryAcquireLockSync(lockPath, buildPayload(options.purpose));
-                if (ownership) {
-                    options.onAcquired?.({ waitedMs: Date.now() - startedAt });
-                    return createLease(lockPath, ownership);
-                }
-                const probe = probeLock(lockPath, { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });
-                if (probe.state === "stale") {
-                    if (reclaimStaleLock(lockPath, probe))
-                        continue;
-                }
-            }
-            finally {
-                releaseBarrier();
-            }
+        const lease = tryAcquireIndexWriterLease(lockPath, options.purpose);
+        if (lease) {
+            options.onAcquired?.({ waitedMs: Date.now() - startedAt });
+            return lease;
         }
         if (mode === "try")
             return undefined;
@@ -109,6 +114,37 @@ export async function withIndexWriterLease(options, run) {
 export function withAssetMutationLease(purpose, run) {
     return withIndexWriterLease({ purpose }, run);
 }
+/** Synchronous asset-write boundary over the same interprocess lease. */
+export function withAssetMutationLeaseSync(purpose, run) {
+    const lockPath = getIndexWriterLockPath();
+    const inherited = leaseContext.getStore();
+    if (inherited?.has(lockPath))
+        return run();
+    const context = inherited ?? new Set();
+    const execute = () => {
+        const startedAt = Date.now();
+        fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+        let lease;
+        while (!lease) {
+            lease = tryAcquireIndexWriterLease(lockPath, purpose);
+            if (!lease) {
+                if (Date.now() - startedAt >= DEFAULT_INDEX_WRITER_MAX_WAIT_MS) {
+                    throw new Error(`timed out waiting for index writer lease for ${purpose}`);
+                }
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, INDEX_WRITER_WAIT_MS);
+            }
+        }
+        context.add(lockPath);
+        try {
+            return run();
+        }
+        finally {
+            context.delete(lockPath);
+            lease.release();
+        }
+    };
+    return inherited ? execute() : leaseContext.run(context, execute);
+}
 export function probeIndexWriterLease() {
     return probeLock(getIndexWriterLockPath(), { staleAfterMs: INDEX_WRITER_LOCK_STALE_AFTER_MS });
 }

package/dist/indexer/index-written-assets.js

@@ -22,7 +22,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import { akmAdapter } from "../core/adapter/adapters/akm-adapter.js";
-import { recoverTxnsForRoot } from "../core/fs-txn.js";
 import { getDbPath } from "../core/paths.js";
 import { warnVerbose } from "../core/warn.js";
 import { closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
@@ -57,17 +56,12 @@ export const WRITE_PATH_INDEX_BUSY_TIMEOUT_MS = 5_000;
 export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
     try {
         return await withIndexWriterLease({ purpose: "index-written-assets" }, async () => {
-            if (options.recoverMoves !== false) {
-                // Unified fs-txn engine (WI-6.3): finish/roll back interrupted mv
-                // transactions before the targeted write-path refresh reads the tree.
-                await recoverTxnsForRoot(stashDir, (journal) => journal.kind === "mv");
-            }
             const dbPath = getDbPath();
             if (!fs.existsSync(dbPath))
                 return true;
-            // The full walk never descends into dot-directories (they hold state like
-            // `.meta/` and the legacy metadata sidecar) — mirror that dot-segment skip
-            // here so this fast path indexes exactly what a full run would. Sensitive/
+            // The full walk never descends into dot-directories (for example `.meta/`)
+            // — mirror that dot-segment skip here so this fast path indexes exactly
+            // what a full run would. Sensitive/
             // infra abstention is the adapter's job now (see the `akmAdapter` note
             // below), not a path pre-filter.
             const files = filePaths.filter((f) => {
@@ -80,12 +74,11 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
             // short. One drain call per file keeps the entry↔path pairing exact and
             // reuses the full-index recognize engine (F4a M-core-2 item 5): broken
             // workflows drop, valid workflow docs are cached for the side-table upsert.
-            const component = deriveInstallations([{ path: stashDir, writable: true }])[0]?.components[0] ?? {
-                id: stashDir,
-                adapter: "akm",
-                root: stashDir,
-                writable: true,
-            };
+            const component = deriveInstallations([
+                { path: stashDir, writable: true, ...(options.bundleId ? { registryId: options.bundleId } : {}) },
+            ])[0]?.components[0];
+            if (!component)
+                throw new Error(`Could not derive bundle provenance for ${stashDir}`);
             const pairs = [];
             const unindexable = new Set();
             for (const file of files) {
@@ -96,17 +89,18 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
                 const ctx = buildFileContext(stashDir, file);
                 // Hardcoded `akmAdapter` on purpose (owner ruling 2026-07-21): this
                 // write-path fast path only ever runs for assets a first-class akm
-                // mutation command (`remember`/`wiki`/`workflow`/`setup`/`mv`) just wrote
-                // into the PRIMARY akm workspace, so the akm adapter is always the right
-                // recognizer here — no per-component dispatch needed.
+                // mutation command just wrote into a managed akm source, so the akm
+                // adapter is always the right recognizer here — no per-component
+                // dispatch needed.
                 const drained = drainDirDocuments(akmAdapter, component, [ctx]);
                 const entry = drained.entries[0];
                 // Workflows also carry a workflow_documents side-table upsert — handled
                 // below, mirroring the full walk — since `akm mv` rewrites citer files
                 // that can be workflows. A broken workflow drains to zero entries (like
                 // the old skip-with-warning) and is treated as unindexable.
-                if (entry)
-                    pairs.push({ file, entry, contentHash: drained.hashByFile.get(ctx.absPath) });
+                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);
             }
@@ -119,7 +113,7 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
                     const rows = db.prepare("SELECT id FROM entries WHERE file_path = ?").all(file);
                     deleteEntriesByIds(db, rows.map((row) => row.id));
                 }
-                for (const { file, entry, contentHash } of pairs) {
+                for (const { file, entry, conceptId, contentHash } of pairs) {
                     const entryKey = `${stashDir}:${entry.type}:${entry.name}`;
                     let entryWithSize = entry;
                     try {
@@ -131,7 +125,7 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
                     // Real provenance (F4a M-core-2 item 5): populate item_ref/content_hash
                     // via the SAME derivation the full-index writer uses, so a write-path
                     // row is never a NULL-item_ref straggler.
-                    const provenance = deriveEntryProvenance({ bundleId: component.id, componentId: component.id, adapterId: component.adapter }, entry.type, entry.name);
+                    const provenance = deriveEntryProvenance({ bundleId: component.id, componentId: component.id, adapterId: component.adapter }, entry.type, entry.name, conceptId);
                     const entryId = upsertEntry(db, entryKey, path.dirname(file), file, stashDir, entryWithSize, buildSearchText(entry), provenance, contentHash);
                     if (entry.type === "workflow") {
                         // Same contract as the full walk (indexer.ts): the renderer cached