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

package/dist/commands/health/improve-metrics.js

@@ -74,7 +74,6 @@ export function emptyImproveMetrics() {
             },
             memoryPrune: 0,
             memoryInference: 0,
-            graphExtraction: 0,
             error: 0,
         },
         autoAccept: { promoted: 0, validationFailed: 0 },
@@ -91,7 +90,6 @@ export function emptyImproveMetrics() {
             durationMs: 0,
         },
         memoryInference: { considered: 0, freshAttempts: 0, written: 0, skippedNoFacts: 0, yieldRate: 0, durationMs: 0 },
-        graphExtraction: { extractedFiles: 0, entities: 0, relations: 0, failures: 0, durationMs: 0 },
         wallTime: { medianMs: 0, p95Ms: 0 },
         coverage: { acceptedProposals: 0, distinctRefs: 0 },
     };
@@ -151,9 +149,6 @@ function applyAction(metrics, action) {
         case "memory-inference":
             metrics.actions.memoryInference += 1;
             break;
-        case "graph-extraction":
-            metrics.actions.graphExtraction += 1;
-            break;
         case "error":
             metrics.actions.error += 1;
             break;
@@ -209,19 +204,6 @@ function projectRunMetrics(result) {
         mi.skippedNoFacts += toFiniteNumber(memoryInference.skippedNoFacts);
     }
     metrics.memoryInference.durationMs += toFiniteNumber(result.memoryInferenceDurationMs);
-    const graphExtraction = result.graphExtraction;
-    if (graphExtraction) {
-        const ge = metrics.graphExtraction;
-        // This run's counts, like entities and relations. `quality` describes the
-        // whole stored graph after the run; summing it would count each stored file
-        // once per run in the window.
-        ge.extractedFiles += toFiniteNumber(graphExtraction.extracted);
-        ge.entities += toFiniteNumber(graphExtraction.totalEntities);
-        ge.relations += toFiniteNumber(graphExtraction.totalRelations);
-        const telemetry = graphExtraction.telemetry;
-        ge.failures += toFiniteNumber(telemetry?.failureCount);
-    }
-    metrics.graphExtraction.durationMs += toFiniteNumber(result.graphExtractionDurationMs);
     return metrics;
 }
 /** Derived rates on an accumulator (window aggregate or single run). */
@@ -251,7 +233,6 @@ function mergeImproveMetrics(dst, src) {
     }
     dst.actions.memoryPrune += src.actions.memoryPrune;
     dst.actions.memoryInference += src.actions.memoryInference;
-    dst.actions.graphExtraction += src.actions.graphExtraction;
     dst.actions.error += src.actions.error;
     dst.autoAccept.promoted += src.autoAccept.promoted;
     dst.autoAccept.validationFailed += src.autoAccept.validationFailed;
