akm-cli 0.9.17-alpha.8 → 0.9.17

package/dist/commands/improve/consolidate.js

@@ -4,12 +4,19 @@
 /**
  * `akm consolidate` — show the model the memory pool in chunks of similar
  * memories and queue a knowledge proposal for each memory it says should be
- * promoted. Promotion is the only operation: it emits a reviewable proposal and
- * never touches the memory. Memories the improve ledger judged recently and
+ * promoted. Promotion emits a reviewable proposal and never touches the
+ * memory directly; accepting it later retires the source memory (O1, in
+ * `proposal/repository.ts`). Memories the improve ledger judged recently and
  * that have not changed since are not judged again.
  *
- * Accounting invariant: `processed == promoted + judgedNoAction +
- * Σ(skipReasons) + failedChunkMemories`.
+ * Accounting invariant (the promote pass only): `processed == promoted +
+ * judgedNoAction + Σ(skipReasons) + failedChunkMemories`.
+ *
+ * A second pass, the pair pass (`consolidate/pair-pass.ts`, alpha.9), runs
+ * alongside this one and keeps its own separate counters (`pairPass` on the
+ * result) — it judges near-duplicate and superseding pairs across the wider
+ * memory tier and mints `retire` proposals; see that module's own doc
+ * comment.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -21,7 +28,6 @@ import { conceptIdFromTypeName, displayRef, parseRefInput } from "../../core/ass
 import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
 import { openStateDatabase } from "../../core/state-db.js";
-import { parseSinceToIsoLenient } from "../../core/time.js";
 import { warn, warnVerbose } from "../../core/warn.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
 import { deriveInstallations } from "../../indexer/installations.js";
@@ -31,11 +37,11 @@ import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatc
 import { cosineSimilarity, embedBatch, resolveEmbeddingModelId } from "../../llm/embedder.js";
 import { getBodyEmbeddings, upsertBodyEmbeddings } from "../../storage/repositories/embeddings-repository.js";
 import { closeDatabase, openExistingDatabase, openReadonlyExistingDatabase, } from "../../storage/repositories/index-connection.js";
-import { findEntryIdByRef, getAllEntries, getEntryById } from "../../storage/repositories/index-entries-repository.js";
-import { getNeighborsByEntryId } from "../../storage/repositories/index-vec-repository.js";
+import { getAllEntries } from "../../storage/repositories/index-entries-repository.js";
 import { listProposals, listProposalsReadOnly, proposalContent } from "../proposal/repository.js";
 import { hasHotCaptureMode, hasSupersededStatus, validateProposalFrontmatter, } from "../proposal/validators/proposal-quality-validators.js";
 import { buildChunkPrompt, computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
+import { runConsolidatePairPass } from "./consolidate/pair-pass.js";
 import { sanitizeMergedContent } from "./consolidate/sanitize.js";
 import { contentHash } from "./content-hash.js";
 import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
@@ -77,7 +83,8 @@ export function isHotCapturedMemory(filePath) {
 }
 /**
  * Structured-output schema for a plan. Promote-only: merge/delete/contradict
- * were advisory, never executed, and cost thousands of completion tokens.
+ * were removed in 0.9.17-alpha.1 (`e82eec811`) after running in production —
+ * they cost thousands of completion tokens.
  */
 export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
     type: "object",
