akm-cli 0.9.17-alpha.5 → 0.9.17-alpha.7

package/dist/commands/improve/preparation.js

@@ -23,7 +23,7 @@ import { ConfigError, rethrowIfTestIsolationError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
 import { withStateDb } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
-import { countUsageEventsByType } from "../../indexer/usage/usage-events.js";
+import { countUsageEventsByType, USAGE_EVENT_RETENTION_DAYS } from "../../indexer/usage/usage-events.js";
 import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
 import { getZeroResultSearches } from "../../storage/repositories/index-entries-repository.js";
 import { getRetrievalCounts } from "../../storage/repositories/index-utility-repository.js";
@@ -41,6 +41,7 @@ import { applyMemoryCleanup } from "./memory/memory-improve.js";
 import { getAllAssetOutcomes, getAssetOutcome, getOutcomeScoresByRef, OUTCOME_SCORE_MAX, outcomeScoreToSalience, projectAssetOutcome, updateAssetOutcome, } from "./outcome-loop.js";
 import { projectMemoryCleanup, selectEffectiveImproveRefs } from "./planner.js";
 import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
+import { isInRetrievalScope, loadRetrievalScope } from "./retrieval-scope.js";
 import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getLastUseMsByRef, isContentEncodingRow, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
 import { attributeStage, errMessage } from "./stage.js";
 /** The candidate's durable state key (salience, outcome, ledger). */
@@ -663,12 +664,23 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
     const processableRefs = [...partition.eligibleRefs, ...partition.distillOnlyRefs];
     const signalFiltered = processableRefs.filter((c) => snapshot.feedback.get(c.ref)?.hasSignal === true);
     const signalBearingSet = new Set(signalFiltered.map((r) => r.ref));
-    const noFeedbackCandidates = dedupeRefs([
+    // The fallback lanes (proactive, high salience, forgetting safety) have no
+    // usage evidence of their own: they pick only what retrieval returned or new
+    // material improve never processed (#986). Evaluated once per candidate.
+    const fallbackEligible = postCleanupRefs.filter((c) => !validationFailureRefs.has(c.ref));
+    const allowFallbacks = options.requireFeedbackSignal !== true;
+    const retrievalScope = scope.mode === "ref" || !allowFallbacks
+        ? undefined
+        : loadRetrievalScope({ eventsCtx, ...(persist ? {} : { readOnly: true }) }, primaryStashDir ?? options.stashDir);
+    const unscoped = new Set(fallbackEligible.filter((c) => !isInRetrievalScope(retrievalScope, c.ref, c.filePath)).map((c) => c.ref));
+    const noFeedbackPool = dedupeRefs([
         ...processableRefs.filter((r) => !signalBearingSet.has(r.ref)),
         ...partition.noFeedbackPool,
     ]);
+    const noFeedbackCandidates = noFeedbackPool.filter((r) => !unscoped.has(r.ref));
+    // Only a ref no fallback lane may pick anymore is charged to the retrieval gate.
+    const outOfScope = new Set(noFeedbackPool.filter((r) => unscoped.has(r.ref)).map((r) => r.ref));
     const retrieval = fetchRetrievalSignals(options, signalFiltered, noFeedbackCandidates, eventsCtx, persist);
-    const allowFallbacks = options.requireFeedbackSignal !== true;
     const proactive = allowFallbacks
         ? selectProactiveMaintenanceLane(args, noFeedbackCandidates, snapshot, retrieval, persist)
         : { proactiveRefs: [] };
@@ -692,10 +704,10 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
             sourceByRef.set(r.ref, "scope");
     for (const r of mergedRefs)
         r.eligibilitySource = sourceByRef.get(r.ref) ?? "unknown";
-    // Forgetting safety may only reuse this plan's own surviving objects, and
-    // never a ref whose reflect window is still open.
-    const fallbackEligible = postCleanupRefs.filter((c) => !validationFailureRefs.has(c.ref));
-    const forgettingEligible = fallbackEligible.filter((c) => !isLedgerBlocked(ledgerRowFor(snapshot.ledger, "reflect", c.ref, c.itemRef), snapshot.nowIso));
+    // Forgetting safety may only reuse this plan's own surviving objects inside
+    // the retrieval scope, and never a ref whose reflect window is still open.
+    const forgettingEligible = fallbackEligible.filter((c) => !unscoped.has(c.ref) &&
+        !isLedgerBlocked(ledgerRowFor(snapshot.ledger, "reflect", c.ref, c.itemRef), snapshot.nowIso));
     const scored = scoreSalience(args, mergedRefs, snapshot.feedback, retrieval.retrievalCounts, persist);
     mergedRefs = applyForgettingSafety({
         pendingForgettingRefs: scored.pendingForgettingRefs,
@@ -739,28 +751,46 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
     // Skip observability waits until every fallback lane has finalized the
     // survivors, so a rescued ref is never also reported skipped.
     const survivors = new Set(sorted.map((c) => c.ref));
-    const signalSkipped = fallbackEligible.filter((c) => !survivors.has(c.ref));
+    const skipped = fallbackEligible.filter((c) => !survivors.has(c.ref));
+    const retrievalSkipped = skipped.filter((c) => outOfScope.has(c.ref));
+    const signalSkipped = skipped.filter((c) => !outOfScope.has(c.ref));
     for (const ref of partition.distillCooledRefs) {
         actions.push({ ref, mode: "distill-skipped", result: { ok: true, reason: "distill signal-delta" } });
         if (persist)
             recordImproveSkip(eventsCtx, ref, { reason: "distill_no_new_signal" });
     }
-    for (const candidate of signalSkipped) {
+    for (const candidate of skipped) {
         actions.push({
             ref: candidate.ref,
             mode: "distill-skipped",
-            result: { ok: true, reason: "no new signal since last proposal" },
+            result: {
+                ok: true,
+                reason: outOfScope.has(candidate.ref)
+                    ? "not retrieved inside the usage window"
+                    : "no new signal since last proposal",
+            },
         });
     }
     if (persist && signalSkipped.length > 0) {
         recordImproveSkip(eventsCtx, undefined, { reason: "no_new_signal", count: signalSkipped.length });
     }
+    if (persist && retrievalSkipped.length > 0) {
+        recordImproveSkip(eventsCtx, undefined, { reason: "not_retrieved", count: retrievalSkipped.length });
+    }
     const blocked = signalSkipped.length + partition.distillOnlyRefs.length;
     if (blocked > 0) {
         info(`[improve] ${blocked} of ${partition.preCooldownCount} indexed refs blocked by reflect signal-delta ` +
             `(${signalSkipped.length} fully skipped, ${partition.distillOnlyRefs.length} routed to distill-only)`);
     }
+    if (retrievalSkipped.length > 0) {
+        info(`[improve] ${retrievalSkipped.length} refs left out: not retrieved in the last ${USAGE_EVENT_RETENTION_DAYS} days, and not new material`);
+    }
     const gates = [
+        {
+            name: "retrieval",
+            removed: retrievalSkipped.length,
+            reason: `no feedback, and neither returned by search, curate or show in the last ${USAGE_EVENT_RETENTION_DAYS} days nor new material improve never processed`,
+        },
         {
             name: "signal",
             removed: signalSkipped.length,

package/dist/commands/improve/reflect.js

@@ -43,6 +43,7 @@ import { findAssetFilePath } from "./eligibility.js";
 import { resolveImproveLlmExecution } from "./execution.js";
 import { recordLedgerAttempt } from "./ledger.js";
 import { classifyReflectChange, splitFrontmatter } from "./reflect-noise.js";
+import { loadRetrievalQueries, runRetrievalRegressionGate } from "./retrieval-gate.js";
 import { callStage, mintProposal, noticeSet, rejectedProposalContext, runReflectQualityJudge, } from "./stage.js";
 const MAX_FEEDBACK_LINES = 10;
 const MAX_GLOBAL_FEEDBACK_LINES = 20;
@@ -960,6 +961,24 @@ async function finalizeReflectProposal(args) {
     }
     const flagged = Boolean(sanitized.sizeGuardRatio || sanitized.truncationMarkerLeaked);
     const judged = judge.enabled && !flagged;
+    /** A judge refused the revision: record it for the ledger's rejection window and stop. */
+    const refuse = (detail, metadata, message) => {
+        if (options.ref) {
+            recordLedgerAttempt({ proposalsCtx: options.ctx, eventsCtx: options.eventsCtx }, {
+                stashDir: run.stash,
+                ref: options.itemRef ?? options.ref,
+                source: "reflect",
+                outcome: "quality_rejected",
+                detail,
+            });
+        }
+        appendEvent({
+            eventType: "reflect_completed",
+            ref: payload.ref,
+            metadata: { source: "reflect", qualityRejected: true, ...metadata, ...telemetry },
+        }, options.eventsCtx);
+        return reflectFailure(run, result, "quality_rejected", message, false);
+    };
     if (judged) {
         const verdict = await runReflectQualityJudge(run.config, payload.content, assetContent ?? "", feedback, options.chat, {
             runnerSelectionFrozen: true,
@@ -969,28 +988,33 @@ async function finalizeReflectProposal(args) {
             onNotices: run.notices.add,
         });
         if (!verdict.pass) {
-            if (options.ref) {
-                recordLedgerAttempt({ proposalsCtx: options.ctx, eventsCtx: options.eventsCtx }, {
-                    stashDir: run.stash,
-                    ref: options.itemRef ?? options.ref,
-                    source: "reflect",
-                    outcome: "quality_rejected",
-                    detail: verdict.reason,
-                });
-            }
-            appendEvent({
-                eventType: "reflect_completed",
-                ref: payload.ref,
-                metadata: {
-                    source: "reflect",
-                    qualityRejected: true,
-                    qualityScore: verdict.score,
-                    qualityReason: verdict.reason,
-                    ...(verdict.criteria ? { qualityCriteria: verdict.criteria } : {}),
-                    ...telemetry,
-                },
-            }, options.eventsCtx);
-            return reflectFailure(run, result, "quality_rejected", `Reflect proposal quality gate rejected: score=${verdict.score}, reason="${verdict.reason}"`, false);
+            return refuse(verdict.reason, {
+                qualityScore: verdict.score,
+                qualityReason: verdict.reason,
+                ...(verdict.criteria ? { qualityCriteria: verdict.criteria } : {}),
+            }, `Reflect proposal quality gate rejected: score=${verdict.score}, reason="${verdict.reason}"`);
+        }
+    }
+    // #722: a rewrite of an existing asset must not grade lower on its own retrieval queries.
+    if (judged && judge.runner && assetContent !== undefined) {
+        const retrieval = await runRetrievalRegressionGate({
+            ref: payload.ref,
+            before: assetContent,
+            after: payload.content,
+            queries: loadRetrievalQueries({ proposalsCtx: options.ctx, eventsCtx: options.eventsCtx }, payload.ref),
+            runner: judge.runner,
+            ...(options.chat ? { chat: options.chat } : {}),
+            ...(Object.hasOwn(options, "timeoutMs") ? { timeoutMs: options.timeoutMs } : {}),
+            ...(options.signal ? { signal: options.signal } : {}),
+            onNotices: run.notices.add,
+        });
+        if (!retrieval.pass) {
+            return refuse(retrieval.reason, {
+                retrievalRegression: true,
+                retrievalQueries: retrieval.queries,
+                ...(retrieval.oldMean !== undefined ? { retrievalGradeBefore: retrieval.oldMean } : {}),
+                ...(retrieval.newMean !== undefined ? { retrievalGradeAfter: retrieval.newMean } : {}),
+            }, `Reflect proposal refused: ${retrieval.reason}`);
         }
     }
     // A lesson reflect wrote is marked so a later reflect on the same skill does

package/dist/commands/improve/retrieval-gate.js

@@ -0,0 +1,127 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The retrieval regression gate (#722): a reflect rewrite of an existing asset
+ * must not grade lower on the queries that actually retrieved it.
+ *
+ * Measured before it was built: of 60 accepted reflect rewrites judged against
+ * their own queries, 14 graded lower (23%, 95% CI 14–35%) and 12 higher. The
+ * old and new content are graded one query at a time, blind, with the
+ * retrieval-eval judge's prompt (kappa 0.83 against human grades) and its
+ * document shape: type, ref, name, description and the first 1,500 characters
+ * of the body.
+ */
+import relevanceJudgePrompt from "../../assets/prompts/retrieval-relevance-judge.md" with { type: "text" };
+import { parseFrontmatter } from "../../core/asset/frontmatter.js";
+import { parseRefInput } from "../../core/asset/resolve-ref.js";
+import { nonTaskInput } from "../../core/non-task-input.js";
+import { parseEmbeddedJsonResponse } from "../../core/parse.js";
+import { listRetrievalQueries } from "../../indexer/usage/usage-events.js";
+import { readLedgerDb, stripBundle } from "./ledger.js";
+import { callStage } from "./stage.js";
+/** Queries graded per rewrite, as measured. */
+const MAX_QUERIES = 5;
+/** The retrieval suite treats a longer input as a paste, not a query; the measurement did the same. */
+const MAX_QUERY_CHARS = 2000;
+/** The judge sees this much of the body, as in the retrieval eval. */
+const MAX_DOC_CHARS = 1500;
+const GRADE_SCHEMA = {
+    type: "object",
+    required: ["grade", "reason"],
+    additionalProperties: false,
+    properties: { grade: { type: "integer", minimum: 0, maximum: 3 }, reason: { type: "string" } },
+};
+/** Up to five distinct task queries, in the given order, whitespace collapsed. */
+export function usableRetrievalQueries(raw) {
+    const out = [];
+    for (const text of raw) {
+        const query = text.replace(/\s+/g, " ").trim();
+        if (!query || query.length > MAX_QUERY_CHARS || nonTaskInput(query) || out.includes(query))
+            continue;
+        out.push(query);
+        if (out.length === MAX_QUERIES)
+            break;
+    }
+    return out;
+}
+/** The asset's own retrieval queries from the usage log (none when state.db cannot be read). */
+export function loadRetrievalQueries(access, ref) {
+    try {
+        return usableRetrievalQueries(readLedgerDb(access, (db) => listRetrievalQueries(db, stripBundle(ref))) ?? []);
+    }
+    catch {
+        return [];
+    }
+}
+function judgeDocument(ref, raw) {
+    const conceptId = stripBundle(ref);
+    const parsed = parseRefInput(conceptId);
+    const { data, content } = parseFrontmatter(raw);
+    const text = content
+        .replace(/\n{3,}/g, "\n\n")
+        .trim()
+        .slice(0, MAX_DOC_CHARS);
+    const name = typeof data.name === "string" && data.name ? data.name : parsed.name;
+    const description = typeof data.description === "string" ? data.description : "";
+    return [
+        "Candidate asset:",
+        `Type: ${parsed.type}`,
+        `Ref: ${conceptId}`,
+        `Name: ${name}`,
+        `Description: ${description}`,
+        "",
+        "Content:",
+        text,
+    ].join("\n");
+}
+/**
+ * Grade `before` and `after` on each query; refuse the rewrite when the new
+ * content's mean grade is lower. Fails closed, like the quality judge: a grade
+ * that cannot be obtained refuses the rewrite.
+ */
+export async function runRetrievalRegressionGate(args) {
+    if (args.queries.length === 0)
+        return { pass: true, queries: 0, reason: "no retrieval queries to compare on" };
+    const documents = { old: judgeDocument(args.ref, args.before), new: judgeDocument(args.ref, args.after) };
+    const totals = { old: 0, new: 0 };
+    for (const query of args.queries) {
+        for (const version of ["old", "new"]) {
+            const outcome = await callStage({
+                feature: "proposal_quality_gate",
+                runner: args.runner,
+                system: relevanceJudgePrompt.trim(),
+                prompt: `Query: ${query}\n\n${documents[version]}`,
+                request: {
+                    enableThinking: false,
+                    temperature: 0,
+                    responseSchema: GRADE_SCHEMA,
+                    ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : {}),
+                    ...(args.signal ? { signal: args.signal } : {}),
+                    ...(args.chat ? { chat: args.chat } : {}),
+                },
+                ...(args.onNotices ? { onNotices: args.onNotices } : {}),
+            });
+            const grade = outcome.ok ? parseEmbeddedJsonResponse(outcome.raw)?.grade : undefined;
+            if (typeof grade !== "number" || !Number.isInteger(grade) || grade < 0 || grade > 3) {
+                return {
+                    pass: false,
+                    queries: args.queries.length,
+                    reason: `retrieval check could not grade the ${version} content${outcome.ok ? "" : ` (${outcome.reason})`}`,
+                };
+            }
+            totals[version] += grade;
+        }
+    }
+    const oldMean = totals.old / args.queries.length;
+    const newMean = totals.new / args.queries.length;
+    const pass = newMean >= oldMean;
+    const grades = `${oldMean.toFixed(2)} -> ${newMean.toFixed(2)} over ${args.queries.length} retrieval ${args.queries.length === 1 ? "query" : "queries"}`;
+    return {
+        pass,
+        queries: args.queries.length,
+        oldMean,
+        newMean,
+        reason: pass ? `retrieval grade ${grades}` : `retrieval regression: grade ${grades}`,
+    };
+}

package/dist/commands/improve/retrieval-scope.js

@@ -0,0 +1,77 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * What improve may rework (#986): an asset that retrieval returned inside the
+ * usage window, or newly captured material no improve stage has processed.
+ *
+ * Fresh feedback and an explicit `--scope <ref>` are usage evidence of their
+ * own, so the signal-delta and scope lanes need no check. The fallback lanes
+ * (proactive maintenance, high salience, forgetting safety) and consolidation
+ * pick assets without such evidence, so they pick only inside this scope.
+ */
+import fs from "node:fs";
+import { daysToMs } from "../../core/common.js";
+import { warn } from "../../core/warn.js";
+import { listUsedEntryRefs, USAGE_EVENT_RETENTION_DAYS } from "../../indexer/usage/usage-events.js";
+import { listImproveLedgerRows } from "../../storage/repositories/improve-ledger-repository.js";
+import { listProposalRefSources } from "../../storage/repositories/proposals-repository.js";
+import { readLedgerDb, stripBundle } from "./ledger.js";
+/**
+ * Ledger and proposal sources that bring material in. Every other source is an
+ * improve stage reworking an asset (reflect, distill, consolidate, schema repair).
+ */
+const CAPTURE_SOURCES = new Set(["extract", "propose", "remember", "import"]);
+/**
+ * Load the scope from state.db. The window is the usage log's retention: the
+ * log keeps nothing older, and anything shorter would drop assets read less
+ * often than the window. A `.derived` hit counts for its parent memory, whose
+ * facts it carries. `undefined` (every asset eligible, as before #986) only
+ * when state.db cannot be read.
+ */
+export function loadRetrievalScope(access, stashDir) {
+    const sinceMs = Date.now() - daysToMs(USAGE_EVENT_RETENTION_DAYS);
+    const used = new Set();
+    const processed = new Set();
+    try {
+        readLedgerDb(access, (db) => {
+            for (const entryRef of listUsedEntryRefs(db, new Date(sinceMs).toISOString())) {
+                const conceptId = stripBundle(entryRef);
+                used.add(conceptId);
+                if (conceptId.endsWith(".derived"))
+                    used.add(conceptId.slice(0, -".derived".length));
+            }
+            if (!stashDir)
+                return;
+            for (const row of [...listImproveLedgerRows(db, stashDir), ...listProposalRefSources(db, stashDir)]) {
+                if (!CAPTURE_SOURCES.has(row.source))
+                    processed.add(stripBundle(row.ref));
+            }
+        });
+    }
+    catch (error) {
+        warn(`[improve] usage history unreadable, so every asset stays eligible: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+    return { used, processed, sinceMs };
+}
+/**
+ * Whether improve may rework `ref` (whose file is `filePath`) under `scope`. An
+ * unprocessed asset whose file cannot be read is left to the disk check that
+ * follows, which reports it as missing.
+ */
+export function isInRetrievalScope(scope, ref, filePath) {
+    if (!scope)
+        return true;
+    const conceptId = stripBundle(ref);
+    if (scope.used.has(conceptId))
+        return true;
+    if (scope.processed.has(conceptId))
+        return false;
+    try {
+        return filePath === undefined || fs.statSync(filePath).mtimeMs >= scope.sinceMs;
+    }
+    catch {
+        return true;
+    }
+}

package/dist/commands/read/curate.js

@@ -15,17 +15,14 @@
  * The exported `akmCurate()` API is the single entry point; tests can also
  * drive `curateSearchResults` with a fixture search response.
  */
-import fs from "node:fs";
-import { parseFrontmatter } from "../../core/asset/frontmatter.js";
-import { getIndexPassConfig, loadConfig } from "../../core/config/config.js";
+import { loadConfig } from "../../core/config/config.js";
 import { rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
+import { nonTaskInput } from "../../core/non-task-input.js";
 import { redactCredentialPatterns } from "../../core/redaction.js";
 import { withStateDbTelemetry } from "../../core/state-db.js";
-import { enqueueGraphExtraction, hasGraphData } from "../../indexer/db/graph-db.js";
 import { searchHitContent } from "../../indexer/search/db-search.js";
 import { copySearchHitAttribution, getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
-import { findSourceForPath, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
 import { estimateTokenCount } from "../../llm/embedders/remote.js";
 import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
@@ -33,7 +30,6 @@ import { rerankDocuments } from "../../llm/rerank-client.js";
 import { truncateDescription } from "../../output/shapes/helpers.js";
 import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
 import { findEntryIdByRef, getItemRefById } from "../../storage/repositories/index-entries-repository.js";
-import { computeBodyHash } from "../../storage/repositories/index-llm-cache-repository.js";
 import { akmSearch, parseSearchSource } from "./search.js";
 import { akmShowUnified } from "./show.js";
 const DEFAULT_CURATE_LIMIT = 4;
@@ -104,6 +100,19 @@ export async function akmCurate(options) {
     if (!trimmedQuery) {
         throw new UsageError('A curation query is required. Usage: akm curate "<task or prompt>" [--type <type>] [--limit <n>]', "MISSING_REQUIRED_ARGUMENT");
     }
+    const nonTask = nonTaskInput(trimmedQuery);
+    if (nonTask) {
+        const abstained = {
+            query: options.query,
+            summary: `Curate abstained: the input is ${nonTask}, not a task.`,
+            items: [],
+            tip: 'Nothing was selected on purpose. To curate for it, pass the task itself: akm curate "<what you are trying to do>".',
+        };
+        if (!options.skipLogging) {
+            logCurateEvent(options.query, abstained, options.eventSource, options.attributionProjection);
+        }
+        return abstained;
+    }
     const limit = options.limit && options.limit > 0 ? options.limit : DEFAULT_CURATE_LIMIT;
     const source = options.source ?? parseSearchSource("local");
     const searchResponse = options.searchResponse ??
@@ -201,11 +210,6 @@ async function enrichCuratedStashHit(query, hit, selectedRefs, eventSource) {
     catch {
         shown = undefined;
     }
-    // #624-P3: when lazy graph extraction is opted in, enqueue an ungraphed
-    // asset for a later pass to extract. Fire-and-forget, non-blocking, NO inline
-    // extraction and NO LLM call here. Default-off (flag unset) = byte-identical.
-    if (shown?.path)
-        maybeEnqueueLazyGraph(shown.path);
     const description = shown?.description ?? hit.description;
     const preview = buildCuratedPreview(shown, hit);
     const supportRefs = buildCurateSupportRefs(shown?.related?.hits, selectedRefs, hit.ref);
@@ -232,44 +236,6 @@ async function enrichCuratedStashHit(query, hit, selectedRefs, eventSource) {
     copySearchHitAttribution(hit, item, item.description);
     return item;
 }
-/**
- * #624-P3 — enqueue an ungraphed asset for lazy graph extraction when the
- * `index.graph.lazyGraphExtraction` flag is on. Pure side-effect, fully
- * best-effort: any failure (config, fs, db) is swallowed so curate never fails
- * on it. NO LLM call and NO inline extraction — only a cheap queue insert.
- * Default-off (flag unset) returns immediately = byte-identical behavior.
- */
-function maybeEnqueueLazyGraph(assetPath) {
-    try {
-        const config = loadConfig();
-        if (getIndexPassConfig(config.index, "graph")?.lazyGraphExtraction !== true)
-            return;
-        const sources = resolveSourceEntries();
-        const source = findSourceForPath(assetPath, sources);
-        const stashRoot = source?.path;
-        if (!stashRoot)
-            return;
-        let raw;
-        try {
-            raw = fs.readFileSync(assetPath, "utf8");
-        }
-        catch {
-            return;
-        }
-        const body = parseFrontmatter(raw).content.trim();
-        if (!body)
-            return;
-        const bodyHash = computeBodyHash(body);
-        withIndexDb((db) => {
-            if (!hasGraphData(db, stashRoot, assetPath)) {
-                enqueueGraphExtraction(db, stashRoot, assetPath, bodyHash, 0);
-            }
-        }, { busyTimeoutMs: TELEMETRY_BUSY_TIMEOUT_MS });
-    }
-    catch (err) {
-        rethrowIfTestIsolationError(err);
-    }
-}
 function buildCuratedRegistryItem(query, hit) {
     return {
         source: "registry",

package/dist/commands/read/show.js

@@ -27,14 +27,12 @@ import { buildMarkdownLeadContext, fragmentForSelector, MARKDOWN_FRAGMENT_CONTEX
 import { displayRef, typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 import { META_DIR, parseMetaRef, readMetaFile } from "../../core/asset/stash-meta.js";
 import { asNonEmptyString, isWithin } from "../../core/common.js";
-import { getIndexPassConfig, loadConfig } from "../../core/config/config.js";
+import { loadConfig } from "../../core/config/config.js";
 import { NotFoundError, rethrowIfDataDirUnreadable, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { SCRIPT_EXTENSIONS } from "../../core/recognition-util.js";
 import { presentationFor } from "../../core/type-presentation.js";
 import { warn, warnOnce } from "../../core/warn.js";
-import { hasGraphData } from "../../indexer/db/graph-db.js";
-import { extractGraphForSingleFile } from "../../indexer/graph/graph-extraction.js";
 import { listRelatedPathsForFile } from "../../indexer/graph/graph-related.js";
 import { lookupBundleRef, lookupBundleRefWithResolution } from "../../indexer/indexer.js";
 import { projectMarkdownFragmentContent } from "../../indexer/passes/metadata.js";
@@ -42,11 +40,8 @@ import { ensurePrimaryIndexForRead, resolveReadSources } from "../../indexer/rea
 import { buildEditHint, findSourceForPath, isEditable, resolveSourceEntries, } from "../../indexer/search/search-source.js";
 import { recentShowCount, recordShowUsage } from "../../indexer/usage/show-usage.js";
 import { buildFileContext, buildRenderContext, getRenderer, } from "../../indexer/walk/file-context.js";
-import { resolveIndexPassExecution } from "../../llm/index-passes.js";
 import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
-import { resolveStorageLocations } from "../../storage/locations.js";
-import { closeDatabase, openExistingDatabase } from "../../storage/repositories/index-connection.js";
-import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
+import { withIndexDb } from "../../storage/repositories/index-db.js";
 import { getIndexedMarkdownFragment } from "../../storage/repositories/index-fts-repository.js";
 import { getCurrentWorkflowScopeKey } from "../../workflows/authoring/scope-key.js";
 import { buildWorkflowAction } from "../../workflows/renderer.js";
@@ -405,15 +400,6 @@ export async function showLocal(input) {
     if (activeRun) {
         fullResponse.activeRun = activeRun;
     }
-    // #624-P3: opt-in inline graph extraction. Default OFF — when the flag is
-    // unset this whole block is skipped (no hasGraphData check, no LLM call), so
-    // behavior is byte-identical to today. When ON, it extracts graph data for an
-    // ungraphed asset, but ONLY when a model is configured (model-available
-    // guard) and ALWAYS bounded by a 30s timeout so `show` can never hang. Any
-    // timeout/model-unavailable/error path returns the response unchanged.
-    if (getIndexPassConfig(config.index, "graph")?.lazyGraphExtraction === true) {
-        await maybeExtractGraphInline(config, sourceStashDir, assetPath);
-    }
     if (input.detail === "brief") {
         return buildBriefResponse(fullResponse, assetPath);
     }
@@ -470,71 +456,6 @@ function findUnrecognizedScriptSource(assetParts, sources) {
     }
     return undefined;
 }
-/**
- * #624-P3 — opt-in inline graph extraction for `akm show`. Best-effort and
- * timeout-bounded: never throws, never hangs, never mutates the response.
- *
- * Preconditions (caller already checked the flag): a model must be configured
- * (model-available guard via {@link resolveIndexPassExecution}) and the asset
- * must be ungraphed ({@link hasGraphData}). Extraction races a 30s timeout so
- * `show` cannot block on a slow provider; any timeout/error/missing-model path
- * is swallowed and `show` returns its already-assembled response unchanged.
- */
-async function maybeExtractGraphInline(config, sourceStashDir, assetPath) {
-    try {
-        // Resolve readiness and the symbolic runner once. The inline dispatch must
-        // consume this same snapshot even if models.json changes while show runs.
-        const graphExecution = resolveIndexPassExecution("graph", config);
-        if (!graphExecution.runner)
-            return;
-        const emittedNoticeKeys = new Set();
-        const reportNotices = (notices) => {
-            for (const notice of notices) {
-                const key = JSON.stringify(notice);
-                if (emittedNoticeKeys.has(key))
-                    continue;
-                emittedNoticeKeys.add(key);
-                const field = typeof notice.field === "string" ? ` field=${notice.field}` : "";
-                warn(`[akm] lazy graph extraction notice ${notice.code} adapter=${notice.adapter}${field}: ${notice.message}`);
-            }
-        };
-        reportNotices(graphExecution.notices);
-        let alreadyGraphed = false;
-        withIndexDb((db) => {
-            alreadyGraphed = hasGraphData(db, sourceStashDir, assetPath);
-        }, { busyTimeoutMs: TELEMETRY_BUSY_TIMEOUT_MS });
-        if (alreadyGraphed)
-            return;
-        // Open the db for the async extraction ourselves: `withIndexDb` is
-        // synchronous and would close the connection the instant the async fn
-        // returns its Promise (before extraction completes). Close it explicitly
-        // after the race settles instead.
-        const db = openExistingDatabase(resolveStorageLocations().indexDb);
-        let timer;
-        const timeout = new Promise((resolve) => {
-            timer = setTimeout(resolve, 30_000);
-        });
-        try {
-            await Promise.race([
-                extractGraphForSingleFile(db, sourceStashDir, assetPath, {
-                    config,
-                    llmRunner: graphExecution.runner,
-                    onNotices: reportNotices,
-                }),
-                timeout,
-            ]);
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-            closeDatabase(db);
-        }
-    }
-    catch (err) {
-        rethrowIfTestIsolationError(err);
-        // Any other failure: silently return the unchanged show response.
-    }
-}
 /**
  * Minimal `show`: ref → indexer lookup → file contents. Used by callers that
  * just need the raw file (e.g. clone, write-source) and don't want the full