akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/commands/health/advisories.js

@@ -1,150 +0,0 @@
-// 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/.
-/**
- * Improve-pipeline advisories for `akm health`: projects the computed
- * {@link ImproveHealthMetrics} plus a few direct event reads into the
- * ordered advisory list.
- */
-import { readEvents } from "../../core/events.js";
-import { getLatestCycleMetrics } from "../../storage/repositories/canaries-repository.js";
-import { ENRICHMENT_MINTED_FAIL_SHARE, ENRICHMENT_MINTED_WARN_SHARE, } from "./types.js";
-/**
- * Build the improve-pipeline advisories for the health window from the already
- * computed {@link ImproveHealthMetrics} plus a few direct event reads. Pure
- * projection of state → advisories; emission order is preserved so the health
- * report is byte-identical to the previous inline construction.
- */
-export function collectImproveAdvisories(db, stateDbPath, since, improveSummary) {
-    const advisories = [];
-    // WS-2 proxy-adequacy tripwire: surface any outcome_proxy_inverted events
-    // in the health window as an advisory so operators know when the 0.10+
-    // rich in-session signal is no longer deferrable.
-    const proxyInvertedEvents = readEvents({ since, type: "outcome_proxy_inverted" }, { dbPath: stateDbPath }).events;
-    if (proxyInvertedEvents.length > 0) {
-        const lastEvent = proxyInvertedEvents[proxyInvertedEvents.length - 1];
-        const correlation = typeof lastEvent.metadata?.correlation === "number" ? lastEvent.metadata.correlation.toFixed(3) : "unknown";
-        advisories.push({
-            name: "outcome-proxy-adequacy",
-            status: "warn",
-            kind: "deterministic",
-            confidence: "high",
-            message: `WS-2 outcome proxy inverted (${proxyInvertedEvents.length} event(s) in window). ` +
-                `corr(outcome_score, accepted_change_rate) = ${correlation} < −0.3. ` +
-                "Popular assets are also the most-needing-improvement assets — " +
-                "the retrieval-based proxy is inverted. " +
-                "The 0.10+ rich in-session outcome signal is no longer deferrable. See plan §WS-2.",
-        });
-    }
-    // Two-tailed companion: a proxy that decays to noise (|corr| < 0.1 at scale)
-    // is as much a failure as an inverted one — it just fails silently.
-    const proxyDeadEvents = readEvents({ since, type: "outcome_proxy_dead" }, { dbPath: stateDbPath, db }).events;
-    if (proxyDeadEvents.length > 0) {
-        const lastEvent = proxyDeadEvents[proxyDeadEvents.length - 1];
-        const correlation = typeof lastEvent.metadata?.correlation === "number" ? lastEvent.metadata.correlation.toFixed(3) : "unknown";
-        advisories.push({
-            name: "outcome-proxy-dead",
-            status: "warn",
-            kind: "deterministic",
-            confidence: "high",
-            message: `WS-2 outcome proxy is DEAD (${proxyDeadEvents.length} event(s) in window). ` +
-                `|corr(outcome_score, accepted_change_rate)| = ${correlation} < 0.1 at n ≥ 500. ` +
-                "outcome_score is statistically unrelated to improvement outcomes — " +
-                "treat outcome-derived rank contributions as noise until a real usage/outcome signal lands.",
-        });
-    }
-    // Salience-distribution collapse across all assets with retrieval evidence.
-    if (improveSummary.degradation?.salienceUniformityFlagged) {
-        const sampleSize = improveSummary.degradation.retrievalSalienceSampleSize;
-        advisories.push({
-            name: "salience-uniformity-collapse",
-            status: "warn",
-            kind: "deterministic",
-            confidence: "high",
-            message: `Salience distribution collapsed toward uniform: retrieval_salience Gini = ` +
-                `${improveSummary.degradation.corpusCentroidDistance} < 0.08 across ${sampleSize} ` +
-                "observed, resolvable assets. Ranking carries little discrimination among assets with retrieval evidence.",
-        });
-    }
-    // Enrichment-vs-minting policy: enrichment lanes edit existing assets;
-    // a rising minted share means a lane is generating new content instead.
-    const minting = improveSummary.enrichmentMinting;
-    if (minting && Number.isFinite(minting.share) && minting.share > ENRICHMENT_MINTED_WARN_SHARE) {
-        advisories.push({
-            name: "enrichment-lane-minting",
-            status: minting.share > ENRICHMENT_MINTED_FAIL_SHARE ? "fail" : "warn",
-            kind: "deterministic",
-            confidence: "high",
-            message: `Enrichment lanes minted ${minting.minted} NEW asset(s) vs ${minting.updated} update(s) ` +
-                `(${Math.round(minting.share * 100)}% minted, threshold ${Math.round(ENRICHMENT_MINTED_WARN_SHARE * 100)}%). ` +
-                "Enrichment-classed lanes (proactive/high-salience/signal-delta) are ratified to edit " +
-                "existing assets only — new-asset generation belongs to the signal-gated minting lanes.",
-        });
-    }
-    // Churn: accepted proposals far exceeding distinct touched refs means the
-    // loop is repeatedly rewriting the same assets, not covering the corpus.
-    if (Number.isFinite(improveSummary.coverage.churnRatio) && improveSummary.coverage.churnRatio > 1.5) {
-        advisories.push({
-            name: "improve-churn-ratio",
-            status: "warn",
-            kind: "deterministic",
-            confidence: "high",
-            message: `Improve churn ratio ${improveSummary.coverage.churnRatio} > 1.5: ` +
-                `${improveSummary.coverage.acceptedProposals} accepted proposals touched only ` +
-                `${improveSummary.coverage.distinctRefs} distinct assets in the window — ` +
-                "repeated rewrites of the same refs count as churn, not coverage.",
-        });
-    }
-    // R5 collapse/churn detector: surface any collapse_detector_alert events
-    // in the health window, plus the latest cycle row's headline numbers so
-    // the operator can act without opening the DB. `unknown` when the detector
-    // has never produced a cycle row (no consolidate work yet).
-    try {
-        // Reuse the already-open state.db handle (readEvents supports a
-        // borrowed connection) — no extra open/migrate/close per health call.
-        const collapseAlertEvents = readEvents({ since, type: "collapse_detector_alert" }, { dbPath: stateDbPath, db }).events;
-        const latestCycle = getLatestCycleMetrics(db);
-        const cycleSummary = latestCycle
-            ? `Latest cycle (${latestCycle.ts}, ${latestCycle.pass}): mean canary recall ${latestCycle.mean_recall.toFixed(3)}, ` +
-                `distinct-content ratio ${latestCycle.distinct_content_ratio.toFixed(3)}.`
-            : "";
-        if (collapseAlertEvents.length > 0) {
-            const kinds = [...new Set(collapseAlertEvents.map((e) => String(e.metadata?.kind ?? "unknown")))];
-            const collapseKinds = kinds.filter((k) => k.startsWith("collapse"));
-            advisories.push({
-                name: "collapse-churn-detector",
-                status: "warn",
-                kind: "deterministic",
-                // Collapse kinds are measured, not inferred; the merge-floor
-                // volume threshold is still being tuned (design doc §7).
-                confidence: collapseKinds.length > 0 ? "high" : "medium",
-                message: `R5 detector fired ${collapseAlertEvents.length} alert(s) in window (kinds: ${kinds.join(", ")}). ` +
-                    `${cycleSummary} See docs/architecture/specs/improve-collapse-churn-detector-design.md §6.3 runbook queries.`,
-            });
-        }
-        else if (latestCycle) {
-            advisories.push({
-                name: "collapse-churn-detector",
-                status: "pass",
-                kind: "deterministic",
-                confidence: "high",
-                message: `No collapse/churn alerts in window. ${cycleSummary}`,
-            });
-        }
-        else {
-            advisories.push({
-                name: "collapse-churn-detector",
-                status: "unknown",
-                kind: "deterministic",
-                confidence: "high",
-                message: "No detector cycle rows yet — the collapse/churn detector runs only on improve cycles " +
-                    "where consolidate did work.",
-            });
-        }
-    }
-    catch {
-        // Table may predate migration 016 in odd mixed-version setups — advisory
-        // is best-effort and must never fail the health command.
-    }
-    return advisories;
-}

