@mono-agent/agent-app 0.3.0 → 0.4.1

package/dist/doctor.js

@@ -1,8 +1,17 @@
-import { mkdir, stat } from "node:fs/promises";
-import { join } from "node:path";
-import { describeMonoRuntimeSupport } from "@mono-agent/runtime-adapter";
-import { isAppCoreConfigError, loadAppCoreConfig, resolveAppConsoleSettings } from "./app-config.js";
-import { defaultChannelDrivers } from "./channels.js";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { listRecordedRuns } from "@mono-agent/observability";
+import { serializeTraceSpans } from "@mono-agent/observability/otel";
+import { describeMonoRuntimeSupport, modelReferenceKey, parseMonoRuntimeModelReference } from "@mono-agent/runtime-adapter";
+import { buildMonoAgentConfigView, findJsonSecretConfigWarnings, findRemovedConfigWarnings, readMonoAgentConfigJson, redactMonoAgentConfig, resolveSupermemoryContainer, } from "@mono-agent/config";
+import { describeSandboxEffectiveState, resolveSandboxEffectiveState, sandboxEffectiveStateWarning, } from "@mono-agent/runtime-adapter";
+import { describeSensitiveDataExportWarning, isAppCoreConfigError, loadAppCoreConfig, phoenixAppBaseUrl, resolveAppArtifactDir, resolveAppObservabilityExporters, } from "./app-config.js";
+import { adapterSendToolNames, resolveAdapterSendToolsSettings } from "./adapter-send-tools.js";
+import { collectChannelConfigViews } from "./channel-config-view.js";
+import { resolveChannelDrivers } from "./channels.js";
+import { findUnknownAppConfigWarnings } from "./config-reference.js";
+import { buildRunsHealthDisplay, RUNS_HEALTH_MAX_RUNS } from "./runs-health.js";
 /**
  * Loads every config section the app would use at start and reports it
  * per-section, so an engineer can see exactly what would run, wait, or fail —
@@ -10,7 +19,9 @@ import { defaultChannelDrivers } from "./channels.js";
  */
 export async function validateMonoAgentFolder(options) {
     const sections = [];
-    const drivers = options.drivers ?? defaultChannelDrivers();
+    const drivers = options.drivers ?? await resolveChannelDrivers(options);
+    const liveness = options.liveness ?? true;
+    const allowFilesystemWrites = options.allowFilesystemWrites ?? true;
     let coreConfig;
     try {
         coreConfig = await loadAppCoreConfig(options);
@@ -23,13 +34,33 @@ export async function validateMonoAgentFolder(options) {
         sections.push({ id: "core", label: "Core config", status: "error", details: [error.message] });
     }
     if (coreConfig !== undefined) {
+        const jsonResult = await readMonoAgentConfigJson(options.configPath);
+        // Channel secrets (bot tokens, API keys) live outside the core view, so the
+        // placement check spans both: core sections + every channel's config view.
+        const configWarnings = [
+            ...findUnknownAppConfigWarnings(jsonResult.json),
+            ...findJsonSecretConfigWarnings([
+                ...buildMonoAgentConfigView({
+                    redacted: redactMonoAgentConfig(coreConfig),
+                    json: jsonResult.json,
+                    env: options.env,
+                }),
+                ...(await collectChannelConfigViews(drivers, options)),
+            ]),
+            ...findRemovedConfigWarnings({ json: jsonResult.json, env: options.env }),
+        ];
+        if (configWarnings.length > 0) {
+            sections.push({ id: "secret-placement", label: "Config warnings", status: "waiting", details: configWarnings });
+        }
         sections.push(runtimeSection(coreConfig));
+        sections.push(await credentialsSection(coreConfig));
         sections.push(await contextSection(coreConfig));
-        sections.push(await memorySection(coreConfig));
-        sections.push(await toolsSection(coreConfig));
-        sections.push(sandboxSection(coreConfig));
+        sections.push(await memorySection(coreConfig, liveness, allowFilesystemWrites));
+        sections.push(await toolsSection(coreConfig, options));
+        sections.push(await sandboxSection(coreConfig, options.sandboxEngine));
     }
-    sections.push(await consoleSection(options));
+    sections.push(await exporterSection(options, liveness));
+    sections.push(await runsSection(options, coreConfig));
     for (const driver of drivers) {
         sections.push(await channelSection(driver, options));
     }
@@ -61,6 +92,105 @@ function runtimeSection(config) {
     }
     return { id: "runtime", label: "Runtime", status, details };
 }
+/** Parses the Pi OAuth auth store (provider -> credentials) at `path`, best-effort. */
+async function readPiAuthProviders(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Missing/invalid auth file is reported per-provider below, not thrown here.
+    }
+    return undefined;
+}
+/** Provider ids configured via the sibling `models.json` (custom/local providers need no OAuth). */
+async function readPiCustomProviders(authPath) {
+    try {
+        const parsed = JSON.parse(await readFile(join(dirname(authPath), "models.json"), "utf8"));
+        const providers = parsed?.providers;
+        if (providers !== null && typeof providers === "object" && !Array.isArray(providers)) {
+            return new Set(Object.keys(providers));
+        }
+    }
+    catch {
+        // No models.json is fine; such providers simply won't be marked custom.
+    }
+    return new Set();
+}
+/**
+ * Checks that every referenced model (primary, fallbacks, and the agent-host memory LLM)
+ * has discoverable credentials, so a keyless or expired-OAuth provider is caught at
+ * `validate` time instead of degrading crons/memory silently at runtime (the failure mode
+ * that broke memory capture for ~10 days: the auth store's OAuth token had quietly expired).
+ *
+ * The check is intentionally STATIC and read-only — a validator must not mutate the auth
+ * store or hit the network. For each Pi provider it inspects the auth store (`piAuthPath`)
+ * and the sibling `models.json`: a custom/local provider needs no OAuth; an OAuth provider
+ * absent from the store, or whose access token has expired, is flagged `waiting` with a
+ * re-auth hint. SDK-authenticated models (claude/codex) are validated by their own SDK and
+ * are noted but not key-checked here. `waiting` (never `error`) keeps the verdict non-fatal,
+ * mirroring the Ollama/Phoenix probes — the goal is visibility, not blocking start.
+ */
+async function credentialsSection(config) {
+    const refs = [
+        { label: "Primary", ref: config.runtime.model },
+        ...(config.runtime.fallbackModels ?? []).map((ref) => ({ label: "Fallback", ref })),
+    ];
+    if (config.memory?.llm !== undefined && config.memory.llm.provider !== "ollama") {
+        try {
+            refs.push({ label: "Memory LLM", ref: parseMonoRuntimeModelReference(config.memory.llm.model) });
+        }
+        catch {
+            // A malformed memory model reference is surfaced by the memory/runtime shape checks.
+        }
+    }
+    const piRefs = refs.filter((r) => r.ref.sdk === "pi" && typeof r.ref.provider === "string");
+    if (piRefs.length === 0) {
+        return {
+            id: "credentials",
+            label: "Provider credentials",
+            status: "disabled",
+            details: ["No Pi provider-key models referenced (SDK-authenticated models are checked by their SDK)."],
+        };
+    }
+    const authPath = config.providers?.piAuthPath;
+    const authProviders = authPath === undefined ? undefined : await readPiAuthProviders(authPath);
+    const customProviders = authPath === undefined ? new Set() : await readPiCustomProviders(authPath);
+    const now = Date.now();
+    const details = [];
+    let status = "ok";
+    if (authPath !== undefined) {
+        details.push(`Pi auth store: ${authPath}`);
+    }
+    for (const { label, ref } of piRefs) {
+        const provider = ref.provider;
+        const refStr = referenceOf(ref);
+        if (customProviders.has(provider)) {
+            details.push(`${label} ${refStr}: provider \`${provider}\` configured via pi models.json.`);
+            continue;
+        }
+        const entry = authProviders?.[provider];
+        if (entry === undefined) {
+            status = "waiting";
+            details.push(`[WARN] ${label} ${refStr}: no Pi credentials found for provider \`${provider}\` (absent from the auth store and models.json). Authenticate it (\`pi auth login ${provider}\`) or set providers.piAuthPath.`);
+            continue;
+        }
+        const isOAuth = entry.type === "oauth" || typeof entry.expires === "number";
+        const expired = typeof entry.expires === "number" && entry.expires < now;
+        const whenNote = typeof entry.expires === "number" ? ` ${new Date(entry.expires).toISOString()}` : "";
+        if (isOAuth && expired) {
+            status = "waiting";
+            details.push(`[WARN] ${label} ${refStr}: OAuth token for \`${provider}\` expired${whenNote} — the runtime auto-refreshes, but if runs fail with "No API key for provider: ${provider}" the refresh is dead; re-authenticate: \`pi auth login ${provider}\`.`);
+            continue;
+        }
+        details.push(isOAuth
+            ? `${label} ${refStr}: OAuth credentials for \`${provider}\` present (token valid${whenNote}).`
+            : `${label} ${refStr}: credentials for \`${provider}\` present.`);
+    }
+    return { id: "credentials", label: "Provider credentials", status, details };
+}
 async function contextSection(config) {
     const details = [];
     let status = "ok";
@@ -100,66 +230,77 @@ async function contextSection(config) {
     }
     return { id: "context", label: "Context & skills", status, details };
 }