@@ -435,9 +442,6 @@ export function inspectConsolidationPool(opts, stashDir, warnings, existingKnowl
     const beforeScope = memories.length;
     memories = memories.filter((memory) => isInRetrievalScope(retrievalScope, conceptIdFromTypeName("memory", memory.name), memory.filePath));
     const outsideRetrievalScope = beforeScope - memories.length;
-    if (opts.incrementalSince && memories.length > 0) {
-        memories = narrowToIncrementalCandidates(memories, opts.incrementalSince, warnings, opts.neighborsPerChanged, readOnly);
-    }
     const dedupPoolSize = memories.length;
     if (opts.limit === undefined && memories.length > 150) {
         warnings.push(`Consolidation: pool has ${memories.length} memories and no limit is set. Consider adding a limit to your consolidate config to prevent timeouts on slow LLM endpoints.`);
@@ -656,6 +660,12 @@ async function consolidate(opts, config, stashDir, startMs, stateDb) {
         warnings.push(`Consolidation: pre-filtered ${prefilteredAlreadyPromoted} ${plural(prefilteredAlreadyPromoted)} whose body already exists verbatim in knowledge/ before chunking.`);
     }
     const target = opts.target ?? stashDir;
+    // The pair pass (alpha.9) has its own initiator/candidate selection (it
+    // sees .derived memories, flat knowledge and lessons, not just the
+    // promote pool above), so it runs regardless of whether the promote pool
+    // is empty — every return path below carries its result.
+    const pairPassBundleId = resolveConsolidationSourceOwner(opts, stashDir)?.bundleId;
+    const pairPass = await runConsolidatePairPass(opts, config, stashDir, pairPassBundleId, warnings);
     if (memories.length === 0) {
         return makeConsolidateResult({
             dryRun: opts.dryRun ?? false,
@@ -663,6 +673,7 @@ async function consolidate(opts, config, stashDir, startMs, stateDb) {
             warnings,
             durationMs: Date.now() - startMs,
             prefilteredAlreadyPromoted,
+            pairPass,
         });
     }
     const acc = {
@@ -692,7 +703,7 @@ async function consolidate(opts, config, stashDir, startMs, stateDb) {
         durationMs: Date.now() - startMs,
     });
     if (opts.dryRun)
-        return makeConsolidateResult({ ...summary(), dryRun: true, previewOnly: true });
+        return makeConsolidateResult({ ...summary(), dryRun: true, previewOnly: true, pairPass });
     warn(`[consolidate] plan: ${plan.allOps.length} operation(s)`);
     const ctx = {
         config,
@@ -720,6 +731,7 @@ async function consolidate(opts, config, stashDir, startMs, stateDb) {
         ...summary(),
         promoted: ctx.promoted,
         failedPromotions: ctx.promotionFailures.count,
+        pairPass,
         perfTelemetry: {
             dedupPoolSize: pool.dedupPoolSize,
             llmPoolSize: plan.llmPoolSize,
@@ -799,6 +811,12 @@ export async function emitPromotionProposal(op, ctx) {
     catch (e) {
         return skip("promote_read_failed", `Promote: could not read ${op.ref}: ${String(e)}`);
     }
+    // O1 hash nit: the RAW body, before sanitization — accept re-reads the
+    // source with a plain fs.readFileSync and never re-sanitizes, so hashing
+    // anything else here would compare two different representations of the
+    // same unedited memory and report a false "changed since mint" (measured:
+    // 3 of 767 real memories sanitize to different bytes than their raw body).
+    const sourceRawBodyHash = contentHash(memoryContent, "body");
     const sanitized = sanitizeMergedContent(memoryContent);
     if (!sanitized.ok) {
         return skip("promote_sanitization_failed", `Promote: rejected ${op.ref} — source memory failed sanitization (${sanitized.reason}).`);
@@ -856,6 +874,14 @@ export async function emitPromotionProposal(op, ctx) {
             ...(typeof op.confidence === "number" ? { confidence: op.confidence } : {}),
             // The ledger keys the attempt by the source memory.
             attemptedRefs: [op.ref],
+            // O1 (alpha.9): on accept, promoteProposal retires this source memory
+            // (and its .derived twin) so promotion no longer leaves a duplicate.
+            promotionSource: op.ref,
+            // B3: recorded so accept can refuse to archive a source that was
+            // edited after this promotion was queued — the RAW body hash (see
+            // sourceRawBodyHash's own comment above), not `bodyHash`, which is the
+            // sanitized-for-knowledge representation accept never re-derives.
+            promotionSourceHash: sourceRawBodyHash,
         });
         ctx.promoted.push(proposal.id);
         ctx.promotedSourceRefs.add(op.ref);
@@ -865,57 +891,6 @@ export async function emitPromotionProposal(op, ctx) {
         skip("promote_create_failed", `Promote: createProposal failed for ${op.ref}: ${String(e)}`);
     }
 }
-/**
- * {changed} ∪ {top-k indexed neighbours of each changed memory}, within the
- * pool: nothing changed → []; everything changed or no index → the full pool.
- */
-export function narrowToIncrementalCandidates(memories, since, warnings, neighborsPerChanged = 5, readOnly = false) {
-    // Lenient: a garbage `since` passes through and selects nothing.
-    const sinceIso = parseSinceToIsoLenient(since);
-    const changed = memories.filter((m) => {
-        try {
-            return fs.statSync(m.filePath).mtime.toISOString() > sinceIso;
-        }
-        catch {
-            return true; // never silently drop a memory we cannot stat
-        }
-    });
-    if (changed.length === 0)
-        return [];
-    if (changed.length === memories.length)
-        return memories;
-    const inPool = new Set(memories.map((m) => m.name));
-    const keep = new Set(changed.map((m) => m.name));
-    let db;
-    try {
-        db = readOnly ? openReadonlyExistingDatabase(undefined, { isolatedSnapshot: true }) : openExistingDatabase();
-        if (!db)
-            return memories;
-        for (const m of changed) {
-            const id = findEntryIdByRef(db, conceptIdFromTypeName("memory", m.name));
-            if (id === undefined)
-                continue;
-            for (const hit of getNeighborsByEntryId(db, id, neighborsPerChanged + 1)) {
-                if (hit.id === id)
-                    continue;
-                const name = getEntryById(db, hit.id)?.entry.name;
-                if (name && inPool.has(name))
-                    keep.add(name);
-            }
-        }
-    }
-    catch {
-        warnings.push("Incremental consolidation: index unavailable — processing full pool.");
-        return memories;
-    }
-    finally {
-        if (db)
-            closeDatabase(db);
-    }
-    const candidates = memories.filter((m) => keep.has(m.name));
-    warnings.push(`Incremental consolidation: ${changed.length} changed + neighbours → ${candidates.length}/${memories.length} memories considered (since ${since}${sinceIso !== since ? ` = ${sinceIso}` : ""}).`);
-    return candidates;
-}
 /** The target bundle's eligible memories from the index, else walked from disk. */
 function loadMemoriesForSource(source, warnings, readOnly) {
     let memories = [];

package/dist/commands/improve/extract-prompt.js

@@ -111,8 +111,7 @@ function formatAlreadyPreserved(inlineRefs) {
 }
 /**
  * Delimiters that fence the untrusted session transcript in the extract prompt.
- * Mirrors the `=== ASSET N ===` convention (`graph-extract.ts`): everything
- * between the markers is DATA to analyze, never instructions to obey. The
+ * Everything between the markers is DATA to analyze, never instructions to obey. The
  * transcript is external, attacker-influenceable content, so an explicit,
  * greppable boundary defuses prompt-injection that tries to pose as a command.
  */

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

@@ -250,7 +250,7 @@ export const improveCommand = defineCommand({
         },
         strategy: {
             type: "string",
-            description: "Named improve strategy from improve.strategies or built-in strategies (catchup, consolidate, default, graph-refresh, proactive-maintenance, quick, reflect-distill, thorough). Controls which sub-processes run and which asset types are processed.",
+            description: "Named improve strategy from improve.strategies or built-in strategies (catchup, consolidate, default, proactive-maintenance, quick, reflect-distill, thorough). Controls which sub-processes run and which asset types are processed.",
         },
         sync: {
             type: "boolean",

package/dist/commands/improve/improve-strategies.js

@@ -4,13 +4,11 @@
 import catchup from "../../assets/improve-strategies/catchup.json" with { type: "json" };
 import consolidate from "../../assets/improve-strategies/consolidate.json" with { type: "json" };
 import defaultStrategy from "../../assets/improve-strategies/default.json" with { type: "json" };
-import graphRefresh from "../../assets/improve-strategies/graph-refresh.json" with { type: "json" };
 import proactiveMaintenance from "../../assets/improve-strategies/proactive-maintenance.json" with { type: "json" };
 import quick from "../../assets/improve-strategies/quick.json" with { type: "json" };
 import reflectDistill from "../../assets/improve-strategies/reflect-distill.json" with { type: "json" };
 import thorough from "../../assets/improve-strategies/thorough.json" with { type: "json" };
 import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
-import { getIndexPassConfig, } from "../../core/config/config.js";
 import { ImproveProfileConfigSchema } from "../../core/config/config-schema.js";
 import { deepMergeConfig } from "../../core/config/deep-merge.js";
 import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_PROCESS_ENGINE_CAPABILITIES, } from "../../core/config/engine-semantics.js";
@@ -72,7 +70,6 @@ const BUILTIN_STRATEGIES = {
     default: defaultStrategy,
     quick,
     thorough,
-    "graph-refresh": graphRefresh,
     consolidate,
     catchup,
     "reflect-distill": reflectDistill,
@@ -84,6 +81,29 @@ if (BUILTIN_IMPROVE_STRATEGY_NAMES.some((name) => !(name in BUILTIN_STRATEGIES))
 export function resolveImproveStrategy(name, config) {
     const selectedName = name ?? config.defaults?.improveStrategy ?? "default";
     const userStrategies = config.improve?.strategies ?? {};
+    // graph-refresh named a specific, common retirement — refuse it
+    // unconditionally, even when `improve.strategies["graph-refresh"]` still
+    // has an override block from when it customized the (now-deleted) built-in
+    // strategy of the same name. That override is a partial patch (e.g. just
+    // `processes.graphExtraction.mode`), not a full strategy definition —
+    // falling through to the generic "resolve as a user strategy" path below
+    // would silently merge it onto `default` and run a full, unplanned improve
+    // pass instead of refusing. `akm migrate apply` drops the leftover block
+    // (src/core/config/config.ts, normalizeConfigFile) since it can never
+    // apply again.
+    if (selectedName === "graph-refresh") {
+        const hasLeftoverOverride = Boolean(userStrategies["graph-refresh"]);
+        throw new ConfigError(`Improve strategy "graph-refresh" was retired in 0.9.17-alpha.9 along with the LLM entity-graph extraction it ran.` +
+            (hasLeftoverOverride
+                ? ' Your config still has a leftover `improve.strategies["graph-refresh"]` override for it — `akm migrate apply` removes it.'
+                : ""), "UNKNOWN_IMPROVE_STRATEGY", 
+        // Override CONFIG_HINTS.UNKNOWN_IMPROVE_STRATEGY (src/core/errors.ts):
+        // its "listed strategy names" phrase does not apply here (this message
+        // names no strategies), and its "define it under improve.strategies"
+        // suggestion is actively wrong — that is exactly the leftover-override
+        // shape this refusal exists to reject, not a way around it.
+        "Choose a different strategy. `graph-refresh` cannot be redefined under `improve.strategies` — it always refuses.");
+    }
     if (!(selectedName in BUILTIN_STRATEGIES) && !userStrategies[selectedName]) {
         const valid = [...new Set([...Object.keys(BUILTIN_STRATEGIES), ...Object.keys(userStrategies)])].sort();
         throw new ConfigError(`Improve strategy "${selectedName}" not found. Valid strategies: ${valid.join(", ")}.`, "UNKNOWN_IMPROVE_STRATEGY");
@@ -212,8 +232,6 @@ function buildImprovePlan(strategy, config, options) {
                 profile: strategy.config,
                 process: sourceProcessConfig,
                 processName,
-                // Graph extraction's standing engine, model, timeout and llm settings (GR-D15).
-                ...(processName === "graphExtraction" ? { index: getIndexPassConfig(config.index, "graph") } : {}),
             });
             runner = resolved?.runner ?? null;
             notices = resolved?.notices ?? [];

package/dist/commands/improve/improve.js

@@ -42,7 +42,7 @@ import { buildImproveUsageReport } from "./improve-usage-report.js";
 import { lastAttemptByRef, loadLedgerSnapshot } from "./ledger.js";
 import { improveLockPath, releaseImproveLock, tryAcquireImproveLock } from "./locks.js";
 import { runImproveLoopStage, runImprovePostLoopStage } from "./loop-stages.js";
-import { analyzeMemoryCleanup } from "./memory/memory-improve.js";
+import { analyzeMemoryCleanup, purgeGracedArchive, RETIRE_GRACE_DAYS, } from "./memory/memory-improve.js";
 import { buildImproveExecutionPlan } from "./planner.js";
 import { CONSOLIDATION_CONFIG_KEYS, pickDefined, recordImproveSkip, runImprovePreparationStage } from "./preparation.js";
 import { DEFAULT_DUE_DAYS, filterProactiveDue } from "./proactive-maintenance.js";
@@ -175,6 +175,21 @@ export async function akmImprove(options = {}) {
             initialGitPaths =
                 syncRepoDir && isGitBackedStash(syncRepoDir) ? new Set(listGitChangedPaths(syncRepoDir)) : new Set();
             journal = beginWriteProvenance();
+            // Step 8 (alpha.9 plan §5.4): the purge sweep. Deterministic, no LLM,
+            // and first — before anything else this run might touch the archive
+            // for. Git-backed bundles only; a bundle with no git history of its
+            // own is left untouched (akm health reports its size instead).
+            if (setup.primaryStashDir) {
+                try {
+                    const purge = purgeGracedArchive(setup.primaryStashDir);
+                    if (purge.purgedFiles > 0) {
+                        info(`[improve] archive purge: ${purge.purgedFiles} file(s) across ${purge.purgedDirs} retirement(s) past the ${RETIRE_GRACE_DAYS}d grace period removed`);
+                    }
+                }
+                catch (err) {
+                    preEnsureCleanupWarnings.push(`archive purge failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
             // The index is made current BEFORE triage (R6): triage promotes into the
             // stash, and a reindex after it would always find fresh work.
             const bootstrap = await runIndexBootstrapPass(setup, budgetAbortController.signal);
@@ -564,7 +579,6 @@ function buildResultExecutionPlan(run, preparation, collected, dryRun) {
         : undefined;
     const belowMinPending = pendingMemories !== undefined && inferenceMinPending !== undefined && pendingMemories < inferenceMinPending;
     const memoryInferenceEnabled = resolvedPlan.processes.memoryInference.enabled && !belowMinPending;
-    const graphExtractionEnabled = resolvedPlan.processes.graphExtraction.enabled && run.primaryStashDir !== undefined;
     // Per-process routing, plus how many effective refs each ref-scoped process would act on (#947).
     const processes = projectResolvedProcessRouting(resolvedPlan).map((row) => {
         const eligibleRefs = eligibleRefCount(preparation.loopRefs, row.process, resolvedPlan.strategy.config);
@@ -608,16 +622,6 @@ function buildResultExecutionPlan(run, preparation, collected, dryRun) {
         },
         stageConfig: {
             extract: { enabled: preparation.planning.extract.wouldRun, reason: preparation.planning.extract.reason },
-            graphExtraction: {
-                enabled: graphExtractionEnabled,
-                reason: !resolvedPlan.processes.graphExtraction.enabled
-                    ? "disabled"
-                    : graphExtractionEnabled
-                        ? improveProfile.processes?.graphExtraction?.fullScan === true
-                            ? "enabled for a full-corpus scan"
-                            : "enabled for refs touched by this run"
-                        : "enabled but no primary source is available",
-            },
             memoryInference: {
                 enabled: memoryInferenceEnabled,
                 reason: !resolvedPlan.processes.memoryInference.enabled
@@ -825,7 +829,7 @@ async function runImproveStageSequence(run, collected, preEnsureCleanupWarnings,
         improveProfile,
         resolvedPlan,
     });
-    let postLoop = { allWarnings: [], memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
+    let postLoop = { allWarnings: [], memoryInferenceDurationMs: 0 };
     const remainingBudget = budgetAbortController.signal.remainingBudgetMs;
     if (budgetAbortController.signal.aborted || (remainingBudget !== undefined && remainingBudget <= 0)) {
         info("[improve] post-loop maintenance skipped (wall-clock budget exhausted)");
@@ -859,8 +863,8 @@ function finalizeImproveResult(args) {
     const { options, startMs, resolvedPlan } = run;
     const { memoryCleanupPlan, strategyFilteredRefs } = collected;
     const consolidation = preparation.consolidation;
-    const { memoryInference, graphExtraction, allWarnings, deadUrls, deadUrlCoverage, orphansPurged, proposalsExpired } = postLoop;
-    const { memoryInferenceDurationMs, graphExtractionDurationMs } = postLoop;
+    const { memoryInference, allWarnings, deadUrls, deadUrlCoverage, orphansPurged, proposalsExpired } = postLoop;
+    const { memoryInferenceDurationMs } = postLoop;
     // The per-ref distill-skipped rows fold into a bounded aggregate before persistence (C1).
     const { actions: persistedActions, aggregate: distillSkippedAggregate } = foldDistillSkipped(finalActions);
     // This run's LLM accounting (#944): llm_usage rows carry no run id, so the
@@ -880,7 +884,6 @@ function finalizeImproveResult(args) {
         consolidation,
         ...(preparation.extract ?? []).flatMap((extract) => [extract, ...(extract.sessions ?? [])]),
         memoryInference,
-        graphExtraction,
         triageDrain,
     ]);
     const applied = preparation.appliedCleanup;
@@ -933,11 +936,9 @@ function finalizeImproveResult(args) {
         ...(deadUrlCoverage !== undefined ? { deadUrlCoverage } : {}),
         ...(reflectsWithErrorContext > 0 ? { reflectsWithErrorContext } : {}),
         ...(memoryInference ? { memoryInference } : {}),
-        ...(graphExtraction ? { graphExtraction } : {}),
         // Top-level phase durations feed health's wall-time buckets; a phase that
         // did not run is omitted, not zero.
         ...(memoryInferenceDurationMs > 0 ? { memoryInferenceDurationMs } : {}),
-        ...(graphExtractionDurationMs > 0 ? { graphExtractionDurationMs } : {}),
         ...(ensureIndexDurationMs !== undefined ? { ensureIndexDurationMs } : {}),
         ...(orphansPurged !== undefined ? { orphansPurged } : {}),
         ...(proposalsExpired !== undefined && proposalsExpired > 0 ? { proposalsExpired } : {}),
@@ -960,7 +961,6 @@ function finalizeImproveResult(args) {
     };
     emitImproveCompletedEvent(result, {
         memoryInferenceDurationMs,
-        graphExtractionDurationMs,
         totalDurationMs: Date.now() - startMs,
         warningCount: allWarnings.length,
         orphansPurged: orphansPurged ?? 0,
@@ -989,7 +989,6 @@ const ACTION_COUNTER = {
     "distill-skipped": "distillSkippedActions",
     "memory-prune": "memoryPruneActions",
     "memory-inference": "memoryInferenceActions",
-    "graph-extraction": "graphExtractionActions",
     error: "errorActions",
     "reflect-failed": "reflectFailedActions",
     "reflect-cooldown": "reflectCooldownActions",
@@ -1011,7 +1010,6 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
     counts.distillSkippedActions = (counts.distillSkippedActions ?? 0) + distillSkippedTotal;
     classCounts.skipped += distillSkippedTotal;
     const cleanup = result.memoryCleanup;
-    const quality = result.graphExtraction?.quality;
     appendEvent({
         eventType: "improve_completed",
         ref: result.scope.mode === "ref"
@@ -1043,21 +1041,12 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             consolidationDurationMs: result.consolidation?.durationMs ?? 0,
             memoryInferenceWrites: result.memoryInference?.writtenFacts ?? 0,
             memoryInferenceDurationMs: durations.memoryInferenceDurationMs,
-            graphExtractionExtractedFiles: quality?.extractedFiles ?? 0,
-            graphExtractionDurationMs: durations.graphExtractionDurationMs,
             proactiveSelected: result.proactiveMaintenance?.selected ?? 0,
             proactiveDueTotal: result.proactiveMaintenance?.dueTotal ?? 0,
             proactiveNeverReflected: result.proactiveMaintenance?.neverReflected ?? 0,
             durationMs: durations.totalDurationMs,
             warningCount: durations.warningCount,
             orphansPurged: durations.orphansPurged,
-            ...(quality
-                ? {
-                    graphCoverage: quality.extractionCoverage,
-                    graphDensity: quality.density,
-                    graphEntities: quality.entityCount,
-                }
-                : {}),
         },
     }, eventsCtx);
 }

package/dist/commands/improve/ledger.js

@@ -9,9 +9,9 @@
 import fs from "node:fs";
 import { getStateDbPath, withImmediateTransaction, withStateDb } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
-import { isLedgerBlocked, listImproveLedgerRows, recordImproveLedger, } from "../../storage/repositories/improve-ledger-repository.js";
+import { isLedgerBlocked, listImproveLedgerRows, PAIR_PASS_LEDGER_SOURCE, recordImproveLedger, } from "../../storage/repositories/improve-ledger-repository.js";
 import { openSqliteReadSnapshot } from "../../storage/sqlite-read-snapshot.js";
-export { isLedgerBlocked };
+export { isLedgerBlocked, PAIR_PASS_LEDGER_SOURCE };
 /** An improve candidate's durable state key: its index item_ref, else its conceptId. */
 export function stateKey(ref, itemRef) {
     return itemRef ?? ref;
@@ -69,6 +69,7 @@ export function recordLedgerAttempt(access, inputs) {
                     at,
                     ...(input.proposalId !== undefined ? { proposalId: input.proposalId } : {}),
                     ...(input.detail !== undefined ? { detail: input.detail } : {}),
+                    ...(input.contentHash !== undefined ? { contentHash: input.contentHash } : {}),
                 });
             }
         }));

package/dist/commands/improve/loop-stages.js

@@ -3,7 +3,6 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /** The improve loop (reflect + distill per ref), the post-loop checks and the maintenance passes. */
 import fs from "node:fs";
-import path from "node:path";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { daysToMs } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
@@ -13,12 +12,9 @@ import { openLogsDatabase, purgeOldTaskLogs } from "../../core/logs-db.js";
 import { getDbPath, getTaskLogDir } from "../../core/paths.js";
 import { withStateDb } from "../../core/state-db.js";
 import { info } from "../../core/warn.js";
-import { runGraphExtractionPass } from "../../indexer/graph/graph-extraction.js";
 import { indexWrittenAssets } from "../../indexer/index-written-assets.js";
-import { deriveWritableBundleIds } from "../../indexer/installations.js";
 import { collectPendingMemories, runMemoryInferencePass, } from "../../indexer/passes/memory-inference.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { isProcessEnabled } from "../../llm/feature-gate.js";
 import { purgeOldEvents } from "../../storage/repositories/events-repository.js";
 import { purgeOldImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
 import { closeDatabase, openIndexDatabase } from "../../storage/repositories/index-connection.js";
@@ -29,7 +25,7 @@ import { readFreelistInfo, STATE_DB_VACUUMED_EVENT, vacuumIfReclaimable } from "
 import { purgeOldTaskLogFiles } from "../../tasks/run/task-log.js";
 import { expireStaleProposals, purgeOrphanProposals } from "../proposal/repository.js";
 import { checkDeadUrls } from "../url-checker.js";
-import { findAssetFilePath, isDistillCandidateRef } from "./eligibility.js";
+import { isDistillCandidateRef } from "./eligibility.js";
 import { shouldSkipRef } from "./improve-strategies.js";
 import { recordLedgerAttempt, stateKey, stripBundle } from "./ledger.js";
 import { pushRecentError } from "./preparation.js";
@@ -327,23 +323,21 @@ export async function runImprovePostLoopStage(args) {
         deadUrls,
         ...(deadUrlCoverage ? { deadUrlCoverage } : {}),
         ...(maintenance.memoryInference ? { memoryInference: maintenance.memoryInference } : {}),
-        ...(maintenance.graphExtraction ? { graphExtraction: maintenance.graphExtraction } : {}),
         ...(maintenance.actions && maintenance.actions.length > 0 ? { maintenanceActions: maintenance.actions } : {}),
         memoryInferenceDurationMs: maintenance.memoryInferenceDurationMs,
-        graphExtractionDurationMs: maintenance.graphExtractionDurationMs,
         orphansPurged: maintenance.orphansPurged,
         proposalsExpired: maintenance.proposalsExpired,
     };
 }
 /**
- * Memory inference → index what it wrote → graph extraction → proposal hygiene
- * (orphan purge, expiration) → orphan-state GC → retention purges. Warnings go
- * to `allWarnings`.
+ * Memory inference → index what it wrote → proposal hygiene (orphan purge,
+ * expiration) → orphan-state GC → retention purges. Warnings go to
+ * `allWarnings`.
  */
 export async function runImproveMaintenancePasses(args) {
     const { options, primaryStashDir, allWarnings, budgetSignal, eventsCtx } = args;
     if (!primaryStashDir || budgetSignal?.aborted)
-        return { memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
+        return { memoryInferenceDurationMs: 0 };
     const config = options.config ?? loadConfig();
     const ctx = {
         config,
@@ -354,7 +348,6 @@ export async function runImproveMaintenancePasses(args) {
         improveProfile: args.improveProfile,
         resolvedPlan: args.resolvedPlan,
         memoryInferenceFn: options.memoryInferenceFn ?? runMemoryInferencePass,
-        graphExtractionFn: options.graphExtractionFn ?? runGraphExtractionPass,
     };
     const openIndexDb = () => openIndexDatabase(getDbPath());
     const dbCell = {};
@@ -386,20 +379,14 @@ export async function runImproveMaintenancePasses(args) {
                 allWarnings.push(`indexing after memory inference failed: ${errMessage(err)}`);
             }
         }
-        const graph = await runGraphExtractionMaintenancePass(ctx, dbCell, args);
-        if (graph.action)
-            actions.push(graph.action);
-        allWarnings.push(...graph.warnings);
         const hygiene = runProposalHygienePass(ctx);
         allWarnings.push(...hygiene.warnings);
         allWarnings.push(...runOrphanStateGcPass(ctx, dbCell).warnings);
         allWarnings.push(...runRetentionPurgePass(ctx).warnings);
         return {
             ...(inference.memoryInference ? { memoryInference: inference.memoryInference } : {}),
-            ...(graph.graphExtraction ? { graphExtraction: graph.graphExtraction } : {}),
             ...(actions.length > 0 ? { actions } : {}),
             memoryInferenceDurationMs: inference.durationMs,
-            graphExtractionDurationMs: graph.durationMs,
             orphansPurged: hygiene.orphansPurged,
             proposalsExpired: hygiene.proposalsExpired,
         };
@@ -467,73 +454,6 @@ export async function runMemoryInferenceMaintenancePass(ctx, dbCell, memoryRefsF
         warnings: pass.warnings,
     };
 }
-/**
- * Graph extraction over the files this run touched, or the whole corpus when
- * the profile sets `graphExtraction.fullScan` (the `graph-refresh` strategy).
- * With nothing touched the pass still runs and extracts nothing.
- */
-export async function runGraphExtractionMaintenancePass(ctx, dbCell, args) {
-    const { config, sources, primaryStashDir, resolvedPlan } = ctx;
-    const settings = ctx.improveProfile?.processes?.graphExtraction;
-    if (settings?.enabled === false) {
-        info("[improve] graph extraction skipped (disabled by improve profile)");
-        return { durationMs: 0, warnings: [] };
-    }
-    if (sources.length === 0)
-        return { durationMs: 0, warnings: [] };
-    // `index.graph.enabled: false` turns graph extraction off everywhere,
-    // whatever the strategy enables.
-    if (!isProcessEnabled("index", "graph_extraction", config)) {
-        info("[improve] graph extraction skipped (index.graph.enabled is false)");
-        return { durationMs: 0, warnings: [] };
-    }
-    const fullScan = settings?.fullScan === true;
-    info(`[improve] graph extraction starting${fullScan ? " (full-corpus scan)" : ""}`);
-    const pass = await timedLlmPass("graph extraction", async () => {
-        let candidatePaths;
-        if (!fullScan) {
-            candidatePaths = new Set();
-            const touched = new Set([...args.actionableRefs.map((r) => r.ref), ...args.memoryRefsForInference]);
-            if (primaryStashDir && touched.size > 0) {
-                const writableBundleIds = deriveWritableBundleIds(resolveSourceEntries(primaryStashDir));
-                const resolved = await Promise.all([...touched].map((ref) => findAssetFilePath(ref, primaryStashDir, writableBundleIds).catch(() => null)));
-                for (const p of resolved)
-                    if (typeof p === "string" && p.length > 0)
-                        candidatePaths.add(p);
-            }
-        }
-        return attributeStage(resolvedPlan, "graphExtraction", () => ctx.graphExtractionFn({
-            config,
-            ...(resolvedPlan ? { llmRunner: resolvedPlan.processes.graphExtraction.runner } : {}),
-            sources,
-            signal: ctx.budgetSignal,
-            db: dbCell.current,
-            reEnrich: false,
-            onProgress: (event) => {
-                const current = event.currentPath ? ` ${path.basename(event.currentPath)}` : "";
-                info(`[improve] graph extraction ${event.processed}/${event.total}${current} (extracted ${event.extracted}, entities ${event.totalEntities}, relations ${event.totalRelations})`);
-            },
-            options: {
-                candidatePaths,
-                // Only what the strategy sets: the pass falls back to index.graph, then its defaults (GR-D15).
-                ...(settings?.includeTypes ? { includeTypes: settings.includeTypes } : {}),
-                ...(settings?.batchSize != null ? { batchSize: settings.batchSize } : {}),
-                ...(settings?.topN != null ? { topN: settings.topN } : {}),
-                ...(settings?.maxChunksPerAsset != null ? { maxChunksPerAsset: settings.maxChunksPerAsset } : {}),
-            },
-        }));
-    });
-    const graphExtraction = pass.result;
-    if (!graphExtraction)
-        return { durationMs: pass.durationMs, warnings: pass.warnings };
-    info(`[improve] graph extraction complete (${graphExtraction.quality.extractedFiles} files, ${graphExtraction.quality.entityCount} entities, ${graphExtraction.quality.relationCount} relations)`);
-    return {
-        graphExtraction,
-        durationMs: pass.durationMs,
-        action: { ref: "graph/_artifact", mode: "graph-extraction", result: graphExtraction },
-        warnings: pass.warnings,
-    };
-}
 /**
  * Reject pending proposals whose target no longer exists, then expire pending
  * proposals past the retention window; each emits a roll-up event.

package/dist/commands/improve/memory/memory-belief.js

@@ -6,7 +6,9 @@
  * frontmatter and demote its `beliefState`, metadata only. Idempotent (a
  * present edge AND demotion is a no-op; an edge without its demotion is
  * repaired) and never weakens a stronger demotion — severity is
- * superseded > contradicted > archived, per the ranker's `beliefStateBoost`.
+ * superseded > contradicted > archived. (alpha.4 removed belief weights from
+ * ranking: search no longer reads `beliefState` at all, and `--belief
+ * current|historical` is the only reader, opt-in.)
  * The SCC resolver in memory-improve.ts is a state-transition writer (it
  * replaces and clears edges) and deliberately does not use this (#885).
  */