@thotischner/observability-mcp 3.4.0 → 3.5.0

package/dist/postmortem/synthesizer.d.ts

@@ -45,6 +45,13 @@ export interface PostmortemInput {
     traces: TraceSummary[];
     /** Optional log-error summary lines, e.g. ["payment-service: 412 5xx in window"]. */
     logHighlights?: string[];
+    /** Optional custom report template (issue: v3.3 candidate). When set, the
+     *  markdown body is rendered by interpolating `{{placeholder}}` tokens
+     *  instead of the built-in layout. Unset → the default report (unchanged).
+     *  Available tokens: service, window, from, to, tenant, synopsis, timeline,
+     *  blastRadius, signals, traces, logHighlights, followUps. An unknown token
+     *  is left verbatim so a typo is visible rather than silently dropped. */
+    template?: string;
 }
 export interface PostmortemReport {
     service: string;
@@ -81,3 +88,20 @@ export interface PostmortemReport {
 /** Synthesise one report from already-fetched primitives. Pure
  *  compute — no I/O. */
 export declare function synthesizePostmortem(input: PostmortemInput): PostmortemReport;
+type RenderCtx = {
+    input: PostmortemInput;
+    timeline: PostmortemReport["sections"]["timeline"];
+    contributingSignals: PostmortemReport["sections"]["contributingSignals"];
+    peakNode: BlastRadiusNode | undefined;
+    peakScore: number;
+    errorTraces: number;
+    blastSize: number;
+    followUps: string[];
+    synopsis: string;
+};
+/** Build the `{{token}}` → markdown-block map for a custom template. */
+export declare function buildTemplateVars(ctx: RenderCtx): Record<string, string>;
+/** Interpolate `{{token}}` placeholders. An unknown token is left verbatim so
+ *  a typo is visible in the output rather than silently producing a blank. */
+export declare function renderTemplate(template: string, vars: Record<string, string>): string;
+export {};

package/dist/postmortem/synthesizer.js

@@ -22,7 +22,7 @@ export function synthesizePostmortem(input) {
     const blastSize = input.blastRadius.nodes.length;
     const followUps = inferFollowUps(input, { peakScore, errorTraces, blastSize });
     const synopsis = synopsisFor(input, peakScore, errorTraces, blastSize);
-    const markdown = renderMarkdown({
+    const renderCtx = {
         input,
         timeline,
         contributingSignals,
@@ -32,7 +32,12 @@ export function synthesizePostmortem(input) {
         blastSize,
         followUps,
         synopsis,
-    });
+    };
+    // Default layout unless the operator supplied a custom template — the
+    // default path is byte-for-byte unchanged.
+    const markdown = input.template
+        ? renderTemplate(input.template, buildTemplateVars(renderCtx))
+        : renderMarkdown(renderCtx);
     return {
         service: input.service,
         window: input.window,
@@ -203,3 +208,51 @@ function renderMarkdown(ctx) {
     // could approach MB without the slice() caps above.
     return lines.join("\n");
 }
+/** Build the `{{token}}` → markdown-block map for a custom template. */
+export function buildTemplateVars(ctx) {
+    const { input, timeline, contributingSignals, peakNode, errorTraces, followUps, synopsis } = ctx;
+    const timelineBlock = timeline.length === 0
+        ? "_No anomaly samples in this window._"
+        : ["| ts | service | score | severity | method |", "|---|---|---|---|---|",
+            ...timeline.slice(0, 20).map((t) => `| \`${t.ts}\` | \`${t.service}\` | ${t.score} | ${t.severity} | ${t.method} |`),
+            ...(timeline.length > 20 ? [`| … | _${timeline.length - 20} more rows_ |  |  |  |`] : [])].join("\n");
+    const brLines = [];
+    brLines.push(peakNode ? `Root node: **\`${peakNode.name}\`** (\`${peakNode.kind}\`).` : "_Topology snapshot empty._");
+    if (input.blastRadius.nodes.length > 0) {
+        brLines.push("", "| node | kind |", "|---|---|", ...input.blastRadius.nodes.slice(0, 30).map((n) => `| \`${n.name}\`${n.root ? " *(root)*" : ""} | \`${n.kind}\` |`));
+    }
+    brLines.push("", `Edges in radius: **${input.blastRadius.edges.length}**.`);
+    const blastRadiusBlock = brLines.join("\n");
+    const signalsBlock = contributingSignals.length === 0
+        ? "_No anomaly samples to rank._"
+        : ["| signal | samples | mean score |", "|---|---|---|",
+            ...contributingSignals.slice(0, 10).map((s) => `| \`${s.signal}\` | ${s.count} | ${s.meanScore} |`)].join("\n");
+    const tracesBlock = input.traces.length === 0
+        ? "_No traces returned for the window. Configure a Tempo / Jaeger source if traces are expected._"
+        : ["| trace | service | duration ms | error |", "|---|---|---|---|",
+            ...input.traces.slice(0, 10).map((t) => `| \`${t.traceId}\` | \`${t.rootService}\` | ${t.durationMs} | ${t.hasError ? "yes" : "no"} |`),
+            ...(errorTraces > 0 ? [`\n_${errorTraces} of the returned traces carried error spans._`] : [])].join("\n");
+    const logHighlightsBlock = (input.logHighlights ?? []).length === 0
+        ? "_No log highlights._"
+        : input.logHighlights.map((l) => `- ${l}`).join("\n");
+    const followUpsBlock = followUps.map((f) => `- ${f}`).join("\n");
+    return {
+        service: input.service,
+        window: input.window,
+        from: input.fromIso,
+        to: input.toIso,
+        tenant: input.tenant,
+        synopsis,
+        timeline: timelineBlock,
+        blastRadius: blastRadiusBlock,
+        signals: signalsBlock,
+        traces: tracesBlock,
+        logHighlights: logHighlightsBlock,
+        followUps: followUpsBlock,
+    };
+}
+/** Interpolate `{{token}}` placeholders. An unknown token is left verbatim so
+ *  a typo is visible in the output rather than silently producing a blank. */
+export function renderTemplate(template, vars) {
+    return template.replace(/\{\{\s*([a-zA-Z][\w]*)\s*\}\}/g, (whole, key) => Object.prototype.hasOwnProperty.call(vars, key) ? vars[key] : whole);
+}

package/dist/postmortem/synthesizer.test.js

@@ -139,3 +139,30 @@ test("synthesizePostmortem: report carries the input window + iso bounds back in
     assert.equal(r.fromIso, "2026-06-06T00:00:00.000Z");
     assert.equal(r.toIso, "2026-06-06T01:00:00.000Z");
 });
+test("custom template: tokens are interpolated; default path unchanged when no template", () => {
+    const data = input({
+        anomalies: [anomaly("2026-06-06T00:10:00Z", 0.7, "mad", "warn", "cpu")],
+        blastRadius: { nodes: [{ id: "n1", kind: "pod", name: "payment-1", root: true }], edges: [] },
+        logHighlights: ["payment: 5xx spike"],
+    });
+    // Default (no template) still produces the built-in report.
+    const def = synthesizePostmortem(data);
+    assert.match(def.markdown, /^# Post-mortem — payment/);
+    // Custom template interpolates the known tokens.
+    const tpl = "INCIDENT {{service}} ({{window}})\n\n{{synopsis}}\n\nTIMELINE:\n{{timeline}}\n\nFOLLOWUPS:\n{{followUps}}\n\nLOGS:\n{{logHighlights}}";
+    const out = synthesizePostmortem({ ...data, template: tpl }).markdown;
+    assert.match(out, /^INCIDENT payment \(1h\)/);
+    assert.ok(!out.includes("# Post-mortem"), "custom template replaces the default layout");
+    assert.match(out, /TIMELINE:\n\| ts \| service \| score/);
+    assert.match(out, /LOGS:\n- payment: 5xx spike/);
+    assert.ok(out.includes(def.synopsis), "synopsis token expands to the computed synopsis");
+});
+test("custom template: unknown token is left verbatim (visible typo, not silent blank)", () => {
+    const out = synthesizePostmortem({ ...input(), template: "{{service}} / {{nope}}" }).markdown;
+    assert.equal(out, "payment / {{nope}}");
+});
+test("custom template: empty sections render their placeholder text, not a crash", () => {
+    const out = synthesizePostmortem({ ...input(), template: "T:{{timeline}} L:{{logHighlights}}" }).markdown;
+    assert.match(out, /T:_No anomaly samples in this window\._/);
+    assert.match(out, /L:_No log highlights\._/);
+});

package/dist/scim/query.d.ts

@@ -0,0 +1,32 @@
+export interface ScimFilter {
+    attr: string;
+    op: "eq";
+    /** Comparison value: a string, or a boolean for `active eq true`. */
+    value: string | boolean;
+}
+/** Parse a SCIM `filter` expression. Returns null for an empty/absent filter,
+ *  or throws {unsupported:true} for a syntactically-valid filter we don't
+ *  implement (a non-eq operator) so the caller can answer 400, not 200. */
+export declare function parseScimFilter(raw: string | undefined): ScimFilter | null;
+export interface ScimListResult<T> {
+    resources: T[];
+    totalResults: number;
+    startIndex: number;
+    itemsPerPage: number;
+}
+/**
+ * Apply a SCIM `eq` filter + startIndex/count pagination to a resource list.
+ * `filter`/`startIndex`/`count` are the raw query-string values.
+ *
+ * - filter: only `eq` (string, case-insensitive; or boolean for `active`).
+ * - startIndex: 1-based (SCIM); clamped to >= 1; default 1.
+ * - count: page size; clamped to [0, 1000]; absent → all remaining.
+ *
+ * Throws a {scimUnsupported:true} error for a non-eq filter so the route can
+ * return 400 rather than a misleading full list.
+ */
+export declare function applyScimList<T extends Record<string, unknown>>(all: T[], q: {
+    filter?: string;
+    startIndex?: string;
+    count?: string;
+}): ScimListResult<T>;

package/dist/scim/query.js

@@ -0,0 +1,73 @@
+// SCIM 2.0 list query: filter + pagination (RFC 7644 §3.4.2).
+//
+// Identity providers (Entra, Okta) reconcile by issuing
+//   GET /Users?filter=userName eq "alice@example.com"
+// and page large directories with startIndex/count. Without filter support a
+// provider has to pull the whole list and match client-side — slow and, for
+// Okta, a hard requirement. We support the `eq` operator on top-level string
+// attributes (userName, displayName, externalId, id) plus `active eq true`,
+// which covers what Entra/Okta actually send. Other operators are reported as
+// unsupported (400) rather than silently returning everything — silence here
+// would make a provider think "no match" when it means "not implemented".
+/** Parse a SCIM `filter` expression. Returns null for an empty/absent filter,
+ *  or throws {unsupported:true} for a syntactically-valid filter we don't
+ *  implement (a non-eq operator) so the caller can answer 400, not 200. */
+export function parseScimFilter(raw) {
+    if (!raw || !raw.trim())
+        return null;
+    const s = raw.trim();
+    // <attr> eq "value"   |   <attr> eq true|false
+    const m = /^([A-Za-z][\w.]*)\s+(eq)\s+(?:"([^"]*)"|(true|false))$/i.exec(s);
+    if (!m) {
+        // Either an unsupported operator (co, sw, gt, …) or malformed. Signal
+        // unsupported so the route returns 400 instead of an all-rows 200.
+        const err = new Error(`Unsupported or malformed SCIM filter: ${raw}`);
+        err.scimUnsupported = true;
+        throw err;
+    }
+    const attr = m[1];
+    const value = m[3] !== undefined ? m[3] : m[4].toLowerCase() === "true";
+    return { attr, op: "eq", value };
+}
+/** Read a top-level attribute off a SCIM resource for `eq` comparison.
+ *  Only flat attributes are supported (userName/displayName/externalId/id/
+ *  active) — nested paths (name.familyName) aren't part of the eq surface. */
+function attrValue(resource, attr) {
+    // Case-insensitive attribute match per the SCIM spec (attribute names are
+    // case-insensitive); providers send `userName`, some send `username`.
+    const key = Object.keys(resource).find((k) => k.toLowerCase() === attr.toLowerCase());
+    return key ? resource[key] : undefined;
+}
+/**
+ * Apply a SCIM `eq` filter + startIndex/count pagination to a resource list.
+ * `filter`/`startIndex`/`count` are the raw query-string values.
+ *
+ * - filter: only `eq` (string, case-insensitive; or boolean for `active`).
+ * - startIndex: 1-based (SCIM); clamped to >= 1; default 1.
+ * - count: page size; clamped to [0, 1000]; absent → all remaining.
+ *
+ * Throws a {scimUnsupported:true} error for a non-eq filter so the route can
+ * return 400 rather than a misleading full list.
+ */
+export function applyScimList(all, q) {
+    const filter = parseScimFilter(q.filter);
+    let filtered = all;
+    if (filter) {
+        filtered = all.filter((r) => {
+            const v = attrValue(r, filter.attr);
+            if (typeof filter.value === "boolean")
+                return Boolean(v) === filter.value;
+            // String eq is case-insensitive per the SCIM spec for these attrs.
+            return v !== undefined && String(v).toLowerCase() === filter.value.toLowerCase();
+        });
+    }
+    const total = filtered.length;
+    const startIndex = Math.max(1, Number.parseInt(q.startIndex ?? "1", 10) || 1);
+    const from = startIndex - 1;
+    const rawCount = q.count === undefined ? undefined : Number.parseInt(q.count, 10);
+    const count = rawCount === undefined || Number.isNaN(rawCount)
+        ? undefined
+        : Math.min(1000, Math.max(0, rawCount));
+    const page = count === undefined ? filtered.slice(from) : filtered.slice(from, from + count);
+    return { resources: page, totalResults: total, startIndex, itemsPerPage: page.length };
+}

package/dist/scim/query.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scim/query.test.js

@@ -0,0 +1,71 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseScimFilter, applyScimList } from "./query.js";
+describe("parseScimFilter", () => {
+    it("returns null for absent/empty filter", () => {
+        assert.equal(parseScimFilter(undefined), null);
+        assert.equal(parseScimFilter("   "), null);
+    });
+    it("parses string eq (case-insensitive op)", () => {
+        assert.deepEqual(parseScimFilter('userName eq "alice@x.com"'), { attr: "userName", op: "eq", value: "alice@x.com" });
+        assert.deepEqual(parseScimFilter('displayName EQ "Admins"'), { attr: "displayName", op: "eq", value: "Admins" });
+    });
+    it("parses boolean eq for active", () => {
+        assert.deepEqual(parseScimFilter("active eq true"), { attr: "active", op: "eq", value: true });
+        assert.deepEqual(parseScimFilter("active eq false"), { attr: "active", op: "eq", value: false });
+    });
+    it("throws scimUnsupported for non-eq operators / malformed", () => {
+        for (const f of ['userName co "a"', 'userName sw "a"', 'userName pr', 'garbage']) {
+            assert.throws(() => parseScimFilter(f), (e) => e.scimUnsupported === true, `expected unsupported for: ${f}`);
+        }
+    });
+});
+describe("applyScimList", () => {
+    const users = [
+        { id: "1", userName: "alice@x.com", active: true },
+        { id: "2", userName: "bob@x.com", active: false },
+        { id: "3", userName: "carol@x.com", active: true },
+    ];
+    it("no filter, no pagination → all rows, correct envelope", () => {
+        const r = applyScimList(users, {});
+        assert.equal(r.totalResults, 3);
+        assert.equal(r.startIndex, 1);
+        assert.equal(r.itemsPerPage, 3);
+        assert.equal(r.resources.length, 3);
+    });
+    it("eq filter matches case-insensitively on the value", () => {
+        const r = applyScimList(users, { filter: 'userName eq "ALICE@X.COM"' });
+        assert.equal(r.totalResults, 1);
+        assert.equal(r.resources[0].id, "1");
+    });
+    it("eq filter with no match → empty, totalResults 0 (not all rows)", () => {
+        const r = applyScimList(users, { filter: 'userName eq "nobody@x.com"' });
+        assert.equal(r.totalResults, 0);
+        assert.equal(r.resources.length, 0);
+    });
+    it("boolean eq filters on active", () => {
+        assert.equal(applyScimList(users, { filter: "active eq true" }).totalResults, 2);
+        assert.equal(applyScimList(users, { filter: "active eq false" }).totalResults, 1);
+    });
+    it("pagination: startIndex + count slice; totalResults is the pre-page count", () => {
+        const r = applyScimList(users, { startIndex: "2", count: "1" });
+        assert.equal(r.totalResults, 3);
+        assert.equal(r.startIndex, 2);
+        assert.equal(r.itemsPerPage, 1);
+        assert.equal(r.resources[0].id, "2");
+    });
+    it("count=0 returns an empty page but the real totalResults", () => {
+        const r = applyScimList(users, { count: "0" });
+        assert.equal(r.totalResults, 3);
+        assert.equal(r.resources.length, 0);
+    });
+    it("filter + pagination compose", () => {
+        const r = applyScimList(users, { filter: "active eq true", startIndex: "2", count: "5" });
+        assert.equal(r.totalResults, 2); // alice + carol
+        assert.equal(r.resources.length, 1); // from index 2 of the 2 matches
+        assert.equal(r.resources[0].id, "3");
+    });
+    it("propagates the unsupported-filter error for the route to 400", () => {
+        assert.throws(() => applyScimList(users, { filter: 'userName co "x"' }), (e) => e.scimUnsupported === true);
+    });
+});

package/dist/scim/routes.js

@@ -4,7 +4,7 @@
 //   GET    /scim/v2/ServiceProviderConfig
 //   GET    /scim/v2/ResourceTypes
 //   GET    /scim/v2/Schemas
-//   GET    /scim/v2/Users        list (no filter support yet)
+//   GET    /scim/v2/Users        list (filter: <attr> eq "x"; startIndex/count)
 //   GET    /scim/v2/Users/:id
 //   POST   /scim/v2/Users
 //   PATCH  /scim/v2/Users/:id    minimal: replace top-level attrs
@@ -20,6 +20,7 @@
 import { timingSafeEqual } from "node:crypto";
 import { SCIM_SCHEMA_LIST_RESPONSE, SCIM_SCHEMA_USER, SCIM_SCHEMA_GROUP, scimError, } from "./types.js";
 import { ScimNotFoundError, ScimValidationError } from "./store.js";
+import { applyScimList } from "./query.js";
 const constantTimeBearerMatch = (raw, expected) => {
     if (!raw)
         return false;
@@ -57,7 +58,7 @@ export function registerScimRoutes(app, deps) {
             documentationUri: "https://thotischner.github.io/observability-mcp/scim-provisioning/",
             patch: { supported: true },
             bulk: { supported: false, maxOperations: 0, maxPayloadSize: 0 },
-            filter: { supported: false, maxResults: 200 },
+            filter: { supported: true, maxResults: 200 },
             changePassword: { supported: false },
             sort: { supported: false },
             etag: { supported: false },
@@ -108,14 +109,25 @@ export function registerScimRoutes(app, deps) {
         });
     });
     // ---- Users ----
-    app.get("/scim/v2/Users", (_req, res) => {
+    app.get("/scim/v2/Users", (req, res) => {
         const users = store.listUsers().map((u) => withGroups(u, store));
+        let page;
+        try {
+            page = applyScimList(users, req.query);
+        }
+        catch (e) {
+            if (e.scimUnsupported) {
+                res.status(400).json(scimError(400, e.message));
+                return;
+            }
+            throw e;
+        }
         res.json({
             schemas: [SCIM_SCHEMA_LIST_RESPONSE],
-            totalResults: users.length,
-            itemsPerPage: users.length,
-            startIndex: 1,
-            Resources: users,
+            totalResults: page.totalResults,
+            itemsPerPage: page.itemsPerPage,
+            startIndex: page.startIndex,
+            Resources: page.resources,
         });
     });
     app.get("/scim/v2/Users/:id", (req, res) => {
@@ -157,14 +169,25 @@ export function registerScimRoutes(app, deps) {
         res.status(204).end();
     });
     // ---- Groups ----
-    app.get("/scim/v2/Groups", (_req, res) => {
+    app.get("/scim/v2/Groups", (req, res) => {
         const groups = store.listGroups();
+        let page;
+        try {
+            page = applyScimList(groups, req.query);
+        }
+        catch (e) {
+            if (e.scimUnsupported) {
+                res.status(400).json(scimError(400, e.message));
+                return;
+            }
+            throw e;
+        }
         res.json({
             schemas: [SCIM_SCHEMA_LIST_RESPONSE],
-            totalResults: groups.length,
-            itemsPerPage: groups.length,
-            startIndex: 1,
-            Resources: groups,
+            totalResults: page.totalResults,
+            itemsPerPage: page.itemsPerPage,
+            startIndex: page.startIndex,
+            Resources: page.resources,
         });
     });
     app.get("/scim/v2/Groups/:id", (req, res) => {

package/dist/tools/generate-postmortem.d.ts

@@ -1,5 +1,7 @@
 import type { ConnectorRegistry } from "../connectors/registry.js";
 import { type RequestContext } from "../context.js";
+/** Test seam: reset the cached template (so tests can vary the env). */
+export declare function _resetPostmortemTemplateCache(): void;
 export declare const generatePostmortemDefinition: {
     name: "generate_postmortem";
     description: string;

package/dist/tools/generate-postmortem.js

@@ -7,9 +7,37 @@
 // The synthesizer is pure compute (see ./../postmortem/synthesizer);
 // this handler is just the orchestration: pull each upstream
 // primitive in parallel, hand the result to the synthesizer.
+import { readFileSync } from "node:fs";
 import { defaultContext } from "../context.js";
 import { validateDuration, validateServiceName, errorResponse } from "./validation.js";
 import { synthesizePostmortem, } from "../postmortem/synthesizer.js";
+// Optional operator-supplied report template (v3.3 candidate). Set
+// OMCP_POSTMORTEM_TEMPLATE to a file of `{{token}}` placeholders to override
+// the built-in layout; unset → the default report. Read once and cached; a
+// read error falls back to the default (logged once) rather than failing the
+// tool — a broken template must not break incident reporting.
+let _templateCache;
+function loadPostmortemTemplate(env = process.env) {
+    if (_templateCache !== undefined)
+        return _templateCache ?? undefined;
+    const path = env.OMCP_POSTMORTEM_TEMPLATE?.trim();
+    if (!path) {
+        _templateCache = null;
+        return undefined;
+    }
+    try {
+        _templateCache = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        console.error("OMCP_POSTMORTEM_TEMPLATE unreadable, using the built-in layout:", err instanceof Error ? err.message : err);
+        _templateCache = null;
+    }
+    return _templateCache ?? undefined;
+}
+/** Test seam: reset the cached template (so tests can vary the env). */
+export function _resetPostmortemTemplateCache() {
+    _templateCache = undefined;
+}
 export const generatePostmortemDefinition = {
     name: "generate_postmortem",
     description: [
@@ -59,6 +87,7 @@ export async function generatePostmortemHandler(registry, args, ctx = defaultCon
         blastRadius,
         traces,
         logHighlights,
+        template: loadPostmortemTemplate(),
     });
     // Which primitives actually carried data. A post-mortem synthesised from
     // ZERO signal still renders a full, authoritative-looking document — an

package/dist/tools/generate-postmortem.test.js

@@ -1,7 +1,10 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
+import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { ConnectorRegistry } from "../connectors/registry.js";
-import { generatePostmortemHandler } from "./generate-postmortem.js";
+import { generatePostmortemHandler, _resetPostmortemTemplateCache } from "./generate-postmortem.js";
 // R5 — a post-mortem built from ZERO signal (no anomaly/traces/topology/log
 // backend) must label itself, not render as an authoritative finding.
 describe("generatePostmortemHandler — no-signal honesty (R5)", () => {
@@ -20,3 +23,50 @@ describe("generatePostmortemHandler — no-signal honesty (R5)", () => {
         assert.deepEqual(report.coverage, { anomalies: false, traces: false, topology: false, logs: false });
     });
 });
+describe("generatePostmortemHandler — custom template via OMCP_POSTMORTEM_TEMPLATE (C3)", () => {
+    it("renders the operator's template when the env file is set; falls back when unset", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "pm-tpl-"));
+        const file = join(dir, "tpl.md");
+        writeFileSync(file, "## Incident: {{service}} over {{window}}\n\n{{synopsis}}");
+        const prev = process.env.OMCP_POSTMORTEM_TEMPLATE;
+        try {
+            process.env.OMCP_POSTMORTEM_TEMPLATE = file;
+            _resetPostmortemTemplateCache();
+            const reg = new ConnectorRegistry();
+            const md = (await generatePostmortemHandler(reg, { service: "payment", duration: "2h" })).content[0].text;
+            // The custom template body is used (the no-signal honesty banner may
+            // still prepend it — that's deliberate and template-independent).
+            assert.match(md, /## Incident: payment over 2h/);
+            assert.ok(!md.includes("# Post-mortem —"), "custom template replaces the default layout");
+            // Unset → back to the built-in layout.
+            delete process.env.OMCP_POSTMORTEM_TEMPLATE;
+            _resetPostmortemTemplateCache();
+            const md2 = (await generatePostmortemHandler(reg, { service: "payment", duration: "2h" })).content[0].text;
+            assert.match(md2, /# Post-mortem — payment/);
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.OMCP_POSTMORTEM_TEMPLATE;
+            else
+                process.env.OMCP_POSTMORTEM_TEMPLATE = prev;
+            _resetPostmortemTemplateCache();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("an unreadable template path falls back to the default layout, doesn't throw", async () => {
+        const prev = process.env.OMCP_POSTMORTEM_TEMPLATE;
+        try {
+            process.env.OMCP_POSTMORTEM_TEMPLATE = "/nonexistent/nope.md";
+            _resetPostmortemTemplateCache();
+            const md = (await generatePostmortemHandler(new ConnectorRegistry(), { service: "x", duration: "1h" })).content[0].text;
+            assert.match(md, /# Post-mortem — x/);
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.OMCP_POSTMORTEM_TEMPLATE;
+            else
+                process.env.OMCP_POSTMORTEM_TEMPLATE = prev;
+            _resetPostmortemTemplateCache();
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thotischner/observability-mcp",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "description": "Unified observability gateway for AI agents — one MCP server for Prometheus, Loki, and any backend",
   "type": "module",
   "license": "Apache-2.0",