akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

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

@@ -0,0 +1,508 @@
+// 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/.
+/**
+ * Pure `AkmHealthResult` (+ report options) → `HealthReportViewModel`
+ * extractor for the health HTML report (chunk-9 WI-9.5a / H2, anchors C.6).
+ *
+ * Every computed number, string, boolean, and series the report shows is
+ * derived here — deltas, trends, staleness, rate/duration formatting, the
+ * synthesized verdict components, the summary-table rows, the action-item
+ * inputs. NOTHING in this module emits HTML: `html-report.ts` holds the thin
+ * VM→HTML fragment renderers that consume this shape (`buildEchartsTag`,
+ * `isoTimeTag`, the `<li>`/card builders, …).
+ *
+ * Determinism: nothing here depends on Date.now()/Math.random(). Runs are
+ * sorted by startedAt so the view model — and therefore the rendered report —
+ * is byte-identical for identical inputs.
+ */
+import { TASK_FAIL_RATE_WARN, } from "./types.js";
+/** Distill skip-reasons hidden from the breakdown chart (steady-state noise). */
+const DISTILL_REASONS_HIDDEN = new Set(["no new signal since last proposal"]);
+// ── Small pure formatters (ports of render.py helpers; no HTML) ─────────────
+export function num(value) {
+    return Math.round(value).toLocaleString("en-US");
+}
+/** Compact token/count formatter, e.g. 127345 → "127K", 1_500_000 → "1.5M". */
+export function compact(value) {
+    const v = Math.round(value);
+    if (Math.abs(v) >= 1_000_000)
+        return `${(v / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+    if (Math.abs(v) >= 1_000)
+        return `${(v / 1_000).toFixed(1).replace(/\.0$/, "")}K`;
+    return String(v);
+}
+/** Humanize a camelCase / kebab / snake enum into reader-facing text. */
+export function humanize(raw) {
+    return raw
+        .replace(/[-_]/g, " ")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/^./, (c) => c.toUpperCase());
+}
+export function fmtMs(ms) {
+    return ms ? `${(ms / 60000).toFixed(1)}m` : "—";
+}
+export function pct(rate, digits) {
+    return `${(rate * 100).toFixed(digits)}%`;
+}
+/** pctChange may be a number or an "+inf"/"-inf" sentinel (prior window was 0). */
+function coercePct(raw) {
+    if (typeof raw === "number")
+        return raw;
+    if (typeof raw !== "string")
+        return undefined;
+    const s = raw.trim().toLowerCase();
+    if (s === "+inf" || s === "inf" || s === "infinity" || s === "+infinity")
+        return 1e9;
+    if (s === "-inf" || s === "-infinity")
+        return -1e9;
+    const parsed = Number.parseFloat(s.replace(/%$/, ""));
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+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",
+        resultComplete: r.resultComplete ?? (r.resultStatus === undefined || r.resultStatus === "valid"),
+        taskId: r.taskId ?? "manual",
+        strategy: r.strategy,
+        startedAt: r.startedAt,
+        completedAt: r.completedAt,
+        wallTimeMs: wall,
+        ok: r.ok,
+        mode: r.scope.mode,
+        consDurationMs: consMs,
+        miDurationMs: miMs,
+        geDurationMs: geMs,
+        otherMs: Math.max(0, wall - consMs - miMs - geMs),
+        consRan: cons.ran,
+        promoted: cons.promoted,
+        merged: cons.merged,
+        deleted: cons.deleted,
+        contradicted: cons.contradicted,
+        judgedNoAction: cons.judgedNoAction,
+        processed: cons.processed,
+        failedChunks: cons.failedChunks,
+        totalChunks: cons.totalChunks,
+        miWritten: mi.written,
+        miConsidered: mi.considered,
+        miYieldRate: mi.yieldRate,
+        miCacheHits: mi.cacheHits,
+        geEntities: ge.entities,
+        geRelations: ge.relations,
+        geCacheHitRate: ge.cacheHitRate,
+        geFailures: ge.failures,
+        distillSkipped: r.actions.distill.skipped,
+        distillQueued: r.actions.distill.queued,
+        distillLlmFailed: r.actions.distill.llmFailed,
+        distillByReason: r.actions.distill.skippedByReason,
+        reflectOk: r.actions.reflect.ok,
+        reflectFailed: r.actions.reflect.failed,
+        derived: r.memorySummary.derived,
+        eligible: r.memorySummary.eligible,
+        lintFlagged: r.lintFlagged,
+        lintFixed: r.lintFixed,
+        reflectsWithErrorContext: r.reflectsWithErrorContext,
+        orphansPurged: r.orphansPurged,
+        evalCasesWritten: r.evalCasesWritten,
+    };
+}
+function compareRuns(a, b) {
+    return (a.startedAt.localeCompare(b.startedAt) || a.completedAt.localeCompare(b.completedAt) || a.id.localeCompare(b.id));
+}
+// ── Trend classification (port of collect.py classify) ──────────────────────
+function classify(deltas, metricKeys, lowerIsBetter = false) {
+    const changes = metricKeys
+        .map((key) => coercePct(deltas[key]?.pctChange))
+        .filter((c) => c !== undefined);
+    if (changes.length === 0)
+        return "flat";
+    const avg = changes.reduce((acc, c) => acc + c, 0) / changes.length;
+    if (Math.abs(avg) < 5)
+        return "flat";
+    const direction = avg > 0 ? "up" : "down";
+    if (lowerIsBetter)
+        return avg > 0 ? "down" : "up";
+    return direction;
+}
+function buildTrend(deltas) {
+    const decisionQuality = classify(deltas, ["improve.memoryInference.yieldRate", "improve.consolidation.promoted"]);
+    const outputVolume = classify(deltas, [
+        "improve.consolidation.promoted",
+        "improve.memoryInference.written",
+        "improve.sessionExtraction.proposalsCreated",
+    ]);
+    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 overall = score >= 1 ? "improving" : score <= -1 ? "degrading" : "mixed";
+    return { decisionQuality, outputVolume, failures, latency, overall };
+}
+function readSemSearch(advisories) {
+    const check = advisories.find((a) => a.name === "semantic-search-runtime");
+    if (!check)
+        return { blocked: false, detail: "" };
+    const evidence = check.evidence ?? {};
+    const status = String(evidence.status ?? "unknown");
+    const blocked = check.status !== "pass" || status.toLowerCase().includes("block");
+    const entries = typeof evidence.entryCount === "number" ? evidence.entryCount : 0;
+    const embeddings = typeof evidence.embeddingCount === "number" ? evidence.embeddingCount : 0;
+    return { blocked, detail: `${num(entries)} entries, ${num(embeddings)} embeddings` };
+}
+// ── Report-window → time-slice candidates (data only; HTML wrapping is the
+//    renderer's job) ─────────────────────────────────────────────────────────
+/** Parse an akm window string (`24h`, `7d`, `30m`, `2w`) to milliseconds; 0 if unparseable. */
+export function windowToMs(window) {
+    const m = /^(\d+)\s*([mhdw])$/i.exec(window.trim());
+    if (!m)
+        return 0;
+    const n = Number(m[1]);
+    const mult = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 }[m[2].toLowerCase()] ?? 0;
+    return n * mult;
+}
+/**
+ * Candidate sub-window slices strictly shorter than the report window,
+ * largest-first, capped at 4 — the data half of the filter bar's `<option>`s
+ * (the "All" option and the `<option>` tags themselves are the renderer's job).
+ */
+function computeSliceCandidates(window) {
+    const windowMs = windowToMs(window);
+    const HOUR = 3_600_000;
+    const DAY = 86_400_000;
+    const candidates = [
+        [6 * HOUR, "6h"],
+        [12 * HOUR, "12h"],
+        [DAY, "1d"],
+        [3 * DAY, "3d"],
+        [7 * DAY, "7d"],
+        [14 * DAY, "14d"],
+    ];
+    return candidates
+        .filter(([ms]) => windowMs > 0 && ms < windowMs)
+        .sort((a, b) => b[0] - a[0])
+        .slice(0, 4);
+}
+function partitionRuns(result) {
+    const allRuns = (result.runs ?? []).map(reshapeRun).sort(compareRuns);
+    return {
+        invalidRuns: allRuns.filter((run) => run.resultStatus === "invalid"),
+        runs: allRuns.filter((run) => run.resultStatus !== "invalid"),
+    };
+}
+/** Aggregates (collect.py step 6) + the WS-5 sub-rollups + their formatted-rate strings. */
+function buildAggregatesPhase(result, runsPhase) {
+    const { runs, invalidRuns } = runsPhase;
+    const improve = result.improve;
+    const cons = improve.consolidation;
+    const mi = improve.memoryInference;
+    const ge = improve.graphExtraction;
+    const wallTime = improve.wallTime;
+    // WS-5: perf telemetry, coverage, and degradation metrics.
+    const perf = improve.perfTelemetry ?? {
+        dedupPoolSize: 0,
+        llmPoolSize: 0,
+        embedMs: 0,
+        embedCacheHits: 0,
+        embedCacheMisses: 0,
+        overBudgetRuns: 0,
+        runsWithTelemetry: 0,
+    };
+    const coverage = improve.coverage;
+    const degradation = improve.degradation;
+    const minting = improve.enrichmentMinting;
+    // #576: real per-stage LLM token/time accounting (replaces the GPU-time
+    // proxy). Optional-guarded so reports built from older health JSON without
+    // the aggregate still render.
+    const llm = result.metrics.llmUsage ?? {
+        calls: 0,
+        totalDurationMs: 0,
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+        reasoningTokens: 0,
+        byStage: {},
+        byProcess: {},
+        byEngine: {},
+    };
+    const totalRuns = runs.length;
+    const failedRuns = runs.filter((r) => !r.ok).length;
+    const invoked = improve.invoked || totalRuns;
+    const completed = improve.completed || totalRuns - failedRuns;
+    const miWritten = mi.written;
+    return {
+        consolidation: cons,
+        memoryInference: mi,
+        graphExtraction: ge,
+        wallTime,
+        perf,
+        coverage,
+        degradation,
+        minting,
+        llm,
+        memorySummary: improve.memorySummary,
+        includedResultRows: improve.resultRows?.included ?? totalRuns,
+        skippedInvalidResultRows: improve.resultRows?.skipped.invalid ?? invalidRuns.length,
+        invoked,
+        completed,
+        miWritten,
+        completionRate: invoked ? `${Math.round((100 * completed) / invoked)}%` : "0%",
+        completionPct: invoked ? (100 * completed) / invoked : 100,
+        taskFailRate: pct(result.metrics.taskFailRate, 1),
+        agentFailRate: pct(result.metrics.agentFailureRate, 2),
+        miYieldRate: pct(mi.yieldRate, 1),
+        medianDurMin: (wallTime.medianMs / 60000).toFixed(1),
+        p95DurMin: (wallTime.p95Ms / 60000).toFixed(1),
+        avgPromoted: totalRuns ? String(Math.round(cons.promoted / totalRuns)) : "0",
+        chunkFail: `${num(cons.failedChunks)} / ${num(cons.totalChunks)}`,
+        llmTokensCompact: compact(llm.totalTokens),
+        totalRuns,
+        failedRuns,
+    };
+}
+/**
+ * Meta (collect.py steps 10-11) + freshness. Staleness is computed
+ * deterministically (no Date.now()) from the gap between the window start
+ * (`since`) and the newest run we have: if no run landed in the window, or
+ * the newest run sits in the first 25% of a window wider than the 6h
+ * threshold (i.e. a long idle tail), we flag stale.
+ */
+function buildMetaPhase(result, runs) {
+    const sinceIso = result.since;
+    const reportDate = sinceIso.slice(0, 10);
+    const reportTitle = reportDate ? `AKM Health Report — ${reportDate}` : "AKM Health Report";
+    const lastRun = runs[runs.length - 1];
+    const generatedAt = lastRun ? lastRun.completedAt || lastRun.startedAt || sinceIso : sinceIso;
+    const latest = [...runs]
+        .filter((run) => run.resultComplete)
+        .sort(compareRuns)
+        .at(-1);
+    const STALE_MS = 6 * 60 * 60 * 1000;
+    const latestRunMs = lastRun ? Date.parse(lastRun.completedAt || lastRun.startedAt) : NaN;
+    const sinceMs = Date.parse(sinceIso);
+    const generatedMs = Date.parse(generatedAt);
+    const idleTailMs = Number.isFinite(latestRunMs) && Number.isFinite(generatedMs) ? Math.max(0, generatedMs - latestRunMs) : 0;
+    const isStale = runs.length === 0 || (Number.isFinite(latestRunMs) && Number.isFinite(sinceMs) && idleTailMs > STALE_MS);
+    return { sinceIso, reportDate, reportTitle, generatedAt, isStale, lastRun, latest };
+}
+const STATUS_LABEL = { pass: "PASS", warn: "WARN", fail: "FAIL" };
+/**
+ * Synthesized verdict (one sentence + 2-3 drivers). The verdict WORD is the
+ * authoritative health status (hard checks). Concerns (failed improve runs,
+ * blocked search, pending proposals) are advisory and do NOT gate that word,
+ * so a green PASS is never paired with red "drivers" as if they were
+ * failures. When the status is PASS we frame concerns as "watch:" alongside
+ * the trend; only a degraded status (WARN/FAIL) leads with them.
+ */
+function buildVerdictPhase(result, trend, sem, proposals, failedRuns) {
+    const statusLabel = STATUS_LABEL[result.status];
+    const failOk = result.metrics.taskFailRate < TASK_FAIL_RATE_WARN;
+    const concerns = [];
+    if (failedRuns > 0)
+        concerns.push(`${failedRuns} failed run${failedRuns === 1 ? "" : "s"}`);
+    if (sem.blocked)
+        concerns.push("semantic search blocked");
+    if (proposals.length > 0)
+        concerns.push(`${proposals.length} pending proposal${proposals.length === 1 ? "" : "s"}`);
+    const trendClause = trend.overall === "improving"
+        ? "throughput and latency improving"
+        : trend.overall === "degrading"
+            ? "throughput or latency degrading"
+            : "throughput and latency steady";
+    const verdictWord = statusLabel;
+    let verdictRest;
+    if (result.status === "pass") {
+        const watch = concerns.length > 0 ? `; watch: ${concerns.slice(0, 3).join(", ")}` : "";
+        verdictRest = `healthy, ${trendClause}${watch}`;
+    }
+    else {
+        const lead = concerns.length > 0 ? concerns.slice(0, 3).join("; ") : trendClause;
+        verdictRest = trend.overall === "degrading" && concerns.length > 0 ? `${lead}; ${trendClause}` : lead;
+    }
+    return { status: result.status, failOk, statusLabel, concerns, trendClause, verdictWord, verdictRest };
+}
+/** Distill skip-reason chart categories (collect.py chart payload step). */
+function computeDistillReasons(runs) {
+    return [...new Set(runs.flatMap((r) => Object.keys(r.distillByReason)))]
+        .filter((reason) => !DISTILL_REASONS_HIDDEN.has(reason))
+        .sort();
+}
+/** Proposals grouped by `source`, sorted alphabetically (drain-proposals action item). */
+function groupProposalsBySource(proposals) {
+    const bySource = new Map();
+    for (const p of proposals)
+        bySource.set(p.source, (bySource.get(p.source) ?? 0) + 1);
+    return [...bySource.entries()].sort(([a], [b]) => a.localeCompare(b));
+}
+/** 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, minting, perf, degradation } = aggregates;
+    const summaryRows = [
+        ["Task fail rate", aggregates.taskFailRate, "flat"],
+        ["Agent fail rate", aggregates.agentFailRate, "flat"],
+        ["Improve completion", `${num(aggregates.completed)} / ${num(aggregates.invoked)}`, "flat"],
+        [
+            "MI yield rate",
+            aggregates.miYieldRate,
+            trend.decisionQuality,
+            "Memory-inference yield: share of considered candidates that produced a written fact.",
+        ],
+        ["MI written", num(aggregates.miWritten), trend.outputVolume, "Memory-inference: facts written this window."],
+        ["Consolidation promoted", num(cons.promoted), trend.outputVolume],
+        ["Consolidation merged", num(cons.merged), "flat"],
+        ["Consolidation deleted", num(cons.deleted), "flat"],
+        ["Consolidation contradicted", num(cons.contradicted), "flat"],
+        [
+            "Consolidation judged: no action",
+            num(cons.judgedNoAction),
+            "flat",
+            "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),
+            "up",
+            "Whole-bundle recount of derived assets at report time — not a per-run sum.",
+        ],
+        ["Median wall time", fmtMs(wallTime.medianMs), trend.latency],
+        ["P95 wall time", fmtMs(wallTime.p95Ms), trend.latency],
+        // #576: real LLM accounting (replaces the GPU-time proxy).
+        ["LLM calls", num(llm.calls), "flat"],
+        ["LLM total tokens", num(llm.totalTokens), "flat"],
+        ["LLM prompt tokens", num(llm.promptTokens), "flat"],
+        ["LLM completion tokens", num(llm.completionTokens), "flat"],
+        [
+            "LLM reasoning tokens",
+            num(llm.reasoningTokens),
+            "flat",
+            "Tokens spent on model reasoning/thinking, billed separately from prompt and completion.",
+        ],
+        ["LLM wall time", fmtMs(llm.totalDurationMs), trend.latency],
+    ];
+    // WS-5: denominator-fixed coverage rows (only when we have real data).
+    if (coverage && !Number.isNaN(coverage.rate)) {
+        summaryRows.push([
+            "Coverage rate",
+            pct(coverage.rate, 1),
+            "flat",
+            "Distinct accepted refs / total stash assets (denominator-fixed). Shows what fraction of the corpus has been touched.",
+        ], [
+            "Eligible fraction",
+            pct(coverage.eligibleFraction, 1),
+            "flat",
+            "Eligible assets / total stash assets. Fraction the improve pipeline actively considers.",
+        ], [
+            "Coverage accepted",
+            num(coverage.acceptedProposals),
+            "flat",
+            "Total accepted proposals in the window (raw volume — includes repeated rewrites of the same asset).",
+        ], [
+            "Churn ratio",
+            Number.isFinite(coverage.churnRatio) ? num(coverage.churnRatio) : "—",
+            Number.isFinite(coverage.churnRatio) && coverage.churnRatio > 1.5 ? "down" : "flat",
+            "Accepted proposals / distinct refs touched. >1.5 = the loop is repeatedly rewriting the same assets (churn, not coverage).",
+        ]);
+    }
+    // Enrichment-vs-minting policy rollup (reporting-only).
+    if (minting && Number.isFinite(minting.share)) {
+        summaryRows.push([
+            "Enrichment-lane minted share",
+            pct(minting.share, 1),
+            minting.share > 0.05 ? "down" : "flat",
+            `New assets minted by enrichment lanes / their accepted total (${minting.minted} minted vs ${minting.updated} updated). Enrichment lanes are ratified to edit existing assets only; WARN >5%, FAIL >15%.`,
+        ]);
+    }
+    // WS-5: perf telemetry rows (only when at least one run reported telemetry).
+    if (perf.runsWithTelemetry > 0) {
+        const embedCacheTotal = perf.embedCacheHits + perf.embedCacheMisses;
+        const embedCacheHitRate = embedCacheTotal > 0 ? pct(perf.embedCacheHits / embedCacheTotal, 1) : "—";
+        summaryRows.push([
+            "Embed cache hit rate",
+            embedCacheHitRate,
+            "flat",
+            "Fraction of embedding lookups served from cache (>95% is healthy). Aggregated across WS-5 runs.",
+        ], [
+            "Embed wall time",
+            fmtMs(perf.embedMs),
+            "flat",
+            "Cumulative embedding wall-clock time across consolidation runs in the window.",
+        ], [
+            "Dedup pool size",
+            num(perf.dedupPoolSize),
+            "flat",
+            "Memory pool size after incremental narrowing, before the limit cap. WS-5 perf telemetry.",
+        ], [
+            "Over-budget consolidation runs",
+            String(perf.overBudgetRuns),
+            perf.overBudgetRuns > 0 ? "down" : "flat",
+            "Runs where consolidation alone exceeded the total run budget (estimatedBudgetFractionUsed > 1.0).",
+        ]);
+    }
+    // WS-5: degradation metrics rows.
+    if (degradation) {
+        summaryRows.push([
+            "Corpus diversity (Gini)",
+            num(degradation.corpusCentroidDistance),
+            degradation.entrenchmentFlagged || degradation.salienceUniformityFlagged ? "down" : "flat",
+            "Gini coefficient of retrieval_salience for top-100 ranked assets. Two-tailed: >0.35 = entrenchment risk; <0.08 = collapsed toward uniform (ranking no longer discriminates).",
+        ], [
+            "Merge fidelity contradiction rate",
+            pct(degradation.mergeFidelityContradictionRate, 1),
+            "flat",
+            "Fraction of consolidated proposals that involved a contradiction, from consolidation result envelopes.",
+        ]);
+    }
+    return summaryRows;
+}
+/**
+ * Extract the health HTML report's view model from an `AkmHealthResult` +
+ * report options. Pure — no HTML, no I/O, no clock/RNG reads. Byte-identical
+ * output for identical inputs, mirroring the pre-split
+ * `buildHealthHtmlReplacements` arithmetic exactly. File-level decomposed
+ * (chunk-9 WI-9.5a) into one phase helper per section above; this function is
+ * the extract-then-compose glue.
+ */
+export function buildHealthReportViewModel(result, opts) {
+    const deltas = opts.deltas ?? {};
+    const proposals = opts.proposals;
+    const runsPhase = partitionRuns(result);
+    const sem = readSemSearch(result.advisories);
+    const trend = buildTrend(deltas);
+    const aggregates = buildAggregatesPhase(result, runsPhase);
+    const meta = buildMetaPhase(result, runsPhase.runs);
+    const verdict = buildVerdictPhase(result, trend, sem, proposals, aggregates.failedRuns);
+    const distillReasons = computeDistillReasons(runsPhase.runs);
+    const proposalsBySource = groupProposalsBySource(proposals);
+    const summaryRows = buildSummaryRows(aggregates, trend);
+    return {
+        window: opts.window,
+        compare: opts.compare,
+        comparisonMode: opts.comparisonMode ?? "duration",
+        ...meta,
+        runs: runsPhase.runs,
+        invalidRuns: runsPhase.invalidRuns,
+        ...verdict,
+        ...aggregates,
+        trend,
+        deltas,
+        sem,
+        proposals,
+        proposalsBySource,
+        summaryRows,
+        sliceCandidates: computeSliceCandidates(opts.window),
+        distillReasons,
+        advisories: result.advisories,
+        sessionLogAdvisories: result.sessionLogAdvisories,
+    };
+}

package/dist/commands/health/stash-exposure.js

@@ -40,7 +40,7 @@ export function collectStashExposureAdvisory(stashDir, git = realGit) {
         message: `${trackedFiles.length} env/secret file(s) are git-tracked AND a remote is configured — ` +
             `a 'git push' can leak tokens/keys (${preview}). ` +
             "Run 'git rm --cached' on them (a .gitignore rule alone does NOT untrack already-tracked " +
-            "files) and then add env/+secrets/ to .gitignore to prevent recurrence (akm init scaffolds it).",
+            "files) and then add env/+secrets/ to .gitignore to prevent recurrence (akm bundle create scaffolds it).",
         evidence: { trackedSecretFiles: trackedFiles },
     };
 }

package/dist/commands/health/surfaces.js

@@ -4,11 +4,10 @@
 /**
  * The remaining `surfaces` advisory group for `akm health` (meta-review 08).
  * `stash-git-exposure` (08-F1) shipped first in ./stash-exposure.ts; this
- * module adds the other four read-only checks the adjudication approved:
+ * module adds the other three read-only checks the adjudication approved:
  *
  *   - `secret-file-perms`   — env/secret/backup files not 0600, dirs not 0700 (F4)
  *   - `binary-config-skew`  — config.json written by a NEWER akm than this binary (F3)
- *   - `orphan-stores`       — legacy config-backups dirs + 0-byte stash state.db decoy (F4/F7)
  *   - `egress-endpoints`    — the remote-destination list, for eyeball diff (surfaces 3/9)
  *
  * Every collector is a pure projection over injected paths/config (no
@@ -18,7 +17,9 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { CURRENT_CONFIG_VERSION, compareConfigVersion } from "../../core/config/config-migration.js";
+import { MAX_CONFIG_FILE_BYTES, readTextFileWithLimit } from "../../core/common.js";
+import { CURRENT_CONFIG_VERSION } from "../../core/config/config-schema.js";
+import { compareConfigVersion } from "../../core/config/config-version.js";
 const GROUP_OTHER_BITS = 0o077;
 const OFFENDER_EVIDENCE_CAP = 50;
 function modeOctal(mode) {
@@ -97,7 +98,7 @@ export function collectSecretPermsAdvisory(input, platform = process.platform) {
 export function collectConfigSkewAdvisory(configPath) {
     let raw;
     try {
-        raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        raw = JSON.parse(readTextFileWithLimit(configPath, MAX_CONFIG_FILE_BYTES, "Config file"));
     }
     catch {
         return undefined;
@@ -118,49 +119,6 @@ export function collectConfigSkewAdvisory(configPath) {
         evidence: { onDiskConfigVersion: onDisk, binaryConfigVersion: CURRENT_CONFIG_VERSION },
     };
 }
-/**
- * `orphan-stores` (08-F4/F7): stores that look load-bearing but are dead —
- * legacy `config-backups/` dirs in $DATA/$CONFIG (only `$CACHE/config-backups`
- * is written and pruned today) and a 0-byte `<stash>/.akm/state.db` decoy that
- * misleads debugging (the live state.db lives in the data dir). Read-only:
- * this advisory NAMES them; removal stays an owner-approved per-path action.
- */
-export function collectOrphanStoresAdvisory(input) {
-    const orphans = [];
-    for (const [label, dir] of [
-        ["legacy data-dir backup location", path.join(input.dataDir, "config-backups")],
-        ["legacy config-dir backup location", path.join(input.configDir, "config-backups")],
-    ]) {
-        try {
-            if (fs.statSync(dir).isDirectory())
-                orphans.push(`${dir}/ (${label}; live backups are in $CACHE/config-backups)`);
-        }
-        catch {
-            // absent — fine
-        }
-    }
-    const decoy = path.join(input.stashDir, ".akm", "state.db");
-    try {
-        const stat = fs.statSync(decoy);
-        if (stat.isFile() && stat.size === 0) {
-            orphans.push(`${decoy} (0-byte decoy; the live state.db is in the data dir)`);
-        }
-    }
-    catch {
-        // absent — fine
-    }
-    if (orphans.length === 0)
-        return undefined;
-    return {
-        name: "orphan-stores",
-        kind: "deterministic",
-        status: "warn",
-        confidence: "high",
-        message: `${orphans.length} orphan store(s) found: ${orphans.join("; ")}. ` +
-            "These are dead locations that mislead debugging/recovery — review and remove them (owner-approved, per-path).",
-        evidence: { orphans },
-    };
-}
 /**
  * `egress-endpoints` (08 surfaces 3/9): the full list of remote destinations
  * akm can talk to under the effective config — registries, remote sources,
@@ -177,15 +135,18 @@ export function collectEgressAdvisory(config) {
             continue;
         endpoints.push(`registry ${reg.name ?? "(unnamed)"}: ${reg.url}`);
     }
-    for (const source of config.sources ?? []) {
-        if (source.enabled === false || !source.url)
+    for (const [key, bundle] of Object.entries(config.bundles ?? {})) {
+        if (!bundle)
+            continue;
+        const url = bundle.git ?? bundle.website?.url;
+        if (!url)
             continue;
-        endpoints.push(`source ${source.name ?? "(unnamed)"} (${source.type ?? "?"}): ${source.url}`);
+        endpoints.push(`source ${key} (${bundle.git ? "git" : "website"}): ${url}`);
     }
-    for (const [name, profile] of Object.entries(config.profiles?.llm ?? {})) {
-        if (!profile?.endpoint)
+    for (const [name, engine] of Object.entries(config.engines ?? {})) {
+        if (engine?.kind !== "llm" || !engine.endpoint)
             continue;
-        endpoints.push(`llm ${name}: ${profile.endpoint}`);
+        endpoints.push(`llm ${name}: ${engine.endpoint}`);
     }
     if (config.embedding?.endpoint)
         endpoints.push(`embedding: ${config.embedding.endpoint}`);
@@ -202,14 +163,13 @@ export function collectEgressAdvisory(config) {
     };
 }
 /**
- * Aggregate the four collectors into the advisories array shape `akmHealth`
- * consumes. Order is fixed: perms → skew → orphans → egress.
+ * Aggregate the three collectors into the advisories array shape `akmHealth`
+ * consumes. Order is fixed: perms → skew → egress.
  */
 export function collectSurfacesAdvisories(input) {
     const results = [
         collectSecretPermsAdvisory({ stashDir: input.stashDir, cacheDir: input.cacheDir }, input.platform ?? process.platform),
         collectConfigSkewAdvisory(input.configPath),
-        collectOrphanStoresAdvisory({ dataDir: input.dataDir, configDir: input.configDir, stashDir: input.stashDir }),
         collectEgressAdvisory(input.config),
     ];
     return results.filter((r) => r !== undefined);