akm-cli 0.9.0-beta.6 → 0.9.0-rc.0

package/dist/commands/feedback-cli.js

@@ -2,8 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
-import { defineCommand } from "citty";
-import { output, parseAllFlagValues, runWithJsonErrors } from "../cli/shared.js";
+import { defineJsonCommand, output, parseAllFlagValues } from "../cli/shared.js";
 import { parseAssetRef } from "../core/asset/asset-ref.js";
 import { assembleAsset } from "../core/asset/asset-serialize.js";
 import { parseFrontmatter, parseFrontmatterBlock } from "../core/asset/frontmatter.js";
@@ -11,10 +10,9 @@ import { writeFileAtomic } from "../core/common.js";
 import { FEEDBACK_FAILURE_MODES, loadConfig } from "../core/config/config.js";
 import { UsageError } from "../core/errors.js";
 import { appendEvent } from "../core/events.js";
+import { getDbPath } from "../core/paths.js";
 import { warn } from "../core/warn.js";
 import { applyFeedbackToUtilityScore, closeDatabase, findEntryIdByRef, getEntryFilePathById, openExistingDatabase, } from "../indexer/db/db.js";
-import { ensureIndex } from "../indexer/ensure-index.js";
-import { resolveSourceEntries } from "../indexer/search/search-source.js";
 import { countFeedbackSignals, insertUsageEvent } from "../indexer/usage/usage-events.js";
 // ── Tag validation ────────────────────────────────────────────────────────────
 const TAG_KEY_RE = /^[a-z_][a-z0-9_]*$/;
@@ -109,7 +107,7 @@ function appendLessonStrength(type, name, feedbackRef) {
     return { strength: strengthList.length };
 }
 // ── Command definition ────────────────────────────────────────────────────────
