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

package/dist/commands/config-cli.js

@@ -8,105 +8,27 @@
  * new config field is one line of Zod schema in `core/config-schema.ts` and
  * zero lines here — the walker handles get/set/unset/coercion uniformly.
  *
- * Legacy behaviour preserved:
- *   - `akm config set llm.<x>` writes to `profiles.llm.<defaults.llm>` (or
- *     auto-creates a "default" profile), mirroring the pre-rewrite shim.
- *   - `akm config set embedding.ollamaOptions.numCtx` is sugar for
- *     `embedding.ollamaOptions.num_ctx` (camelCase ↔ snake_case bridge).
+ * `configVersion` is controlled by the config lifecycle. All execution
+ * settings use their canonical engine/strategy paths; retired aliases are not
+ * rewritten at this boundary.
  *   - `parseConfigValue` returns a Partial<AkmConfig> so it can be merged with
  *     the runtime config object via `mergeConfigValue`.
  */
 import { defineGroupCommand, defineJsonCommand, output } from "../cli/shared.js";
 import { resolveStashDir } from "../core/common.js";
-import { DEFAULT_CONFIG, getSources, loadConfig, loadUserConfig, saveConfig, } from "../core/config/config.js";
+import { DEFAULT_CONFIG, loadConfig, mutateConfig } from "../core/config/config.js";
 import { configGet, configSet, configUnset, unknownKeyHint } from "../core/config/config-walker.js";
 import { UsageError } from "../core/errors.js";
 import { getCacheDir, getConfigPath, getDbPath, getDefaultStashDir } from "../core/paths.js";