package/dist/commands/health/metrics.js

@@ -1,329 +0,0 @@
-// 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/.
-/**
- * State.db-backed health metrics for `akm health`: the round-trip probe,
- * denominator-fixed coverage, the enrichment-vs-minting rollup, and the WS-5
- * per-run degradation metrics.
- */
-import { rethrowIfTestIsolationError } from "../../core/errors.js";
-import { decodeImproveResult } from "../../core/improve-result.js";
-import { withStateDb } from "../../core/state-db.js";
-import { insertEvent } from "../../storage/repositories/events-repository.js";
-import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
-import { listStateProposals } from "../../storage/repositories/proposals-repository.js";
-import { getObservedRetrievalSalience } from "../../storage/repositories/salience-repository.js";
-import { roundRate, toFiniteNumber } from "./improve-metrics.js";
-import { ENRICHMENT_LANES, } from "./types.js";
-/** Event type appended + read back by the state.db round-trip probe. */
-const HEALTH_PROBE_EVENT = "health_probe";
-/**
- * Retrieval-salience Gini guardrails.
- *
- * These are distribution-shape thresholds, not quantiles tied to a corpus
- * size. Synthetic anchors pinned in monitor-liveness.test.ts are ~0.01 for a
- * near-uniform two-band distribution, 0.25 for a balanced 0.25/0.75 spread,
- * and ~0.82 for one dominant value among nine 0.01 values. Full-observation
- * production snapshots also sit stably in the neutral band: 0.2613 at n=1,209
- * (2026-07-12) and 0.2506 at n=1,454 (2026-08-17, missing rows excluded).
- */
-const SALIENCE_UNIFORMITY_GINI_THRESHOLD = 0.08;
-const SALIENCE_ENTRENCHMENT_GINI_THRESHOLD = 0.35;
-/** Synthetic sentinel ref (ref-grammar decision D-R3): a colon-free
- * `<subsystem>/_<marker>` label. `health` has no asset stash-subdir, so
- * `health/_probe` names the subsystem. */
-const HEALTH_PROBE_REF = "health/_probe";
-/**
- * Verify state.db can accept a write and read it back — WITHOUT leaving any
- * permanent trace (R-030). Earlier versions appended a `health_probe` event
- * on every `akm health` invocation and never removed it: a read-only health
- * check ran on a cron would grow state.db without bound (the only purge is
- * `improve`'s retention pass, which a health-only user never runs). The probe
- * row inserted here is deleted again inside the SAME connection once the
- * round trip is confirmed, so the net effect on the `events` table is always
- * zero rows — the round trip still genuinely exercises append + read against
- * the real table, it just doesn't accumulate.
- */
-export function probeStateDbRoundTrip(stateDbPath) {
-    const started = Date.now();
-    try {
-        return withStateDb((db) => {
-            const ts = new Date().toISOString();
-            const insertedId = insertEvent(db, {
-                eventType: HEALTH_PROBE_EVENT,
-                ts,
-                ref: HEALTH_PROBE_REF,
-                metadata: { source: "akm health" },
-            });
-            const durationMs = Date.now() - started;
-            if (insertedId === undefined) {
-                return { ok: false, durationMs, error: "probe event insert did not return a row id" };
-            }
-            // The round-trip matches on the exact (id, eventType, ref) triple
-            // written above, then removes the row regardless of outcome — a
-            // failed round trip must not leak a row any more than a successful
-            // one should.
-            let roundTripOk = false;
-            try {
-                const row = db
-                    .prepare("SELECT 1 AS present FROM events WHERE id = ? AND event_type = ? AND ref = ?")
-                    .get(insertedId, HEALTH_PROBE_EVENT, HEALTH_PROBE_REF);
-                roundTripOk = row !== undefined;
-            }
-            finally {
-                db.prepare("DELETE FROM events WHERE id = ?").run(insertedId);
-            }
-            if (!roundTripOk) {
-                return { ok: false, durationMs, error: "probe event was not readable after append" };
-            }
-            return { ok: true, durationMs };
-        }, { path: stateDbPath });
-    }
-    catch (err) {
-        rethrowIfTestIsolationError(err);
-        return { ok: false, durationMs: Date.now() - started, error: err instanceof Error ? err.message : String(err) };
-    }
-}
-// ── WS-5 Observability helpers ───────────────────────────────────────────────
-/**
- * Compute WS-5 denominator-fixed coverage metrics.
- *
- * `coverage = accepted_proposals / total_assets` (Part V §3).
- * The denominator is the TOTAL stash size (not the moving eligible set) so
- * more-inclusive WS-1 ranking cannot spuriously inflate coverage.
- * `eligibleFraction = eligible_assets / total_assets` is reported separately.
- *
- * Proposals are counted only when their `updatedAt` falls within `[since, until)`
- * so the rate is genuinely window-scoped (matching the JSDoc on the type).
- *
- * @param db - Open state.db connection.
- * @param totalAssets - Total stash asset count (eligible + derived) from the
- *   most recent run's memorySummary. 0 = denominator unknown, returns NaN rates.
- * @param eligibleAssets - Eligible (non-derived) asset count from the most recent run.
- * @param since - Window start (ISO-8601). Proposals accepted before this are excluded.
- * @param until - Window end (ISO-8601, exclusive). Absent = open-ended (up to now).
- * @param stashDir - Optional: scope accepted proposals to one stash. Absent = all stashes.
- */
-export function computeDenominatorFixedCoverage(db, totalAssets, eligibleAssets, since, until, stashDir) {
-    let acceptedProposals = 0;
-    let distinctRefs = 0;
-    try {
-        const proposals = listStateProposals(db, {
-            status: "accepted",
-            ...(stashDir ? { stashDir } : {}),
-        }).filter((p) => {
-            const updatedAt = p.updatedAt ?? "";
-            if (updatedAt < since)
-                return false;
-            if (until !== undefined && updatedAt >= until)
-                return false;
-            return true;
-        });
-        acceptedProposals = proposals.length;
-        // Coverage counts DISTINCT refs: N accepted rewrites of one asset are
-        // churn, not coverage. The raw proposal count is kept alongside so the
-        // churn ratio (proposals ÷ distinct refs) stays visible.
-        distinctRefs = new Set(proposals.map((p) => p.ref)).size;
-    }
-    catch {
-        // Fail open: table may not exist on older installs.
-    }
-    const churnRatio = distinctRefs > 0 ? roundRate(acceptedProposals / distinctRefs) : Number.NaN;
-    if (totalAssets === 0) {
-        return {
-            rate: Number.NaN,
-            eligibleFraction: Number.NaN,
-            acceptedProposals,
-            distinctRefs,
-            churnRatio,
-            totalAssets: 0,
-        };
-    }
-    return {
-        rate: roundRate(distinctRefs / totalAssets),
-        eligibleFraction: roundRate(eligibleAssets / totalAssets),
-        acceptedProposals,
-        distinctRefs,
-        churnRatio,
-        totalAssets,
-    };
-}
-/**
- * Compute the enrichment-vs-minting rollup over the window's accepted,
- * lane-attributed proposals (reporting-only; see {@link EnrichmentMintingRollup}).
- *
- * SQL-side `json_extract` keeps the (potentially large) `backupContent` blobs
- * out of process memory. Pre-Phase-6C rows without an `eligibilitySource`
- * cannot be lane-classified and are excluded. Fails open (undefined) when the
- * proposals table is absent.
- */
-export function computeEnrichmentMintingRollup(db, since, until) {
-    try {
-        const rows = db
-            .prepare(`SELECT
-           json_extract(metadata_json, '$.eligibilitySource') AS lane,
-           CASE WHEN json_extract(metadata_json, '$.backupContent') IS NULL THEN 1 ELSE 0 END AS is_minted,
-           COUNT(*) AS cnt
-         FROM proposals
-         WHERE status = 'accepted'
-           AND updated_at >= ?
-           AND (? IS NULL OR updated_at < ?)
-           AND json_extract(metadata_json, '$.eligibilitySource') IS NOT NULL
-           AND json_extract(metadata_json, '$.eligibilitySource') != ''
-         GROUP BY lane, is_minted`)
-            .all(since, until ?? null, until ?? null);
-        if (rows.length === 0)
-            return undefined;
-        const byLane = {};
-        for (const row of rows) {
-            byLane[row.lane] ??= { minted: 0, updated: 0 };
-            const entry = byLane[row.lane];
-            if (row.is_minted === 1)
-                entry.minted += row.cnt;
-            else
-                entry.updated += row.cnt;
-        }
-        let minted = 0;
-        let updated = 0;
-        for (const lane of ENRICHMENT_LANES) {
-            const entry = byLane[lane];
-            if (!entry)
-                continue;
-            minted += entry.minted;
-            updated += entry.updated;
-        }
-        const decided = minted + updated;
-        return {
-            minted,
-            updated,
-            share: decided > 0 ? roundRate(minted / decided) : Number.NaN,
-            byLane,
-        };
-    }
-    catch {
-        // Fail open: proposals table may not exist on older installs.
-        return undefined;
-    }
-}
-/**
- * Compute WS-5 per-run degradation metrics (Part V §4).
- *
- * Health VIEWS only — reads from state.db tables populated by prior improve
- * runs. Gracefully returns partial data when tables are absent (pre-WS-1/2).
- *
- * @param db - Open state.db connection.
- * @param since - Window start (ISO-8601).
- * @param until - Window end (ISO-8601).
- */
-export function computeDegradationMetrics(db, since, until) {
-    // (a) Corpus diversity — distribution of every observed retrieval-salience
-    // value for a currently resolvable asset. Zero is the no-observation floor
-    // and is excluded: the diagnostic measures discrimination among assets that
-    // have a retrieval signal, not corpus coverage.
-    //
-    // Do not preselect by rank_score here. The old top-100 sample truncated the
-    // distribution before measuring it, producing a low Gini even when the full
-    // observed corpus had a healthy spread.
-    let corpusCentroidDistance = Number.NaN;
-    let retrievalSalienceSampleSize = 0;
-    let entrenchmentFlagged;
-    let salienceUniformityFlagged;
-    try {
-        // Fail-open: the asset_salience table may not exist yet (pre-WS-1 install).
-        const rows = getObservedRetrievalSalience(db);
-        retrievalSalienceSampleSize = rows.length;
-        if (rows.length >= 5) {
-            // The repository returns ascending values. Keep a defensive sort so the
-            // O(n log n) closed-form Gini remains correct if that contract changes.
-            const vals = rows.map((r) => r.retrieval_salience).sort((a, b) => a - b);
-            const n = vals.length;
-            const sum = vals.reduce((acc, value) => acc + value, 0);
-            const weightedSum = vals.reduce((acc, value, index) => acc + (index + 1) * value, 0);
-            // Closed-form Gini for sorted non-negative values. This is O(n log n)
-            // including the defensive sort; the previous pairwise implementation
-            // was O(n²) and only safe because the sample was capped at 100.
-            const gini = sum > 0 ? (2 * weightedSum) / (n * sum) - (n + 1) / n : 0;
-            // Re-express as a diversity proxy in [0,1]: high gini = low diversity.
-            // corpusCentroidDistance approximation: gini is "distance from uniform".
-            // Two-tailed: high concentration flags entrenchment; very low spread
-            // flags near-uniformity. Calibration provenance is documented with the
-            // constants above and pinned by synthetic distribution tests.
-            corpusCentroidDistance = roundRate(gini);
-            entrenchmentFlagged = gini > SALIENCE_ENTRENCHMENT_GINI_THRESHOLD;
-            salienceUniformityFlagged = gini < SALIENCE_UNIFORMITY_GINI_THRESHOLD;
-        }
-    }
-    catch {
-        // Table not present (pre-WS-1 install) — leave NaN.
-    }
-    // (b) Merge fidelity — fraction of consolidate accepted proposals in the window
-    // whose ref also has a consolidate skip-reason of "contradict_target_missing"
-    // or an event indicating contradiction. Uses the improve_runs result_json
-    // consolidation.contradicted count as a proxy.
-    // Simple implementation: contradictionRate = total_contradicted / max(1, total_processed)
-    // sourced from the window's consolidation envelope.
-    // (The full "merge proposal → later contradiction" correlation requires cross-run
-    // history; this is the available proxy.)
-    let mergeFidelityContradictionRate = 0;
-    try {
-        const runs = queryImproveRuns(db, since, until);
-        let totalContradicted = 0;
-        let totalProcessed = 0;
-        for (const row of runs) {
-            try {
-                const result = decodeImproveResult(row.result_json).envelope;
-                const cons = result.consolidation;
-                if (cons) {
-                    totalContradicted += toFiniteNumber(cons.contradicted);
-                    totalProcessed += toFiniteNumber(cons.processed);
-                }
-            }
-            catch {
-                // Skip malformed rows.
-            }
-        }
-        if (totalProcessed > 0) {
-            mergeFidelityContradictionRate = roundRate(totalContradicted / totalProcessed);
-        }
-    }
-    catch {
-        // Fail open.
-    }
-    // (c) highGenerationFraction was DELETED (meta-review 05 DRIFT-3): it
-    // approximated "LLM-merge generations" from consecutive_no_ops — which counts
-    // the opposite condition (cycles where nothing was changed) — and its own
-    // in-code TODO admitted the proxy. Display-only, never actionable; removed
-    // rather than instrumented.
-    // (d) Oracle spot-check — up to 5 recently accepted proposals in the window.
-    const oracleSpotCheck = [];
-    try {
-        const accepted = listStateProposals(db, { status: "accepted" }).filter((p) => {
-            const updatedAt = p.updatedAt ?? "";
-            return updatedAt >= since && updatedAt < until;
-        });
-        // Sample up to 5: pick evenly spaced (not just the first 5).
-        const step = Math.max(1, Math.floor(accepted.length / 5));
-        for (let i = 0; i < accepted.length && oracleSpotCheck.length < 5; i += step) {
-            const p = accepted[i];
-            if (p) {
-                oracleSpotCheck.push({
-                    proposalId: p.id,
-                    ref: p.ref,
-                    source: p.source ?? "unknown",
-                    acceptedAt: p.updatedAt ?? p.createdAt ?? "",
-                });
-            }
-        }
-    }
-    catch {
-        // Fail open.
-    }
-    return {
-        corpusCentroidDistance,
-        retrievalSalienceSampleSize,
-        entrenchmentFlagged,
-        salienceUniformityFlagged,
-        mergeFidelityContradictionRate,
-        oracleSpotCheck,
-    };
-}

