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

package/dist/assets/templates/html/health.html

@@ -325,7 +325,7 @@
 
       <div class="chart-panel full-width">
         <h3>Per-Phase Wall Time Decomposition (stacked, min)</h3>
-        <div id="chartPhases" class="ec tall" role="img" aria-label="Stacked area chart decomposing wall time per run into consolidation, memory inference, graph extraction, and unattributed phases"></div>
+        <div id="chartPhases" class="ec tall" role="img" aria-label="Stacked area chart decomposing wall time per run into consolidation, memory inference, and unattributed phases"></div>
         <div class="empty-overlay" id="emptyPhases">No runs in the selected slice.</div>
       </div>
 
@@ -390,7 +390,7 @@
       <div class="table-wrap">
       <table>
         <thead>
-          <tr><th>Started</th><th>Task</th><th>Strategy</th><th>Wall</th><th>Promoted</th><th>Merged</th><th>Contradicted</th><th>MI Written</th><th>Entities</th><th>Lint Fixed</th><th>Status</th></tr>
+          <tr><th>Started</th><th>Task</th><th>Strategy</th><th>Wall</th><th>Promoted</th><th>Merged</th><th>Contradicted</th><th>MI Written</th><th>Lint Fixed</th><th>Status</th></tr>
         </thead>
         <tbody id="lastRunsTable"></tbody>
       </table>
@@ -539,7 +539,7 @@ mkChart('chartWallTime', {
 // ── 2. Per-phase wall time decomposition (stacked area) ──────────────────────
 mkChart('chartPhases', {
   tooltip: baseTooltip,
-  legend: { ...baseLegend, data: ['Consolidation', 'Memory inference', 'Graph extraction', 'Unattributed'] },
+  legend: { ...baseLegend, data: ['Consolidation', 'Memory inference', 'Unattributed'] },
   grid: denseGrid,
   dataZoom: denseZoom,
   xAxis: { type: 'category', data: xLabels, ...baseAxis },
@@ -547,7 +547,6 @@ mkChart('chartPhases', {
   series: [
     { name: 'Consolidation',    type: 'line', stack: 'p', areaStyle: { color: 'rgba(88,166,255,0.55)' },  lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.consDurationMs)) },
     { name: 'Memory inference', type: 'line', stack: 'p', areaStyle: { color: 'rgba(63,185,80,0.55)' },   lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.miDurationMs)) },
-    { name: 'Graph extraction', type: 'line', stack: 'p', areaStyle: { color: 'rgba(188,140,255,0.55)' }, lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.geDurationMs)) },
     { name: 'Unattributed',     type: 'line', stack: 'p', areaStyle: { color: 'rgba(210,153,34,0.45)' },  lineStyle: { width: 0 }, showSymbol: false, data: rs.map(r => toMin(r.otherMs)) },
   ],
 });
@@ -695,7 +694,6 @@ tbody.innerHTML = '';
     <td>${r.merged || 0}</td>
     <td style="color:${(r.contradicted||0)>5?'var(--yellow)':'var(--text)'};">${r.contradicted || 0}</td>
     <td style="color:var(--green);">${r.miWritten || 0}</td>
