@sweny-ai/core 0.1.67 → 0.1.69

package/dist/cli/__tests__/diagram.test.js

@@ -2,8 +2,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { Command } from "commander";
-import { runWorkflowDiagram } from "../diagram.js";
+import { runWorkflowDiagram, resolveUseBlock } from "../diagram.js";
 const sampleWorkflow = {
     id: "sample",
     name: "Sample",
@@ -32,6 +31,42 @@ function captureStream() {
         },
     };
 }
+describe("resolveUseBlock", () => {
+    // Centralized behavior test — the renderer is a tiny switch around this
+    // so keeping the rules here as one table makes the policy easy to audit.
+    it("returns false by default (stdout, no -o, no flags)", () => {
+        expect(resolveUseBlock({})).toBe(false);
+    });
+    it("returns true when --block is explicit", () => {
+        expect(resolveUseBlock({ block: true })).toBe(true);
+    });
+    it("returns false when --no-block is explicit, even for .md", () => {
+        expect(resolveUseBlock({ block: false, output: "diagram.md" })).toBe(false);
+    });
+    it("infers true for .md output", () => {
+        expect(resolveUseBlock({ output: "diagram.md" })).toBe(true);
+    });
+    it("infers true for .markdown output", () => {
+        expect(resolveUseBlock({ output: "diagram.markdown" })).toBe(true);
+    });
+    it("infers false for .mmd output", () => {
+        expect(resolveUseBlock({ output: "diagram.mmd" })).toBe(false);
+    });
+    it("infers false for .mermaid output", () => {
+        expect(resolveUseBlock({ output: "diagram.mermaid" })).toBe(false);
+    });
+    it("infers false for any other extension (.txt, no ext, etc.)", () => {
+        expect(resolveUseBlock({ output: "diagram.txt" })).toBe(false);
+        expect(resolveUseBlock({ output: "diagram" })).toBe(false);
+    });
+    it("is case-insensitive on extension", () => {
+        expect(resolveUseBlock({ output: "Diagram.MD" })).toBe(true);
+        expect(resolveUseBlock({ output: "Diagram.MMD" })).toBe(false);
+    });
+    it("lets explicit --block override .mmd extension", () => {
+        expect(resolveUseBlock({ block: true, output: "diagram.mmd" })).toBe(true);
+    });
+});
 describe("runWorkflowDiagram", () => {
     let tmpdir;
     const loadWorkflowFile = vi.fn((_f) => sampleWorkflow);
@@ -44,55 +79,78 @@ describe("runWorkflowDiagram", () => {
     afterEach(() => {
         fs.rmSync(tmpdir, { recursive: true, force: true });
     });
-    describe("stdout", () => {
-        it("writes a fenced mermaid block to stdout by default", () => {
+    describe("stdout — default behavior", () => {
+        it("writes RAW mermaid (no fence, no title frontmatter) by default", () => {
+            // This is the Mermaid-CLI / Live-Editor-compatible output. No ```,
+            // no `---\ntitle: …\n---` — just `graph TB` and the nodes.
             const stdout = captureStream();
             const stderr = captureStream();
             runWorkflowDiagram("any.yml", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: stderr.stream, exit });
-            expect(stdout.text).toMatch(/^```mermaid\n/);
-            expect(stdout.text).toMatch(/\n```\n$/);
+            expect(stdout.text).not.toMatch(/```mermaid/);
+            expect(stdout.text).not.toMatch(/^---\ntitle:/);
+            expect(stdout.text).toMatch(/^graph TB/);
             expect(exit).not.toHaveBeenCalled();
         });
-        it("writes raw mermaid when --no-block is explicit", () => {
+        it("wraps in a ```mermaid fence when --block is explicit", () => {
             const stdout = captureStream();
-            const stderr = captureStream();
-            runWorkflowDiagram("any.yml", { block: false }, { loadWorkflowFile, stdout: stdout.stream, stderr: stderr.stream, exit });
-            expect(stdout.text).not.toMatch(/```mermaid/);
-            expect(stdout.text).toMatch(/graph TB/);
+            runWorkflowDiagram("any.yml", { block: true }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).toMatch(/^```mermaid\n/);
+            expect(stdout.text).toMatch(/\n```\n$/);
         });
         it("honors --direction LR", () => {
             const stdout = captureStream();
             runWorkflowDiagram("any.yml", { direction: "LR" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
             expect(stdout.text).toMatch(/graph LR/);
         });
-        it("honors --title override", () => {
+        it("emits --title as frontmatter only when explicitly set", () => {
             const stdout = captureStream();
             runWorkflowDiagram("any.yml", { title: "Custom Title" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(stdout.text).toContain("Custom Title");
+            expect(stdout.text).toMatch(/^---\ntitle: Custom Title\n---\n/);
+            expect(stdout.text).toContain("graph TB");
+        });
+        it("does NOT default title to the workflow name", () => {
+            // Regression guard: previously we auto-filled `title` from workflow.name,
+            // which broke mmdc / mermaid-live because they don't accept title frontmatter.
+            const stdout = captureStream();
+            runWorkflowDiagram("any.yml", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).not.toMatch(/title:/);
+            expect(stdout.text).not.toContain("Sample"); // workflow.name
         });
     });
     describe("-o / --output file", () => {
-        it("writes raw mermaid to .mmd by default (no fence)", () => {
+        it("writes raw mermaid to .mmd (default)", () => {
             const out = path.join(tmpdir, "diagram.mmd");
             const stderr = captureStream();
             runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: stderr.stream, exit });
             const contents = fs.readFileSync(out, "utf8");
             expect(contents).not.toMatch(/```mermaid/);
-            expect(contents).toMatch(/graph TB/);
+            expect(contents).not.toMatch(/title:/);
+            expect(contents).toMatch(/^graph TB/);
             expect(stderr.text).toMatch(/✓ Wrote diagram to/);
         });
-        it("writes fenced markdown to .md by default", () => {
+        it("writes raw mermaid to .mermaid (Mermaid CLI's canonical extension)", () => {
+            const out = path.join(tmpdir, "diagram.mermaid");
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
+            const contents = fs.readFileSync(out, "utf8");
+            expect(contents).not.toMatch(/```mermaid/);
+            expect(contents).toMatch(/^graph TB/);
+        });
+        it("writes fenced markdown to .md", () => {
             const out = path.join(tmpdir, "diagram.md");
             runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
             const contents = fs.readFileSync(out, "utf8");
             expect(contents).toMatch(/^```mermaid\n/);
             expect(contents).toMatch(/\n```\n$/);
         });
-        it("falls back to fenced default for unknown extensions", () => {
+        it("writes raw mermaid for unknown extensions (no longer falls back to fenced)", () => {
+            // Behavior change: previously .txt and friends got fenced as the
+            // "safe default". Now raw mermaid is the safe default because that's
+            // what every renderer actually accepts.
             const out = path.join(tmpdir, "diagram.txt");
             runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
             const contents = fs.readFileSync(out, "utf8");
-            expect(contents).toMatch(/```mermaid/);
+            expect(contents).not.toMatch(/```mermaid/);
+            expect(contents).toMatch(/graph TB/);
         });
         it("creates parent directories as needed (-o nested/subdir/file.mmd)", () => {
             const out = path.join(tmpdir, "a", "b", "c", "diagram.mmd");
@@ -107,51 +165,15 @@ describe("runWorkflowDiagram", () => {
             expect(stdout.text).toBe("");
         });
     });
-    describe("explicit --block / --no-block precedence over extension inference", () => {
-        function cmdWithBlock(block, explicit) {
-            const cmd = new Command();
-            cmd.option("--block", "fenced", true);
-            cmd.option("--no-block", "raw");
-            if (explicit) {
-                // Simulate user typing `--block` or `--no-block` on the CLI — commander
-                // marks the source as "cli" when the flag is seen in argv.
-                cmd.setOptionValueWithSource("block", block, "cli");
-            }
-            return cmd;
-        }
-        it("explicit --block wins over .mmd extension (writes fenced to .mmd)", () => {
+    describe("explicit --block / --no-block override extension inference", () => {
+        it("explicit --block wins over .mmd (writes fenced to .mmd)", () => {
             const out = path.join(tmpdir, "diagram.mmd");
-            runWorkflowDiagram("any.yml", { output: out, block: true }, {
-                loadWorkflowFile,
-                command: cmdWithBlock(true, true),
-                stdout: captureStream().stream,
-                stderr: captureStream().stream,
-                exit,
-            });
+            runWorkflowDiagram("any.yml", { output: out, block: true }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
             expect(fs.readFileSync(out, "utf8")).toMatch(/```mermaid/);
         });
-        it("explicit --no-block wins over .md extension (writes raw to .md)", () => {
+        it("explicit --no-block wins over .md (writes raw to .md)", () => {
             const out = path.join(tmpdir, "diagram.md");
-            runWorkflowDiagram("any.yml", { output: out, block: false }, {
-                loadWorkflowFile,
-                command: cmdWithBlock(false, true),
-                stdout: captureStream().stream,
-                stderr: captureStream().stream,
-                exit,
-            });
-            expect(fs.readFileSync(out, "utf8")).not.toMatch(/```mermaid/);
-        });
-        it("default --block source does not suppress .mmd extension inference", () => {
-            // Commander always sets `block: true` via the declared default, but its
-            // source is "default" — our inference should still kick in for .mmd.
-            const out = path.join(tmpdir, "diagram.mmd");
-            runWorkflowDiagram("any.yml", { output: out, block: true }, {
-                loadWorkflowFile,
-                command: cmdWithBlock(true, false), // not explicit
-                stdout: captureStream().stream,
-                stderr: captureStream().stream,
-                exit,
-            });
+            runWorkflowDiagram("any.yml", { output: out, block: false }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
             expect(fs.readFileSync(out, "utf8")).not.toMatch(/```mermaid/);
         });
     });
@@ -160,7 +182,9 @@ describe("runWorkflowDiagram", () => {
             const stdout = captureStream();
             runWorkflowDiagram("triage", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
             expect(loadWorkflowFile).not.toHaveBeenCalled();
-            expect(stdout.text).toMatch(/```mermaid/);
+            expect(stdout.text).toMatch(/graph TB/);
+            // Confirm built-in renders raw by default too.
+            expect(stdout.text).not.toMatch(/```mermaid/);
         });
         it("resolves 'implement' without calling loadWorkflowFile", () => {
             const stdout = captureStream();

package/dist/cli/__tests__/report-cloud.test.js

@@ -23,7 +23,7 @@ describe("reportToCloud", () => {
             claudeOauthToken: "",
             openaiApiKey: "",
             geminiApiKey: "",
-            observabilityProvider: "",
+            observabilityProviders: [],
             observabilityCredentials: {},
             issueTrackerProvider: "",
             linearApiKey: "",

package/dist/cli/__tests__/upgrade.test.js

@@ -158,6 +158,17 @@ describe("runUpgrade — no-op paths", () => {
         expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@latest"]);
         expect(exit).toHaveBeenCalledWith(0);
     });
+    it("downgrades when --force is set against a local-dev build ahead of the registry", async () => {
+        const { deps, runInstall, exit } = makeDeps({
+            currentVersion: "0.2.0",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({ force: true }, deps);
+        // --force explicitly overrides the "ahead" short-circuit — this is how
+        // someone pins back to the published train from a stale local build.
+        expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@latest"]);
+        expect(exit).toHaveBeenCalledWith(0);
+    });
 });
 describe("runUpgrade — install dispatch", () => {
     it("invokes the detected package manager and exits 0 on success", async () => {

package/dist/cli/__tests__/version-check.test.js

@@ -166,6 +166,23 @@ describe("maybeNudge", () => {
         expect(readCache(cachePath)).toBeNull(); // fetch failed, nothing written
         expect(stderr.text).toBe(""); // silent on error
     });
+    it("gives up silently when the registry is slower than the budget", async () => {
+        // The race between fetch and the internal timer means a slow fetch should
+        // resolve to null → no cache write → no nudge. We pin down the behavior
+        // here so a future regression (forgetting the race or the timeout) gets
+        // caught even though the budget is configured in the module itself.
+        const slowFetch = vi.fn(() => new Promise((resolve) => {
+            // Never resolves within the test — the internal timer is what wins.
+            const t = setTimeout(() => resolve("9.9.9"), 10_000);
+            if (typeof t.unref === "function") {
+                t.unref();
+            }
+        }));
+        await maybeNudge(baseDeps({ fetchLatestVersion: slowFetch }));
+        expect(slowFetch).toHaveBeenCalled();
+        expect(readCache(cachePath)).toBeNull();
+        expect(stderr.text).toBe("");
+    });
     it("does not refresh when cache is fresh (saves bandwidth)", async () => {
         writeCache(cachePath, { latest: "0.1.65", checkedAt: 1_000_000 });
         await maybeNudge(baseDeps({ now: 1_000_000 + 1 }));

package/dist/cli/check.js

@@ -29,21 +29,24 @@ export async function checkProviderConnectivity(config) {
         });
     }
     // ── Observability ────────────────────────────────────────────────────────────
-    if (config.observabilityProvider === "datadog") {
-        results.push(await checkDatadog(config.observabilityCredentials));
-    }
-    else if (config.observabilityProvider === "sentry") {
-        results.push(await checkSentry(config.observabilityCredentials));
-    }
-    else if (config.observabilityProvider === "file") {
-        results.push({ name: "Observability (file)", status: "skip", detail: "File provider — no network check needed" });
-    }
-    else {
-        results.push({
-            name: `Observability (${config.observabilityProvider})`,
-            status: "skip",
-            detail: "Connectivity check not implemented for this provider",
-        });
+    for (const provider of config.observabilityProviders) {
+        const creds = config.observabilityCredentials[provider] ?? {};
+        if (provider === "datadog") {
+            results.push(await checkDatadog(creds));
+        }
+        else if (provider === "sentry") {
+            results.push(await checkSentry(creds));
+        }
+        else if (provider === "file") {
+            results.push({ name: "Observability (file)", status: "skip", detail: "File provider — no network check needed" });
+        }
+        else {
+            results.push({
+                name: `Observability (${provider})`,
+                status: "skip",
+                detail: "Connectivity check not implemented for this provider",
+            });
+        }
     }
     // ── Issue tracker ────────────────────────────────────────────────────────────
     if (config.issueTrackerProvider === "linear") {

package/dist/cli/config.d.ts

@@ -7,8 +7,8 @@ export interface CliConfig {
     claudeOauthToken: string;
     openaiApiKey: string;
     geminiApiKey: string;
-    observabilityProvider: string;
-    observabilityCredentials: Record<string, string>;
+    observabilityProviders: string[];
+    observabilityCredentials: Record<string, Record<string, string>>;
     issueTrackerProvider: string;
     linearApiKey: string;
     linearTeamId: string;

package/dist/cli/config.js

@@ -86,7 +86,15 @@ export function parseCliInputs(options, fileConfig = {}) {
             return [fileVal];
         return [];
     };
-    const obsProvider = options.observabilityProvider || f("observability-provider") || "none";
+    const obsRaw = options.observabilityProvider || f("observability-provider") || "none";
+    const obsProviders = obsRaw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s && s !== "none");
+    const obsCreds = {};
+    for (const p of obsProviders) {
+        obsCreds[p] = parseObservabilityCredentials(p, options, fileConfig);
+    }
     return {
         codingAgentProvider: options.agent || options.codingAgentProvider || f("coding-agent-provider") || "claude",
         // Secrets: env only — never from config file
@@ -94,8 +102,8 @@ export function parseCliInputs(options, fileConfig = {}) {
         claudeOauthToken: env.CLAUDE_CODE_OAUTH_TOKEN || "",
         openaiApiKey: env.OPENAI_API_KEY || "",
         geminiApiKey: env.GEMINI_API_KEY || env.GOOGLE_API_KEY || "",
-        observabilityProvider: obsProvider,
-        observabilityCredentials: parseObservabilityCredentials(obsProvider, options, fileConfig),
+        observabilityProviders: obsProviders,
+        observabilityCredentials: obsCreds,
         issueTrackerProvider: options.issueTrackerProvider || f("issue-tracker-provider") || "github-issues",
         linearApiKey: env.LINEAR_API_KEY || "",
         linearTeamId: options.linearTeamId || env.LINEAR_TEAM_ID || f("linear-team-id") || "",
@@ -218,122 +226,123 @@ export function validateInputs(config) {
     if (!config.repository && !allLocal) {
         errors.push("Missing: --repository <owner/repo> or GITHUB_REPOSITORY (could not auto-detect from git remote)");
     }
-    // Observability credentials by provider
-    switch (config.observabilityProvider) {
-        case "none":
-            break; // No observability provider configured — nothing to validate
-        case "datadog":
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: DD_API_KEY — find API keys at https://app.datadoghq.com/organization-settings/api-keys");
-            if (!config.observabilityCredentials.appKey)
-                errors.push("Missing: DD_APP_KEY — find application keys at https://app.datadoghq.com/organization-settings/application-keys");
-            break;
-        case "sentry":
-            if (!config.observabilityCredentials.authToken)
-                errors.push("Missing: SENTRY_AUTH_TOKEN — create a token at https://sentry.io/settings/auth-tokens/");
-            if (!config.observabilityCredentials.organization)
-                errors.push("Missing: --sentry-org is required for sentry provider");
-            if (!config.observabilityCredentials.project)
-                errors.push("Missing: --sentry-project is required for sentry provider");
-            break;
-        case "cloudwatch":
-            if (!config.observabilityCredentials.logGroupPrefix)
-                errors.push("Missing: --cloudwatch-log-group-prefix is required for cloudwatch provider");
-            break;
-        case "splunk":
-            if (!config.observabilityCredentials.baseUrl)
-                errors.push("Missing: SPLUNK_URL is required for splunk provider");
-            if (!config.observabilityCredentials.token)
-                errors.push("Missing: SPLUNK_TOKEN is required for splunk provider");
-            break;
-        case "elastic":
-            if (!config.observabilityCredentials.baseUrl)
-                errors.push("Missing: ELASTIC_URL is required for elastic provider");
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: ELASTIC_API_KEY is required for elastic provider");
-            break;
-        case "newrelic":
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: NR_API_KEY is required for newrelic provider");
-            if (!config.observabilityCredentials.accountId)
-                errors.push("Missing: NR_ACCOUNT_ID is required for newrelic provider");
-            break;
-        case "loki":
-            if (!config.observabilityCredentials.baseUrl)
-                errors.push("Missing: LOKI_URL is required for loki provider");
-            break;
-        case "file":
-            if (!config.observabilityCredentials.path)
-                errors.push("Missing: --log-file <path> is required for file provider");
-            break;
-        case "prometheus":
-            if (!config.observabilityCredentials.url)
-                errors.push("Missing: PROMETHEUS_URL or --prometheus-url is required for prometheus provider");
-            break;
-        case "pagerduty":
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: PAGERDUTY_API_KEY is required for pagerduty provider");
-            break;
-        case "heroku":
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: HEROKU_API_KEY is required for heroku provider");
-            if (!config.observabilityCredentials.appName)
-                errors.push("Missing: HEROKU_APP_NAME or --heroku-app-name is required for heroku provider");
-            break;
-        case "opsgenie":
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: OPSGENIE_API_KEY is required for opsgenie provider");
-            break;
-        case "honeycomb":
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: HONEYCOMB_API_KEY is required for honeycomb provider");
-            if (!config.observabilityCredentials.dataset)
-                errors.push("Missing: HONEYCOMB_DATASET is required for honeycomb provider");
-            break;
-        case "axiom":
-            if (!config.observabilityCredentials.apiToken)
-                errors.push("Missing: AXIOM_TOKEN is required for axiom provider");
-            if (!config.observabilityCredentials.dataset)
-                errors.push("Missing: AXIOM_DATASET or --axiom-dataset is required for axiom provider");
-            break;
-        case "betterstack":
-            if (!config.observabilityCredentials.apiToken)
-                errors.push("Missing: BETTERSTACK_API_TOKEN, BETTERSTACK_TELEMETRY_TOKEN, or BETTERSTACK_UPTIME_TOKEN is required for betterstack provider");
-            if (!config.observabilityCredentials.sourceId && !config.observabilityCredentials.tableName)
-                errors.push("Missing: either BETTERSTACK_SOURCE_ID (--betterstack-source-id) or BETTERSTACK_TABLE_NAME (--betterstack-table-name) is required for betterstack provider");
-            break;
-        case "vercel":
-            if (!config.observabilityCredentials.token)
-                errors.push("Missing: VERCEL_TOKEN — create a token at https://vercel.com/account/tokens");
-            if (!config.observabilityCredentials.projectId)
-                errors.push("Missing: VERCEL_PROJECT_ID — find it in your Vercel project settings");
-            break;
-        case "supabase":
-            if (!config.observabilityCredentials.managementApiKey)
-                errors.push("Missing: SUPABASE_MANAGEMENT_KEY — create a token at https://supabase.com/dashboard/account/tokens");
-            if (!config.observabilityCredentials.projectRef)
-                errors.push("Missing: SUPABASE_PROJECT_REF — find it in your Supabase project settings > General");
-            break;
-        case "netlify":
-            if (!config.observabilityCredentials.token)
-                errors.push("Missing: NETLIFY_TOKEN — create a token at https://app.netlify.com/user/applications#personal-access-tokens");
-            if (!config.observabilityCredentials.siteId)
-                errors.push("Missing: NETLIFY_SITE_ID — find it in Site Settings > General > Site details");
-            break;
-        case "fly":
-            if (!config.observabilityCredentials.token)
-                errors.push("Missing: FLY_TOKEN — create a token at https://fly.io/user/personal_access_tokens");
-            if (!config.observabilityCredentials.appName)
-                errors.push("Missing: FLY_APP_NAME — the name of your Fly.io application");
-            break;
-        case "render":
-            if (!config.observabilityCredentials.apiKey)
-                errors.push("Missing: RENDER_API_KEY — create an API key at https://dashboard.render.com/u/settings");
-            if (!config.observabilityCredentials.serviceId)
-                errors.push("Missing: RENDER_SERVICE_ID — find it in your service's Settings page (srv-...)");
-            break;
-        default:
-            errors.push(`Unknown --observability-provider "${config.observabilityProvider}". Valid values: none, datadog, sentry, cloudwatch, splunk, elastic, newrelic, loki, prometheus, pagerduty, honeycomb, heroku, opsgenie, axiom, betterstack, vercel, supabase, netlify, fly, render, file`);
+    // Observability credentials by provider — validate each configured provider
+    for (const provider of config.observabilityProviders) {
+        const creds = config.observabilityCredentials[provider] ?? {};
+        switch (provider) {
+            case "datadog":
+                if (!creds.apiKey)
+                    errors.push("Missing: DD_API_KEY — find API keys at https://app.datadoghq.com/organization-settings/api-keys");
+                if (!creds.appKey)
+                    errors.push("Missing: DD_APP_KEY — find application keys at https://app.datadoghq.com/organization-settings/application-keys");
+                break;
+            case "sentry":
+                if (!creds.authToken)
+                    errors.push("Missing: SENTRY_AUTH_TOKEN — create a token at https://sentry.io/settings/auth-tokens/");
+                if (!creds.organization)
+                    errors.push("Missing: --sentry-org is required for sentry provider");
+                if (!creds.project)
+                    errors.push("Missing: --sentry-project is required for sentry provider");
+                break;
+            case "cloudwatch":
+                if (!creds.logGroupPrefix)
+                    errors.push("Missing: --cloudwatch-log-group-prefix is required for cloudwatch provider");
+                break;
+            case "splunk":
+                if (!creds.baseUrl)
+                    errors.push("Missing: SPLUNK_URL is required for splunk provider");
+                if (!creds.token)
+                    errors.push("Missing: SPLUNK_TOKEN is required for splunk provider");
+                break;
+            case "elastic":
+                if (!creds.baseUrl)
+                    errors.push("Missing: ELASTIC_URL is required for elastic provider");
+                if (!creds.apiKey)
+                    errors.push("Missing: ELASTIC_API_KEY is required for elastic provider");
+                break;
+            case "newrelic":
+                if (!creds.apiKey)
+                    errors.push("Missing: NR_API_KEY is required for newrelic provider");
+                if (!creds.accountId)
+                    errors.push("Missing: NR_ACCOUNT_ID is required for newrelic provider");
+                break;
+            case "loki":
+                if (!creds.baseUrl)
+                    errors.push("Missing: LOKI_URL is required for loki provider");
+                break;
+            case "file":
+                if (!creds.path)
+                    errors.push("Missing: --log-file <path> is required for file provider");
+                break;
+            case "prometheus":
+                if (!creds.url)
+                    errors.push("Missing: PROMETHEUS_URL or --prometheus-url is required for prometheus provider");
+                break;
+            case "pagerduty":
+                if (!creds.apiKey)
+                    errors.push("Missing: PAGERDUTY_API_KEY is required for pagerduty provider");
+                break;
+            case "heroku":
+                if (!creds.apiKey)
+                    errors.push("Missing: HEROKU_API_KEY is required for heroku provider");
+                if (!creds.appName)
+                    errors.push("Missing: HEROKU_APP_NAME or --heroku-app-name is required for heroku provider");
+                break;
+            case "opsgenie":
+                if (!creds.apiKey)
+                    errors.push("Missing: OPSGENIE_API_KEY is required for opsgenie provider");
+                break;
+            case "honeycomb":
+                if (!creds.apiKey)
+                    errors.push("Missing: HONEYCOMB_API_KEY is required for honeycomb provider");
+                if (!creds.dataset)
+                    errors.push("Missing: HONEYCOMB_DATASET is required for honeycomb provider");
+                break;
+            case "axiom":
+                if (!creds.apiToken)
+                    errors.push("Missing: AXIOM_TOKEN is required for axiom provider");
+                if (!creds.dataset)
+                    errors.push("Missing: AXIOM_DATASET or --axiom-dataset is required for axiom provider");
+                break;
+            case "betterstack":
+                if (!creds.apiToken)
+                    errors.push("Missing: BETTERSTACK_API_TOKEN, BETTERSTACK_TELEMETRY_TOKEN, or BETTERSTACK_UPTIME_TOKEN is required for betterstack provider");
+                if (!creds.sourceId && !creds.tableName)
+                    errors.push("Missing: either BETTERSTACK_SOURCE_ID (--betterstack-source-id) or BETTERSTACK_TABLE_NAME (--betterstack-table-name) is required for betterstack provider");
+                break;
+            case "vercel":
+                if (!creds.token)
+                    errors.push("Missing: VERCEL_TOKEN — create a token at https://vercel.com/account/tokens");
+                if (!creds.projectId)
+                    errors.push("Missing: VERCEL_PROJECT_ID — find it in your Vercel project settings");
+                break;
+            case "supabase":
+                if (!creds.managementApiKey)
+                    errors.push("Missing: SUPABASE_MANAGEMENT_KEY — create a token at https://supabase.com/dashboard/account/tokens");
+                if (!creds.projectRef)
+                    errors.push("Missing: SUPABASE_PROJECT_REF — find it in your Supabase project settings > General");
+                break;
+            case "netlify":
+                if (!creds.token)
+                    errors.push("Missing: NETLIFY_TOKEN — create a token at https://app.netlify.com/user/applications#personal-access-tokens");
+                if (!creds.siteId)
+                    errors.push("Missing: NETLIFY_SITE_ID — find it in Site Settings > General > Site details");
+                break;
+            case "fly":
+                if (!creds.token)
+                    errors.push("Missing: FLY_TOKEN — create a token at https://fly.io/user/personal_access_tokens");
+                if (!creds.appName)
+                    errors.push("Missing: FLY_APP_NAME — the name of your Fly.io application");
+                break;
+            case "render":
+                if (!creds.apiKey)
+                    errors.push("Missing: RENDER_API_KEY — create an API key at https://dashboard.render.com/u/settings");
+                if (!creds.serviceId)
+                    errors.push("Missing: RENDER_SERVICE_ID — find it in your service's Settings page (srv-...)");
+                break;
+            default:
+                errors.push(`Unknown --observability-provider "${provider}". Valid values: none, datadog, sentry, cloudwatch, splunk, elastic, newrelic, loki, prometheus, pagerduty, honeycomb, heroku, opsgenie, axiom, betterstack, vercel, supabase, netlify, fly, render, file`);
+        }
     }
     // Issue tracker credentials by provider
     switch (config.issueTrackerProvider) {

package/dist/cli/config.test.js

@@ -12,8 +12,8 @@ function baseConfig(overrides = {}) {
         claudeOauthToken: "",
         openaiApiKey: "",
         geminiApiKey: "",
-        observabilityProvider: "file",
-        observabilityCredentials: {},
+        observabilityProviders: ["file"],
+        observabilityCredentials: { file: {} },
         issueTrackerProvider: "file",
         linearApiKey: "",
         linearTeamId: "",
@@ -114,23 +114,27 @@ describe("validateInputs — notification provider", () => {
 });
 describe("validateInputs — observability provider", () => {
     it("accepts 'none' without requiring any credentials", () => {
-        const errors = validateInputs(baseConfig({ observabilityProvider: "none", observabilityCredentials: {} }));
+        const errors = validateInputs(baseConfig({ observabilityProviders: [], observabilityCredentials: {} }));
         expect(errors.filter((e) => e.includes("DD_") || e.includes("observability"))).toEqual([]);
     });
     it("requires DD keys when explicitly set to datadog", () => {
-        const errors = validateInputs(baseConfig({ observabilityProvider: "datadog", observabilityCredentials: {} }));
+        const errors = validateInputs(baseConfig({ observabilityProviders: ["datadog"], observabilityCredentials: {} }));
         expect(errors.some((e) => e.includes("DD_API_KEY"))).toBe(true);
         expect(errors.some((e) => e.includes("DD_APP_KEY"))).toBe(true);
     });
 });
 describe("parseCliInputs — observability provider default", () => {
-    it("defaults to 'none' when no provider is configured", () => {
+    it("defaults to empty array when no provider is configured", () => {
         const config = parseCliInputs({}, {});
-        expect(config.observabilityProvider).toBe("none");
+        expect(config.observabilityProviders).toEqual([]);
     });
     it("respects explicit datadog provider", () => {
         const config = parseCliInputs({ observabilityProvider: "datadog" }, {});
-        expect(config.observabilityProvider).toBe("datadog");
+        expect(config.observabilityProviders).toEqual(["datadog"]);
+    });
+    it("supports comma-separated multiple providers", () => {
+        const config = parseCliInputs({ observabilityProvider: "loki,sentry" }, {});
+        expect(config.observabilityProviders).toEqual(["loki", "sentry"]);
     });
 });
 describe("fetch.auth + offline parsing", () => {

package/dist/cli/diagram.d.ts

@@ -1,16 +1,24 @@
-import type { Command } from "commander";
 import type { Workflow } from "../types.js";
 export interface DiagramOptions {
     direction?: string;
+    /**
+     * Optional diagram title. When omitted we render pure Mermaid with no
+     * `---\ntitle: …\n---` frontmatter — the format that `mmdc`, Mermaid Live
+     * Editor, and `@mermaid-js/mermaid-cli` all accept as-is.
+     */
     title?: string;
+    /**
+     * Wrap output in a ```mermaid fenced code block. Tri-state:
+     *   - `true`  → fenced (forced by explicit `--block`)
+     *   - `false` → raw (forced by explicit `--no-block`)
+     *   - `undefined` → inferred from `--output` extension; default is raw
+     */
     block?: boolean;
     output?: string;
 }
 export interface DiagramDeps {
     /** Load a workflow file (YAML or JSON). Injected so tests can stub. */
     loadWorkflowFile: (file: string) => Workflow;
-    /** Commander instance used to detect whether --block was set explicitly. */
-    command?: Command;
     /** Stream for success/error messages. Defaults to process.stderr. */
     stderr?: NodeJS.WritableStream;
     /** Stream for diagram output when no --output is set. Defaults to process.stdout. */
@@ -18,13 +26,24 @@ export interface DiagramDeps {
     /** Exit handler. Defaults to process.exit. Tests can throw instead. */
     exit?: (code: number) => void;
 }
+/**
+ * Resolve whether output should be wrapped in a ```mermaid fenced block.
+ *
+ * Precedence:
+ *   1. Explicit `--block` / `--no-block` always wins.
+ *   2. When `-o` points at `.md`/`.markdown` we fence (markdown context).
+ *   3. Everything else — stdout, `.mmd`, `.mermaid`, unknown extensions —
+ *      emits raw Mermaid syntax that Mermaid CLI / Live Editor / mmdc can
+ *      consume directly with no preprocessing.
+ */
+export declare function resolveUseBlock(options: DiagramOptions): boolean;
 /**
  * Render a workflow as a Mermaid diagram and write to stdout or a file.
  *
- * Block-default rules (in order of precedence):
- *   1. Explicit `--block` / `--no-block` — always wins (detected via the
- *      Command's option-value source when provided)
- *   2. When `-o` is set, infer from extension: `.mmd` → raw, `.md` → fenced
- *   3. Otherwise default to fenced (matches prior stdout behavior)
+ * By default the output is pure Mermaid — no ```mermaid fence, no
+ * `---\ntitle: …\n---` frontmatter — so the result is directly consumable
+ * by Mermaid CLI (`mmdc`) and the Live Editor. Pass `--block` to wrap in a
+ * fenced code block for README embedding, or `--title` to inject a title
+ * header for Mermaid renderers that support it.
  */
 export declare function runWorkflowDiagram(file: string, options: DiagramOptions, deps: DiagramDeps): void;

package/dist/cli/diagram.js

@@ -3,14 +3,37 @@ import * as path from "node:path";
 import chalk from "chalk";
 import { toMermaid, toMermaidBlock } from "../mermaid.js";
 import { triageWorkflow, implementWorkflow, seedContentWorkflow } from "../workflows/index.js";
+const MARKDOWN_EXTS = new Set([".md", ".markdown"]);
+/**
+ * Resolve whether output should be wrapped in a ```mermaid fenced block.
+ *
+ * Precedence:
+ *   1. Explicit `--block` / `--no-block` always wins.
+ *   2. When `-o` points at `.md`/`.markdown` we fence (markdown context).
+ *   3. Everything else — stdout, `.mmd`, `.mermaid`, unknown extensions —
+ *      emits raw Mermaid syntax that Mermaid CLI / Live Editor / mmdc can
+ *      consume directly with no preprocessing.
+ */
+export function resolveUseBlock(options) {
+    if (options.block === true)
+        return true;
+    if (options.block === false)
+        return false;
+    if (options.output) {
+        const ext = path.extname(options.output).toLowerCase();
+        if (MARKDOWN_EXTS.has(ext))
+            return true;
+    }
+    return false;
+}
 /**
  * Render a workflow as a Mermaid diagram and write to stdout or a file.
  *
- * Block-default rules (in order of precedence):
- *   1. Explicit `--block` / `--no-block` — always wins (detected via the
- *      Command's option-value source when provided)
- *   2. When `-o` is set, infer from extension: `.mmd` → raw, `.md` → fenced
- *   3. Otherwise default to fenced (matches prior stdout behavior)
+ * By default the output is pure Mermaid — no ```mermaid fence, no
+ * `---\ntitle: …\n---` frontmatter — so the result is directly consumable
+ * by Mermaid CLI (`mmdc`) and the Live Editor. Pass `--block` to wrap in a
+ * fenced code block for README embedding, or `--title` to inject a title
+ * header for Mermaid renderers that support it.
  */
 export function runWorkflowDiagram(file, options, deps) {
     const stderr = deps.stderr ?? process.stderr;
@@ -38,21 +61,14 @@ export function runWorkflowDiagram(file, options, deps) {
         }
     }
     const direction = (options.direction === "LR" ? "LR" : "TB");
-    const title = options.title ?? workflow.name;
-    // Explicit --block / --no-block always wins. When commander's source is
-    // "cli" or "env" the user (or env var) set it; otherwise we may infer.
-    const blockSource = deps.command?.getOptionValueSource("block");
-    const blockExplicit = blockSource === "cli" || blockSource === "env";
-    let useBlock = options.block !== false;
-    if (!blockExplicit && options.output) {
-        const ext = path.extname(options.output).toLowerCase();
-        if (ext === ".mmd")
-            useBlock = false;
-        else if (ext === ".md")
-            useBlock = true;
-    }
+    const useBlock = resolveUseBlock(options);
     const render = useBlock ? toMermaidBlock : toMermaid;
-    const output = render(workflow, { direction, title }) + "\n";
+    // Title is opt-in only — an unset `--title` produces no frontmatter. Users
+    // who want the workflow.name as title can pass `--title "$(name)"`.
+    const renderOpts = { direction };
+    if (options.title)
+        renderOpts.title = options.title;
+    const output = render(workflow, renderOpts) + "\n";
     if (options.output) {
         try {
             // Create parent dirs so `-o some/nested/diagram.mmd` works without a

package/dist/cli/main.js

@@ -111,7 +111,7 @@ function buildMcpAutoConfig(config) {
     return {
         sourceControlProvider: config.sourceControlProvider,
         issueTrackerProvider: config.issueTrackerProvider,
-        observabilityProvider: config.observabilityProvider,
+        observabilityProviders: config.observabilityProviders,
         credentials: buildCredentialMap(),
         workspaceTools: config.workspaceTools,
         userMcpServers: Object.keys(config.mcpServers).length > 0 ? config.mcpServers : undefined,
@@ -122,14 +122,15 @@ function buildMcpAutoConfig(config) {
  */
 function buildProviderCtx(config, mcpServers) {
     const extras = {};
-    if (config.observabilityCredentials.sourceId) {
-        extras["BetterStack source ID"] = config.observabilityCredentials.sourceId;
+    const bsCreds = config.observabilityCredentials["betterstack"];
+    if (bsCreds?.sourceId) {
+        extras["BetterStack source ID"] = bsCreds.sourceId;
     }
-    if (config.observabilityCredentials.tableName) {
-        extras["BetterStack table name"] = config.observabilityCredentials.tableName;
+    if (bsCreds?.tableName) {
+        extras["BetterStack table name"] = bsCreds.tableName;
     }
     return buildProviderContext({
-        observabilityProvider: config.observabilityProvider,
+        observabilityProviders: config.observabilityProviders,
         issueTrackerProvider: config.issueTrackerProvider,
         sourceControlProvider: config.sourceControlProvider,
         mcpServers: Object.keys(mcpServers),
@@ -306,6 +307,7 @@ triageCmd.action(async (options) => {
     if (config.additionalInstructions)
         contextParts.push(config.additionalInstructions);
     const fullContext = [contextParts.join("\n\n"), context].filter(Boolean).join("\n\n---\n\n");
+    const bsCreds = config.observabilityCredentials["betterstack"];
     const workflowInput = {
         timeRange: config.timeRange,
         severityFocus: config.severityFocus,
@@ -320,12 +322,12 @@ triageCmd.action(async (options) => {
         issueOverride: config.issueOverride,
         noveltyMode: config.noveltyMode,
         reviewMode: config.reviewMode,
-        observabilityProvider: config.observabilityProvider,
-        ...(config.observabilityCredentials.sourceId && {
-            betterstackSourceId: config.observabilityCredentials.sourceId,
+        observabilityProviders: config.observabilityProviders,
+        ...(bsCreds?.sourceId && {
+            betterstackSourceId: bsCreds.sourceId,
         }),
-        ...(config.observabilityCredentials.tableName && {
-            betterstackTableName: config.observabilityCredentials.tableName,
+        ...(bsCreds?.tableName && {
+            betterstackTableName: bsCreds.tableName,
         }),
         // Structured rules/context for executor (URLs resolved eagerly by loadAdditionalContext)
         rules,
@@ -665,12 +667,12 @@ export async function workflowRunAction(file, options) {
             baseBranch: config.baseBranch,
             prLabels: config.prLabels,
             additionalInstructions: config.additionalInstructions,
-            observabilityProvider: config.observabilityProvider,
-            ...(config.observabilityCredentials.sourceId && {
-                betterstackSourceId: config.observabilityCredentials.sourceId,
+            observabilityProviders: config.observabilityProviders,
+            ...(config.observabilityCredentials["betterstack"]?.sourceId && {
+                betterstackSourceId: config.observabilityCredentials["betterstack"].sourceId,
             }),
-            ...(config.observabilityCredentials.tableName && {
-                betterstackTableName: config.observabilityCredentials.tableName,
+            ...(config.observabilityCredentials["betterstack"]?.tableName && {
+                betterstackTableName: config.observabilityCredentials["betterstack"].tableName,
             }),
             context: buildProviderCtx(config, mcpServers),
         };
@@ -799,14 +801,14 @@ workflowCmd
     .action(workflowRunAction);
 workflowCmd
     .command("diagram <file>")
-    .description("Render a workflow as a Mermaid diagram")
+    .description("Render a workflow as a Mermaid diagram (raw .mmd by default; .md output auto-fences)")
     .option("--direction <dir>", "Graph direction: TB (top-bottom) or LR (left-right)", "TB")
-    .option("--title <title>", "Diagram title (defaults to workflow name)")
-    .option("--block", "Wrap in ```mermaid fenced code block (default)", true)
-    .option("--no-block", "Output raw Mermaid without code fence")
-    .option("-o, --output <path>", "Write the diagram to a file instead of stdout")
-    .action(function diagramAction(file, options) {
-    runWorkflowDiagram(file, options, { loadWorkflowFile, command: this });
+    .option("--title <title>", "Inject a title header (off by default — raw Mermaid has no title)")
+    .option("--block", "Wrap in ```mermaid fenced code block (forces fencing in any output)")
+    .option("--no-block", "Force raw Mermaid even when writing to a .md file")
+    .option("-o, --output <path>", "Write to a file instead of stdout (.mmd/.mermaid raw; .md fenced)")
+    .action((file, options) => {
+    runWorkflowDiagram(file, options, { loadWorkflowFile });
 });
 workflowCmd
     .command("export <name>")
@@ -967,7 +969,7 @@ workflowCmd
 // ── sweny upgrade / update ────────────────────────────────────────────
 // Self-update the globally-installed @sweny-ai/core. Mirrors the UX of
 // `bun upgrade`, `deno upgrade`, `rustup update`, etc.
-const upgradeCmd = program
+program
     .command("upgrade")
     .alias("update")
     .description("Upgrade sweny to the latest published version")
@@ -991,7 +993,13 @@ const upgradeCmd = program
         installPath,
         fetchLatestVersion: fetchLatestFromNpm,
         runInstall: (cmd, args) => {
-            const res = spawnSync(cmd, args, { stdio: "inherit" });
+            // Windows: `npm`/`pnpm`/`yarn` are `.cmd` shims and Node's spawn can't
+            // resolve them without a shell. Everywhere else we skip the shell to
+            // keep argv unambiguous and avoid injection surface.
+            const res = spawnSync(cmd, args, {
+                stdio: "inherit",
+                shell: process.platform === "win32",
+            });
             if (res.error) {
                 process.stderr.write(chalk.red(`  Error: couldn't run ${cmd} — ${res.error.message}`) + "\n");
                 return 127;
@@ -1009,8 +1017,6 @@ const upgradeCmd = program
         },
     });
 });
-// Touch upgradeCmd so TS/ESLint don't flag it unused if someone tightens rules.
-void upgradeCmd;
 // ── Passive "new version available" nudge ─────────────────────────────
 // Runs after every command. Non-blocking, bounded to 1.5s, silent on any
 // failure, skipped in CI / non-TTY / opt-out environments.

package/dist/cli/output.js

@@ -89,7 +89,7 @@ export function formatBanner(config, version) {
     const rows = [
         `${c.subtle("Repository")}${" ".repeat(6)}${chalk.white(config.repository)}`,
         `${c.subtle("Agent")}${" ".repeat(11)}${chalk.white(config.codingAgentProvider)}`,
-        `${c.subtle("Observability")}${" ".repeat(3)}${chalk.white(config.observabilityProvider)}`,
+        `${c.subtle("Observability")}${" ".repeat(3)}${chalk.white(config.observabilityProviders.join(", "))}`,
         `${c.subtle("Issue tracker")}${" ".repeat(3)}${chalk.white(config.issueTrackerProvider)}`,
         `${c.subtle("Time range")}${" ".repeat(6)}${chalk.white(config.timeRange)}`,
         `${c.subtle("Mode")}${" ".repeat(12)}${mode}`,
@@ -460,8 +460,8 @@ export function formatDagResultMarkdown(results, durationMs, config, options = {
     const rows = [];
     if (config?.repository)
         rows.push(["Repository", `\`${config.repository}\``]);
-    if (config?.observabilityProvider)
-        rows.push(["Observability", config.observabilityProvider]);
+    if (config?.observabilityProviders?.length)
+        rows.push(["Observability", config.observabilityProviders.join(", ")]);
     if (config?.issueTrackerProvider)
         rows.push(["Issue tracker", config.issueTrackerProvider]);
     if (config?.timeRange)

package/dist/cli/output.test.js

@@ -12,7 +12,7 @@ function minimalConfig(overrides = {}) {
         timeRange: "6h",
         serviceFilter: "permit-service",
         repository: "acme/app",
-        observabilityProvider: "betterstack",
+        observabilityProviders: ["betterstack"],
         issueTrackerProvider: "linear",
         dryRun: false,
         ...overrides,

package/dist/mcp.d.ts

@@ -35,7 +35,7 @@ export declare function buildSkillMcpServers(opts: SkillMcpOptions): Record<stri
  */
 export declare function buildAutoMcpServers(config: McpAutoConfig): Record<string, McpServerConfig>;
 export interface ProviderContextOptions {
-    observabilityProvider?: string;
+    observabilityProviders?: string[];
     issueTrackerProvider?: string;
     sourceControlProvider?: string;
     /** Which MCP servers were actually injected (keys from buildAutoMcpServers) */

package/dist/mcp.js

@@ -230,10 +230,14 @@ export function buildAutoMcpServers(config) {
             },
         };
     }
+    // ── Observability MCP servers ──────────────────────────────────
+    // Inject MCP for every configured observability provider whose credentials
+    // are present. Multiple providers are supported (e.g. "loki,sentry").
+    const obsProviders = new Set(config.observabilityProviders ?? []);
     // Datadog MCP — HTTP transport.
     const ddApiKey = creds.DD_API_KEY;
     const ddAppKey = creds.DD_APP_KEY;
-    if (config.observabilityProvider === "datadog" && ddApiKey && ddAppKey) {
+    if (obsProviders.has("datadog") && ddApiKey && ddAppKey) {
         auto["datadog"] = {
             type: "http",
             url: "https://mcp.datadoghq.com/api/unstable/mcp-server/mcp",
@@ -242,7 +246,7 @@ export function buildAutoMcpServers(config) {
     }
     // Sentry MCP — @sentry/mcp-server reads SENTRY_ACCESS_TOKEN (not SENTRY_AUTH_TOKEN).
     const sentryAuthToken = creds.SENTRY_AUTH_TOKEN;
-    if (config.observabilityProvider === "sentry" && sentryAuthToken) {
+    if (obsProviders.has("sentry") && sentryAuthToken) {
         const sentryEnv = { SENTRY_ACCESS_TOKEN: sentryAuthToken };
         const sentryUrl = creds.SENTRY_URL;
         if (sentryUrl && sentryUrl !== "https://sentry.io") {
@@ -261,10 +265,8 @@ export function buildAutoMcpServers(config) {
         };
     }
     // New Relic MCP — HTTP transport; region-aware endpoint.
-    // Header key is "Api-Key" (not "Authorization"), unique to New Relic's MCP.
-    // Trailing slash is intentional — New Relic's MCP spec requires it.
     const nrApiKey = creds.NEW_RELIC_API_KEY;
-    if (config.observabilityProvider === "newrelic" && nrApiKey) {
+    if (obsProviders.has("newrelic") && nrApiKey) {
         const nrRegion = creds.NEW_RELIC_REGION;
         const nrEndpoint = nrRegion === "eu" ? "https://mcp.eu.newrelic.com/mcp/" : "https://mcp.newrelic.com/mcp/";
         auto["newrelic"] = {
@@ -274,13 +276,8 @@ export function buildAutoMcpServers(config) {
         };
     }
     // Better Stack MCP — HTTP remote MCP; Bearer token auth.
-    // BetterStack uses separate tokens for Uptime vs Telemetry APIs.
-    // The MCP server accepts the telemetry token for log/metric queries.
-    // Accept: BETTERSTACK_API_TOKEN (legacy), BETTERSTACK_TELEMETRY_TOKEN, or BETTERSTACK_UPTIME_TOKEN.
-    // Injected whenever any token is present (not just when it's the primary provider)
-    // because BetterStack logs complement any primary observability provider.
     const bsApiToken = creds.BETTERSTACK_API_TOKEN || creds.BETTERSTACK_TELEMETRY_TOKEN || creds.BETTERSTACK_UPTIME_TOKEN;
-    if (bsApiToken) {
+    if (obsProviders.has("betterstack") && bsApiToken) {
         auto["betterstack"] = {
             type: "http",
             url: "https://mcp.betterstack.com",
@@ -361,16 +358,13 @@ export function buildAutoMcpServers(config) {
  */
 export function buildProviderContext(opts) {
     const lines = ["## Available Providers & Tools", ""];
-    // Observability
-    if (opts.observabilityProvider) {
-        const mcpNote = opts.mcpServers.includes(opts.observabilityProvider)
+    // Observability — list all configured providers
+    const obsProviders = opts.observabilityProviders ?? [];
+    for (const provider of obsProviders) {
+        const mcpNote = opts.mcpServers.includes(provider)
             ? ` (available via MCP — use its tools to query logs, errors, and metrics)`
             : "";
-        lines.push(`- **Observability**: ${opts.observabilityProvider}${mcpNote}`);
-    }
-    // BetterStack as secondary (token present but not primary provider)
-    if (opts.observabilityProvider !== "betterstack" && opts.mcpServers.includes("betterstack")) {
-        lines.push(`- **Logs**: betterstack (available via MCP — use its tools to query logs)`);
+        lines.push(`- **Observability**: ${provider}${mcpNote}`);
     }
     // Issue tracker
     if (opts.issueTrackerProvider) {

package/dist/mcp.test.js

@@ -47,7 +47,7 @@ describe("buildAutoMcpServers", () => {
     // ── Datadog MCP ─────────────────────────────────────────────────
     it("injects Datadog MCP (HTTP) when observabilityProvider is datadog with DD_API_KEY + DD_APP_KEY", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "datadog",
+            observabilityProviders: ["datadog"],
             credentials: { DD_API_KEY: "dd_api", DD_APP_KEY: "dd_app" },
         }));
         expect(result["datadog"]).toEqual({
@@ -57,12 +57,12 @@ describe("buildAutoMcpServers", () => {
         });
     });
     it("does NOT inject Datadog MCP when DD_APP_KEY is missing", () => {
-        const result = buildAutoMcpServers(cfg({ observabilityProvider: "datadog", credentials: { DD_API_KEY: "dd_api" } }));
+        const result = buildAutoMcpServers(cfg({ observabilityProviders: ["datadog"], credentials: { DD_API_KEY: "dd_api" } }));
         expect(result["datadog"]).toBeUndefined();
     });
     // ── Sentry MCP ──────────────────────────────────────────────────
     it("injects Sentry MCP (stdio) when observabilityProvider is sentry with SENTRY_AUTH_TOKEN", () => {
-        const result = buildAutoMcpServers(cfg({ observabilityProvider: "sentry", credentials: { SENTRY_AUTH_TOKEN: "sntryu_abc" } }));
+        const result = buildAutoMcpServers(cfg({ observabilityProviders: ["sentry"], credentials: { SENTRY_AUTH_TOKEN: "sntryu_abc" } }));
         expect(result["sentry"]).toEqual({
             type: "stdio",
             command: "npx",
@@ -72,7 +72,7 @@ describe("buildAutoMcpServers", () => {
     });
     it("injects Sentry MCP with self-hosted SENTRY_HOST from SENTRY_URL", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "sentry",
+            observabilityProviders: ["sentry"],
             credentials: {
                 SENTRY_AUTH_TOKEN: "sntryu_abc",
                 SENTRY_URL: "https://sentry.mycompany.com",
@@ -85,7 +85,7 @@ describe("buildAutoMcpServers", () => {
     });
     it("does NOT set SENTRY_HOST when SENTRY_URL is sentry.io", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "sentry",
+            observabilityProviders: ["sentry"],
             credentials: {
                 SENTRY_AUTH_TOKEN: "sntryu_abc",
                 SENTRY_URL: "https://sentry.io",
@@ -95,7 +95,7 @@ describe("buildAutoMcpServers", () => {
     });
     it("handles malformed SENTRY_URL gracefully (no SENTRY_HOST set)", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "sentry",
+            observabilityProviders: ["sentry"],
             credentials: {
                 SENTRY_AUTH_TOKEN: "sntryu_abc",
                 SENTRY_URL: "not-a-url",
@@ -143,7 +143,7 @@ describe("buildAutoMcpServers", () => {
     // ── New Relic MCP ───────────────────────────────────────────────
     it("injects New Relic MCP with EU region endpoint", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "newrelic",
+            observabilityProviders: ["newrelic"],
             credentials: { NEW_RELIC_API_KEY: "NRAK-abc", NEW_RELIC_REGION: "eu" },
         }));
         expect(result["newrelic"]).toEqual({
@@ -154,7 +154,7 @@ describe("buildAutoMcpServers", () => {
     });
     it("injects New Relic MCP with US (default) region endpoint", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "newrelic",
+            observabilityProviders: ["newrelic"],
             credentials: { NEW_RELIC_API_KEY: "NRAK-abc" },
         }));
         expect(result["newrelic"]).toEqual({
@@ -166,7 +166,7 @@ describe("buildAutoMcpServers", () => {
     // ── Better Stack MCP ────────────────────────────────────────────
     it("injects Better Stack MCP (HTTP) with Bearer token", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "betterstack",
+            observabilityProviders: ["betterstack"],
             credentials: { BETTERSTACK_API_TOKEN: "bst_abc" },
         }));
         expect(result["betterstack"]).toEqual({
@@ -175,9 +175,9 @@ describe("buildAutoMcpServers", () => {
             headers: { Authorization: "Bearer bst_abc" },
         });
     });
-    it("injects Better Stack MCP even when primary provider is not betterstack", () => {
+    it("injects multiple observability MCPs when both are configured", () => {
         const result = buildAutoMcpServers(cfg({
-            observabilityProvider: "sentry",
+            observabilityProviders: ["sentry", "betterstack"],
             credentials: { BETTERSTACK_API_TOKEN: "bst_xyz", SENTRY_AUTH_TOKEN: "sntrx_test" },
         }));
         expect(result["betterstack"]).toEqual({
@@ -329,7 +329,7 @@ describe("buildAutoMcpServers", () => {
         const result = buildAutoMcpServers(cfg({
             sourceControlProvider: "github",
             issueTrackerProvider: "linear",
-            observabilityProvider: "datadog",
+            observabilityProviders: ["datadog"],
             credentials: {
                 GITHUB_TOKEN: "ghp_abc",
                 LINEAR_API_KEY: "lin_key_abc",

package/dist/types.d.ts

@@ -216,7 +216,8 @@ export interface McpServerConfig {
 export interface McpAutoConfig {
     sourceControlProvider?: string;
     issueTrackerProvider?: string;
-    observabilityProvider?: string;
+    /** One or more observability providers (e.g. ["loki", "sentry"]). */
+    observabilityProviders?: string[];
     credentials: Record<string, string>;
     workspaceTools?: string[];
     userMcpServers?: Record<string, McpServerConfig>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"