package/dist/commands/health/surfaces.js

@@ -1,102 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * The 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 two read-only checks the adjudication approved:
- *
- *   - `binary-config-skew`  — config.json written by a NEWER akm than this binary (F3)
- *   - `egress-endpoints`    — the remote-destination list, for eyeball diff (surfaces 3/9)
- *
- * Every collector is a pure projection over injected paths/config (no
- * process.env reads) and is silent when there is nothing to report, matching
- * the stash-exposure pattern. `egress-endpoints` is the one informational
- * (pass-status) entry: it emits whenever any remote endpoint is configured.
- */
-import { readTextFile } from "../../core/common.js";
-import { CURRENT_CONFIG_VERSION } from "../../core/config/config-schema.js";
-import { compareConfigVersion } from "../../core/config/config-version.js";
-import { formatRegistryUrl } from "../../core/registry-url.js";
-/**
- * `binary-config-skew` (08-F3): warn when config.json carries a configVersion
- * NEWER than (or unorderable against) this binary's CURRENT_CONFIG_VERSION —
- * i.e. a newer/foreign akm wrote the shared config and this install is stale.
- * That is the proven multi-install incident class. Silent for current or older
- * versions and unreadable configs (config loading surfaces its own errors).
- */
-export function collectConfigSkewAdvisory(configPath) {
-    let raw;
-    try {
-        raw = JSON.parse(readTextFile(configPath, "Config file"));
-    }
-    catch {
-        return undefined;
-    }
-    const onDisk = raw.configVersion;
-    const order = compareConfigVersion(onDisk, CURRENT_CONFIG_VERSION);
-    const skewed = order === 1 || (onDisk !== undefined && order === undefined);
-    if (!skewed)
-        return undefined;
-    return {
-        name: "binary-config-skew",
-        kind: "deterministic",
-        status: "warn",
-        confidence: "high",
-        message: `config.json has configVersion ${JSON.stringify(onDisk)} but this binary knows ${CURRENT_CONFIG_VERSION} — ` +
-            "a newer akm wrote the shared config, so this install is stale. Upgrade this install; do not keep a stale " +
-            "binary against the shared config/DBs.",
-        evidence: { onDiskConfigVersion: onDisk, binaryConfigVersion: CURRENT_CONFIG_VERSION },
-    };
-}
-/**
- * `egress-endpoints` (08 surfaces 3/9): the full list of remote destinations
- * akm can talk to under the effective config — registries, remote sources,
- * LLM endpoints, embedding endpoint — as one pass-status informational entry
- * for eyeball diff against expectations. Silent only when nothing remote is
- * configured at all.
- */
-export function collectEgressAdvisory(config) {
-    if (!config)
-        return undefined;
-    const endpoints = [];
-    for (const reg of config.registries ?? []) {
-        if (reg.enabled === false || !reg.url)
-            continue;
-        endpoints.push(`registry ${reg.name ?? "(unnamed)"}: ${formatRegistryUrl(reg.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 ${key} (${bundle.git ? "git" : "website"}): ${url}`);
-    }
-    for (const [name, engine] of Object.entries(config.engines ?? {})) {
-        if (engine?.kind !== "llm" || !engine.endpoint)
-            continue;
-        endpoints.push(`llm ${name}: ${engine.endpoint}`);
-    }
-    if (config.embedding?.endpoint)
-        endpoints.push(`embedding: ${config.embedding.endpoint}`);
-    if (endpoints.length === 0)
-        return undefined;
-    return {
-        name: "egress-endpoints",
-        kind: "deterministic",
-        status: "pass",
-        confidence: "high",
-        message: `${endpoints.length} remote endpoint(s) in the effective config (registries/sources/LLM/embedding) — ` +
-            "review the evidence list for unexpected destinations.",
-        evidence: { endpoints },
-    };
-}
-/**
- * Aggregate the two collectors into the advisories array shape `akmHealth`
- * consumes. Order is fixed: skew → egress.
- */
-export function collectSurfacesAdvisories(input) {
-    const results = [collectConfigSkewAdvisory(input.configPath), collectEgressAdvisory(input.config)];
-    return results.filter((r) => r !== undefined);
-}