-const DEFAULT_REFLECTION_CRON = "0 3 * * *";
-const DEFAULT_MIGRATION_CRON = "0 4 1 * *";
-async function memorySection(config) {
+const DEFAULT_CONSOLIDATION_CRON = "0 */2 * * *";
+async function memorySection(config, liveness, allowFilesystemWrites) {
     if (config.memory === undefined) {
         return { id: "memory", label: "Memory", status: "disabled", details: ["No memory configured."] };
     }
+    // External backend (e.g. supermemory): mode/embeddings/llm are bujo-only and ignored, so report the
+    // backend's own shape. We do not ping the instance here (config-shape check); the playbook covers
+    // starting the server.
+    if ((config.memory.backend ?? "bujo") === "supermemory") {
+        const sm = config.memory.supermemory;
+        if (sm === undefined) {
+            return {
+                id: "memory",
+                label: "Memory",
+                status: "error",
+                details: ["[ERROR] backend 'supermemory' requires a memory.supermemory block."],
+            };
+        }
+        return {
+            id: "memory",
+            label: "Memory",
+            status: "ok",
+            details: [
+                `Backend: supermemory, writeMode: ${config.memory.writeMode}.`,
+                `Endpoint: ${sm.baseUrl} (container "${resolveSupermemoryContainer(config)}").`,
+                sm.apiKey === undefined
+                    ? "Auth: no API key configured (keyless — works only if the instance allows it)."
+                    : "Auth: API key configured.",
+                "Start the Supermemory instance (e.g. `supermemory-server`) before sending turns; ingestion is async.",
+            ],
+        };
+    }
     const details = [
         `Mode: ${config.memory.mode}, path: ${config.memory.path}, writeMode: ${config.memory.writeMode}.`,
     ];
+    if (config.memory.llm !== undefined) {
+        details.push(`Chat LLM: ${memoryLlmLabel(config.memory.llm)}.`);
+    }
     if (config.memory.mode === "bujo") {
-        // Report ritual scheduler cadence
-        const reflectionEnabled = config.memory.reflection?.enabled !== false;
-        const migrationEnabled = config.memory.migration?.enabled !== false;
-        const reflectionCron = config.memory.reflection?.cron ?? DEFAULT_REFLECTION_CRON;
-        const migrationCron = config.memory.migration?.cron ?? DEFAULT_MIGRATION_CRON;
+        // Report consolidation scheduler cadence.
+        const consolidationEnabled = config.memory.consolidation?.enabled !== false;
+        const consolidationCron = config.memory.consolidation?.cron ?? DEFAULT_CONSOLIDATION_CRON;
         const hasLlm = config.memory.llm !== undefined;
         if (hasLlm) {
-            const ritualParts = [];
-            if (reflectionEnabled) {
-                ritualParts.push(`reflection ${reflectionCron}`);
-            }
-            else {
-                ritualParts.push("reflection disabled");
-            }
-            if (migrationEnabled) {
-                ritualParts.push(`migration ${migrationCron}`);
+            if (consolidationEnabled) {
+                details.push(`Consolidation: ${consolidationCron} (auto).`);
             }
             else {
-                ritualParts.push("migration disabled");
+                details.push("Consolidation: disabled.");
             }
-            details.push(`Rituals: ${ritualParts.join(" / ")} (auto).`);
         }
         else {
-            details.push("Rituals: manual (no chat model — reflect/migrate need a local LLM).");
+            details.push("Consolidation: not scheduled (no chat model — bujo runtime tier downgrades to journal).");
         }
     }
     if (config.memory.mode === "journal" || config.memory.mode === "bujo") {
-        const warns = await memoryLivenessWarnings(config.memory);
+        const warns = await memoryLivenessWarnings(config.memory, liveness, allowFilesystemWrites);
         if (warns.length > 0) {
             return { id: "memory", label: "Memory", status: "waiting", details: [...details, ...warns] };
         }
     }
     if (config.memory.mode === "lite") {
-        const liteWarns = await liteRootWritableWarning(config.memory.path);
+        const liteWarns = await liteRootWritableWarning(config.memory.path, allowFilesystemWrites);
         if (liteWarns.length > 0) {
             return { id: "memory", label: "Memory", status: "waiting", details: [...details, ...liteWarns] };
         }
     }
     return { id: "memory", label: "Memory", status: "ok", details };
 }
-async function liteRootWritableWarning(memoryPath) {
-    try {
-        await mkdir(memoryPath, { recursive: true });
-        return [];
-    }
-    catch (err) {
-        return [
-            `[WARN] lite memory root is not writable: ${memoryPath} (${err instanceof Error ? err.message : String(err)}). Fix filesystem permissions.`,
-        ];
-    }
+async function liteRootWritableWarning(memoryPath, allowFilesystemWrites) {
+    return await memoryRootWritableWarnings("lite", memoryPath, allowFilesystemWrites);
 }
 const BUJO_PROBE_TIMEOUT_MS = 3_000;
 /** Probes Ollama /api/tags and returns a sorted list of model names, or throws. */
@@ -178,47 +319,101 @@ async function fetchOllamaModels(endpoint) {
         clearTimeout(timer);
     }
 }
-async function memoryLivenessWarnings(memory) {
+async function memoryLivenessWarnings(memory, liveness, allowFilesystemWrites) {
     const warns = [];
     const mode = memory.mode;
     const embeddingsUsesOllama = (memory.embeddings?.provider ?? "ollama") === "ollama";
     const llmUsesOllama = memory.llm?.provider === "ollama";
-    // 1. Memory root writable (every embedded tier)
-    try {
-        await mkdir(memory.path, { recursive: true });
-    }
-    catch (err) {
-        warns.push(`[WARN] ${mode} memory root is not writable: ${memory.path} (${err instanceof Error ? err.message : String(err)}). Fix filesystem permissions.`);
-    }
-    // 2. Ollama liveness — only probe when embeddings and/or the chat LLM actually use Ollama. With
-    // OpenAI embeddings there is nothing local to probe, so we must not tell the user to start Ollama.
-    if (embeddingsUsesOllama || llmUsesOllama) {
-        const endpoint = ((embeddingsUsesOllama ? memory.embeddings?.endpoint : memory.llm?.endpoint) ?? "http://localhost:11434").replace(/\/$/u, "");
-        let ollamaModels;
+    const ollamaModelsByEndpoint = new Map();
+    // 1. Memory root writable (every embedded tier) — local I/O, always checked.
+    const rootWarns = await memoryRootWritableWarnings(mode, memory.path, allowFilesystemWrites);
+    warns.push(...rootWarns);
+    // Network-dependent probes below only ever produce `waiting`, so the start
+    // preflight skips them (liveness=false) without changing the pass/fail verdict.
+    if (!liveness) {
+        return warns;
+    }
+    async function modelsForOllamaEndpoint(endpoint) {
+        const normalizedEndpoint = endpoint.replace(/\/$/u, "");
+        if (ollamaModelsByEndpoint.has(normalizedEndpoint)) {
+            return ollamaModelsByEndpoint.get(normalizedEndpoint);
+        }
         try {
-            ollamaModels = await fetchOllamaModels(endpoint);
+            const models = await fetchOllamaModels(normalizedEndpoint);
+            ollamaModelsByEndpoint.set(normalizedEndpoint, models);
+            return models;
         }
         catch (err) {
-            warns.push(`[WARN] Ollama not reachable at ${endpoint}; ${mode} memory cannot embed and will fail at runtime (${err instanceof Error ? err.message : String(err)}). Start Ollama or fix the endpoint.`);
+            ollamaModelsByEndpoint.set(normalizedEndpoint, undefined);
+            warns.push(`[WARN] Ollama not reachable at ${normalizedEndpoint}; ${mode} memory components configured for that endpoint will fail at runtime (${err instanceof Error ? err.message : String(err)}). Start Ollama or fix the endpoint.`);
+            return undefined;
         }
+    }
+    // 2. Ollama liveness — only probe components that actually use Ollama. OpenAI embeddings and
+    // agent-host chat LLMs have no local model list to validate here.
+    if (embeddingsUsesOllama) {
+        const endpoint = memory.embeddings?.endpoint ?? "http://localhost:11434";
+        const ollamaModels = await modelsForOllamaEndpoint(endpoint);
         if (ollamaModels !== undefined) {
-            if (embeddingsUsesOllama) {
-                const embeddingsModel = memory.embeddings?.model ?? "nomic-embed-text:v1.5";
-                if (!ollamaModels.includes(embeddingsModel)) {
-                    warns.push(`[WARN] Embeddings model ${embeddingsModel} not pulled — run \`ollama pull ${embeddingsModel}\`.`);
-                }
+            const embeddingsModel = memory.embeddings?.model ?? "nomic-embed-text:v1.5";
+            if (!ollamaModels.includes(embeddingsModel)) {
+                warns.push(`[WARN] Embeddings model ${embeddingsModel} not pulled — run \`ollama pull ${embeddingsModel}\`.`);
             }
-            if (llmUsesOllama && memory.llm !== undefined) {
-                const chatModel = memory.llm.model;
-                if (!ollamaModels.includes(chatModel)) {
-                    warns.push(`[WARN] Chat LLM model ${chatModel} not pulled — run \`ollama pull ${chatModel}\`.`);
-                }
+        }
+    }
+    if (llmUsesOllama && memory.llm !== undefined) {
+        const endpoint = memory.llm.endpoint ?? "http://localhost:11434";
+        const ollamaModels = await modelsForOllamaEndpoint(endpoint);
+        if (ollamaModels !== undefined) {
+            const chatModel = memory.llm.model;
+            if (!ollamaModels.includes(chatModel)) {
+                warns.push(`[WARN] Chat LLM model ${chatModel} not pulled — run \`ollama pull ${chatModel}\`.`);
             }
         }
     }
     return warns;
 }
-async function toolsSection(config) {
+async function memoryRootWritableWarnings(mode, memoryPath, allowFilesystemWrites) {
+    if (allowFilesystemWrites) {
+        try {
+            await mkdir(memoryPath, { recursive: true });
+            return [];
+        }
+        catch (err) {
+            return [
+                `[WARN] ${mode} memory root is not writable: ${memoryPath} (${err instanceof Error ? err.message : String(err)}). Fix filesystem permissions.`,
+            ];
+        }
+    }
+    try {
+        const info = await stat(memoryPath);
+        if (!info.isDirectory()) {
+            return [`[WARN] ${mode} memory root is not a directory: ${memoryPath}. Fix filesystem permissions.`];
+        }
+        await access(memoryPath, constants.W_OK);
+        return [];
+    }
+    catch (err) {
+        const code = err !== null && typeof err === "object" && "code" in err ? String(err.code) : undefined;
+        if (code === "ENOENT") {
+            return [
+                `[WARN] ${mode} memory root is missing: ${memoryPath}. Consumer validation is read-only and did not create it.`,
+            ];
+        }
+        return [
+            `[WARN] ${mode} memory root is not writable: ${memoryPath} (${err instanceof Error ? err.message : String(err)}). Fix filesystem permissions.`,
+        ];
+    }
+}
+function memoryLlmLabel(llm) {
+    if (llm === undefined) {
+        return "none";
+    }
+    return llm.provider === "ollama"
+        ? `ollama:${llm.model}`
+        : `agent-host:${llm.model}${llm.executionMode === undefined ? "" : ` (${llm.executionMode})`}`;
+}
+async function toolsSection(config, input) {
     const details = [];
     let status = "ok";
     details.push(config.tools.allowedTools.length === 0
@@ -236,48 +431,143 @@ async function toolsSection(config) {
             details.push(`MCP config file is missing: ${config.tools.mcpConfigPath}`);
         }
     }
+    const adapterSendTools = await resolveAdapterSendToolsSettings(input, {
+        allowedTools: config.tools.allowedTools,
+        disallowedTools: config.tools.disallowedTools,
+    });
+    if (adapterSendTools === undefined) {
+        details.push("No adapter-derived send tools enabled.");
+    }
+    else {
+        details.push(`Adapter send tools: ${adapterSendToolNames(adapterSendTools).join(", ")}.`);
+    }
     return { id: "tools", label: "Tools & MCP", status, details };
 }
-function sandboxSection(config) {
+async function sandboxSection(config, engine) {
     if (config.sandbox === undefined) {
         return { id: "sandbox", label: "Sandbox", status: "disabled", details: ["No sandbox policy configured."] };
     }
+    const state = await resolveSandboxEffectiveState({
+        policy: config.sandbox,
+        ...(engine === undefined ? {} : { engine }),
+    });
+    const warning = sandboxEffectiveStateWarning(state);
+    const details = [
+        `Mode: ${config.sandbox.mode}, network: ${config.sandbox.network.mode}, fallback: ${config.sandbox.fallback}.`,
+        describeSandboxEffectiveState(state),
+        ...(warning === undefined ? [] : [warning]),
+    ];
+    const status = warning !== undefined
+        ? "waiting"
+        : state.effective === "off"
+            ? "disabled"
+            : state.effective === "blocked"
+                ? "waiting"
+                : "ok";
     return {
         id: "sandbox",
         label: "Sandbox",
-        status: "ok",
-        details: [
-            `Mode: ${config.sandbox.mode}, network: ${config.sandbox.network.mode}, fallback: ${config.sandbox.fallback}.`,
-        ],
+        status,
+        details,
     };
 }
-async function consoleSection(input) {
+async function runsSection(input, config) {
+    const artifactDir = await resolveAppArtifactDir(input);
+    const { totalRuns, runs, warnings } = await listRecordedRuns({ artifactDir, maxRuns: RUNS_HEALTH_MAX_RUNS, scope: "agent" });
+    const display = buildRunsHealthDisplay({ artifactDir, totalRuns, runs, warnings });
+    const retentionDetails = config === undefined
+        ? []
+        : [
+            `Artifact retention: maxAgeDays=${config.artifacts.retention.maxAgeDays}, maxCount=${config.artifacts.retention.maxCount}, dryRun=${config.artifacts.retention.dryRun ? "true" : "false"}.`,
+            `Memory artifact retention: maxAgeDays=${config.artifacts.memoryRetention.maxAgeDays}, maxCount=${config.artifacts.memoryRetention.maxCount}, dryRun=${config.artifacts.memoryRetention.dryRun ? "true" : "false"}.`,
+        ];
+    return { id: "runs", label: "Runs health", status: display.status, details: [...retentionDetails, ...display.details] };
+}
+const LOCAL_ARTIFACTS_NOTE = "JSONL artifacts remain local (the exporter is additive; export failures never affect them).";
+/**
+ * Reports observability exporter state and, uniquely among the validation
+ * sections, performs a LIVE reachability probe of the Phoenix endpoint. An
+ * invalid exporter shape is a hard `error` (fails the report) so bad config is
+ * caught before startup, but an unreachable endpoint is only `waiting` — Phoenix
+ * may start after the agent, mirroring the Ollama-unreachable precedent so
+ * `validate` still passes. Probe failures are swallowed into a warning.
+ */
+async function exporterSection(input, liveness) {
+    let exporters;
     try {
-        const settings = await resolveAppConsoleSettings(input);
-        if (!settings.enabled) {
-            return {
-                id: "console",
-                label: "Operator console",
-                status: "disabled",
-                details: ["Disabled via console.enabled; start stays headless."],
-            };
-        }
-        return {
-            id: "console",
-            label: "Operator console",
-            status: "ok",
-            details: [
-                settings.port === undefined
-                    ? "Starts on a free loopback port."
-                    : `Starts on loopback port ${settings.port}.`,
-            ],
-        };
+        exporters = await resolveAppObservabilityExporters(input);
     }
     catch (error) {
         if (!isAppCoreConfigError(error)) {
             throw error;
         }
-        return { id: "console", label: "Operator console", status: "error", details: [error.message] };
+        return { id: "observability", label: "Observability exporter", status: "error", details: [error.message] };
+    }
+    if (exporters.length === 0) {
+        return {
+            id: "observability",
+            label: "Observability exporter",
+            status: "disabled",
+            details: ["No observability exporter configured."],
+        };
+    }
+    const exporter = exporters[0];
+    const details = [`Exporter: ${exporter.type} -> ${exporter.endpoint}`];
+    const appUrl = phoenixAppBaseUrl(exporter.endpoint);
+    if (appUrl !== undefined) {
+        details.push(`Phoenix app: ${appUrl}`);
+    }
+    if (exporter.includeSensitiveData) {
+        details.push(describeSensitiveDataExportWarning(exporter.endpoint));
+    }
+    // The reachability probe only ever yields `waiting`, so the start preflight
+    // skips it (liveness=false): the exporter shape is valid, and Phoenix may
+    // legitimately come up after the agent.
+    if (!liveness) {
+        details.push(LOCAL_ARTIFACTS_NOTE);
+        return { id: "observability", label: "Observability exporter", status: "ok", details };
+    }
+    const probeError = await probeExporterEndpoint(exporter.endpoint);
+    if (probeError !== undefined) {
+        details.push(`[WARN] Phoenix export not confirmed at ${exporter.endpoint} (${probeError}); exports will fail until it accepts OTLP protobuf. This is non-fatal.`);
+        details.push(LOCAL_ARTIFACTS_NOTE);
+        return { id: "observability", label: "Observability exporter", status: "waiting", details };
+    }
+    details.push(LOCAL_ARTIFACTS_NOTE);
+    return { id: "observability", label: "Observability exporter", status: "ok", details };
+}
+/**
+ * Live export-compatibility probe: POSTs a tiny but VALID empty OTLP protobuf
+ * `ExportTraceServiceRequest` (zero spans, so nothing is recorded) with
+ * `content-type: application/x-protobuf` — exactly the wire format a real export
+ * uses. Returns undefined when the endpoint accepts it (2xx), else an error
+ * string. This catches what the old OPTIONS reachability probe missed: a server
+ * that is listening but rejects the export (e.g. Phoenix returns 415 for the
+ * wrong content type), so `validate` no longer reports `[ok]` for an endpoint
+ * that every real export would 415. A throw (refused / DNS / timeout) means
+ * nothing is listening. Kept non-fatal upstream (`waiting`, not `error`): Phoenix
+ * may start after the agent.
+ */
+async function probeExporterEndpoint(endpoint) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => { ctrl.abort(); }, BUJO_PROBE_TIMEOUT_MS);
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/x-protobuf" },
+            body: serializeTraceSpans([]),
+            signal: ctrl.signal,
+        });
+        if (!response.ok) {
+            return `HTTP ${response.status}`;
+        }
+        return undefined;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+    finally {
+        clearTimeout(timer);
     }
 }
 async function channelSection(driver, input) {
@@ -292,6 +582,13 @@ async function channelSection(driver, input) {
         if (waitingReason !== undefined) {
             return { id, label: driver.label, status: "waiting", details: [waitingReason] };
         }
+        // A structural issue (e.g. a typo'd per-trigger model override) fails
+        // validate loudly here; `start` still runs the channel and warn-ignores
+        // the bad value at run time.
+        const issues = driver.configIssues?.(config) ?? [];
+        if (issues.length > 0) {
+            return { id, label: driver.label, status: "error", details: [...issues] };
+        }
         return { id, label: driver.label, status: "ok", details: ["Configured; will start with the app."] };
     }
     catch (error) {
@@ -303,7 +600,7 @@ async function channelSection(driver, input) {
     }
 }
 function referenceOf(model) {
-    return model.reference ?? `${model.sdk}:${model.provider === undefined ? "" : `${model.provider}:`}${model.model}`;
+    return modelReferenceKey(model);
 }
 async function pathExists(path) {
     try {