-// ── Legacy `llm.*` → `profiles.llm.<default>.*` aliasing ────────────────────
-/**
- * Map a legacy top-level `llm.<sub>` path onto the actual schema path. The
- * default profile name is "default" when `defaults.llm` is unset.
- */
-function rewriteLegacyLlmPath(config, key) {
-    if (key !== "llm" && !key.startsWith("llm."))
-        return key;
-    const sub = key === "llm" ? "" : key.slice("llm.".length);
-    const profileName = config.defaults?.llm ?? "default";
-    return sub ? `profiles.llm.${profileName}.${sub}` : `profiles.llm.${profileName}`;
-}
-/**
- * Translate the legacy `embedding.ollamaOptions.numCtx` to the actual schema
- * key `embedding.ollamaOptions.num_ctx`.
- */
-function rewriteEmbeddingPath(key) {
-    if (key === "embedding.ollamaOptions.numCtx")
-        return "embedding.ollamaOptions.num_ctx";
-    return key;
-}
-/**
- * Translate the deprecated `stashes` alias for `sources` (one-way: both read
- * and write go through `sources`).
- */
-function rewriteSourcesAlias(key) {
-    if (key === "stashes")
-        return "sources";
-    if (key.startsWith("stashes."))
-        return `sources.${key.slice("stashes.".length)}`;
-    return key;
-}
-function rewriteKey(config, key) {
-    let k = rewriteLegacyLlmPath(config, key);
-    k = rewriteEmbeddingPath(k);
-    k = rewriteSourcesAlias(k);
-    return k;
-}
 // ── Public API ──────────────────────────────────────────────────────────────
 export function getConfigValue(config, key) {
-    const k = rewriteKey(config, key);
-    const value = configGet(config, k);
-    if (k.split(".").at(-1) === "apiKey")
-        return null;
-    return omitApiKeysForOutput(value);
+    return redactConfigValue(configGet(config, key));
 }
 export function setConfigValue(config, key, rawValue) {
-    // #454: reject the legacy aliases up front so the error message names the
-    // env var the user typed (AKM_LLM_API_KEY) rather than the rewritten profile
-    // env var (AKM_PROFILE_DEFAULT_API_KEY) — both work at runtime, but the
-    // shorter name matches the user's mental model.
-    if (key === "llm.apiKey") {
-        throw new UsageError("apiKey cannot be persisted in config; export AKM_LLM_API_KEY instead. (key: llm.apiKey)", "INVALID_FLAG_VALUE", "Storing API keys in config.json leaks them through backups, logs, and version control. " +
-            "Use the corresponding environment variable. AKM reads it at request time.");
-    }
-    if (key === "embedding.apiKey") {
-        throw new UsageError("apiKey cannot be persisted in config; export AKM_EMBED_API_KEY instead. (key: embedding.apiKey)", "INVALID_FLAG_VALUE", "Storing API keys in config.json leaks them through backups, logs, and version control. " +
-            "Use the corresponding environment variable. AKM reads it at request time.");
-    }
-    const k = rewriteKey(config, key);
-    // Legacy ergonomic: `akm config set semanticSearchMode true|false`
-    let coerced = rawValue;
-    if (k === "semanticSearchMode") {
-        if (rawValue === "true")
-            coerced = "auto";
-        else if (rawValue === "false")
-            coerced = "off";
-    }
-    let next = configSet(config, k, coerced);
-    // Legacy ergonomic shim: when the user sets `llm.<field>` and no
-    // `defaults.llm` is set, point it at the freshly-created profile so the
-    // value actually takes effect at runtime.
-    if (key === "llm" || key.startsWith("llm.")) {
-        if (!next.defaults?.llm) {
-            next = {
-                ...next,
-                defaults: { ...(next.defaults ?? {}), llm: "default" },
-            };
-        }
-    }
-    return next;
+    return configSet(config, key, rawValue);
 }
 export function unsetConfigValue(config, key) {
-    const k = rewriteKey(config, key);
-    return configUnset(config, k);
+    return configUnset(config, key);
 }
 /**
  * Compatibility shim: returns a `Partial<AkmConfig>` containing just the
@@ -128,48 +50,21 @@ export function parseConfigValue(key, value) {
     return patch;
 }
 export function listConfig(config) {
-    const result = {
-        semanticSearchMode: config.semanticSearchMode,
-        registries: config.registries ?? DEFAULT_CONFIG.registries ?? [],
-        output: { ...(DEFAULT_CONFIG.output ?? {}), ...(config.output ?? {}) },
-        stashDir: config.stashDir ?? null,
-        installed: config.installed ?? [],
-        sources: getSources(config),
-    };
-    if (config.defaultWriteTarget)
-        result.defaultWriteTarget = config.defaultWriteTarget;
-    if (config.embedding)
-        result.embedding = config.embedding;
-    if (config.profiles)
-        result.profiles = config.profiles;
-    if (config.defaults)
-        result.defaults = config.defaults;
-    if (config.search)
-        result.search = config.search;
-    if (config.index)
-        result.index = config.index;
-    if (config.feedback)
-        result.feedback = config.feedback;
-    if (config.improve)
-        result.improve = config.improve;
-    if (config.archiveRetentionDays !== undefined)
-        result.archiveRetentionDays = config.archiveRetentionDays;
-    if (config.configVersion !== undefined)
-        result.configVersion = config.configVersion;
-    return omitApiKeysForOutput(result);
+    return redactConfigValue({ ...DEFAULT_CONFIG, ...config, sources: config.sources ?? [] });
 }
-function omitApiKeysForOutput(value) {
+function redactConfigValue(value) {
     if (Array.isArray(value))
-        return value.map(omitApiKeysForOutput);
+        return value.map(redactConfigValue);
     if (!value || typeof value !== "object")
         return value;
-    const out = {};
+    const result = {};
     for (const [key, child] of Object.entries(value)) {
-        if (key === "apiKey")
-            continue;
-        out[key] = omitApiKeysForOutput(child);
+        if (key !== "apiKey" ||
+            (typeof child === "string" && /^\$(?:[A-Za-z_][A-Za-z0-9_]*|\{[A-Za-z_][A-Za-z0-9_]*\})$/.test(child))) {
+            result[key] = redactConfigValue(child);
+        }
     }
-    return out;
+    return result;
 }
 export { unknownKeyHint };
 // ── `akm config` command surface ────────────────────────────────────────────
@@ -190,25 +85,21 @@ function normalizeToggleTarget(target) {
     throw new UsageError(`Unsupported target "${target}". Supported targets: skills.sh`);
 }
 function toggleSkillsShRegistry(enabled) {
-    const config = loadUserConfig();
-    const registries = (config.registries ?? DEFAULT_CONFIG.registries ?? []).map((registry) => ({ ...registry }));
-    const idx = registries.findIndex((registry) => registry.provider === SKILLS_SH_PROVIDER || registry.name === SKILLS_SH_NAME || registry.url === SKILLS_SH_URL);
-    if (idx >= 0) {
-        const existing = registries[idx];
-        const wasEnabled = existing.enabled !== false;
-        existing.enabled = enabled;
-        saveConfig({ ...config, registries });
-        return { changed: wasEnabled !== enabled, component: SKILLS_SH_NAME, enabled };
-    }
-    if (!enabled) {
-        // Materialize the skills.sh registry explicitly if absent.
-        registries.push({ url: SKILLS_SH_URL, name: SKILLS_SH_NAME, provider: SKILLS_SH_PROVIDER, enabled: false });
-        saveConfig({ ...config, registries });
-        return { changed: true, component: SKILLS_SH_NAME, enabled: false };
-    }
-    registries.push({ url: SKILLS_SH_URL, name: SKILLS_SH_NAME, provider: SKILLS_SH_PROVIDER, enabled: true });
-    saveConfig({ ...config, registries });
-    return { changed: true, component: SKILLS_SH_NAME, enabled: true };
+    let changed = false;
+    mutateConfig((config) => {
+        const registries = (config.registries ?? DEFAULT_CONFIG.registries ?? []).map((registry) => ({ ...registry }));
+        const idx = registries.findIndex((registry) => registry.provider === SKILLS_SH_PROVIDER || registry.name === SKILLS_SH_NAME || registry.url === SKILLS_SH_URL);
+        if (idx >= 0) {
+            const wasEnabled = registries[idx].enabled !== false;
+            registries[idx].enabled = enabled;
+            changed = wasEnabled !== enabled;
+            return { ...config, registries };
+        }
+        registries.push({ url: SKILLS_SH_URL, name: SKILLS_SH_NAME, provider: SKILLS_SH_PROVIDER, enabled });
+        changed = true;
+        return { ...config, registries };
+    });
+    return { changed, component: SKILLS_SH_NAME, enabled };
 }
 function toggleComponent(targetRaw, enabled) {
     const target = normalizeToggleTarget(targetRaw);
@@ -276,7 +167,11 @@ export const configCommand = defineGroupCommand({
         set: defineJsonCommand({
             meta: { name: "set", description: "Set a configuration value by key" },
             args: {
-                key: { type: "positional", required: true, description: "Config key (for example: embedding, llm)" },
+                key: {
+                    type: "positional",
+                    required: true,
+                    description: "Config key (for example: embedding, engines.default)",
+                },
                 value: { type: "positional", required: true, description: "Config value" },
                 // #463: stable machine-friendly entry point for plugins / hooks.
                 // `--silent` suppresses the config dump on stdout so hook-driven
@@ -297,20 +192,19 @@ export const configCommand = defineGroupCommand({
             },
             run({ args }) {
                 if (args.layer && args.layer !== "user") {
-                    throw new UsageError(`Unsupported --layer "${args.layer}". Only "user" is settable in 0.8.0.`, "INVALID_FLAG_VALUE");
+                    throw new UsageError(`Unsupported --layer "${args.layer}". Only "user" is settable in 0.9.0.`, "INVALID_FLAG_VALUE");
                 }
                 // Use loadConfig (not loadUserConfig) so the project-config
                 // deprecation warning fires consistently with `akm config get`
                 // (#457). Effective merged shape is identical post-0.8.0.
-                const updated = setConfigValue(loadConfig(), args.key, args.value);
-                saveConfig(updated);
+                const updated = mutateConfig((current) => setConfigValue(current, args.key, args.value)).config;
                 if (!args.silent) {
                     output("config", listConfig(updated));
                 }
             },
         }),
         unset: defineJsonCommand({
-            meta: { name: "unset", description: "Unset an optional configuration key or whole embedding/llm section" },
+            meta: { name: "unset", description: "Unset an optional configuration key or whole embedding/engine section" },
             args: {
                 key: { type: "positional", required: true, description: "Config key to unset" },
                 silent: {
@@ -326,10 +220,10 @@ export const configCommand = defineGroupCommand({
             },
             run({ args }) {
                 if (args.layer && args.layer !== "user") {
-                    throw new UsageError(`Unsupported --layer "${args.layer}". Only "user" is settable in 0.8.0.`, "INVALID_FLAG_VALUE");
+                    throw new UsageError(`Unsupported --layer "${args.layer}". Only "user" is settable in 0.9.0.`, "INVALID_FLAG_VALUE");
                 }
-                const updated = unsetConfigValue(loadConfig(), args.key);
-                saveConfig(updated);
+                const result = mutateConfig((current) => unsetConfigValue(current, args.key), { absentNoop: true });
+                const updated = result.config;
                 if (!args.silent) {
                     output("config", listConfig(updated));
                 }
@@ -348,19 +242,11 @@ export const configCommand = defineGroupCommand({
         migrate: defineJsonCommand({
             meta: {
                 name: "migrate",
-                description: "Migrate the config file to the current schema version. Use --dry-run to preview without writing.",
+                description: "Diagnose whether the user config is already in the current schema. Never writes or translates config.",
             },
-            args: {
-                "dry-run": { type: "boolean", description: "Preview the migration result without writing.", default: false },
-                "print-diff": {
-                    type: "boolean",
-                    description: "Print a unified diff of old vs new config alongside the migration output.",
-                    default: false,
-                },
-            },
-            async run({ args }) {
+            async run() {
                 const { runConfigMigrate } = await import("../cli/config-migrate.js");
-                await runConfigMigrate({ dryRun: Boolean(args["dry-run"]), printDiff: Boolean(args["print-diff"]) });
+                await runConfigMigrate();
             },
         }),
         enable: defineJsonCommand({

package/dist/commands/env/secret.js

@@ -27,7 +27,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { writeFileAtomic } from "../../core/common.js";
-import { probeLock, releaseLock, tryAcquireLockSync } from "../../core/file-lock.js";
+import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync, } from "../../core/file-lock.js";
 import { sleepSync } from "../../runtime.js";
 // ── Write-lock helper ─────────────────────────────────────────────────────────
 /**
@@ -39,10 +39,13 @@ import { sleepSync } from "../../runtime.js";
 export function withSecretLock(secretPath, fn) {
     const lockPath = `${secretPath}.lock`;
     const deadline = Date.now() + 5000;
-    while (!tryAcquireLockSync(lockPath, String(process.pid))) {
+    let ownership;
+    while (!ownership) {
+        ownership = tryAcquireLockSync(lockPath, createLockPayload());
+        if (ownership)
+            break;
         const probe = probeLock(lockPath);
-        if (probe.state === "stale") {
-            releaseLock(lockPath);
+        if (probe.state === "stale" && reclaimStaleLock(lockPath, probe)) {
             continue;
         }
         if (Date.now() > deadline) {
@@ -57,7 +60,7 @@ export function withSecretLock(secretPath, fn) {
         return fn();
     }
     finally {
-        releaseLock(lockPath);
+        releaseLock(ownership);
     }
 }
 // ── Atomic byte write ──────────────────────────────────────────────────────────

package/dist/commands/health/checks.js

@@ -2,111 +2,158 @@
 // 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 { 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];
+export function runDefaultEngineProbe(deps = {}) {
+    const config = deps.loadConfig?.() ?? loadConfig();
+    const engineName = config.defaults?.engine ?? config.defaults?.llmEngine;
+    if (!engineName) {
         return {
-            name: "agent-profile",
-            kind: "deterministic",
-            status: "pass",
-            confidence: "high",
-            message: `v2 agent profile "${profileName}" configured (platform: ${profile?.platform ?? "unknown"}).`,
-            evidence: { profile: profileName, platform: profile?.platform, profileCount },
-        };
-    }
-    if (!config.profiles?.agent && !config.defaults?.agent) {
-        return {
-            name: "agent-profile",
+            name: "default-engine",
             kind: "deterministic",
             status: "unknown",
             confidence: "high",
-            message: "No agent config present.",
-        };
-    }
-    let profile;
-    try {
-        profile = requireAgentProfile(config);
-    }
-    catch (error) {
-        return {
-            name: "agent-profile",
-            kind: "deterministic",
-            status: "warn",
-            confidence: "high",
-            message: error instanceof Error ? error.message : String(error),
+            message: "No default engine is configured.",
         };
     }
-    if (profile.sdkMode === true) {
+    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 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 };
+        }
+        else if (fallbackEngine) {
+            try {
+                const resolved = resolve(fallbackEngine, config);
+                if (resolved.kind === "llm")
+                    fallback = resolved;
+            }
+            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 missing = [
+            !packageAvailable ? "@opencode-ai/sdk package" : undefined,
+            !binaryAvailable ? `${binary} binary` : undefined,
+            !fallback ? "fallback LLM connection" : undefined,
+            !effectiveModel ? "effective SDK model" : undefined,
+        ].filter((value) => value !== undefined);
         return {
-            name: "agent-profile",
+            name: "default-engine",
             kind: "deterministic",
-            status: profile.model ? "pass" : "warn",
+            status: missing.length === 0 ? "pass" : "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: 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,
+            },
         };
     }
-    const detections = detectAgentCliProfiles(config);
-    const detection = detections.find((entry) => entry.name === profile.name);
-    if (!detection?.available) {
+    try {
+        const runner = (deps.resolveEngine ?? resolveEngine)(engineName, config);
+        if (runner.kind === "llm") {
+            return {
+                name: "default-engine",
+                kind: "deterministic",
+                status: "pass",
+                confidence: "high",
+                message: `LLM engine "${engineName}" is configured.`,
+                evidence: {
+                    engine: engineName,
+                    platform: null,
+                    runtimeKind: "llm",
+                    model: runner.connection.model,
+                    endpoint: runner.connection.endpoint,
+                },
+            };
+        }
+        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: "default-engine",
+                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: "default-engine",
             kind: "deterministic",
-            status: "fail",
+            status: "pass",
             confidence: "high",
-            message: `Default agent profile "${profile.name}" is not available on PATH.`,
-            evidence: { profile: profile.name, bin: profile.bin },
+            message: `Agent engine "${engineName}" is available.`,
+            evidence: {
+                engine: engineName,
+                platform: profile.platform ?? null,
+                runtimeKind: "agent",
+                model: profile.model ?? null,
+            },
         };
     }
-    const version = spawnSync(profile.bin, ["--version"], { encoding: "utf8", timeout: 5_000 });
-    if ((version.status ?? 1) !== 0) {
+    catch (error) {
         return {
-            name: "agent-profile",
+            name: "default-engine",
             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(),
-            },
+            confidence: "high",
+            message: error instanceof Error ? error.message : String(error),
         };
     }
-    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 +232,9 @@ export const HEALTH_CHECKS = [
         }),
     },
     {
-        name: "agent-profile",
+        name: "default-engine",
         channel: "hard",
-        run: () => runAgentProbe(),
+        run: () => runDefaultEngineProbe(),
     },
     {
         // 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;