package/dist/commands/improve/anti-collapse.js

@@ -1,83 +0,0 @@
-// 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/.
-/**
- * WS-3b Step 8 — Anti-collapse merge guards.
- *
- *   (a) Generation counter: merged.generation = max(sources)+1; merges cite
- *       sources. `over_generation_count` (collapse-detector.ts) tracks assets
- *       above the generation threshold as an advisory metric only — there is
- *       no merge-refusal path wired in.
- *   (b) Lexical-diversity check: low n-gram diversity ⇒ raise merge threshold.
- *   (d) Occasional random non-similar cluster in the pool.
- *
- * @module anti-collapse
- */
-/** Default max generation depth before merge is refused. */
-export const DEFAULT_MAX_GENERATION = 2;
-/** Default fraction of pool to fill with random (non-similar) clusters. */
-export const DEFAULT_RANDOM_CLUSTER_FRACTION = 0.05;
-/**
- * Read the `generation` field from an asset's frontmatter.
- * Returns 0 when absent (no generation metadata = original asset).
- */
-export function readAssetGeneration(frontmatterData) {
-    const gen = frontmatterData.generation;
-    if (typeof gen === "number" && Number.isFinite(gen) && gen >= 0) {
-        return Math.floor(gen);
-    }
-    return 0;
-}
-/**
- * Compute the new generation for a merged asset.
- * Rule: `merged.generation = max(source generations) + 1`.
- */
-export function computeMergedGeneration(sourceGenerations) {
-    if (sourceGenerations.length === 0)
-        return 1;
-    return Math.max(...sourceGenerations) + 1;
-}
-/**
- * Compute the bigram n-gram diversity of a text string.
- * Returns a value in [0, 1] where 0 = all identical bigrams, 1 = all unique.
- * Used by the lexical-diversity check to detect correlated-extraction artifacts.
- */
-export function computeBigramDiversity(text) {
-    const words = text
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((w) => w.length > 0);
-    if (words.length < 2)
-        return 1; // too short to have bigrams; treat as diverse
-    const total = words.length - 1;
-    const unique = new Set();
-    for (let i = 0; i < total; i++) {
-        unique.add(`${words[i]}\t${words[i + 1]}`);
-    }
-    return unique.size / total;
-}
-/**
- * Check whether a cluster of memories exhibits suspiciously low lexical diversity.
- * When true, the cluster is likely a correlated-extraction artifact; the merge
- * threshold should be raised.
- *
- * @param bodies - The stripped body texts of the cluster members.
- * @param config - Anti-collapse config.
- * @returns `{ lowDiversity: true, diversity }` when the cluster diversity is
- *   below the 0.3 threshold; `{ lowDiversity: false }` otherwise.
- */
-export function checkLexicalDiversity(bodies, config) {
-    // R5: default ON — only an explicit opt-out disables the check.
-    if (config.enabled === false || config.lexicalDiversityCheck === false) {
-        return { lowDiversity: false };
-    }
-    if (bodies.length === 0)
-        return { lowDiversity: false };
-    // Average bigram diversity across all bodies in the cluster.
-    const avg = bodies.reduce((sum, b) => sum + computeBigramDiversity(b), 0) / bodies.length;
-    const DIVERSITY_FLOOR = 0.3;
-    if (avg < DIVERSITY_FLOOR) {
-        return { lowDiversity: true, diversity: avg };
-    }
-    return { lowDiversity: false };
-}