mergen-server 1.4.0

package/dist/intelligence/license.js

@@ -0,0 +1,185 @@
+import fs from "fs/promises";
+import { DATA_DIR, LICENSE_FILE } from "../sensor/paths.js";
+import { PLANS } from "./plans.js";
+import logger from "../sensor/logger.js";
+let _state = null;
+function getLicenseState() {
+  return _state;
+}
+function getActivePlanId() {
+  return _state?.planId ?? "free";
+}
+async function initLicense() {
+  try {
+    const raw = await fs.readFile(LICENSE_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.key && parsed.planId && PLANS[parsed.planId]) {
+      _state = parsed;
+      logger.info({ planId: _state.planId }, "license: loaded");
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      logger.warn({ err }, "license: failed to read license file");
+    }
+  }
+}
+async function activateKey(key) {
+  const apiUrl = process.env.MERGEN_API_URL ?? "https://api.mergen.app";
+  if (key.startsWith("mrgn_")) {
+    return _activateViaCloud(key, apiUrl);
+  }
+  return _activateViaLemonSqueezy(key);
+}
+async function _activateViaCloud(key, apiUrl) {
+  const res = await fetch(`${apiUrl}/v1/validate`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ key, instance: "mergen-server" })
+  });
+  const data = await res.json();
+  if (!res.ok || !data.valid) {
+    throw new Error(data.error ?? "Key validation failed");
+  }
+  _state = {
+    key,
+    planId: data.planId ?? "free",
+    customerEmail: data.email ?? void 0,
+    validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lsSubscriptionItemId: data.subscriptionItemId ?? void 0,
+    resetsAt: data.resetsAt ?? void 0,
+    status: "active",
+    customerName: data.name ?? void 0
+  };
+  await _persist();
+  return { activated: true, planId: _state.planId, email: _state.customerEmail };
+}
+async function _activateViaLemonSqueezy(key) {
+  const res = await fetch("https://api.lemonsqueezy.com/v1/licenses/activate", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ license_key: key, instance_name: "mergen-server" })
+  });
+  const data = await res.json();
+  if (!res.ok || !data.activated) {
+    throw new Error(data.error ?? "Activation failed");
+  }
+  const meta = data.meta ?? {};
+  const variantId = meta.variant_id;
+  const instance = data.instance ?? {};
+  const resolvedPlan = planFromVariantId(variantId);
+  const hasVariant = variantId != null && variantId !== "" && variantId !== 0;
+  if (hasVariant && resolvedPlan === "free") {
+    throw new Error(
+      `License activated but its LemonSqueezy variant (${String(variantId)}) is not mapped to a plan. Set MERGEN_LS_VARIANT_MAP={"${String(variantId)}":"<planId>"} and retry. Refusing to activate as free.`
+    );
+  }
+  _state = {
+    key,
+    planId: resolvedPlan,
+    customerEmail: meta.customer_email ?? void 0,
+    validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lsSubscriptionItemId: void 0,
+    lsInstanceId: instance.id ?? void 0,
+    status: "active"
+  };
+  await _persist();
+  return { activated: true, planId: _state.planId, email: _state.customerEmail };
+}
+async function _persist() {
+  try {
+    await fs.mkdir(DATA_DIR, { recursive: true });
+    await fs.writeFile(LICENSE_FILE, JSON.stringify(_state, null, 2));
+  } catch (err) {
+    logger.warn({ err }, "license: failed to persist license file");
+  }
+}
+async function deactivateKey() {
+  if (!_state) return;
+  try {
+    if (_state.key.startsWith("mrgn_")) {
+      const apiUrl = process.env.MERGEN_API_URL ?? "https://api.mergen.app";
+      await fetch(`${apiUrl}/v1/deactivate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ key: _state.key })
+      });
+    } else if (_state.lsInstanceId) {
+      await fetch("https://api.lemonsqueezy.com/v1/licenses/deactivate", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ license_key: _state.key, instance_id: _state.lsInstanceId })
+      });
+    }
+  } catch (err) {
+    logger.warn({ err }, "license: deactivate request failed");
+  }
+  _state = null;
+  try {
+    await fs.rm(LICENSE_FILE);
+  } catch {
+  }
+}
+const VARIANT_PLAN_MAP = {
+  // Map LemonSqueezy variant IDs to plan IDs.
+  // Override with MERGEN_LS_VARIANT_MAP={"123":"solo_pro",...} if needed.
+  ...process.env.MERGEN_LS_VARIANT_MAP ? JSON.parse(process.env.MERGEN_LS_VARIANT_MAP) : {}
+};
+function planFromVariantId(variantId) {
+  if (variantId == null || variantId === "" || variantId === 0) return "free";
+  const key = String(variantId);
+  const mapped = VARIANT_PLAN_MAP[key];
+  if (mapped && PLANS[mapped]) return mapped;
+  logger.warn(
+    { variantId },
+    'license: unknown LemonSqueezy variant ID \u2014 defaulting to free plan. Set MERGEN_LS_VARIANT_MAP={"' + key + '":"<planId>"} to fix.'
+  );
+  return "free";
+}
+async function revalidateLicense() {
+  if (!_state) return;
+  try {
+    if (_state.key.startsWith("mrgn_")) {
+      const apiUrl = process.env.MERGEN_API_URL ?? "https://api.mergen.app";
+      const res = await fetch(`${apiUrl}/v1/validate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ key: _state.key, instance: "mergen-server" })
+      });
+      const data = await res.json();
+      if (!res.ok || !data.valid) {
+        logger.warn({ status: res.status }, "license: revalidation failed \u2014 reverting to free");
+        _state = null;
+        try {
+          await fs.rm(LICENSE_FILE);
+        } catch {
+        }
+      }
+    } else {
+      const res = await fetch("https://api.lemonsqueezy.com/v1/licenses/validate", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ license_key: _state.key, instance_name: "mergen-server" })
+      });
+      const data = await res.json();
+      if (!res.ok || !data.valid) {
+        logger.warn({ status: res.status }, "license: revalidation failed \u2014 reverting to free");
+        _state = null;
+        try {
+          await fs.rm(LICENSE_FILE);
+        } catch {
+        }
+      }
+    }
+  } catch (err) {
+    logger.warn({ err }, "license: revalidation request failed \u2014 keeping current state");
+  }
+}
+export {
+  activateKey,
+  deactivateKey,
+  getActivePlanId,
+  getLicenseState,
+  initLicense,
+  planFromVariantId,
+  revalidateLicense
+};