@@ -269,11 +250,6 @@ function mergeImproveMetrics(dst, src) {
     dst.memoryInference.written += src.memoryInference.written;
     dst.memoryInference.skippedNoFacts += src.memoryInference.skippedNoFacts;
     dst.memoryInference.durationMs += src.memoryInference.durationMs;
-    dst.graphExtraction.extractedFiles += src.graphExtraction.extractedFiles;
-    dst.graphExtraction.entities += src.graphExtraction.entities;
-    dst.graphExtraction.relations += src.graphExtraction.relations;
-    dst.graphExtraction.failures += src.graphExtraction.failures;
-    dst.graphExtraction.durationMs += src.graphExtraction.durationMs;
 }
 function compareImproveRunRecency(a, b) {
     const started = a.started_at.localeCompare(b.started_at);
@@ -354,7 +330,6 @@ export function projectImproveRunSummary(row, wallTimeMs, taskId) {
         memorySummary: perRow.memorySummary,
         consolidation: perRow.consolidation,
         memoryInference: perRow.memoryInference,
-        graphExtraction: perRow.graphExtraction,
         orphansPurged: toFiniteNumber(result.orphansPurged),
         lintFixed: lintSummary ? toFiniteNumber(lintSummary.fixed) : 0,
         lintFlagged: lintSummary ? toFiniteNumber(lintSummary.flagged) : 0,

package/dist/commands/health/md-report.js

@@ -20,7 +20,7 @@ function renderTable(headers, rows) {
  *
  * Columns: ts | ok | actions | refl_ok/fail/cd/skip |
  *   distill_q/llm-fail/qrej/cfg/skip | cons_proc/promo/merge/del |
- *   mem_cons/written/skip | graph_f/e/r | orphans | lint_f/fl
+ *   mem_cons/written/skip | orphans | lint_f/fl
  */
 export function renderRunsDetailMd(runs) {
     const headers = [
@@ -32,7 +32,6 @@ export function renderRunsDetailMd(runs) {
         "distill_q/llm-fail/judge/validator/cfg/skip",
         "cons_proc/promo/merge/del",
         "mem_cons/written/skip",
-        "graph_f/e/r",
         "orphans",
         "lint_f/fl",
         "result_status",
@@ -50,7 +49,6 @@ export function renderRunsDetailMd(runs) {
             r.actions.distill.skipped +
             r.actions.memoryPrune +
             r.actions.memoryInference +
-            r.actions.graphExtraction +
             r.actions.error;
         return [
             r.startedAt,
@@ -61,7 +59,6 @@ export function renderRunsDetailMd(runs) {
             `${r.actions.distill.queued}/${r.actions.distill.llmFailed}/${r.actions.distill.judgeRejected}/${r.actions.distill.validatorRejected}/${r.actions.distill.configDisabled}/${r.actions.distill.skipped}`,
             `${r.consolidation.processed}/${r.consolidation.promoted}/${r.consolidation.merged}/${r.consolidation.deleted}`,
             `${r.memoryInference.considered}/${r.memoryInference.written}/${r.memoryInference.skippedNoFacts}`,
-            `${r.graphExtraction.extractedFiles}/${r.graphExtraction.entities}/${r.graphExtraction.relations}`,
             String(r.orphansPurged),
             `${r.lintFixed}/${r.lintFlagged}`,
             r.resultStatus ?? "valid",
@@ -81,8 +78,6 @@ export function renderWindowCompareMd(windows, deltas) {
     const badIfPositive = new Set([
         "improve.actions.reflect.failed",
         "improve.actions.distill.llmFailed",
-        "improve.graphExtraction.failures",
-        "improve.graphExtraction.nonArrayBatchFailures",
         "improve.wallTime.medianMs",
         "improve.wallTime.p95Ms",
         "improve.memoryInference.skippedNoFacts",

package/dist/commands/health/report-view-model.js

@@ -64,11 +64,9 @@ function coercePct(raw) {
 function reshapeRun(r) {
     const cons = r.consolidation;
     const mi = r.memoryInference;
-    const ge = r.graphExtraction;
     const wall = r.wallTimeMs || 0;
     const consMs = cons.durationMs || 0;
     const miMs = mi.durationMs || 0;
-    const geMs = ge.durationMs || 0;
     return {
         id: r.id,
         resultStatus: r.resultStatus ?? "valid",
@@ -81,16 +79,13 @@ function reshapeRun(r) {
         ok: r.ok,
         consDurationMs: consMs,
         miDurationMs: miMs,
-        geDurationMs: geMs,
-        otherMs: Math.max(0, wall - consMs - miMs - geMs),
+        otherMs: Math.max(0, wall - consMs - miMs),
         promoted: cons.promoted,
         merged: cons.merged,
         deleted: cons.deleted,
         contradicted: cons.contradicted,
         judgedNoAction: cons.judgedNoAction,
         miWritten: mi.written,
-        geEntities: ge.entities,
-        geRelations: ge.relations,
         distillByReason: r.actions.distill.skippedByReason,
         reflectOk: r.actions.reflect.ok,
         reflectFailed: r.actions.reflect.failed,
@@ -121,11 +116,10 @@ function classify(deltas, metricKeys, lowerIsBetter = false) {
 function buildTrend(deltas) {
     const decisionQuality = classify(deltas, ["improve.memoryInference.yieldRate", "improve.consolidation.promoted"]);
     const outputVolume = classify(deltas, ["improve.consolidation.promoted", "improve.memoryInference.written"]);
-    const failures = classify(deltas, ["improve.graphExtraction.failures"], true);
     const latency = classify(deltas, ["improve.wallTime.medianMs", "improve.wallTime.p95Ms"], true);
-    const score = [decisionQuality, outputVolume, failures, latency].reduce((acc, d) => acc + (d === "up" ? 1 : d === "down" ? -1 : 0), 0);
+    const score = [decisionQuality, outputVolume, latency].reduce((acc, d) => acc + (d === "up" ? 1 : d === "down" ? -1 : 0), 0);
     const overall = score >= 1 ? "improving" : score <= -1 ? "degrading" : "mixed";
-    return { decisionQuality, outputVolume, failures, latency, overall };
+    return { decisionQuality, outputVolume, latency, overall };
 }
 function readSemSearch(advisories) {
     const check = advisories.find((a) => a.name === "semantic-search-runtime");
@@ -184,7 +178,6 @@ function buildAggregatesPhase(result, runsPhase) {
     const improve = result.improve;
     const cons = improve.consolidation;
     const mi = improve.memoryInference;
-    const ge = improve.graphExtraction;
     const wallTime = improve.wallTime;
     const coverage = improve.coverage;
     // #576: real per-stage LLM token/time accounting (replaces the GPU-time
@@ -209,7 +202,6 @@ function buildAggregatesPhase(result, runsPhase) {
     return {
         consolidation: cons,
         memoryInference: mi,
-        graphExtraction: ge,
         wallTime,
         coverage,
         llm,
@@ -309,7 +301,7 @@ function groupProposalsBySource(proposals) {
 }
 /** Summary table rows: the base metric set + the WS-5 coverage/minting/perf/degradation extensions, when present. */
 function buildSummaryRows(aggregates, trend) {
-    const { consolidation: cons, graphExtraction: ge, wallTime, llm, coverage } = aggregates;
+    const { consolidation: cons, wallTime, llm, coverage } = aggregates;
     const summaryRows = [
         ["Task fail rate", aggregates.taskFailRate, "flat"],
         ["Agent fail rate", aggregates.agentFailRate, "flat"],
@@ -332,8 +324,6 @@ function buildSummaryRows(aggregates, trend) {
             "Candidates reviewed but intentionally left unchanged (the 'judgedNoAction' field).",
         ],
         ["Chunk failure", aggregates.chunkFail, "flat"],
-        ["Graph entities", num(ge.entities), "up"],
-        ["Graph relations", num(ge.relations), "up"],
         [
             "Stash derived",
             num(aggregates.memorySummary.derived),

package/dist/commands/health/windows.js

@@ -81,7 +81,6 @@ export const INTERESTING_DELTA_PATHS = [
     "improve.memoryInference.written",
     "improve.memoryInference.yieldRate",
     "improve.memoryInference.skippedNoFacts",
-    "improve.graphExtraction.failures",
     "improve.autoAccept.promoted",
     "improve.autoAccept.validationFailed",
     "improve.coverage.acceptedProposals",

package/dist/commands/health.js

@@ -19,6 +19,7 @@ import { getAllEntries } from "../storage/repositories/index-entries-repository.
 import { queryTaskHistory } from "../storage/repositories/task-history-repository.js";
 import { getStateDbFreelistInfo, runStateDbQuickCheck } from "../storage/state-db-integrity.js";
 import { pkgVersion } from "../version.js";
+import { collectArchiveUsageAdvisory } from "./health/archive-usage.js";
 import { HEALTH_CHECKS, probeActiveImproveStrategy, runHealthEngineProbes, runPendingStateMigrationsCheck, SESSION_EXTRACTION_LEDGER_WINDOW_DAYS, } from "./health/checks.js";
 import { collectConfigSkewAdvisory } from "./health/config-skew.js";
 import { collectDataDirUsageAdvisory } from "./health/data-dir-usage.js";
@@ -291,6 +292,18 @@ function gatherAncillaryAdvisories(db, options, egressConfigView) {
     catch {
         // Non-fatal.
     }
+    // Item 4 (alpha.9 plan §5.4/§8 step 8): a bundle with no git history of its
+    // own never gets the purge sweep, so its memory-cleanup archive only ever
+    // grows — report its size and file count instead. Best-effort — an
+    // unreadable archive must not abort the health report.
+    try {
+        const archiveUsage = collectArchiveUsageAdvisory(options.stashDir ?? resolveStashDir());
+        if (archiveUsage)
+            advisories.push(archiveUsage);
+    }
+    catch {
+        // Non-fatal.
+    }
     // #896: report the data dir's total size and its largest top-level
     // subdirectory, so a disk-usage blowup (e.g. unpruned migration snapshot
     // backups, #897) is self-diagnosing instead of requiring `du` archaeology.

package/dist/commands/improve/consolidate/continuity-check.js

@@ -0,0 +1,137 @@
+// 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/.
+import { searchLocal } from "../../../indexer/search/db-search.js";
+import { stripFrontmatterBody } from "../content-hash.js";
+import { stripBundle } from "../ledger.js";
+import { loadRetrievalQueries } from "../retrieval-gate.js";
+/** At most this many of the retired asset's most recent queries are replayed (plan §5.4, §7). */
+export const CONTINUITY_MAX_QUERIES = 5;
+/** "Top 10" per the plan's rule — both the pass/fail cutoff and the search `limit`. */
+export const CONTINUITY_TOP_N = 10;
+/**
+ * Builds the real search call the continuity check uses, stateful across
+ * every query asked of ONE instance (S2): the first time a query falls back
+ * to keyword-only ranking (`mode: "fts-fallback"` — most often a down or
+ * unreachable embedding endpoint), every later call through THIS instance
+ * forces `semanticSearchMode: "off"` instead of attempting semantic search
+ * again, so a dead endpoint costs one failed attempt per run, not one per
+ * remaining query (a hanging endpoint at ~3s/query, 300 proposals x 5
+ * queries, would otherwise cost on the order of an hour). Construct exactly
+ * one instance per pair-pass run and reuse it for every proposal judged, so
+ * the throttle covers the whole run, not just one proposal's own queries —
+ * and every call made once it has switched, across every remaining proposal
+ * in the run, reports `forcedKeywordOnly: true`, not just the one call that
+ * discovered the fallback (round-3 review: the first fix only marked THAT
+ * call unverified, so a second proposal checked while the endpoint was
+ * still down came back with a clean, `mode: "keyword"` — and therefore
+ * bulk-acceptable — result).
+ */
+export function createContinuitySearch(stashDir, config) {
+    const base = {
+        searchType: "any",
+        limit: CONTINUITY_TOP_N,
+        stashDir,
+        sources: [{ path: stashDir, isDefault: true }],
+    };
+    let keywordOnly = false;
+    return async (query) => {
+        const forcedKeywordOnly = keywordOnly;
+        const callConfig = keywordOnly ? { ...config, semanticSearchMode: "off" } : config;
+        const result = await searchLocal({ ...base, query, config: callConfig });
+        if (result.mode === "fts-fallback")
+            keywordOnly = true;
+        return { hits: result.hits, mode: result.mode, forcedKeywordOnly };
+    };
+}
+/** 1-indexed position of `conceptId` in `hits`, or `undefined` if it is not among them. */
+function rankOf(hits, conceptId) {
+    const index = hits.findIndex((hit) => stripBundle(hit.ref) === conceptId);
+    return index === -1 ? undefined : index + 1;
+}
+/** Body only, whitespace collapsed — the same shape `db-search.ts`'s own content-dedupe compares (S3b). */
+function normalizedBody(raw) {
+    return stripFrontmatterBody(raw).replace(/\s+/g, " ").trim();
+}
+/**
+ * Replay `retiredRef`'s own past queries and check that `successorRef` ranks
+ * in the top {@link CONTINUITY_TOP_N} for every one where the retired asset
+ * did. Returns `undefined` when there is nothing to flag: the two bodies are
+ * content-identical, no recorded queries, or every query ran on the real
+ * ranking and either the retired asset never ranked top 10 for it, or the
+ * survivor always did too. Never throws.
+ *
+ * S3: two fixes against false flags measured on a real night-1 admission
+ * (300 pairs, 6 flags, half spurious):
+ *  - queries are the SAME cleaned set `loadRetrievalQueries` replays for the
+ *    retrieval regression gate (`../retrieval-gate.ts`) — stash-README
+ *    boilerplate, harness/tool envelopes, pastes over 2,000 characters, and
+ *    duplicates are dropped before replay, not just capped at 5 raw entries;
+ *  - when the retired and successor bodies normalize identical, the check
+ *    never runs at all: search's own content-dedupe (`db-search.ts`) already
+ *    hides the successor behind the retired asset for every such query, so a
+ *    "successor missing from the top 10" finding here would not be a real
+ *    risk, just that dedupe working as designed.
+ *
+ * S2: a query that never ran (the search call threw), ran on the
+ * keyword-only fallback (`mode: "fts-fallback"` — the real ranking was
+ * attempted and failed, most often a down or unreachable embedding
+ * endpoint), or ran after the shared search instance had already switched
+ * to forced keyword-only because an EARLIER query in the same run fell back
+ * (`forcedKeywordOnly`) is "unverified" — it is dropped from the rank
+ * comparison below (its hits cannot be trusted as "the ranking a user
+ * actually gets"), but unlike a query the retired asset simply did not rank
+ * for, it can never by itself lead to a silent `undefined` — at least one
+ * unverified query always produces a `continuityRisk`, so a dead endpoint
+ * reads as "risk unknown" for every proposal it touches that run, never as
+ * "no risk found" for the ones checked after the first failure.
+ */
+export async function checkRetirementContinuity(args) {
+    // S3b: identical bodies — search's own content-dedupe already hides the
+    // successor for every query that would rank the retired asset, so there is
+    // no real risk here to check for.
+    if (normalizedBody(args.retiredRaw) === normalizedBody(args.successorRaw))
+        return undefined;
+    // S3a: the SAME cleaned queries the retrieval regression gate replays —
+    // boilerplate, envelopes, pastes and duplicates dropped before replay.
+    const queries = loadRetrievalQueries(args.ledgerAccess, args.retiredRef).slice(0, CONTINUITY_MAX_QUERIES);
+    if (queries.length === 0)
+        return undefined; // no queries recorded: no check, no flag
+    const search = args.search ?? createContinuitySearch(args.stashDir, args.config);
+    // N2: no rank-change-report abstraction — a query only ever needs "did the
+    // retired asset rank top 10, and if so, did the successor too?", and
+    // `rankOf` (search itself returning at most CONTINUITY_TOP_N hits) already
+    // answers both directly.
+    const ranks = [];
+    let unverifiedQueries = 0;
+    for (const query of queries) {
+        let hits;
+        try {
+            const result = await search(query);
+            if (result.mode === "fts-fallback" || result.forcedKeywordOnly) {
+                unverifiedQueries++; // S2: never silently compare keyword-only ranks
+                continue;
+            }
+            hits = result.hits;
+        }
+        catch {
+            unverifiedQueries++; // S2: a query that never ran cannot be "no risk"
+            continue;
+        }
+        const retiredRank = rankOf(hits, args.retiredRef);
+        if (retiredRank === undefined)
+            continue; // the retired asset itself did not rank top 10 here — nothing to protect
+        const successorRank = rankOf(hits, args.successorRef);
+        if (successorRank === undefined)
+            ranks.push({ query, retiredRank, successorRank: null });
+    }
+    // Every query verified, and either the retired asset never ranked top 10
+    // for any of them, or the survivor always did too: nothing to flag.
+    if (unverifiedQueries === 0 && ranks.length === 0)
+        return undefined;
+    return {
+        failingQueries: ranks.length,
+        ranks,
+        ...(unverifiedQueries > 0 ? { unverifiedQueries } : {}),
+    };
+}