-    <td>${r.geEntities || 0}</td>
     <td>${r.lintFixed || 0}</td>
     <td>${badge}</td>
   `;

package/dist/cli/retired-commands.js

@@ -38,7 +38,7 @@ const RETIRED_COMMAND_HINTS = {
     events: "`akm events` moved in 0.9 — use `akm log`.",
     // Removed observability surfaces.
     history: "`akm history` was removed in 0.9 — use `akm log --ref <ref>` for an asset's event trail.",
-    graph: "`akm graph` was removed in 0.9 — graph counts appear in `akm health`; refresh extraction with `akm improve --strategy graph-refresh`.",
+    graph: "`akm graph` was removed in 0.9. The LLM entity graph it inspected was itself retired in 0.9.17-alpha.9 — use `akm show <ref>` for an asset's declared links.",
     lessons: "`akm lessons` was removed in 0.9 — lesson strength is indexed; use `akm search --type lesson`.",
     lesson: "`akm lesson` was removed in 0.9 — lesson strength is indexed; use `akm search --type lesson`.",
     // Relocated guidance / removed asset verbs.

package/dist/commands/health/archive-usage.js

@@ -0,0 +1,98 @@
+// 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/.
+/**
+ * `memory-cleanup-archive` advisory for `akm health` (item 4, 0.9.17-alpha.9
+ * plan §5.4/§8 step 8).
+ *
+ * Reports the archive's size and file count for every bundle, git-backed or
+ * not. A bundle with no `.git` of its own keeps every retirement's archived
+ * bytes forever (the purge sweep never runs there at all), so that alone is
+ * reported. A git-backed bundle can ALSO have bytes the purge sweep will
+ * never remove: `.git` presence alone does not prove a retirement was ever
+ * committed (`proposal accept` only commits for a `kind: "git"` write
+ * target, and a `kind: "filesystem"` bundle that merely happens to have a
+ * `.git` directory never gets one) — those bytes sit there indefinitely,
+ * however old they get, with nothing else to say so. This checks the SAME
+ * git state `purgeGracedArchive` checks (tracked, clean, verifiable) and
+ * reports how much of the archive fails it.
+ *
+ * Silent whenever there is nothing to say: the archive does not exist or is
+ * empty, or (for a git-backed bundle) every byte in it is purgeable once it
+ * ages out.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { MEMORY_ARCHIVE_REL } from "../../core/asset/memory-archive.js";
+import { toPosix } from "../../core/common.js";
+import { isGitBackedStash, tryListGitChangedPaths, tryListGitTrackedPaths, tryListGitUnverifiablePaths, } from "../../sources/providers/git-stash.js";
+import { MAX_WALK_ENTRIES, sizeOfPath } from "./data-dir-usage.js";
+/**
+ * Build the `memory-cleanup-archive` advisory, or `undefined` when there is
+ * nothing to report.
+ */
+export function collectArchiveUsageAdvisory(stashDir) {
+    const archiveRoot = path.join(stashDir, MEMORY_ARCHIVE_REL);
+    if (!fs.existsSync(archiveRoot))
+        return undefined;
+    if (!isGitBackedStash(stashDir)) {
+        const usage = sizeOfPath(archiveRoot, { remaining: MAX_WALK_ENTRIES });
+        if (usage.files === 0)
+            return undefined;
+        const lowerBound = usage.truncated ? ` (a lower bound — the walk stopped after ${MAX_WALK_ENTRIES} entries)` : "";
+        return {
+            name: "memory-cleanup-archive",
+            kind: "deterministic",
+            status: "pass",
+            confidence: "high",
+            message: `${usage.files} archived file(s), ${usage.bytes} byte(s)${lowerBound} in .akm/memory-cleanup/archive — ` +
+                "this bundle has no git history, so the purge sweep leaves it untouched.",
+            evidence: { files: usage.files, bytes: usage.bytes, truncated: usage.truncated },
+        };
+    }
+    // Git-backed: the SAME three checks purgeGracedArchive runs (B1, G10) —
+    // computed once here, not per file, and reused via `onFile` below instead
+    // of a second walk of the same tree.
+    const dirtyQuery = tryListGitChangedPaths(stashDir);
+    const trackedQuery = tryListGitTrackedPaths(stashDir, MEMORY_ARCHIVE_REL);
+    const unverifiableQuery = tryListGitUnverifiablePaths(stashDir, MEMORY_ARCHIVE_REL);
+    // A failed git check here fails the same way purgeGracedArchive's own
+    // sweep would: nothing in the archive can be proven purgeable, so every
+    // byte counts as unpurgeable rather than guessing.
+    const gitStateKnown = dirtyQuery.ok && trackedQuery.ok && unverifiableQuery.ok;
+    const dirty = new Set(dirtyQuery.paths);
+    const tracked = new Set(trackedQuery.paths);
+    const unverifiable = new Set(unverifiableQuery.paths);
+    let unpurgeableFiles = 0;
+    let unpurgeableBytes = 0;
+    const usage = sizeOfPath(archiveRoot, { remaining: MAX_WALK_ENTRIES }, (filePath, bytes) => {
+        const key = toPosix(path.relative(stashDir, filePath));
+        const safe = gitStateKnown && tracked.has(key) && !dirty.has(key) && !unverifiable.has(key);
+        if (!safe) {
+            unpurgeableFiles++;
+            unpurgeableBytes += bytes;
+        }
+    });
+    if (usage.files === 0)
+        return undefined;
+    if (unpurgeableFiles === 0)
+        return undefined; // everything here is purgeable once it ages out — nothing to say
+    const lowerBound = usage.truncated ? ` (a lower bound — the walk stopped after ${MAX_WALK_ENTRIES} entries)` : "";
+    return {
+        name: "memory-cleanup-archive",
+        kind: "deterministic",
+        status: "warn",
+        confidence: "high",
+        message: `${usage.files} archived file(s), ${usage.bytes} byte(s)${lowerBound} in .akm/memory-cleanup/archive; ` +
+            `${unpurgeableFiles} file(s), ${unpurgeableBytes} byte(s) of that cannot be purged (untracked, modified, ` +
+            "or unverifiable in git) — commit them so the purge sweep can remove them once they age out.",
+        evidence: {
+            files: usage.files,
+            bytes: usage.bytes,
+            truncated: usage.truncated,
+            unpurgeableFiles,
+            unpurgeableBytes,
+            gitStateKnown,
+        },
+    };
+}

package/dist/commands/health/data-dir-usage.js

@@ -41,7 +41,7 @@ const DOMINANT_SUBDIR_PERCENT_THRESHOLD = 50;
  * cap the walk stops descending further and the advisory says its size
  * figures are a lower bound.
  */
-const MAX_WALK_ENTRIES = 100_000;
+export const MAX_WALK_ENTRIES = 100_000;
 /**
  * Below this the data dir is not worth an opinion. The advisory exists for
  * disk blowups (74 GB in the incident); on a small directory a ratio is
@@ -59,31 +59,42 @@ function liveDbBytesFor(name, sizes) {
     return ((sizes.get(name)?.bytes ?? 0) + (sizes.get(`${name}-wal`)?.bytes ?? 0) + (sizes.get(`${name}-shm`)?.bytes ?? 0));
 }
 /**
- * Recursively sum file sizes under `root` (stat-only, symlinks not
- * followed so a cyclic or huge-target symlink can't blow up the walk).
- * `budget` is a shared mutable counter across the whole tree so the
- * `MAX_WALK_ENTRIES` cap applies to the walk as a whole, not per-branch.
+ * Recursively sum file sizes (and count files) under `root` (stat-only,
+ * symlinks not followed so a cyclic or huge-target symlink can't blow up the
+ * walk). `budget` is a shared mutable counter across the whole tree so the
+ * entry cap applies to the walk as a whole, not per-branch — callers
+ * typically pass {@link MAX_WALK_ENTRIES}, sized for this module's own data
+ * dir walk, but a smaller/larger budget is fine for a different tree.
+ * Shared with the `archive-usage` advisory (N2) — the same "don't let a
+ * pathological tree hang a health check" concern applies to both.
+ *
+ * `onFile`, when given, is called once per leaf file (path, bytes) as the
+ * walk visits it — `archive-usage` uses this to classify each file's git
+ * state without a second, separate walk of the same tree.
  */
-function sizeOfPath(root, budget) {
+export function sizeOfPath(root, budget, onFile) {
     let stat;
     try {
         stat = fs.lstatSync(root);
     }
     catch {
-        return { bytes: 0, truncated: false };
+        return { bytes: 0, files: 0, truncated: false };
     }
     if (stat.isSymbolicLink())
-        return { bytes: 0, truncated: false };
-    if (!stat.isDirectory())
-        return { bytes: stat.size, truncated: false };
+        return { bytes: 0, files: 0, truncated: false };
+    if (!stat.isDirectory()) {
+        onFile?.(root, stat.size);
+        return { bytes: stat.size, files: 1, truncated: false };
+    }
     let entries;
     try {
         entries = fs.readdirSync(root, { withFileTypes: true });
     }
     catch {
-        return { bytes: 0, truncated: false };
+        return { bytes: 0, files: 0, truncated: false };
     }
     let bytes = 0;
+    let files = 0;
     let truncated = false;
     for (const entry of entries) {
         if (budget.remaining <= 0) {
@@ -91,12 +102,13 @@ function sizeOfPath(root, budget) {
             break;
         }
         budget.remaining--;
-        const sub = sizeOfPath(path.join(root, entry.name), budget);
+        const sub = sizeOfPath(path.join(root, entry.name), budget, onFile);
         bytes += sub.bytes;
+        files += sub.files;
         if (sub.truncated)
             truncated = true;
     }
-    return { bytes, truncated };
+    return { bytes, files, truncated };
 }
 /** `1610612736` -> `"1.5G"`. Values under 10 in a unit keep one decimal; 10+ round to an integer. */
 function formatBytes(bytes) {

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

@@ -131,7 +131,6 @@ function renderExecSummary(vm) {
     const trendRows = [
         trendLi("Decision quality", vm.trend.decisionQuality),
         trendLi("Output volume", vm.trend.outputVolume),
-        trendLi("Failures", vm.trend.failures),
         trendLi("Latency", vm.trend.latency),
     ].join("");
     const deltaRows = [
@@ -151,7 +150,6 @@ function renderExecSummary(vm) {
             li("Promoted", String(vm.latest.promoted)),
             li("Judged: no action", `<abbr title="Candidates reviewed but intentionally left unchanged on this run.">${vm.latest.judgedNoAction}</abbr>`),
             li("MI written", String(vm.latest.miWritten)),
-            li("Graph entities/relations", `${vm.latest.geEntities} / ${vm.latest.geRelations}`),
         ].join("")
         : '<li><span class="k">No runs in window</span><span class="v">—</span></li>';
     const windowRows = [
@@ -197,7 +195,7 @@ function renderExecSummary(vm) {
       </div>
     </div>
     <div class="overall">Overall trend: <b>${esc(vm.trend.overall)}</b> ${overallEmoji}
-      &nbsp;·&nbsp; based on decision quality, output volume, failures, and latency ${vm.comparisonMode === "custom" ? "across the selected windows" : "vs the prior window"}.</div>`.trim();
+      &nbsp;·&nbsp; based on decision quality, output volume, and latency ${vm.comparisonMode === "custom" ? "across the selected windows" : "vs the prior window"}.</div>`.trim();
 }
 /**
  * Color is a health SIGNAL, not decoration: green/yellow/red where a card has
@@ -221,7 +219,6 @@ function renderKpiCards(vm) {
         kpiCard("neutral", "Median Duration", `${vm.medianDurMin}m`, `p95 = ${vm.p95DurMin}m`),
         kpiCard("blue", "Total Promoted", num(vm.consolidation.promoted), `avg ${vm.avgPromoted} / run`),
         kpiCard("blue", "MI Written", num(vm.miWritten), `${vm.miYieldRate} yield rate`),
-        kpiCard("purple", "Graph Entities", num(vm.graphExtraction.entities), `+${num(vm.graphExtraction.relations)} relations`),
         kpiCard("neutral", "Stash Derived", num(vm.memorySummary.derived), `of ${num(vm.memorySummary.eligible)} eligible (whole-stash)`),
         // #576: real LLM work — duration leads, tokens compact, not a GPU proxy.
         kpiCard(vm.llm.calls > 0 ? "purple" : "neutral", "🧠 LLM Work", `${vm.llmTokensCompact} tok`, `${fmtMs(vm.llm.totalDurationMs)} · ${num(vm.llm.calls)} calls · ${compact(vm.llm.reasoningTokens)} reasoning`),

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 } : {}),
+    };
+}