package/dist/intelligence/llm-spokesperson.js

@@ -0,0 +1,62 @@
+import { plattScale } from "./platt-scaling.js";
+import { serviceGraph } from "../sensor/service-graph.js";
+function formatValidatedFactsForLLM(hyp, service, gate, errorCount, runtimeFact, calibratedScore) {
+  const rawScore = hyp.confidenceScore;
+  const { calibrated: autoCalibrated, source, n } = plattScale(rawScore, hyp.tag);
+  const calibrated = calibratedScore ?? autoCalibrated;
+  const calibratedPct = Math.round(calibrated * 100);
+  const basisNote = source === "raw" ? "(prior \u2014 no calibration data yet)" : source === "empirical" ? `(empirical \u2014 ${n} verdicts)` : `(Platt-calibrated \u2014 ${n} verdicts)`;
+  const callers = serviceGraph.getCallers(service);
+  const callees = serviceGraph.getCallees(service);
+  const topoLines = [];
+  if (callers.length > 0) topoLines.push(`- Called by: ${callers.slice(0, 5).join(", ")}`);
+  if (callees.length > 0) topoLines.push(`- Calls: ${callees.slice(0, 5).join(", ")}`);
+  const topoSection = topoLines.length > 0 ? `
+Service topology (from live OTLP traces):
+${topoLines.join("\n")}` : "";
+  const signalLines = [
+    `- Classifier P(correct): ${(gate.signals.classifierScore * 100).toFixed(0)}%`,
+    `- Blast risk: ${gate.signals.blastRisk} (${gate.signals.upstreamImpact} upstream services)`,
+    gate.signals.histSuccessRate !== null ? `- Historical success rate for this detector: ${(gate.signals.histSuccessRate * 100).toFixed(0)}%` : "- Historical success rate: insufficient data"
+  ];
+  const systemPrompt = "You are the communications interface for an autonomous incident-response system. You will be given a structured facts package produced by deterministic analysis (topology graphs, calibrated classifiers, verdict corpus). Your ONLY job is to translate these validated facts into clear, human-readable engineering language. Do NOT add new hypotheses, speculate beyond the provided facts, or introduce uncertainty the data does not support. Do NOT pad with generic advice. Every sentence must trace back to a provided fact.";
+  const userPrompt = [
+    `## Incident Facts Package \u2014 ${service}`,
+    "",
+    `**Service under analysis:** ${service}`,
+    `**Error count in window:** ${errorCount}`,
+    topoSection,
+    "",
+    `## Validated Root Cause`,
+    `**Detector:** ${hyp.tag}`,
+    `**Summary:** ${hyp.summary}`,
+    `**Calibrated confidence:** ${calibratedPct}% ${basisNote}`,
+    hyp.causalPath.length > 0 ? `**Causal path:**
+${hyp.causalPath.map((s, i) => `${i + 1}. ${s}`).join("\n")}` : "",
+    hyp.evidence.length > 0 ? `**Evidence:**
+${hyp.evidence.map((e) => `- ${e}`).join("\n")}` : "",
+    "",
+    `## Validated Planning Decision`,
+    `**Decision:** ${gate.execute ? "EXECUTE FIX" : "HOLD \u2014 MANUAL ACTION REQUIRED"}`,
+    `**Reason:** ${gate.reason}`,
+    `**Signals:**
+${signalLines.join("\n")}`,
+    hyp.fixHint ? `
+## Recommended Action
+${hyp.fixHint}` : "",
+    runtimeFact ? `
+## Runtime Fact (Datadog trace summary)
+${runtimeFact.slice(0, 800)}` : "",
+    "",
+    "## Instructions",
+    "Write a concise Slack thread reply (max 300 words) that explains the root cause and recommended action to the on-call engineer. Use the facts above. Do not add speculation."
+  ].filter((l) => l !== null).join("\n");
+  return {
+    systemPrompt,
+    userPrompt,
+    estimatedTokens: Math.round((systemPrompt.length + userPrompt.length) / 4)
+  };
+}
+export {
+  formatValidatedFactsForLLM
+};

