akm-cli 0.9.0-rc.1 → 0.9.0-rc.3

package/dist/commands/health/checks.js

@@ -2,111 +2,227 @@
 // 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 { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
 import { loadConfig } from "../../core/config/config.js";
-import { detectAgentCliProfiles, requireAgentProfile } from "../../integrations/agent/index.js";
+import { resolveEngine } from "../../integrations/agent/engine-resolution.js";
+import { resolveModel } from "../../integrations/agent/model-aliases.js";
+import { resolveImprovePlan } from "../improve/improve-strategies.js";
 import { TASK_FAIL_RATE_WARN, } from "./types.js";
 const ACTIVE_RUN_WARN_MS = 15 * 60 * 1000;
-/**
- * Probe the configured agent profile. Self-contained (reads config + PATH); the
- * only check that performs IO at dispatch time, preserving the original inline
- * `runAgentProbe()` call site behaviour exactly.
- */
-export function runAgentProbe() {
-    const config = loadConfig();
-    // v2: check profiles.agent first
-    if (config.profiles?.agent) {
-        const defaultName = config.defaults?.agent;
-        const profileCount = Object.keys(config.profiles.agent).length;
-        if (profileCount === 0) {
-            return {
-                name: "agent-profile",
-                kind: "deterministic",
-                status: "unknown",
-                confidence: "high",
-                message: "No agent profiles configured in profiles.agent.",
-            };
-        }
-        const profileName = defaultName ?? Object.keys(config.profiles.agent)[0];
-        const profile = config.profiles.agent[profileName];
+function credentialAvailable(credential, env) {
+    return !credential?.required || credential.names.some((name) => Boolean(env[name]?.trim()));
+}
+function runConfiguredEngineProbe(checkName, engineName, config, deps) {
+    if (!engineName) {
         return {
-            name: "agent-profile",
+            name: checkName,
             kind: "deterministic",
-            status: "pass",
+            status: "unknown",
             confidence: "high",
-            message: `v2 agent profile "${profileName}" configured (platform: ${profile?.platform ?? "unknown"}).`,
-            evidence: { profile: profileName, platform: profile?.platform, profileCount },
+            message: checkName === "default-llm-engine"
+                ? "No default LLM engine is configured."
+                : "No default engine is configured.",
         };
     }
-    if (!config.profiles?.agent && !config.defaults?.agent) {
+    const env = deps.env ?? process.env;
+    const configuredEngine = config.engines?.[engineName];
+    if (configuredEngine?.kind === "agent" && configuredEngine.platform === "opencode-sdk") {
+        let packageAvailable = false;
+        try {
+            const resolvePackage = deps.resolvePackage ?? ((name) => createRequire(import.meta.url).resolve(name));
+            resolvePackage("@opencode-ai/sdk");
+            packageAvailable = true;
+        }
+        catch {
+            packageAvailable = false;
+        }
+        const binary = configuredEngine.bin ?? "opencode";
+        const version = (deps.spawnSync ?? spawnSync)(binary, ["--version"], { encoding: "utf8", timeout: 5_000 });
+        const binaryAvailable = (version.status ?? 1) === 0;
+        const fallbackEngine = configuredEngine.llmEngine ?? config.defaults?.llmEngine;
+        let fallback;
+        let fallbackCredential;
+        let sdkRunner;
+        const resolve = deps.resolveEngine ?? resolveEngine;
+        try {
+            const resolved = resolve(engineName, config);
+            if (resolved.kind === "sdk")
+                sdkRunner = resolved;
+        }
+        catch {
+            sdkRunner = undefined;
+        }
+        if (sdkRunner?.fallbackConnection) {
+            fallback = { kind: "llm", connection: sdkRunner.fallbackConnection };
+            fallbackCredential = sdkRunner.fallbackCredential;
+        }
+        else if (fallbackEngine) {
+            try {
+                const resolved = resolve(fallbackEngine, config);
+                if (resolved.kind === "llm") {
+                    fallback = resolved;
+                    fallbackCredential = resolved.credential;
+                }
+            }
+            catch {
+                fallback = undefined;
+            }
+        }
+        const configuredModel = configuredEngine.model
+            ? resolveModel(configuredEngine.model, "opencode-sdk", configuredEngine.modelAliases, config.modelAliases)
+            : undefined;
+        const effectiveModel = sdkRunner?.profile.model ?? configuredModel ?? fallback?.connection.model;
+        const fallbackCredentialAvailable = credentialAvailable(fallbackCredential, env);
+        const missing = [
+            !packageAvailable ? "@opencode-ai/sdk package" : undefined,
+            !binaryAvailable ? `${binary} binary` : undefined,
+            fallbackEngine && !fallback ? "configured fallback LLM connection" : undefined,
+            !fallbackCredentialAvailable ? "required fallback credential" : undefined,
+        ].filter((value) => value !== undefined);
         return {
-            name: "agent-profile",
+            name: checkName,
             kind: "deterministic",
-            status: "unknown",
+            status: missing.length === 0 ? "pass" : "warn",
             confidence: "high",
-            message: "No agent config present.",
+            message: missing.length === 0
+                ? `SDK engine "${engineName}" is available.`
+                : `SDK engine "${engineName}" is incomplete: missing ${missing.join(", ")}.`,
+            evidence: {
+                engine: engineName,
+                platform: configuredEngine.platform,
+                runtimeKind: "sdk",
+                binary,
+                binaryAvailable,
+                package: "@opencode-ai/sdk",
+                packageAvailable,
+                model: effectiveModel ?? null,
+                configuredModel: configuredModel ?? null,
+                modelSource: configuredModel ? "sdk" : effectiveModel ? "fallback" : null,
+                fallbackEngine: fallbackEngine ?? null,
+                fallbackEndpoint: fallback?.connection.endpoint ?? null,
+                fallbackModel: fallback?.connection.model ?? null,
+                requiredCredentialAvailable: fallbackCredentialAvailable,
+            },
         };
     }
-    let profile;
     try {
-        profile = requireAgentProfile(config);
-    }
-    catch (error) {
+        const runner = (deps.resolveEngine ?? resolveEngine)(engineName, config);
+        if (runner.kind === "llm") {
+            const requiredCredentialAvailable = credentialAvailable(runner.credential, env);
+            return {
+                name: checkName,
+                kind: "deterministic",
+                status: requiredCredentialAvailable ? "pass" : "warn",
+                confidence: "high",
+                message: requiredCredentialAvailable
+                    ? `LLM engine "${engineName}" is configured.`
+                    : `LLM engine "${engineName}" is configured, but its required credential is unavailable.`,
+                evidence: {
+                    engine: engineName,
+                    platform: null,
+                    runtimeKind: "llm",
+                    model: runner.connection.model,
+                    endpoint: runner.connection.endpoint,
+                    requiredCredentialAvailable,
+                },
+            };
+        }
+        const profile = runner.profile;
+        if (runner.kind === "sdk")
+            throw new Error(`SDK engine "${engineName}" has no matching SDK config.`);
+        const version = (deps.spawnSync ?? spawnSync)(profile.bin, ["--version"], { encoding: "utf8", timeout: 5_000 });
+        if ((version.status ?? 1) !== 0) {
+            return {
+                name: checkName,
+                kind: "deterministic",
+                status: "warn",
+                confidence: "medium",
+                message: `Agent engine "${engineName}" was found but \`--version\` failed.`,
+                evidence: {
+                    engine: engineName,
+                    platform: profile.platform ?? null,
+                    runtimeKind: "agent",
+                    model: profile.model ?? null,
+                },
+            };
+        }
         return {
-            name: "agent-profile",
+            name: checkName,
             kind: "deterministic",
-            status: "warn",
+            status: "pass",
             confidence: "high",
-            message: error instanceof Error ? error.message : String(error),
+            message: `Agent engine "${engineName}" is available.`,
+            evidence: {
+                engine: engineName,
+                platform: profile.platform ?? null,
+                runtimeKind: "agent",
+                model: profile.model ?? null,
+            },
         };
     }
-    if (profile.sdkMode === true) {
+    catch (error) {
         return {
-            name: "agent-profile",
+            name: checkName,
             kind: "deterministic",
-            status: profile.model ? "pass" : "warn",
+            status: "warn",
             confidence: "high",
-            message: profile.model
-                ? `SDK mode profile "${profile.name}" is configured.`
-                : `SDK mode profile "${profile.name}" has no explicit model.`,
-            evidence: { profile: profile.name, sdkMode: true, model: profile.model ?? null },
+            message: error instanceof Error ? error.message : String(error),
         };
     }
-    const detections = detectAgentCliProfiles(config);
-    const detection = detections.find((entry) => entry.name === profile.name);
-    if (!detection?.available) {
+}
+export function runDefaultEngineProbe(deps = {}) {
+    const config = deps.loadConfig?.() ?? loadConfig();
+    return runConfiguredEngineProbe("default-engine", config.defaults?.engine, config, deps);
+}
+export function runDefaultLlmEngineProbe(deps = {}) {
+    const config = deps.loadConfig?.() ?? loadConfig();
+    return runConfiguredEngineProbe("default-llm-engine", config.defaults?.llmEngine, config, deps);
+}
+export function runActiveImproveStrategyProbe(deps = {}) {
+    const config = deps.loadConfig?.() ?? loadConfig();
+    const strategyName = config.defaults?.improveStrategy ?? "default";
+    try {
+        const plan = resolveImprovePlan(strategyName, config);
+        const env = deps.env ?? process.env;
+        const unavailableProcesses = Object.entries(plan.processes).flatMap(([name, process]) => {
+            if (!process.enabled || !process.runner)
+                return [];
+            return credentialAvailable(process.runner.credential, env) ? [] : [name];
+        });
+        if (plan.triageJudgment) {
+            const judgmentCredential = plan.triageJudgment.kind === "llm"
+                ? plan.triageJudgment.credential
+                : plan.triageJudgment.kind === "sdk"
+                    ? plan.triageJudgment.fallbackCredential
+                    : undefined;
+            if (!credentialAvailable(judgmentCredential, env))
+                unavailableProcesses.push("triage.judgment");
+        }
         return {
-            name: "agent-profile",
+            name: "active-improve-strategy",
             kind: "deterministic",
-            status: "fail",
+            status: unavailableProcesses.length === 0 ? "pass" : "warn",
             confidence: "high",
-            message: `Default agent profile "${profile.name}" is not available on PATH.`,
-            evidence: { profile: profile.name, bin: profile.bin },
+            message: unavailableProcesses.length === 0
+                ? `Active improve strategy "${plan.strategy.name}" has available process engines.`
+                : `Active improve strategy "${plan.strategy.name}" has unavailable required credentials for: ${unavailableProcesses.join(", ")}.`,
+            evidence: {
+                strategy: plan.strategy.name,
+                unavailableProcesses,
+            },
         };
     }
-    const version = spawnSync(profile.bin, ["--version"], { encoding: "utf8", timeout: 5_000 });
-    if ((version.status ?? 1) !== 0) {
+    catch (error) {
+        const explicitlyConfigured = config.defaults?.improveStrategy !== undefined || Object.keys(config.improve?.strategies ?? {}).length > 0;
         return {
-            name: "agent-profile",
+            name: "active-improve-strategy",
             kind: "deterministic",
-            status: "warn",
-            confidence: "medium",
-            message: `Agent binary "${profile.bin}" was found but \`--version\` failed.`,
-            evidence: {
-                profile: profile.name,
-                bin: profile.bin,
-                exitCode: version.status ?? null,
-                stderr: (version.stderr ?? "").trim(),
-            },
+            status: explicitlyConfigured ? "warn" : "unknown",
+            confidence: "high",
+            message: `Active improve strategy "${strategyName}" is unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            evidence: { strategy: strategyName, unavailableProcesses: [] },
         };
     }
-    return {
-        name: "agent-profile",
-        kind: "deterministic",
-        status: "pass",
-        confidence: "high",
-        message: `Agent profile "${profile.name}" is available.`,
-        evidence: { profile: profile.name, bin: profile.bin, version: (version.stdout ?? "").trim() },
-    };
 }
 /**
  * The ordered health-check registry. ORDER IS LOAD-BEARING: `akmHealth`
@@ -185,9 +301,19 @@ export const HEALTH_CHECKS = [
         }),
     },
     {
-        name: "agent-profile",
+        name: "default-engine",
+        channel: "hard",
+        run: () => runDefaultEngineProbe(),
+    },
+    {
+        name: "default-llm-engine",
+        channel: "hard",
+        run: () => runDefaultLlmEngineProbe(),
+    },
+    {
+        name: "active-improve-strategy",
         channel: "hard",
-        run: () => runAgentProbe(),
+        run: () => runActiveImproveStrategyProbe(),
     },
     {
         // C2 (13-bus-factor): the cron task-failure rate was computed and rendered

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

@@ -93,6 +93,8 @@ function reshapeRun(r) {
     return {
         id: r.id,
         taskId: r.taskId ?? "manual",
+        strategy: r.strategy,
+        legacyProfile: r.legacyProfile,
         startedAt: r.startedAt,
         completedAt: r.completedAt,
         wallTimeMs: wall,
@@ -295,6 +297,8 @@ export function buildHealthHtmlReplacements(result, opts) {
         totalTokens: 0,
         reasoningTokens: 0,
         byStage: {},
+        byProcess: {},
+        byEngine: {},
     };
     const totalRuns = runs.length;
     const failedRuns = runs.filter((r) => !r.ok).length;

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

@@ -1,18 +1,23 @@
 // 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 { decodeImproveResult } from "../../core/improve-result.js";
 import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
+import { decodeTaskHistoryMetadata } from "../../storage/repositories/task-history-repository.js";
 import { summarizeCalibration } from "../improve/calibration.js";
 export function roundRate(value) {
     return Number(value.toFixed(4));
 }
 export function parseTaskMetadata(row) {
-    try {
-        return JSON.parse(row.metadata_json);
-    }
-    catch {
-        return {};
-    }
+    const metadata = decodeTaskHistoryMetadata(row.metadata_json);
+    return {
+        ...(metadata.durationMs !== undefined ? { durationMs: metadata.durationMs } : {}),
+        ...(metadata.detail ? { detail: metadata.detail } : {}),
+        ...(metadata.metadataVersion === 2 && metadata.engine !== undefined ? { engine: metadata.engine } : {}),
+        ...(metadata.metadataVersion === 1 && metadata.legacyProfile !== undefined
+            ? { legacyProfile: metadata.legacyProfile }
+            : {}),
+    };
 }
 function createUnknownImproveMetrics() {
     return {
@@ -21,7 +26,7 @@ function createUnknownImproveMetrics() {
         skipped: 0,
         skipReasons: {},
         plannedRefs: 0,
-        profileFilteredRefs: 0,
+        strategyFilteredRefs: 0,
         actions: {
             reflect: { ok: 0, failed: 0, cooldown: 0, skipped: 0, guardRejected: 0, skippedByReason: {} },
             distill: {
@@ -181,12 +186,14 @@ function projectRunMetrics(result) {
     const plannedRefs = result.plannedRefs;
     if (Array.isArray(plannedRefs))
         metrics.plannedRefs += plannedRefs.length;
-    // profileFilteredRefs (array of {ref, reason}) — 2026-05-27: pre-filter
+    // strategyFilteredRefs (array of {ref, reason}) — 2026-05-27: pre-filter
     // bucket from `collectEligibleRefs` so the metric reflects work the
     // planner dropped before signal-delta / per-pass dispatch.
-    const profileFilteredRefs = result.profileFilteredRefs;
-    if (Array.isArray(profileFilteredRefs))
-        metrics.profileFilteredRefs += profileFilteredRefs.length;
+    // Health v3 reports strategy metrics only. Historical v1 profile filtering
+    // remains legacy data and must not be silently relabelled as a strategy metric.
+    const strategyFilteredRefs = result.schemaVersion === 2 ? result.strategyFilteredRefs : undefined;
+    if (Array.isArray(strategyFilteredRefs))
+        metrics.strategyFilteredRefs += strategyFilteredRefs.length;
     // actions: split reflect / distill by outcome, count others.
     const actions = result.actions;
     if (Array.isArray(actions)) {
@@ -496,8 +503,8 @@ function finalizeImproveMetrics(metrics) {
  */
 function mergeImproveMetrics(dst, src) {
     dst.plannedRefs += src.plannedRefs;
-    // profileFilteredRefs is the count of refs the planner drops up-front for the
-    // active profile — recomputed against the (stable) stash every run, so it is a
+    // strategyFilteredRefs is the count of refs the planner drops up-front for the
+    // active strategy — recomputed against the (stable) stash every run, so it is a
     // snapshot, NOT a per-run increment. Summing it re-counts the same refs each
     // run (the ~2.4M bug). Set from the most recent run in summarizeImproveRuns.
     dst.actions.reflect.ok += src.actions.reflect.ok;
@@ -613,22 +620,16 @@ export function summarizeImproveRuns(db, since, until) {
     // MOST RECENT run's snapshot (current state) — not a sum across runs.
     let latestStartMs = Number.NEGATIVE_INFINITY;
     let latestMemorySummary;
-    let latestProfileFilteredRefs = 0;
+    let latestStrategyFilteredRefs = 0;
     for (const row of rows) {
-        let result;
-        try {
-            result = JSON.parse(row.result_json);
-        }
-        catch {
-            continue;
-        }
+        const result = decodeImproveResult(row.result_json).envelope;
         const perRow = projectRunMetrics(result);
         mergeImproveMetrics(accum, perRow);
         const startMs = new Date(row.started_at).getTime();
         if (Number.isFinite(startMs) && startMs >= latestStartMs) {
             latestStartMs = startMs;
             latestMemorySummary = perRow.memorySummary;
-            latestProfileFilteredRefs = perRow.profileFilteredRefs;
+            latestStrategyFilteredRefs = perRow.strategyFilteredRefs;
         }
         // Collect per-phase durations directly off the envelope. consolidation's
         // duration lives inside the sub-object; memoryInference and graphExtraction
@@ -648,7 +649,7 @@ export function summarizeImproveRuns(db, since, until) {
     finalizeImproveMetrics(accum);
     if (latestMemorySummary)
         accum.memorySummary = latestMemorySummary;
-    accum.profileFilteredRefs = latestProfileFilteredRefs;
+    accum.strategyFilteredRefs = latestStrategyFilteredRefs;
     accum.wallTime.byPhase = {
         consolidation: summarizePhaseDurations(phaseDurations.consolidation),
         memoryInference: summarizePhaseDurations(phaseDurations.memoryInference),
@@ -680,13 +681,8 @@ export function summarizePhaseDurations(samples) {
  * Used by `akm health --detail per-run`.
  */
 export function projectImproveRunSummary(row, wallTimeMs, taskId) {
-    let result = {};
-    try {
-        result = JSON.parse(row.result_json);
-    }
-    catch {
-        // fall through with empty result so per-stage rollups are zeros
-    }
+    const decoded = decodeImproveResult(row.result_json);
+    const result = decoded.envelope;
     const perRow = projectRunMetrics(result);
     finalizeImproveMetrics(perRow);
     const orphansPurged = toFiniteNumber(result.orphansPurged);
@@ -699,6 +695,8 @@ export function projectImproveRunSummary(row, wallTimeMs, taskId) {
         completedAt: row.completed_at,
         wallTimeMs,
         ok: row.ok === 1,
+        strategy: row.strategy,
+        legacyProfile: row.legacyProfile,
         scope: {
             mode: row.scope_mode,
             ...(row.scope_value ? { value: row.scope_value } : {}),
@@ -744,10 +742,10 @@ export function buildImproveSkipSummary(events) {
     //  - Per-occurrence (no `count`): one event per skipped ref → SUM is correct.
     //  - Aggregated snapshot (carries `count`): a single per-run event whose count
     //    is the number of refs that hit a STABLE, whole-stash condition that run
-    //    (`no_new_signal`, `profile_filtered_all_passes`). Each run re-counts the
+    //    (`no_new_signal`, `strategy_filtered_all_passes`). Each run re-counts the
     //    same stable set, so summing across the window re-counts it N times (the
     //    2.7M / 3M inflation). For these we keep the MOST RECENT run's count — the
-    //    current snapshot — matching how memorySummary/profileFilteredRefs are
+    //    current snapshot — matching how memorySummary/strategyFilteredRefs are
     //    handled. Events arrive in chronological (offset) order, so the last
     //    count-bearing event per reason is the latest run's value.
     const summed = {};

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

@@ -7,7 +7,7 @@
  */
 import { readEvents } from "../../core/events.js";
 import { LLM_USAGE_EVENT } from "../../llm/usage-persist.js";
-import { toFiniteNumber } from "./improve-metrics.js";
+import { decodeLlmUsageRecord } from "../../llm/usage-telemetry.js";
 /** Stage key used for `llm_usage` events recorded outside any stage scope. */
 const UNATTRIBUTED_STAGE = "unattributed";
 function emptyLlmUsageStageAggregate() {
@@ -21,7 +21,7 @@ function emptyLlmUsageStageAggregate() {
     };
 }
 function emptyLlmUsageAggregate() {
-    return { ...emptyLlmUsageStageAggregate(), byStage: {} };
+    return { ...emptyLlmUsageStageAggregate(), byStage: {}, byProcess: {}, byEngine: {} };
 }
 /**
  * Aggregate `llm_usage` events (#576) into a window total plus a per-stage
@@ -32,25 +32,25 @@ function emptyLlmUsageAggregate() {
 export function summarizeLlmUsage(events) {
     const aggregate = emptyLlmUsageAggregate();
     for (const event of events) {
-        const meta = event.metadata ?? {};
-        const stageKey = typeof meta.stage === "string" && meta.stage ? meta.stage : UNATTRIBUTED_STAGE;
-        let stage = aggregate.byStage[stageKey];
-        if (!stage) {
-            stage = emptyLlmUsageStageAggregate();
-            aggregate.byStage[stageKey] = stage;
+        const record = decodeLlmUsageRecord(event.metadata);
+        if (!record)
+            continue;
+        const dimensions = [];
+        for (const [groups, key] of [
+            [aggregate.byStage, record.stage ?? UNATTRIBUTED_STAGE],
+            [aggregate.byProcess, record.process ?? UNATTRIBUTED_STAGE],
+            [aggregate.byEngine, record.engine ?? UNATTRIBUTED_STAGE],
+        ]) {
+            groups[key] ??= emptyLlmUsageStageAggregate();
+            dimensions.push(groups[key]);
         }
-        const durationMs = toFiniteNumber(meta.durationMs);
-        const promptTokens = toFiniteNumber(meta.promptTokens);
-        const completionTokens = toFiniteNumber(meta.completionTokens);
-        const totalTokens = toFiniteNumber(meta.totalTokens);
-        const reasoningTokens = toFiniteNumber(meta.reasoningTokens);
-        for (const target of [aggregate, stage]) {
+        for (const target of [aggregate, ...dimensions]) {
             target.calls += 1;
-            target.totalDurationMs += durationMs;
-            target.promptTokens += promptTokens;
-            target.completionTokens += completionTokens;
-            target.totalTokens += totalTokens;
-            target.reasoningTokens += reasoningTokens;
+            target.totalDurationMs += record.durationMs;
+            target.promptTokens += record.promptTokens ?? 0;
+            target.completionTokens += record.completionTokens ?? 0;
+            target.totalTokens += record.totalTokens ?? 0;
+            target.reasoningTokens += record.reasoningTokens ?? 0;
         }
     }
     return aggregate;

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

@@ -28,6 +28,8 @@ export function renderRunsDetailMd(runs) {
     const headers = [
         "ts",
         "ok",
+        "strategy",
+        "legacy_profile",
         "actions",
         "refl_ok/fail/cd/skip",
         "distill_q/llm-fail/qrej/cfg/skip",
@@ -54,6 +56,8 @@ export function renderRunsDetailMd(runs) {
         return [
             r.startedAt,
             String(r.ok),
+            r.strategy ?? "",
+            r.legacyProfile ?? "",
             String(totalActions),
             `${r.actions.reflect.ok}/${r.actions.reflect.failed}/${r.actions.reflect.cooldown}/${r.actions.reflect.skipped}`,
             `${r.actions.distill.queued}/${r.actions.distill.llmFailed}/${r.actions.distill.qualityRejected}/${r.actions.distill.configDisabled}/${r.actions.distill.skipped}`,

package/dist/commands/health/metrics.js

@@ -7,6 +7,7 @@
  * minting rollup, and the WS-5 per-run degradation metrics.
  */
 import { appendEvent, readEvents } from "../../core/events.js";
+import { decodeImproveResult } from "../../core/improve-result.js";
 import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
 import { listProposalGateDecisions, listStateProposals } from "../../storage/repositories/proposals-repository.js";
 import { gateDecisionsToSamples, summarizeCalibration } from "../improve/calibration.js";
@@ -221,7 +222,7 @@ export function computeDegradationMetrics(db, since, until) {
         let totalProcessed = 0;
         for (const row of runs) {
             try {
-                const result = JSON.parse(row.result_json);
+                const result = decodeImproveResult(row.result_json).envelope;
                 const cons = result.consolidation;
                 if (cons) {
                     totalContradicted += toFiniteNumber(cons.contradicted);

package/dist/commands/health/surfaces.js

@@ -18,7 +18,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 +99,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;
@@ -182,10 +184,10 @@ export function collectEgressAdvisory(config) {
             continue;
         endpoints.push(`source ${source.name ?? "(unnamed)"} (${source.type ?? "?"}): ${source.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}`);

package/dist/commands/health.js

@@ -284,7 +284,7 @@ export function akmHealth(options = {}) {
             runs = buildPerRunSummaries(db, since);
         }
         return {
-            schemaVersion: 2,
+            schemaVersion: 3,
             ok: !hardFailure,
             status,
             since: topLevelSince,

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

@@ -72,8 +72,8 @@ function distinctTokens(text) {
 }
 /**
  * A merge must strictly increase information (R5 §4.2):
- *  1. Provenance: the merged asset's `source_refs` must be a superset of the
- *     union of all participants' `source_refs` plus the participant refs
+ *  1. Provenance: the merged asset's `xrefs` must be a superset of the union of
+ *     all participants' `xrefs` plus the participant refs
  *     themselves — provenance never shrinks through a merge.
  *  2. Specificity: distinctTokens(mergedBody) ≥ minSpecificityRetention ×
  *     |union(distinctTokens(participant bodies))| — a merge that only
@@ -111,7 +111,7 @@ export function checkMergeInformationFloor(mergedBody, mergedSourceRefs, partici
     const specificityOk = specificityRetention >= minRetention;
     const reasons = [];
     if (!provenanceOk) {
-        reasons.push(`provenance shrank: merged source_refs missing ${missing.length} ref(s) (e.g. ${missing[0]})`);
+        reasons.push(`provenance shrank: merged xrefs missing ${missing.length} ref(s) (e.g. ${missing[0]})`);
     }
     if (!specificityOk) {
         reasons.push(`specificity retention ${specificityRetention.toFixed(2)} < ${minRetention} (merge genericized/shortened)`);