-export const feedbackCommand = defineCommand({
+export const feedbackCommand = defineJsonCommand({
     meta: {
         name: "feedback",
         description: "Record positive or negative feedback for any indexed stash asset.\n\n" +
@@ -153,163 +151,171 @@ export const feedbackCommand = defineCommand({
                 "`lessonStrength[]` frontmatter array (dedup, idempotent). Ignored on non-lesson targets.",
         },
     },
-    run({ args }) {
-        return runWithJsonErrors(async () => {
-            const ref = (args.ref ?? "").trim();
-            if (!ref) {
-                throw new UsageError("Asset ref is required. Usage: akm feedback <ref> --positive|--negative", "MISSING_REQUIRED_ARGUMENT", "Pass a ref like `skill:deploy` and either --positive or --negative.");
+    async run({ args }) {
+        const ref = (args.ref ?? "").trim();
+        if (!ref) {
+            throw new UsageError("Asset ref is required. Usage: akm feedback <ref> --positive|--negative", "MISSING_REQUIRED_ARGUMENT", "Pass a ref like `skill:deploy` and either --positive or --negative.");
+        }
+        parseAssetRef(ref);
+        if (args.positive && args.negative) {
+            throw new UsageError("Specify either --positive or --negative, not both.");
+        }
+        if (!args.positive && !args.negative) {
+            throw new UsageError("Specify --positive or --negative.");
+        }
+        const signal = args.positive ? "positive" : "negative";
+        const reason = args.reason;
+        // F-3 / #384: Validate --failure-mode against the curated enum.
+        const failureMode = args["failure-mode"]?.trim() || undefined;
+        if (failureMode) {
+            if (args.positive) {
+                throw new UsageError("--failure-mode is only valid for negative feedback.", "INVALID_FLAG_VALUE", "Remove --failure-mode or switch to --negative.");
             }
-            parseAssetRef(ref);
-            if (args.positive && args.negative) {
-                throw new UsageError("Specify either --positive or --negative, not both.");
+            const cfg = loadConfig();
+            const allowedModes = cfg.feedback?.allowedFailureModes ?? FEEDBACK_FAILURE_MODES;
+            if (allowedModes.length > 0 && !allowedModes.includes(failureMode)) {
+                throw new UsageError(`Invalid --failure-mode "${failureMode}". Accepted values: ${allowedModes.join(", ")}.`, "INVALID_FLAG_VALUE", `Use one of: ${allowedModes.join(", ")}`);
             }
-            if (!args.positive && !args.negative) {
-                throw new UsageError("Specify --positive or --negative.");
+        }
+        if (args.negative === true && !reason?.trim()) {
+            // F-3 / #384: Default requireReason is now true. Load config to allow
+            // operators to opt out via feedback.requireReason: false in akm.json.
+            const cfg = loadConfig();
+            const requireReason = cfg.feedback?.requireReason ?? true; // Default: true (F-3 / #384)
+            if (requireReason) {
+                throw new UsageError("Negative feedback requires --reason (structured failure signals are needed for distillation). " +
+                    "Use --failure-mode for a curated taxonomy or --reason for free text. " +
+                    "Set feedback.requireReason: false in akm.json to downgrade to a warning.", "MISSING_REQUIRED_ARGUMENT", `Hint: akm feedback ${ref} --negative --reason "..." [--failure-mode incorrect|outdated|dangerous|incomplete|redundant]`);
             }
-            const signal = args.positive ? "positive" : "negative";
-            const reason = args.reason;
-            // F-3 / #384: Validate --failure-mode against the curated enum.
-            const failureMode = args["failure-mode"]?.trim() || undefined;
-            if (failureMode) {
-                if (args.positive) {
-                    throw new UsageError("--failure-mode is only valid for negative feedback.", "INVALID_FLAG_VALUE", "Remove --failure-mode or switch to --negative.");
-                }
-                const cfg = loadConfig();
-                const allowedModes = cfg.feedback?.allowedFailureModes ?? FEEDBACK_FAILURE_MODES;
-                if (allowedModes.length > 0 && !allowedModes.includes(failureMode)) {
-                    throw new UsageError(`Invalid --failure-mode "${failureMode}". Accepted values: ${allowedModes.join(", ")}.`, "INVALID_FLAG_VALUE", `Use one of: ${allowedModes.join(", ")}`);
-                }
+            else {
+                warn("Warning: negative feedback without --reason provides less distillation signal.");
             }
-            if (args.negative === true && !reason?.trim()) {
-                // F-3 / #384: Default requireReason is now true. Load config to allow
-                // operators to opt out via feedback.requireReason: false in akm.json.
-                const cfg = loadConfig();
-                const requireReason = cfg.feedback?.requireReason ?? true; // Default: true (F-3 / #384)
-                if (requireReason) {
-                    throw new UsageError("Negative feedback requires --reason (structured failure signals are needed for distillation). " +
-                        "Use --failure-mode for a curated taxonomy or --reason for free text. " +
-                        "Set feedback.requireReason: false in akm.json to downgrade to a warning.", "MISSING_REQUIRED_ARGUMENT", `Hint: akm feedback ${ref} --negative --reason "..." [--failure-mode incorrect|outdated|dangerous|incomplete|redundant]`);
-                }
-                else {
-                    warn("Warning: negative feedback without --reason provides less distillation signal.");
-                }
+        }
+        const rawTags = parseAllFlagValues("--tag");
+        const validatedTags = validateFeedbackTags(rawTags);
+        const metadataObj = {
+            signal,
+            ...(reason?.trim() ? { reason: reason.trim() } : {}),
+            ...(failureMode ? { failureMode } : {}),
+            ...(validatedTags.length > 0 ? { tags: validatedTags } : {}),
+        };
+        const metadataStr = Object.keys(metadataObj).length > 1 ? JSON.stringify(metadataObj) : undefined;
+        // Feedback only needs the index to exist, not to be current. A stale index
+        // is fine — the ref lookup works against any populated DB. We do NOT call
+        // ensureIndex here: it either blocks (3+ min inline reindex) or spawns a
+        // background process that holds the writer lock, causing the feedback write
+        // to spin-wait for the full reindex duration. If the DB is absent we give a
+        // clear error below rather than silently triggering a rebuild.
+        if (!fs.existsSync(getDbPath())) {
+            throw new UsageError("Index not found. Run 'akm index' first to build the index before recording feedback.", "MISSING_REQUIRED_ARGUMENT", "akm index");
+        }
+        // Feedback writes exactly 2 rows (usage_events + utility_score). SQLite
+        // WAL mode + busy_timeout=30s handles concurrent access with an ongoing
+        // `akm improve` run without needing the application-level writer lock.
+        // The lock was originally needed to prevent feedback from racing a
+        // background reindex it spawned — now that ensureIndex is removed, holding
+        // the lock only causes feedback to block for the full improve run duration.
+        let utilityResult;
+        const db = openExistingDatabase();
+        try {
+            const entryId = findEntryIdByRef(db, ref);
+            if (entryId === undefined) {
+                throw new UsageError(`Ref "${ref}" is not in the index. ` +
+                    "Run 'akm search' to verify the asset exists, then 'akm index' if it was recently added.");
             }
-            const rawTags = parseAllFlagValues("--tag");
-            const validatedTags = validateFeedbackTags(rawTags);
-            const metadataObj = {
+            // Persist the feedback signal into usage_events. For positive signals,
+            // the EMA utility score is updated immediately on the next read path.
+            // For negative signals, the score is adjusted the next time `akm index`
+            // runs — the signal is durable in the DB but does NOT suppress ranking
+            // in search results until after reindexing.
+            insertUsageEvent(db, {
+                event_type: "feedback",
+                entry_ref: ref,
+                entry_id: entryId,
                 signal,
-                ...(reason?.trim() ? { reason: reason.trim() } : {}),
-                ...(failureMode ? { failureMode } : {}),
-                ...(validatedTags.length > 0 ? { tags: validatedTags } : {}),
-            };
-            const metadataStr = Object.keys(metadataObj).length > 1 ? JSON.stringify(metadataObj) : undefined;
-            // Auto-index when stale so the index is current before recording feedback.
-            const sources = resolveSourceEntries();
-            if (sources.length > 0) {
-                await ensureIndex(sources[0].path);
+                metadata: metadataStr,
+            });
+            // Apply feedback-derived utility score adjustment immediately so that
+            // positive/negative signals influence search ranking without requiring
+            // a full reindex. We query the total accumulated feedback counts from
+            // usage_events so the delta reflects the entire signal history.
+            // Uses MemRL bounded-step EMA (F-5 / #386, arXiv:2601.03192).
+            try {
+                const { pos, neg } = countFeedbackSignals(db, entryId);
+                utilityResult = applyFeedbackToUtilityScore(db, entryId, pos, neg);
             }
-            let utilityResult;
-            const db = openExistingDatabase();
+            catch {
+                // best-effort — feedback recording succeeds even if utility update fails
+            }
+        }
+        finally {
+            closeDatabase(db);
+        }
+        appendEvent({
+            eventType: "feedback",
+            ref,
+            metadata: metadataObj,
+        });
+        // F-5 / #386: When a high-utility asset crosses below the review threshold,
+        // auto-create a review-needed escalation proposal so a human can confirm
+        // whether the negative feedback is valid before the asset falls out of
+        // the improve loop. Best-effort — failure is logged but does not fail the
+        // feedback command.
+        // Emit a structured event rather than a proposal so the review-needed
+        // signal is queryable via `akm events list --type improve_review_needed`
+        // without risking accidental asset overwrite if the proposal is accepted.
+        if (utilityResult?.crossedReviewThreshold) {
             try {
-                const entryId = findEntryIdByRef(db, ref);
-                if (entryId === undefined) {
-                    throw new UsageError(`Ref "${ref}" is not in the index. ` +
-                        "Run 'akm search' to verify the asset exists, then 'akm index' if it was recently added.");
-                }
-                // Persist the feedback signal into usage_events. For positive signals,
-                // the EMA utility score is updated immediately on the next read path.
-                // For negative signals, the score is adjusted the next time `akm index`
-                // runs — the signal is durable in the DB but does NOT suppress ranking
-                // in search results until after reindexing.
-                insertUsageEvent(db, {
-                    event_type: "feedback",
-                    entry_ref: ref,
-                    entry_id: entryId,
-                    signal,
-                    metadata: metadataStr,
+                appendEvent({
+                    eventType: "improve_review_needed",
+                    ref,
+                    metadata: {
+                        previousUtility: utilityResult.previousUtility,
+                        nextUtility: utilityResult.nextUtility,
+                        reason: reason?.trim() ?? null,
+                        failureMode: failureMode ?? null,
+                    },
                 });
-                // Apply feedback-derived utility score adjustment immediately so that
-                // positive/negative signals influence search ranking without requiring
-                // a full reindex. We query the total accumulated feedback counts from
-                // usage_events so the delta reflects the entire signal history.
-                // Uses MemRL bounded-step EMA (F-5 / #386, arXiv:2601.03192).
-                try {
-                    const { pos, neg } = countFeedbackSignals(db, entryId);
-                    utilityResult = applyFeedbackToUtilityScore(db, entryId, pos, neg);
-                }
-                catch {
-                    // best-effort — feedback recording succeeds even if utility update fails
-                }
             }
-            finally {
-                closeDatabase(db);
-            }
-            appendEvent({
-                eventType: "feedback",
-                ref,
-                metadata: metadataObj,
-            });
-            // F-5 / #386: When a high-utility asset crosses below the review threshold,
-            // auto-create a review-needed escalation proposal so a human can confirm
-            // whether the negative feedback is valid before the asset falls out of
-            // the improve loop. Best-effort — failure is logged but does not fail the
-            // feedback command.
-            // Emit a structured event rather than a proposal so the review-needed
-            // signal is queryable via `akm events list --type improve_review_needed`
-            // without risking accidental asset overwrite if the proposal is accepted.
-            if (utilityResult?.crossedReviewThreshold) {
-                try {
-                    appendEvent({
-                        eventType: "improve_review_needed",
-                        ref,
-                        metadata: {
-                            previousUtility: utilityResult.previousUtility,
-                            nextUtility: utilityResult.nextUtility,
-                            reason: reason?.trim() ?? null,
-                            failureMode: failureMode ?? null,
-                        },
-                    });
-                }
-                catch (escalationErr) {
-                    warn(`[feedback] Could not emit review-needed event for ${ref}: ${escalationErr instanceof Error ? escalationErr.message : String(escalationErr)}`);
-                }
+            catch (escalationErr) {
+                warn(`[feedback] Could not emit review-needed event for ${ref}: ${escalationErr instanceof Error ? escalationErr.message : String(escalationErr)}`);
             }
-            // Phase 7A / Advantage D4b: --applied-to credits a lesson. When the
-            // target is a `lesson:<name>` ref and the signal is positive, append
-            // the feedback ref to the target lesson's `lessonStrength[]`
-            // frontmatter array (dedup, idempotent). Non-lesson targets are
-            // ignored. Failures here are warnings — feedback recording is the
-            // primary contract and must not regress on lesson-write errors.
-            const appliedToRaw = args["applied-to"]?.trim();
-            let appliedToResult = null;
-            if (appliedToRaw && signal === "positive") {
-                try {
-                    const parsedApplied = parseAssetRef(appliedToRaw);
-                    if (parsedApplied.type === "lesson") {
-                        const updated = appendLessonStrength(parsedApplied.type, parsedApplied.name, ref);
-                        if (updated) {
-                            appliedToResult = { lessonRef: appliedToRaw, strength: updated.strength };
-                        }
+        }
+        // Phase 7A / Advantage D4b: --applied-to credits a lesson. When the
+        // target is a `lesson:<name>` ref and the signal is positive, append
+        // the feedback ref to the target lesson's `lessonStrength[]`
+        // frontmatter array (dedup, idempotent). Non-lesson targets are
+        // ignored. Failures here are warnings — feedback recording is the
+        // primary contract and must not regress on lesson-write errors.
+        const appliedToRaw = args["applied-to"]?.trim();
+        let appliedToResult = null;
+        if (appliedToRaw && signal === "positive") {
+            try {
+                const parsedApplied = parseAssetRef(appliedToRaw);
+                if (parsedApplied.type === "lesson") {
+                    const updated = appendLessonStrength(parsedApplied.type, parsedApplied.name, ref);
+                    if (updated) {
+                        appliedToResult = { lessonRef: appliedToRaw, strength: updated.strength };
                     }
                 }
-                catch (err) {
-                    warn(`[feedback] --applied-to failed for ${appliedToRaw}: ${err instanceof Error ? err.message : String(err)}`);
-                }
             }
-            else if (appliedToRaw && signal !== "positive") {
-                warn("[feedback] --applied-to is ignored without --positive; lesson credit is only recorded on positive signals.");
+            catch (err) {
+                warn(`[feedback] --applied-to failed for ${appliedToRaw}: ${err instanceof Error ? err.message : String(err)}`);
             }
-            output("feedback", {
-                ok: true,
-                ref,
-                signal,
-                reason: reason?.trim() ?? null,
-                failureMode: failureMode ?? null,
-                tags: validatedTags,
-                ...(appliedToResult
-                    ? { appliedTo: { ref: appliedToResult.lessonRef, lessonStrength: appliedToResult.strength } }
-                    : {}),
-            });
+        }
+        else if (appliedToRaw && signal !== "positive") {
+            warn("[feedback] --applied-to is ignored without --positive; lesson credit is only recorded on positive signals.");
+        }
+        output("feedback", {
+            ok: true,
+            ref,
+            signal,
+            reason: reason?.trim() ?? null,
+            failureMode: failureMode ?? null,
+            tags: validatedTags,
+            ...(appliedToResult
+                ? { appliedTo: { ref: appliedToResult.lessonRef, lessonStrength: appliedToResult.strength } }
+                : {}),
         });
     },
 });

package/dist/commands/graph/graph-cli.js

@@ -9,12 +9,9 @@
  * same JSON envelope (stdout/stderr/exit-code) as the inline `runWithJsonErrors`
  * form it replaces.
  */
-import { defineCommand } from "citty";
-import { hasSubcommand, parsePositiveIntFlag } from "../../cli/parse-args.js";
-import { defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
+import { parsePositiveIntFlag } from "../../cli/parse-args.js";
+import { defineGroupCommand, defineJsonCommand, output } from "../../cli/shared.js";
 import { akmGraphEntities, akmGraphEntity, akmGraphExport, akmGraphOrphans, akmGraphRelated, akmGraphRelations, akmGraphSummary, akmGraphUpdate, } from "./graph.js";
-// Single source of truth: the routing set is derived from the subCommands keys
-// (M10) so adding a subcommand can never silently desync from `hasSubcommand`.
 const graphSubCommands = {
     summary: defineJsonCommand({
         meta: { name: "summary", description: "Show entity-graph counts and quality telemetry" },
@@ -118,15 +115,10 @@ const graphSubCommands = {
         },
     }),
 };
-const GRAPH_SUBCOMMAND_SET = new Set(Object.keys(graphSubCommands));
-export const graphCommand = defineCommand({
+export const graphCommand = defineGroupCommand({
     meta: { name: "graph", description: "Inspect the indexed entity graph stored in SQLite" },
     subCommands: graphSubCommands,
-    run({ args }) {
-        return runWithJsonErrors(() => {
-            if (hasSubcommand(args, GRAPH_SUBCOMMAND_SET))
-                return;
-            output("graph-summary", akmGraphSummary());
-        });
+    defaultRun() {
+        output("graph-summary", akmGraphSummary());
     },
 });

package/dist/commands/graph/graph.js

@@ -8,10 +8,11 @@ import { loadConfig } from "../../core/config/config.js";
 import { NotFoundError, UsageError } from "../../core/errors.js";
 import { getDbPath } from "../../core/paths.js";
 import { warn } from "../../core/warn.js";
-import { closeDatabase, findEntryIdByRef, getEntryById, getEntryRefRowsForStashRoot, openDatabase, openExistingDatabase, } from "../../indexer/db/db.js";
+import { closeDatabase, findEntryIdByRef, getEntryById, getEntryRefRowsForStashRoot, openExistingDatabase, openIndexDatabase, } from "../../indexer/db/db.js";
 import { loadStoredGraphSnapshot } from "../../indexer/db/graph-db.js";
 import { listRelatedPathsForFile } from "../../indexer/graph/graph-boost.js";
 import { runGraphExtractionPass } from "../../indexer/graph/graph-extraction.js";
+import { withIndexWriterLease } from "../../indexer/index-writer-lock.js";
 import { lookup } from "../../indexer/indexer.js";
 import { findSourceForPath, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
@@ -375,85 +376,88 @@ export async function akmGraphUpdate(options) {
         }
     }
     const scoped = Array.isArray(options.refs) && options.refs.length > 0;
-    let candidatePaths;
-    if (scoped && options.refs) {
-        // Resolve each ref to an absolute file path via the index DB.
-        const dbPath = getDbPath();
-        let db;
-        const resolvedPaths = new Set();
-        try {
-            db = openDatabase(dbPath);
-            for (const ref of options.refs) {
-                const trimmed = ref.trim();
-                if (!trimmed)
-                    continue;
-                const entryId = findEntryIdByRef(db, trimmed);
-                if (entryId === undefined) {
-                    warn(`[graph] ref not found in index, skipping: ${trimmed}`);
-                    continue;
+    return withIndexWriterLease({ purpose: "graph-update" }, async () => {
+        let candidatePaths;
+        if (scoped && options.refs) {
+            // Resolve each ref to an absolute file path while the writer lease is held
+            // so the scoped graph write sees the same index snapshot it resolved from.
+            const dbPath = getDbPath();
+            let db;
+            const resolvedPaths = new Set();
+            try {
+                db = openIndexDatabase(dbPath);
+                for (const ref of options.refs) {
+                    const trimmed = ref.trim();
+                    if (!trimmed)
+                        continue;
+                    const entryId = findEntryIdByRef(db, trimmed);
+                    if (entryId === undefined) {
+                        warn(`[graph] ref not found in index, skipping: ${trimmed}`);
+                        continue;
+                    }
+                    const row = getEntryById(db, entryId);
+                    if (!row?.filePath) {
+                        warn(`[graph] could not resolve path for ref, skipping: ${trimmed}`);
+                        continue;
+                    }
+                    resolvedPaths.add(row.filePath);
                 }
-                const row = getEntryById(db, entryId);
-                if (!row?.filePath) {
-                    warn(`[graph] could not resolve path for ref, skipping: ${trimmed}`);
-                    continue;
-                }
-                resolvedPaths.add(row.filePath);
             }
+            finally {
+                if (db)
+                    closeDatabase(db);
+            }
+            if (resolvedPaths.size === 0) {
+                warn("[graph] none of the provided refs resolved to indexed paths — no extraction performed.");
+                return {
+                    shape: "graph-update",
+                    ok: true,
+                    filesExtracted: 0,
+                    entitiesUpserted: 0,
+                    relationsUpserted: 0,
+                    durationMs: 0,
+                    scoped: true,
+                };
+            }
+            candidatePaths = resolvedPaths;
         }
-        finally {
-            if (db)
-                closeDatabase(db);
-        }
-        if (resolvedPaths.size === 0) {
-            warn("[graph] none of the provided refs resolved to indexed paths — no extraction performed.");
+        const extractionFn = options.graphExtractionFn ?? runGraphExtractionPass;
+        const passOptions = candidatePaths ? { candidatePaths } : {};
+        let db;
+        const startMs = Date.now();
+        try {
+            db = openIndexDatabase(getDbPath());
+            const onProgress = (event) => {
+                if (!event.currentPath)
+                    return;
+                const file = path.basename(event.currentPath);
+                warn(`[graph] extracting ${event.processed}/${event.total} ${file}`);
+            };
+            const result = await extractionFn({
+                config,
+                sources,
+                signal: undefined,
+                db,
+                reEnrich: false,
+                onProgress,
+                options: passOptions,
+            });
+            const durationMs = Date.now() - startMs;
             return {
                 shape: "graph-update",
                 ok: true,
-                filesExtracted: 0,
-                entitiesUpserted: 0,
-                relationsUpserted: 0,
-                durationMs: 0,
-                scoped: true,
+                filesExtracted: result.quality.extractedFiles,
+                entitiesUpserted: result.quality.entityCount,
+                relationsUpserted: result.quality.relationCount,
+                durationMs,
+                scoped,
             };
         }
-        candidatePaths = resolvedPaths;
-    }
-    const extractionFn = options.graphExtractionFn ?? runGraphExtractionPass;
-    const passOptions = candidatePaths ? { candidatePaths } : {};
-    let db;
-    const startMs = Date.now();
-    try {
-        db = openDatabase(getDbPath());
-        const onProgress = (event) => {
-            if (!event.currentPath)
-                return;
-            const file = path.basename(event.currentPath);
-            warn(`[graph] extracting ${event.processed}/${event.total} ${file}`);
-        };
-        const result = await extractionFn({
-            config,
-            sources,
-            signal: undefined,
-            db,
-            reEnrich: false,
-            onProgress,
-            options: passOptions,
-        });
-        const durationMs = Date.now() - startMs;
-        return {
-            shape: "graph-update",
-            ok: true,
-            filesExtracted: result.quality.extractedFiles,
-            entitiesUpserted: result.quality.entityCount,
-            relationsUpserted: result.quality.relationCount,
-            durationMs,
-            scoped,
-        };
-    }
-    finally {
-        if (db)
-            closeDatabase(db);
-    }
+        finally {
+            if (db)
+                closeDatabase(db);
+        }
+    });
 }
 async function resolveGraphTarget(ref, source) {
     const parsedRef = parseAssetRef(ref);