package/dist/intelligence/mcp-prompts.js

@@ -0,0 +1,320 @@
+import { z } from "zod";
+import { store } from "../sensor/buffer.js";
+import { hypothesisHistory } from "./hypothesis-history.js";
+function registerPrompts(server) {
+  server.registerPrompt(
+    "debug",
+    {
+      description: "Universal debugging prompt \u2014 use this when something is broken. Pre-fills the AI with your live browser telemetry so you skip the copy-paste step. Works for any error type: JavaScript crashes, auth failures, network errors, performance issues.",
+      argsSchema: {
+        focus: z.enum(["errors", "network", "auth", "all"]).optional().describe('Narrow the focus (default: all). Use "auth" for login issues, "network" for API failures.')
+      }
+    },
+    async ({ focus = "all" }) => {
+      const errors = store.getLogs(10, "error");
+      const warns = store.getLogs(5, "warn");
+      const network = store.getNetwork(10);
+      const netFails = network.filter((n) => n.status >= 400 || n.status === 0 || !!n.error);
+      const contexts = store.getContext(3);
+      const signals = store.getSignals();
+      const latest = hypothesisHistory.latest();
+      const topHyp = latest?.topHypothesis ?? null;
+      const total = errors.length + netFails.length;
+      if (total === 0 && warns.length === 0) {
+        return {
+          messages: [{
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                "I want to debug my app with Mergen, but the buffer is currently empty.",
+                "",
+                "Steps to capture events:",
+                "1. Make sure the Mergen Chrome extension is active on this tab (check the toolbar \u2014 icon should be lit, not greyed out)",
+                '   Alternative: add `<script src="http://localhost:3000/sdk.js"></script>` to your page HTML',
+                "2. Reproduce the issue in your browser",
+                "3. Come back and ask me again",
+                "",
+                "Or run: `npx mergen-server demo` for an instant demo.",
+                "",
+                "Once events are captured, call `quick_check` to see what's in the buffer."
+              ].join("\n")
+            }
+          }]
+        };
+      }
+      const lines = [];
+      if (topHyp && topHyp.confidenceScore >= 0.45) {
+        const pct = Math.round(topHyp.confidenceScore * 100);
+        lines.push(`## Prior hypothesis (${pct}% confidence)`);
+        lines.push(`**${topHyp.summary}**`);
+        if (topHyp.fixHint) lines.push(`Fix hint: ${topHyp.fixHint}`);
+        lines.push("");
+      }
+      lines.push(`## Live buffer state`);
+      lines.push(`- Console errors: ${errors.length}`);
+      lines.push(`- Warnings: ${warns.length}`);
+      lines.push(`- Network failures: ${netFails.length}`);
+      if (signals.length > 0) {
+        lines.push(`- Detected patterns: ${signals.map((s) => s.message).join("; ")}`);
+      }
+      lines.push("");
+      if ((focus === "all" || focus === "errors") && errors.length > 0) {
+        lines.push("## Recent console errors");
+        for (const e of errors.slice(0, 5)) {
+          const msg = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 200);
+          lines.push(`- [${new Date(e.timestamp).toISOString()}] ${msg}`);
+          if (e.stack) lines.push(`  Stack: ${e.stack.split("\n")[0]}`);
+        }
+        lines.push("");
+      }
+      if ((focus === "all" || focus === "network" || focus === "auth") && netFails.length > 0) {
+        lines.push("## Failing network requests");
+        for (const n of netFails.slice(0, 5)) {
+          const traceNote = n.traceId ? ` [traceId: ${n.traceId.slice(0, 8)}\u2026]` : "";
+          lines.push(`- ${n.method} ${n.url} \u2192 ${n.status || "ERR"} (${n.duration}ms)${traceNote}`);
+          if (n.error) lines.push(`  Error: ${n.error}`);
+        }
+        lines.push("");
+      }
+      if ((focus === "auth" || focus === "all") && contexts.length > 0) {
+        const ctx = contexts[contexts.length - 1];
+        const authKeys = Object.entries(ctx.localStorage).filter(([k]) => /token|auth|session|jwt|user/i.test(k));
+        if (authKeys.length > 0) {
+          lines.push("## Auth-related localStorage");
+          for (const [k, v] of authKeys) lines.push(`- ${k}: ${v.slice(0, 100)}`);
+          lines.push("");
+        }
+      }
+      lines.push("## Task");
+      lines.push(
+        "Call `reconstruct_context` to get the root cause with source-mapped stack frames and a fix. If there are network failures with traceIds, call `get_unified_timeline` first \u2014 `EXACT` joins mean the browser request and backend log share the same trace ID (deterministic, not a guess). Lead your response with: what broke, why, and the exact code change needed."
+      );
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: lines.join("\n") }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "debug_auth_failure",
+    {
+      description: "Diagnose why login or authentication is broken. Use when users cannot sign in, tokens are missing after login, or auth endpoints are returning 4xx/5xx. Injects live error logs, auth network calls, and localStorage state."
+    },
+    async () => {
+      const errors = store.getLogs(10, "error");
+      const authNetwork = store.getNetwork(10).filter(
+        (e) => /login|auth|signin|token|session/i.test(e.url)
+      );
+      const contexts = store.getContext(3);
+      const storage = contexts.length > 0 ? contexts[contexts.length - 1].localStorage : {};
+      const telemetry = { errors, authNetwork, localStorage: storage };
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: "Authentication is broken in my app. Here is the live browser telemetry:\n\n" + JSON.stringify(telemetry, null, 2) + "\n\nDiagnose:\n1. Which auth endpoint is failing and the HTTP status/error\n2. Whether the token is being stored in localStorage after a successful response\n3. The exact code fix (before/after diff)"
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "debug_network_error",
+    {
+      description: "Diagnose a failing network request. Use when a specific API call returns 4xx/5xx or a network error. Optionally filter to a specific URL pattern.",
+      argsSchema: {
+        url_pattern: z.string().optional().describe("URL substring to focus on, e.g. /api/users or checkout")
+      }
+    },
+    async ({ url_pattern }) => {
+      let failed = store.getNetwork(20).filter(
+        (e) => e.status >= 400 || e.status === 0 || !!e.error
+      );
+      if (url_pattern) failed = failed.filter((e) => e.url.includes(url_pattern));
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: "A network request is failing. Failed requests from the live buffer:\n\n" + JSON.stringify(failed, null, 2) + "\n\nDiagnose:\n1. Root cause of the failure\n2. Whether this is a client error (bad request) or server error\n3. The exact code fix"
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "debug_page_error",
+    {
+      description: "Diagnose the most recent JavaScript error or page crash. Use immediately after reproducing a bug to get a structured diagnosis with the stack trace, storage state, and network context."
+    },
+    async () => {
+      const errors = store.getLogs(5, "error");
+      const network = store.getNetwork(5);
+      const contexts = store.getContext(2);
+      const telemetry = { errors, lastNetworkCalls: network, dom: contexts };
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: "The page just showed an error. Live telemetry at the moment of crash:\n\n" + JSON.stringify(telemetry, null, 2) + "\n\nDiagnose:\n1. Root cause with the exact source file and line\n2. What application state triggered it\n3. The fix as a before/after code diff"
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "summarize_session",
+    {
+      description: "Summarize the entire current debugging session. Use at end of session or when picking up after a break. Returns top issues found, what is healthy, and next actions."
+    },
+    async () => {
+      const counters = store.getCounters();
+      const signals = store.getSignals();
+      const errors = store.getLogs(10, "error");
+      const network = store.getNetwork(10);
+      const telemetry = { counters, signals, recentErrors: errors, recentNetwork: network };
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: "Please summarize this debugging session:\n\n" + JSON.stringify(telemetry, null, 2) + "\n\nProvide:\n1. Top 3 issues found (with root causes)\n2. What is healthy and working correctly\n3. Recommended next actions in priority order"
+          }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "fix",
+    {
+      description: "Check if your last code change fixed the problem. Call this after applying a fix and reloading the app. Returns: what was resolved, what still persists, and any new regressions.",
+      argsSchema: {
+        session_id: z.string().optional().describe("Debug session ID from start_debug_session (if you started one). Skip if you just want to check current error state.")
+      }
+    },
+    async ({ session_id }) => {
+      const errors = store.getLogs(200, "error");
+      const warns = store.getLogs(50, "warn");
+      const netFails = store.getNetwork(200).filter((n) => n.status >= 400 || n.status === 0 || !!n.error);
+      const signals = store.getSignals();
+      const lines = [];
+      if (session_id) {
+        lines.push(
+          `I applied a fix. Check the current state against the debug session baseline.
+Call \`checkpoint_debug_session\` with session_id: "${session_id}" and note: "applied fix".
+Then tell me: what resolved, what persists, any new regressions.`
+        );
+      } else {
+        const total = errors.length + netFails.length;
+        lines.push(`I just applied a fix and reloaded the app. Current Mergen state:
+`);
+        lines.push(`- Console errors: ${errors.length}`);
+        lines.push(`- Network failures: ${netFails.length}`);
+        lines.push(`- Warnings: ${warns.length}`);
+        lines.push(`- Active signals: ${signals.length}`);
+        lines.push("");
+        if (errors.length > 0) {
+          lines.push("**Current errors (may or may not be the same as before the fix):**");
+          for (const e of errors.slice(0, 3)) {
+            const msg = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 150);
+            lines.push(`- ${msg}`);
+          }
+          lines.push("");
+        }
+        if (netFails.length > 0) {
+          lines.push("**Current network failures:**");
+          for (const n of netFails.slice(0, 3)) {
+            lines.push(`- ${n.method} ${n.url} \u2192 ${n.status || "ERR"}`);
+          }
+          lines.push("");
+        }
+        lines.push(
+          total === 0 ? `**Give me a verdict: \u2705 Buffer is clean \u2014 the fix appears to have worked. Tell me clearly: "Fixed" or "Not fixed" and what to do next.**` : `**Give me a verdict: is this the same error as before, or is it different? Clearly state: "Fixed", "Partially fixed" (describe what changed), or "Not fixed" (describe what's the same). Then tell me the next step.**`
+        );
+        lines.push("");
+        lines.push("Call `get_recent_logs` and `get_network_activity` to get the fresh events if needed.");
+      }
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: lines.join("\n") }
+        }]
+      };
+    }
+  );
+  server.registerPrompt(
+    "why",
+    {
+      description: "Get the root cause of the current error \u2014 fastest path from symptom to fix. Use when you see an error but don't know why it's happening. Pre-fills the AI with the full error context so you skip description entirely.",
+      argsSchema: {
+        symptom: z.string().optional().describe('Optional: one sentence describing what you see (e.g. "login button does nothing", "page goes blank", "500 from /api/users"). Skip to use whatever is in the buffer.')
+      }
+    },
+    async ({ symptom }) => {
+      const errors = store.getLogs(5, "error");
+      const netFails = store.getNetwork(5).filter((n) => n.status >= 400 || n.status === 0 || !!n.error);
+      const contexts = store.getContext(2);
+      const latest = hypothesisHistory.latest();
+      const topHyp = latest?.topHypothesis;
+      if (errors.length === 0 && netFails.length === 0 && !symptom) {
+        return {
+          messages: [{
+            role: "user",
+            content: {
+              type: "text",
+              text: 'I want to diagnose a bug but the Mergen buffer is empty. Reproduce the issue in your browser first, then run /why again. Or describe the symptom: /why "login page goes blank after submit"'
+            }
+          }]
+        };
+      }
+      const lines = [];
+      if (symptom) lines.push(`**Symptom:** ${symptom}
+`);
+      if (topHyp && topHyp.confidenceScore >= 0.5) {
+        const pct = Math.round(topHyp.confidenceScore * 100);
+        lines.push(`**Prior hypothesis (${pct}% confidence):** ${topHyp.summary}`);
+        if (topHyp.fixHint) lines.push(`**Prior fix hint:** ${topHyp.fixHint}`);
+        lines.push("");
+      }
+      lines.push("**Live telemetry:**");
+      for (const e of errors.slice(0, 3)) {
+        const msg = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 300);
+        lines.push(`
+[ERROR] ${msg}`);
+        if (e.stack) lines.push(`Stack: ${e.stack.split("\n").slice(0, 4).join("\n  ")}`);
+        if (e.gitSuspect) lines.push(`Git: ${e.gitSuspect.sha.slice(0, 7)} by ${e.gitSuspect.author} \u2014 "${e.gitSuspect.summary}"`);
+      }
+      for (const n of netFails.slice(0, 3)) {
+        lines.push(`
+[NETWORK] ${n.method} ${n.url} \u2192 ${n.status || "ERR"} (${n.duration}ms)`);
+        if (n.error) lines.push(`  Error: ${n.error}`);
+        if (n.traceId) lines.push(`  TraceId: ${n.traceId} \u2014 call get_correlated_trace if you have backend spans`);
+      }
+      if (contexts.length > 0) {
+        const ctx = contexts[contexts.length - 1];
+        lines.push(`
+[STATE] URL: ${ctx.url} | Component: ${ctx.component ?? "none"} | Focused: ${ctx.activeElement ?? "none"}`);
+        const authKeys = Object.entries(ctx.localStorage).filter(([k]) => /token|auth|user|session/i.test(k));
+        if (authKeys.length > 0) lines.push(`Auth state: ${authKeys.map(([k, v]) => `${k}=${v.slice(0, 30)}`).join(", ")}`);
+      }
+      lines.push("");
+      lines.push(
+        '**Task:** Explain WHY this is broken. One clear sentence: "This is broken because [specific cause]." Then give the exact file + line + code change that fixes it. Call `reconstruct_context` for source-mapped stack frames if you need more context. Do NOT ask clarifying questions \u2014 diagnose from what you have.'
+      );
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: lines.join("\n") }
+        }]
+      };
+    }
+  );
+}
+export {
+  registerPrompts
+};