agent-detective 1.0.0

package/dist/chunk-H2IXGHNA.js

@@ -0,0 +1,1237 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var APP_NAME = "agent-detective";
+var APP_VERSION = "1.0.0";
+
+// src/config/env-whitelist.ts
+var JIRA_PACKAGE = "@agent-detective/jira-adapter";
+var LINEAR_PACKAGE = "@agent-detective/linear-adapter";
+var LOCAL_REPOS_PACKAGE = "@agent-detective/local-repos-plugin";
+var PR_PIPELINE_PACKAGE = "@agent-detective/pr-pipeline";
+function getExistingPluginOptions(config, packageName) {
+  if (!Array.isArray(config.plugins)) {
+    return null;
+  }
+  const entry = config.plugins.find((p) => p.package === packageName);
+  if (!entry) return null;
+  if (!entry.options) {
+    entry.options = {};
+  }
+  return entry.options;
+}
+function setNested(options, path, value) {
+  let cur = options;
+  for (let i = 0; i < path.length - 1; i++) {
+    const k = path[i];
+    const next = cur[k];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      cur[k] = {};
+    }
+    cur = cur[k];
+  }
+  cur[path[path.length - 1]] = value;
+}
+function applyCoreEnvWhitelist(config) {
+  if (process.env.PORT) {
+    const n = parseInt(process.env.PORT, 10);
+    if (!Number.isNaN(n)) {
+      config.port = n;
+    }
+  }
+  if (process.env.AGENT) {
+    config.agent = process.env.AGENT;
+  }
+  const agentModelEnvVars = ["AGENTS_OPENCODE_MODEL", "AGENTS_CLAUDE_MODEL", "AGENTS_CURSOR_MODEL"];
+  for (const envVar of agentModelEnvVars) {
+    const raw = process.env[envVar];
+    if (!raw) continue;
+    const agentId = envVar.replace("AGENTS_", "").replace("_MODEL", "").toLowerCase();
+    if (agentId === "runner") continue;
+    if (!config.agents) {
+      config.agents = {};
+    }
+    if (!config.agents[agentId]) {
+      config.agents[agentId] = { defaultModel: raw };
+    } else {
+      config.agents[agentId].defaultModel = raw;
+    }
+  }
+  for (const [key, value] of Object.entries(process.env)) {
+    const m = /^AGENTS_([A-Z0-9]+)_MODEL$/.exec(key);
+    if (!m || !value) continue;
+    const agentId = m[1].toLowerCase();
+    if (agentId === "runner") continue;
+    if (agentModelEnvVars.includes(key)) continue;
+    if (!config.agents) {
+      config.agents = {};
+    }
+    if (!config.agents[agentId]) {
+      config.agents[agentId] = { defaultModel: value };
+    } else {
+      config.agents[agentId].defaultModel = value;
+    }
+  }
+  if (process.env.DOCS_AUTH_REQUIRED === "true" || process.env.DOCS_AUTH_REQUIRED === "false") {
+    config.docsAuthRequired = process.env.DOCS_AUTH_REQUIRED === "true";
+  }
+  if (process.env.DOCS_API_KEY) {
+    config.docsApiKey = process.env.DOCS_API_KEY;
+  }
+  if (process.env.PLUGINS_FAIL_ON_CONTRACT_ERRORS === "true" || process.env.PLUGINS_FAIL_ON_CONTRACT_ERRORS === "false") {
+    if (!config.pluginSystem) config.pluginSystem = {};
+    config.pluginSystem.failOnContractErrors = process.env.PLUGINS_FAIL_ON_CONTRACT_ERRORS === "true";
+  }
+  if (process.env.PLUGINS_FAIL_ON_DEPENDENCY_ERRORS === "true" || process.env.PLUGINS_FAIL_ON_DEPENDENCY_ERRORS === "false") {
+    if (!config.pluginSystem) config.pluginSystem = {};
+    config.pluginSystem.failOnDependencyErrors = process.env.PLUGINS_FAIL_ON_DEPENDENCY_ERRORS === "true";
+  }
+  if (process.env.PLUGINS_FAIL_ON_PLUGIN_LOAD_ERRORS === "true" || process.env.PLUGINS_FAIL_ON_PLUGIN_LOAD_ERRORS === "false") {
+    if (!config.pluginSystem) config.pluginSystem = {};
+    config.pluginSystem.failOnPluginLoadErrors = process.env.PLUGINS_FAIL_ON_PLUGIN_LOAD_ERRORS === "true";
+  }
+  const parseMs = (raw) => {
+    if (raw === void 0 || raw === "") return void 0;
+    const n = parseInt(raw, 10);
+    return !Number.isNaN(n) && n >= 0 ? n : void 0;
+  };
+  const parseBytes = (raw) => {
+    if (raw === void 0 || raw === "") return void 0;
+    const n = parseInt(raw, 10);
+    return !Number.isNaN(n) && n > 0 ? n : void 0;
+  };
+  const t = parseMs(process.env.AGENTS_RUNNER_TIMEOUT_MS);
+  const buf = parseBytes(process.env.AGENTS_RUNNER_MAX_BUFFER_BYTES);
+  const grace = parseMs(process.env.AGENTS_RUNNER_POST_FINAL_GRACE_MS);
+  const forceKill = parseMs(process.env.AGENTS_RUNNER_FORCE_KILL_DELAY_MS);
+  if (t !== void 0 || buf !== void 0 || grace !== void 0 || forceKill !== void 0) {
+    if (!config.agents) {
+      config.agents = {};
+    }
+    const runnerPath = "runner";
+    if (!config.agents[runnerPath]) {
+      config.agents[runnerPath] = {};
+    }
+    const runner = config.agents[runnerPath];
+    if (t !== void 0) runner.timeoutMs = t;
+    if (buf !== void 0) runner.maxBufferBytes = buf;
+    if (grace !== void 0) runner.postFinalGraceMs = grace;
+    if (forceKill !== void 0) runner.forceKillDelayMs = forceKill;
+  }
+  const obsExclude = process.env.OBSERVABILITY_REQUEST_LOGGER_EXCLUDE_PATHS;
+  if (obsExclude !== void 0 && obsExclude !== "") {
+    if (!config.observability) {
+      config.observability = {};
+    }
+    const obs = config.observability;
+    if (!obs.requestLogger) {
+      obs.requestLogger = {};
+    }
+    obs.requestLogger.excludePaths = obsExclude.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const tasksMaxConcurrentRaw = process.env.TASKS_MAX_CONCURRENT;
+  if (tasksMaxConcurrentRaw !== void 0 && tasksMaxConcurrentRaw !== "") {
+    const n = parseInt(tasksMaxConcurrentRaw, 10);
+    if (!Number.isNaN(n) && n > 0 && n <= 1e3) {
+      if (!config.tasks) config.tasks = {};
+      config.tasks.maxConcurrent = n;
+    }
+  }
+  const wallFromEnv = parseMs(process.env.TASKS_MAX_WALL_TIME_MS);
+  if (wallFromEnv !== void 0 && wallFromEnv > 0) {
+    if (!config.tasks) config.tasks = {};
+    config.tasks.maxWallTimeMs = wallFromEnv;
+  }
+  const runRecordsPath = process.env.RUN_RECORDS_PATH?.trim();
+  if (runRecordsPath) {
+    config.runRecords = { path: runRecordsPath };
+  }
+}
+function applyPluginEnvWhitelist(config) {
+  const jiraToken = process.env.JIRA_API_TOKEN;
+  const jiraEmail = process.env.JIRA_EMAIL;
+  const jiraBase = process.env.JIRA_BASE_URL;
+  const jiraOAuthClientId = process.env.JIRA_OAUTH_CLIENT_ID;
+  const jiraOAuthClientSecret = process.env.JIRA_OAUTH_CLIENT_SECRET;
+  const jiraOAuthRedirectBase = process.env.JIRA_OAUTH_REDIRECT_BASE_URL;
+  const jiraOAuthRefreshToken = process.env.JIRA_OAUTH_REFRESH_TOKEN;
+  const jiraCloudId = process.env.JIRA_CLOUD_ID;
+  if (jiraToken || jiraEmail || jiraBase || jiraOAuthClientId || jiraOAuthClientSecret || jiraOAuthRedirectBase || jiraOAuthRefreshToken || jiraCloudId) {
+    const opts = getExistingPluginOptions(config, JIRA_PACKAGE);
+    if (opts) {
+      if (jiraToken) opts.apiToken = jiraToken;
+      if (jiraEmail) opts.email = jiraEmail;
+      if (jiraBase) opts.baseUrl = jiraBase;
+      if (jiraOAuthClientId) opts.oauthClientId = jiraOAuthClientId;
+      if (jiraOAuthClientSecret) opts.oauthClientSecret = jiraOAuthClientSecret;
+      if (jiraOAuthRedirectBase) opts.oauthRedirectBaseUrl = jiraOAuthRedirectBase;
+      if (jiraOAuthRefreshToken) opts.oauthRefreshToken = jiraOAuthRefreshToken;
+      if (jiraCloudId) opts.cloudId = jiraCloudId;
+    }
+  }
+  const linearApiKey = process.env.LINEAR_API_KEY;
+  const linearWebhookSecret = process.env.LINEAR_WEBHOOK_SIGNING_SECRET;
+  const linearOAuthClientId = process.env.LINEAR_OAUTH_CLIENT_ID;
+  const linearOAuthClientSecret = process.env.LINEAR_OAUTH_CLIENT_SECRET;
+  const linearOAuthRedirectBase = process.env.LINEAR_OAUTH_REDIRECT_BASE_URL;
+  const linearOAuthRefreshToken = process.env.LINEAR_OAUTH_REFRESH_TOKEN;
+  const linearOAuthActor = process.env.LINEAR_OAUTH_ACTOR;
+  if (linearApiKey || linearWebhookSecret || linearOAuthClientId || linearOAuthClientSecret || linearOAuthRedirectBase || linearOAuthRefreshToken || linearOAuthActor) {
+    const opts = getExistingPluginOptions(config, LINEAR_PACKAGE);
+    if (opts) {
+      if (linearApiKey) opts.apiKey = linearApiKey;
+      if (linearWebhookSecret) opts.webhookSigningSecret = linearWebhookSecret;
+      if (linearOAuthClientId) opts.oauthClientId = linearOAuthClientId;
+      if (linearOAuthClientSecret) opts.oauthClientSecret = linearOAuthClientSecret;
+      if (linearOAuthRedirectBase) opts.oauthRedirectBaseUrl = linearOAuthRedirectBase;
+      if (linearOAuthRefreshToken) opts.oauthRefreshToken = linearOAuthRefreshToken;
+      if (linearOAuthActor === "app" || linearOAuthActor === "user") {
+        opts.oauthActor = linearOAuthActor;
+      }
+    }
+  }
+  const maxCommitsRaw = process.env.REPO_CONTEXT_GIT_LOG_MAX_COMMITS;
+  if (maxCommitsRaw !== void 0 && maxCommitsRaw !== "") {
+    const n = parseInt(maxCommitsRaw, 10);
+    if (!Number.isNaN(n) && n > 0) {
+      const opts = getExistingPluginOptions(config, LOCAL_REPOS_PACKAGE);
+      if (opts) {
+        setNested(opts, ["repoContext", "gitLogMaxCommits"], n);
+      }
+    }
+  }
+  const gitTimeout = process.env.REPO_CONTEXT_GIT_COMMAND_TIMEOUT_MS;
+  if (gitTimeout !== void 0 && gitTimeout !== "") {
+    const n = parseInt(gitTimeout, 10);
+    if (!Number.isNaN(n) && n > 0) {
+      const opts = getExistingPluginOptions(config, LOCAL_REPOS_PACKAGE);
+      if (opts) {
+        setNested(opts, ["repoContext", "gitCommandTimeoutMs"], n);
+      }
+    }
+  }
+  const gitMaxBuf = process.env.REPO_CONTEXT_GIT_MAX_BUFFER_BYTES;
+  if (gitMaxBuf !== void 0 && gitMaxBuf !== "") {
+    const n = parseInt(gitMaxBuf, 10);
+    if (!Number.isNaN(n) && n > 0) {
+      const opts = getExistingPluginOptions(config, LOCAL_REPOS_PACKAGE);
+      if (opts) {
+        setNested(opts, ["repoContext", "gitMaxBufferBytes"], n);
+      }
+    }
+  }
+  const diffFromRef = process.env.REPO_CONTEXT_DIFF_FROM_REF;
+  if (diffFromRef && diffFromRef.trim()) {
+    const opts = getExistingPluginOptions(config, LOCAL_REPOS_PACKAGE);
+    if (opts) {
+      setNested(opts, ["repoContext", "diffFromRef"], diffFromRef.trim());
+    }
+  }
+  const maxOut = process.env.SUMMARY_MAX_OUTPUT_CHARS;
+  if (maxOut !== void 0 && maxOut !== "") {
+    const n = parseInt(maxOut, 10);
+    if (!Number.isNaN(n) && n > 0) {
+      const opts = getExistingPluginOptions(config, LOCAL_REPOS_PACKAGE);
+      if (opts) {
+        setNested(opts, ["summaryGeneration", "maxOutputChars"], n);
+      }
+    }
+  }
+  const jiraAutoCd = process.env.JIRA_AUTO_ANALYSIS_COOLDOWN_MS;
+  if (jiraAutoCd !== void 0 && jiraAutoCd !== "") {
+    const n = parseInt(jiraAutoCd, 10);
+    if (!Number.isNaN(n) && n >= 0) {
+      const opts = getExistingPluginOptions(config, JIRA_PACKAGE);
+      if (opts) {
+        opts.autoAnalysisCooldownMs = n;
+      }
+    }
+  }
+  const jiraRemCd = process.env.JIRA_MISSING_LABELS_REMINDER_COOLDOWN_MS;
+  if (jiraRemCd !== void 0 && jiraRemCd !== "") {
+    const n = parseInt(jiraRemCd, 10);
+    if (!Number.isNaN(n) && n >= 0) {
+      const opts = getExistingPluginOptions(config, JIRA_PACKAGE);
+      if (opts) {
+        opts.missingLabelsReminderCooldownMs = n;
+      }
+    }
+  }
+  const prPipelineOpts = getExistingPluginOptions(config, PR_PIPELINE_PACKAGE);
+  if (prPipelineOpts) {
+    if (process.env.GITHUB_TOKEN) {
+      prPipelineOpts.githubToken = process.env.GITHUB_TOKEN;
+    } else if (process.env.GH_TOKEN) {
+      prPipelineOpts.githubToken = process.env.GH_TOKEN;
+    }
+    if (process.env.BITBUCKET_TOKEN) {
+      prPipelineOpts.bitbucketToken = process.env.BITBUCKET_TOKEN;
+    }
+    if (process.env.BITBUCKET_USERNAME) {
+      prPipelineOpts.bitbucketUsername = process.env.BITBUCKET_USERNAME;
+    }
+    if (process.env.BITBUCKET_APP_PASSWORD) {
+      prPipelineOpts.bitbucketAppPassword = process.env.BITBUCKET_APP_PASSWORD;
+    }
+  }
+}
+function applyLogLevelAliasForObservability() {
+  const log = process.env.LOG_LEVEL;
+  if (!log || process.env.OBSERVABILITY_LOG_LEVEL) return;
+  if (["debug", "info", "warn", "error"].includes(log)) {
+    process.env.OBSERVABILITY_LOG_LEVEL = log;
+  }
+}
+
+// src/server.ts
+import Fastify from "fastify";
+import {
+  jsonSchemaTransform,
+  serializerCompiler,
+  validatorCompiler
+} from "fastify-type-provider-zod";
+import swagger from "@fastify/swagger";
+
+// src/core/openapi/tags.ts
+var CORE_PLUGIN_TAG = "@agent-detective/core";
+var SCALAR_TAG_GROUPS = {
+  CORE: "Core",
+  PLUGINS: "Plugins"
+};
+function createTagDescription(tag) {
+  switch (tag) {
+    case CORE_PLUGIN_TAG:
+      return "Core API endpoints";
+    default:
+      return `${tag} plugin endpoints`;
+  }
+}
+
+// src/core/openapi/tag-groups.ts
+function applyTagGroups(spec, options = {}) {
+  const doc = spec;
+  doc.tags = doc.tags ?? [];
+  const byName = new Map(doc.tags.map((t) => [t.name, t]));
+  const ensureTag = (name) => {
+    const existing = byName.get(name);
+    const desc = options.descriptions?.[name] ?? createTagDescription(name);
+    if (!existing) {
+      const tag = { name, description: desc };
+      doc.tags.push(tag);
+      byName.set(name, tag);
+    } else if (!existing.description) {
+      existing.description = desc;
+    }
+  };
+  ensureTag(CORE_PLUGIN_TAG);
+  const pluginTags = options.pluginTags ?? [...byName.keys()].filter((n) => n !== CORE_PLUGIN_TAG);
+  for (const name of pluginTags) ensureTag(name);
+  doc["x-tagGroups"] = [
+    { name: SCALAR_TAG_GROUPS.CORE, tags: [CORE_PLUGIN_TAG] },
+    { name: SCALAR_TAG_GROUPS.PLUGINS, tags: pluginTags }
+  ];
+  return doc;
+}
+
+// src/server.ts
+import { createRequestLogger } from "@agent-detective/observability";
+
+// src/core/core-api-controller.ts
+import { randomUUID } from "crypto";
+import { z } from "zod";
+import { defineRoute, registerRoutes } from "@agent-detective/sdk";
+var ServerInfoResponse = z.object({
+  name: z.string(),
+  version: z.string(),
+  plugins: z.array(z.string())
+});
+var HealthCheckResponse = z.object({ status: z.enum(["ok", "degraded", "error"]) }).loose();
+var AgentInfoResponse = z.array(
+  z.object({
+    id: z.string(),
+    label: z.string(),
+    defaultModel: z.string().optional(),
+    available: z.boolean().optional(),
+    needsPty: z.boolean().optional(),
+    mergeStderr: z.boolean().optional()
+  }).loose()
+);
+var QueueStatusResponse = z.object({
+  status: z.literal("ok"),
+  backend: z.string()
+});
+var PluginStatusResponse = z.object({
+  configured: z.array(z.string()),
+  loaded: z.array(z.string()),
+  failures: z.array(
+    z.object({
+      plugin: z.string(),
+      stage: z.string(),
+      message: z.string()
+    })
+  )
+});
+var ErrorResponse = z.object({
+  error: z.string(),
+  availableAgents: z.array(z.string()).optional(),
+  agentId: z.string().optional()
+});
+var AgentRunBody = z.object({
+  agentId: z.string().min(1, "agentId is required"),
+  prompt: z.string().min(1, "prompt is required"),
+  options: z.object({
+    model: z.string().optional(),
+    repoPath: z.string().nullable().optional(),
+    cwd: z.string().optional(),
+    threadId: z.string().optional()
+  }).optional()
+});
+var AgentRunOk = z.object({
+  taskId: z.string(),
+  output: z.string(),
+  sawJson: z.boolean(),
+  threadId: z.string().optional()
+});
+var ProcessEventBody = z.object({
+  type: z.enum(["incident", "question", "command"]),
+  message: z.string().min(1),
+  context: z.object({
+    repoPath: z.string().nullable().optional(),
+    threadId: z.string().nullable().optional(),
+    cwd: z.string().optional(),
+    model: z.string().optional()
+  }).optional()
+});
+var ProcessEventOk = z.object({ taskId: z.string() });
+function startSseHeaders(reply) {
+  reply.hijack();
+  const raw = reply.raw;
+  raw.setHeader("Content-Type", "text/event-stream");
+  raw.setHeader("Cache-Control", "no-cache");
+  raw.setHeader("Connection", "keep-alive");
+  raw.setHeader("X-Accel-Buffering", "no");
+  raw.flushHeaders?.();
+  return raw;
+}
+function writeSse(stream, payload) {
+  stream.write(`data: ${JSON.stringify(payload)}
+
+`);
+}
+function buildCoreApiRoutes(deps) {
+  const { agentModels, agentRunner, enqueue, observability, config, pluginStatus } = deps;
+  const getServerInfo = defineRoute({
+    method: "GET",
+    url: "/api/",
+    schema: {
+      tags: [CORE_PLUGIN_TAG],
+      summary: "Get server info",
+      description: "Returns basic information about the agent-detective server",
+      response: { 200: ServerInfoResponse }
+    },
+    handler() {
+      const plugins = (config.plugins ?? []).map((p) => p.package).filter((p) => Boolean(p));
+      return { name: APP_NAME, version: APP_VERSION, plugins };
+    }
+  });
+  const getHealth = defineRoute({
+    method: "GET",
+    url: "/api/health",
+    schema: {
+      tags: [CORE_PLUGIN_TAG],
+      summary: "Health check",
+      description: "Returns the health status of the server",
+      response: { 200: HealthCheckResponse, 503: ErrorResponse }
+    },
+    async handler(_req, reply) {
+      const healthStatus = await observability.health.check();
+      const statusCode = healthStatus.status === "unhealthy" ? 503 : 200;
+      return reply.code(statusCode).send(healthStatus);
+    }
+  });
+  const listAgents2 = defineRoute({
+    method: "GET",
+    url: "/api/agent/list",
+    schema: {
+      tags: [CORE_PLUGIN_TAG],
+      summary: "List available agents",
+      description: "Returns a list of all available AI agents and their status",
+      response: { 200: AgentInfoResponse, 503: ErrorResponse }
+    },
+    async handler(_req, reply) {
+      if (!agentRunner) {
+        return reply.code(503).send({ error: "Agent runner not available" });
+      }
+      const list = await agentRunner.listAgents();
+      if (!agentModels) return list;
+      return list.map((a) => ({
+        ...a,
+        defaultModel: agentModels[a.id]?.defaultModel ?? a.defaultModel
+      }));
+    }
+  });
+  const queueStatus = defineRoute({
+    method: "GET",
+    url: "/api/queue/status",
+    schema: {
+      tags: [CORE_PLUGIN_TAG],
+      summary: "Queue status",
+      description: "In-process task queue: serializes work per task key. No depth metrics exposed yet.",
+      response: { 200: QueueStatusResponse }
+    },
+    handler() {
+      return { status: "ok", backend: "memory" };
+    }
+  });
+  const pluginsStatus = defineRoute({
+    method: "GET",
+    url: "/api/plugins",
+    schema: {
+      tags: [CORE_PLUGIN_TAG],
+      summary: "Plugin status",
+      description: "Returns configured plugins, loaded plugins, and recent plugin load failures",
+      response: { 200: PluginStatusResponse }
+    },
+    handler() {
+      const configured = (config.plugins ?? []).map((p) => p.package).filter((p) => Boolean(p));
+      const status = pluginStatus?.() ?? { loaded: [], failures: [] };
+      return {
+        configured,
+        loaded: status.loaded,
+        failures: status.failures
+      };
+    }
+  });
+  const runAgent = defineRoute({
+    method: "POST",
+    url: "/api/agent/run",
+    schema: {
+      tags: [CORE_PLUGIN_TAG],
+      summary: "Run AI agent",
+      description: "Executes an AI agent with the provided prompt and options",
+      body: AgentRunBody,
+      response: { 200: AgentRunOk, 404: ErrorResponse, 503: ErrorResponse }
+    },
+    async handler(req, reply) {
+      const { agentId, prompt, options } = req.body;
+      if (!agentRunner) {
+        return reply.code(503).send({ error: "Agent runner not available" });
+      }
+      const list = await agentRunner.listAgents();
+      const agentInfo = list.find((a) => a.id === agentId);
+      if (!agentInfo) {
+        return reply.code(404).send({
+          error: `Unknown agent: ${agentId}`,
+          availableAgents: list.map((a) => a.id)
+        });
+      }
+      if (!agentInfo.available) {
+        return reply.code(404).send({
+          error: `Agent '${agentId}' is not installed or not available on this system`,
+          agentId
+        });
+      }
+      const wantsStream = req.headers.accept?.includes("text/event-stream");
+      const taskId = randomUUID();
+      if (wantsStream) {
+        const stream = startSseHeaders(reply);
+        try {
+          await agentRunner.runAgentForChat(taskId, prompt, {
+            agentId,
+            repoPath: options?.repoPath,
+            cwd: options?.cwd,
+            model: options?.model,
+            threadId: options?.threadId,
+            onProgress: (messages) => {
+              for (const msg of messages) {
+                writeSse(stream, { type: "progress", content: msg });
+              }
+            },
+            onFinal: (text) => {
+              writeSse(stream, { type: "final", content: text });
+              stream.end();
+            }
+          });
+        } catch (err) {
+          writeSse(stream, {
+            type: "final",
+            content: `Error: ${err.message}`
+          });
+          stream.end();
+        }
+        return reply;
+      }
+      try {
+        const output = await agentRunner.runAgentForChat(taskId, prompt, {
+          agentId,
+          repoPath: options?.repoPath,
+          cwd: options?.cwd,
+          model: options?.model,
+          threadId: options?.threadId
+        });
+        return {
+          taskId,
+          output: output.text,
+          sawJson: output.sawJson,
+          threadId: output.threadId
+        };
+      } catch (err) {
+        return reply.code(500).send({ error: err.message });
+      }
+    }
+  });
+  const processEvent = defineRoute({
+    method: "POST",
+    url: "/api/events",
+    schema: {
+      tags: [CORE_PLUGIN_TAG],
+      summary: "Process event",
+      description: "Processes a TaskEvent and executes the appropriate agent",
+      body: ProcessEventBody,
+      response: { 200: ProcessEventOk, 503: ErrorResponse }
+    },
+    async handler(req, reply) {
+      const body = req.body;
+      const taskId = randomUUID();
+      if (!agentRunner || !enqueue) {
+        return reply.code(503).send({ error: "Agent runner or queue not available" });
+      }
+      const wantsStream = req.headers.accept?.includes("text/event-stream");
+      if (wantsStream) {
+        const stream = startSseHeaders(reply);
+        try {
+          await enqueue(taskId, async () => {
+            writeSse(stream, { type: "progress", content: `Processing event ${taskId}...` });
+            await agentRunner.runAgentForChat(taskId, body.message, {
+              repoPath: body.context?.repoPath ?? void 0,
+              cwd: body.context?.cwd || process.cwd(),
+              threadId: body.context?.threadId ?? void 0,
+              onProgress: (messages) => {
+                for (const msg of messages) {
+                  writeSse(stream, { type: "progress", content: msg });
+                }
+              },
+              onFinal: (text) => {
+                writeSse(stream, { type: "final", content: text });
+                stream.end();
+              }
+            });
+          });
+        } catch (err) {
+          writeSse(stream, { type: "final", content: `Error: ${err.message}` });
+          stream.end();
+        }
+        return reply;
+      }
+      try {
+        await enqueue(taskId, async () => {
+          await agentRunner.runAgentForChat(taskId, body.message, {
+            repoPath: body.context?.repoPath ?? void 0,
+            cwd: body.context?.cwd || process.cwd(),
+            threadId: body.context?.threadId ?? void 0
+          });
+        });
+        return { taskId };
+      } catch (err) {
+        return reply.code(500).send({ error: err.message });
+      }
+    }
+  });
+  return [getServerInfo, getHealth, listAgents2, queueStatus, pluginsStatus, runAgent, processEvent];
+}
+function registerCoreApiRoutes(app, deps) {
+  registerRoutes(app, buildCoreApiRoutes(deps));
+}
+
+// src/config/load.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+
+// src/config/deep-merge.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue !== void 0 && typeof sourceValue === "object" && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+
+// src/config/load.ts
+import * as z3 from "zod";
+
+// src/config/schema.ts
+import * as z2 from "zod";
+var pluginEntrySchema = z2.object({
+  package: z2.string().optional(),
+  options: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var agentsRunnerConfigSchema = z2.object({
+  timeoutMs: z2.number().int().positive().optional(),
+  maxBufferBytes: z2.number().int().positive().optional(),
+  postFinalGraceMs: z2.number().int().nonnegative().optional(),
+  forceKillDelayMs: z2.number().int().nonnegative().optional()
+}).strict();
+var agentModelConfigSchema = z2.object({
+  defaultModel: z2.string().optional()
+}).strict();
+var agentsEntrySchema = z2.union([agentModelConfigSchema, agentsRunnerConfigSchema]);
+var appConfigSchema = z2.object({
+  port: z2.number().optional(),
+  agent: z2.string().optional(),
+  agents: z2.record(z2.string(), agentsEntrySchema).optional(),
+  plugins: z2.array(pluginEntrySchema).optional(),
+  pluginSystem: z2.object({
+    /**
+     * When true, the host aborts startup if plugin contract validation
+     * detects missing capability-backed providers (e.g. requires capability
+     * but no mapped service is registered).
+     */
+    failOnContractErrors: z2.boolean().optional(),
+    /**
+     * When true, the host aborts startup if plugin dependency resolution
+     * detects missing dependencies or circular cycles.
+     */
+    failOnDependencyErrors: z2.boolean().optional(),
+    /**
+     * When true, the host aborts startup if any configured plugin fails
+     * to import, validate, or register.
+     */
+    failOnPluginLoadErrors: z2.boolean().optional()
+  }).strict().optional(),
+  /** Merged into `createObservability` / request logger; `requestLogger.excludePaths` is read in `server.ts`. */
+  observability: z2.record(z2.string(), z2.unknown()).optional(),
+  /**
+   * Operator guardrails for orchestrated tasks (webhook-driven and similar).
+   * `maxConcurrent` wraps the default in-memory task queue so at most N agent
+   * runs execute at once across all queue keys. `maxWallTimeMs` caps a single
+   * orchestrated `runAgentForChat` call (the subprocess may still shut down
+   * on its own schedule — see agent `agents.runner.timeoutMs`).
+   */
+  tasks: z2.object({
+    maxConcurrent: z2.number().int().positive().max(1e3).optional(),
+    maxWallTimeMs: z2.number().int().positive().optional()
+  }).strict().optional(),
+  /**
+   * When set, each task lifecycle line (start / completed / failed) is appended
+   * as one JSON object per line (JSONL) to `path` (absolute or relative to the
+   * config directory).
+   */
+  runRecords: z2.object({
+    path: z2.string().min(1)
+  }).strict().optional(),
+  docsAuthRequired: z2.boolean().optional(),
+  docsApiKey: z2.string().optional()
+}).strict();
+
+// src/config/load.ts
+function loadConfig(options) {
+  const configDir = options?.configRoot ?? resolve(process.cwd(), "config");
+  let config = {};
+  const defaultConfigPath = resolve(configDir, "default.json");
+  if (existsSync(defaultConfigPath)) {
+    try {
+      config = JSON.parse(readFileSync(defaultConfigPath, "utf8"));
+    } catch (err) {
+      console.warn("Failed to load config/default.json, using defaults:", err.message);
+    }
+  }
+  const localConfigPath = resolve(configDir, "local.json");
+  if (existsSync(localConfigPath)) {
+    try {
+      const localConfig = JSON.parse(readFileSync(localConfigPath, "utf8"));
+      config = deepMerge(config, localConfig);
+    } catch (err) {
+      console.warn("Failed to load config/local.json:", err.message);
+    }
+  }
+  const merged = config;
+  applyCoreEnvWhitelist(merged);
+  applyPluginEnvWhitelist(merged);
+  const parsed = appConfigSchema.safeParse(merged);
+  if (!parsed.success) {
+    throw new Error(`Invalid application config: ${JSON.stringify(z3.treeifyError(parsed.error))}`);
+  }
+  return parsed.data;
+}
+
+// src/server.ts
+var loadConfig2 = loadConfig;
+async function createServer(config, observability, agentModels, agentRunner, enqueue, options = {}) {
+  const app = Fastify({
+    logger: false,
+    bodyLimit: 5 * 1024 * 1024
+  }).withTypeProvider();
+  app.setValidatorCompiler(validatorCompiler);
+  app.setSerializerCompiler(serializerCompiler);
+  app.setErrorHandler((err, _req, reply) => {
+    const error = err;
+    const status = error.statusCode ?? 500;
+    if (status >= 500) {
+      observability.logger.error("Unhandled error", error);
+    }
+    if (reply.sent) return;
+    void reply.code(status).send({ error: error.message });
+  });
+  const obsCfg = config.observability;
+  const excludePaths = obsCfg?.requestLogger?.excludePaths ?? ["/api/health", "/api/metrics"];
+  await app.register(
+    createRequestLogger({
+      logger: observability.logger,
+      tracing: observability.tracing,
+      metrics: observability.metrics,
+      excludePaths
+    })
+  );
+  await app.register(swagger, {
+    openapi: {
+      info: {
+        title: "Agent Detective API",
+        version: APP_VERSION,
+        description: `Core and plugin endpoints for the ${APP_NAME} server.`
+      },
+      servers: [{ url: "/" }],
+      tags: [
+        { name: CORE_PLUGIN_TAG, description: createTagDescription(CORE_PLUGIN_TAG) }
+      ]
+    },
+    transform: jsonSchemaTransform,
+    transformObject: (documentObject) => {
+      const doc = "openapiObject" in documentObject ? documentObject.openapiObject : documentObject.swaggerObject;
+      return applyTagGroups(doc, {
+        pluginTags: options.getPluginTags?.()
+      });
+    }
+  });
+  await registerDocsRoute(app, config, observability);
+  app.get("/", async () => {
+    const pluginPackages = (config.plugins ?? []).map((e) => e.package).filter((p) => Boolean(p));
+    return {
+      name: APP_NAME,
+      version: APP_VERSION,
+      plugins: pluginPackages
+    };
+  });
+  registerCoreApiRoutes(app, {
+    agentModels,
+    agentRunner,
+    enqueue,
+    observability,
+    config: { plugins: config.plugins },
+    pluginStatus: options.getPluginStatus
+  });
+  return { app };
+}
+async function registerDocsRoute(app, config, observability) {
+  const docsAuthRequired = config.docsAuthRequired ?? process.env.DOCS_AUTH_REQUIRED === "true";
+  const docsApiKey = config.docsApiKey ?? process.env.DOCS_API_KEY;
+  await app.register(
+    async (scope) => {
+      if (docsAuthRequired) {
+        scope.addHook("onRequest", async (req, reply) => {
+          const apiKey = req.headers["x-api-key"];
+          if (!apiKey || apiKey !== docsApiKey) {
+            await reply.code(401).send({ error: "Unauthorized. Provide X-API-KEY header." });
+          }
+        });
+      }
+      const { default: scalarReference } = await import("@scalar/fastify-api-reference");
+      await scope.register(scalarReference, {
+        routePrefix: "/",
+        configuration: {
+          metaData: { title: "Agent Detective API" }
+        }
+      });
+    },
+    { prefix: "/docs" }
+  );
+  observability.logger.info("API documentation available at /docs");
+}
+
+// src/agents/index.ts
+import { execSync as execSync2 } from "child_process";
+
+// src/agents/utils.ts
+import { execSync } from "child_process";
+function shellQuote(value) {
+  const escaped = String(value).replace(/'/g, String.raw`'\''`);
+  return `'${escaped}'`;
+}
+function resolvePromptValue(prompt, promptExpression) {
+  if (promptExpression) return promptExpression;
+  return shellQuote(prompt);
+}
+function isCommandAvailable(command) {
+  try {
+    execSync(`command -v ${command} > /dev/null 2>&1`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/agents/claude.ts
+var CLAUDE_CMD = "claude";
+var CLAUDE_OUTPUT_FORMAT = "stream-json";
+var CLAUDE_SESSION_ID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var DEFAULT_MODEL = "sonnet";
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+var ESC = String.fromCharCode(27);
+var BEL = String.fromCharCode(7);
+var DEL = String.fromCharCode(127);
+var C0_AND_DEL = [...Array(32).keys()].map((i) => String.fromCharCode(i)).join("") + DEL;
+var ANSI_CSI_PATTERN = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
+var ANSI_OSC_PATTERN = new RegExp(`${ESC}\\][^${BEL}]*(?:${BEL}|${ESC}\\\\)`, "g");
+var CTRL_OR_DEL_PATTERN = new RegExp(`[${C0_AND_DEL}]`, "g");
+function stripAnsi(value) {
+  return String(value || "").replace(ANSI_CSI_PATTERN, "").replace(ANSI_OSC_PATTERN, "");
+}
+function sanitizeSessionId(value) {
+  if (value === void 0 || value === null) return void 0;
+  const cleaned = String(value).replace(CTRL_OR_DEL_PATTERN, "").trim().replace(/^['"]+/, "").replace(/['"\\]+$/, "").trim();
+  if (!CLAUDE_SESSION_ID_REGEX.test(cleaned)) return void 0;
+  return cleaned;
+}
+function buildCommand({ prompt, promptExpression, threadId, model, readOnly }) {
+  const promptValue = resolvePromptValue(prompt, promptExpression);
+  const args = [
+    "-p",
+    promptValue,
+    "--output-format",
+    CLAUDE_OUTPUT_FORMAT,
+    "--verbose",
+    ...readOnly ? ["--allowedTools", "Read,LS,Glob,Grep,WebSearch,WebFetch"] : ["--dangerously-skip-permissions"]
+  ];
+  if (model) {
+    args.push("--model", shellQuote(model));
+  }
+  const safeThreadId = sanitizeSessionId(threadId);
+  if (safeThreadId) {
+    args.push("--resume", shellQuote(safeThreadId));
+  }
+  return `${CLAUDE_CMD} ${args.join(" ")}`.trim();
+}
+function extractUsage(evt) {
+  if (evt.type !== "result") return void 0;
+  const u = {};
+  if (typeof evt.duration_ms === "number") u.durationMs = evt.duration_ms;
+  if (typeof evt.duration_api_ms === "number") u.durationApiMs = evt.duration_api_ms;
+  if (typeof evt.num_turns === "number") u.numTurns = evt.num_turns;
+  if (typeof evt.total_cost_usd === "number") u.totalCostUsd = evt.total_cost_usd;
+  if (typeof evt.usage?.input_tokens === "number") u.inputTokens = evt.usage.input_tokens;
+  if (typeof evt.usage?.output_tokens === "number") u.outputTokens = evt.usage.output_tokens;
+  return Object.keys(u).length > 0 ? u : void 0;
+}
+function parseOutput(output) {
+  const cleaned = stripAnsi(output);
+  const lines = cleaned.split(/\r?\n/).filter((l) => l.trim());
+  let sessionId;
+  let resultText = "";
+  let usage;
+  for (const line of lines) {
+    const evt = safeJsonParse(line.trim());
+    if (!evt) continue;
+    if (evt.session_id) {
+      sessionId = sanitizeSessionId(evt.session_id) ?? sessionId;
+    }
+    if (evt.type === "result") {
+      resultText = typeof evt.result === "string" ? evt.result : "";
+      usage = extractUsage(evt);
+    }
+  }
+  if (resultText) {
+    return { text: resultText.trim(), threadId: sessionId, sawJson: true, usage };
+  }
+  let accumulated = "";
+  for (const line of lines) {
+    const evt = safeJsonParse(line.trim());
+    if (!evt || evt.type !== "stream_event") continue;
+    if (evt.event?.delta?.type === "text_delta" && evt.event.delta.text) {
+      accumulated += evt.event.delta.text;
+    }
+  }
+  if (accumulated) {
+    return { text: accumulated.trim(), threadId: sessionId, sawJson: true };
+  }
+  return { text: cleaned.trim(), threadId: sessionId, sawJson: false };
+}
+function parseStreamingOutput(output) {
+  const cleaned = stripAnsi(output);
+  const lines = cleaned.split(/\r?\n/).filter((l) => l.trim());
+  let sessionId;
+  let sawFinal = false;
+  let resultText = "";
+  let usage;
+  const commentary = [];
+  for (const line of lines) {
+    const evt = safeJsonParse(line.trim());
+    if (!evt) continue;
+    if (evt.session_id) {
+      sessionId = sanitizeSessionId(evt.session_id) ?? sessionId;
+    }
+    if (evt.type === "result") {
+      sawFinal = true;
+      resultText = typeof evt.result === "string" ? evt.result : "";
+      usage = extractUsage(evt);
+    }
+    if (evt.type === "stream_event" && evt.event) {
+      if (evt.event.type === "content_block_start" && evt.event.content_block?.type === "tool_use" && evt.event.content_block.name) {
+        commentary.push(`Tool: ${evt.event.content_block.name}`);
+      }
+    }
+  }
+  return {
+    text: resultText.trim(),
+    threadId: sessionId,
+    sawJson: sawFinal,
+    sawFinal,
+    commentaryMessages: commentary,
+    usage
+  };
+}
+var claudeAgent = {
+  id: "claude",
+  label: "claude",
+  needsPty: false,
+  mergeStderr: false,
+  command: CLAUDE_CMD,
+  buildCommand,
+  parseOutput,
+  parseStreamingOutput,
+  defaultModel: DEFAULT_MODEL,
+  checkAvailable: () => isCommandAvailable(CLAUDE_CMD)
+};
+var claude_default = claudeAgent;
+
+// src/agents/cursor.ts
+var CURSOR_AGENT_CMD = "agent";
+var OUTPUT_FORMAT = "json";
+var DEFAULT_MODEL2 = "composer-2.5-fast";
+function safeJsonParse2(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function buildCommand2({
+  prompt,
+  promptExpression,
+  threadId,
+  model,
+  readOnly
+}) {
+  const promptValue = resolvePromptValue(prompt, promptExpression);
+  const modelToUse = model || DEFAULT_MODEL2;
+  const args = [
+    "-p",
+    promptValue,
+    "--output-format",
+    OUTPUT_FORMAT,
+    "--model",
+    shellQuote(modelToUse)
+  ];
+  if (readOnly) {
+    args.push("--mode=ask");
+  }
+  if (threadId) {
+    args.push("--resume", shellQuote(threadId));
+  }
+  return `${CURSOR_AGENT_CMD} ${args.join(" ")}`.trim();
+}
+function parseOutput2(output) {
+  const trimmed = String(output || "").trim();
+  if (!trimmed) {
+    return { text: "", threadId: void 0, sawJson: false };
+  }
+  const payload = safeJsonParse2(trimmed);
+  if (!payload || payload.type !== "result") {
+    return { text: trimmed, threadId: void 0, sawJson: false };
+  }
+  const result = payload.result;
+  const sessionId = payload.session_id;
+  const text = typeof result === "string" ? result.trim() : "";
+  const threadId = typeof sessionId === "string" && sessionId.trim() ? sessionId.trim() : void 0;
+  return { text, threadId, sawJson: true };
+}
+var cursorAgent = {
+  id: "cursor",
+  label: "cursor",
+  needsPty: false,
+  mergeStderr: false,
+  command: CURSOR_AGENT_CMD,
+  buildCommand: buildCommand2,
+  parseOutput: parseOutput2,
+  defaultModel: DEFAULT_MODEL2,
+  checkAvailable: () => isCommandAvailable(CURSOR_AGENT_CMD)
+};
+var cursor_default = cursorAgent;
+
+// src/agents/opencode.ts
+var OPENCODE_CMD = "opencode";
+var OPENCODE_OUTPUT_FORMAT = "json";
+var DEFAULT_MODEL3 = "opencode/deepseek-v4-flash-free";
+var OPENCODE_PERMISSION_FULL = '{"*": "allow"}';
+var OPENCODE_PERMISSION_READ_ONLY = '{"*":"allow","bash":"deny","edit":"deny","write":"deny","multiedit":"deny","patch":"deny"}';
+function pickPermission(readOnly) {
+  return readOnly ? OPENCODE_PERMISSION_READ_ONLY : OPENCODE_PERMISSION_FULL;
+}
+function safeJsonParse3(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function buildCommand3({
+  prompt,
+  promptExpression,
+  threadId,
+  model,
+  readOnly
+}) {
+  const promptValue = resolvePromptValue(prompt, promptExpression);
+  const args = ["run", "--format", OPENCODE_OUTPUT_FORMAT];
+  const modelToUse = model || DEFAULT_MODEL3;
+  args.push("--model", shellQuote(modelToUse));
+  if (threadId) {
+    args.push("--continue");
+    args.push("--session", shellQuote(threadId));
+  }
+  args.push(promptValue);
+  const command = `${OPENCODE_CMD} ${args.join(" ")}`.trim();
+  const permission = pickPermission(readOnly);
+  return `OPENCODE_PERMISSION=${shellQuote(permission)} ${command} < /dev/null`;
+}
+function parseOutput3(output) {
+  const lines = String(output || "").split(/\r?\n/);
+  let threadId;
+  const textParts = [];
+  let sawJson = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (!trimmed.startsWith("{")) continue;
+    const payload = safeJsonParse3(trimmed);
+    if (!payload || typeof payload !== "object") continue;
+    sawJson = true;
+    if (payload.sessionID) {
+      threadId = payload.sessionID;
+    }
+    if (payload.type === "text" && payload.part && payload.part.text) {
+      textParts.push(payload.part.text);
+    }
+  }
+  const text = textParts.join("").trim();
+  if (!sawJson) {
+    return {
+      text: String(output || "").trim(),
+      threadId: void 0,
+      sawJson: false
+    };
+  }
+  return { text, threadId, sawJson: true };
+}
+function listModelsCommand() {
+  return `OPENCODE_PERMISSION=${shellQuote(OPENCODE_PERMISSION_FULL)} ${OPENCODE_CMD} models < /dev/null`;
+}
+function parseModelList(output) {
+  const lines = String(output || "").split(/\r?\n/);
+  const models = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("INFO")) continue;
+    models.push(trimmed);
+  }
+  return models.join("\n");
+}
+var opencodeAgent = {
+  id: "opencode",
+  label: "opencode",
+  needsPty: false,
+  mergeStderr: false,
+  command: OPENCODE_CMD,
+  buildCommand: buildCommand3,
+  parseOutput: parseOutput3,
+  listModelsCommand,
+  parseModelList,
+  defaultModel: DEFAULT_MODEL3,
+  checkAvailable: () => isCommandAvailable(OPENCODE_CMD),
+  // opencode keeps a single-user SQLite DB at `~/.local/share/opencode/`
+  // and crashes with `PRAGMA journal_mode = WAL` when two CLI instances
+  // race to open it. See https://github.com/anomalyco/opencode/issues/21215.
+  // The runner serializes opencode invocations to avoid that, at the cost of
+  // losing parallelism for multi-repo Jira fan-out.
+  singleInstance: true
+};
+var opencode_default = opencodeAgent;
+
+// src/agents/index.ts
+var agents = /* @__PURE__ */ new Map([
+  [claude_default.id, claude_default],
+  [cursor_default.id, cursor_default],
+  [opencode_default.id, opencode_default]
+]);
+var DEFAULT_AGENT = opencode_default.id;
+var AGENT_CLAUDE = claude_default.id;
+var AGENT_CURSOR = cursor_default.id;
+var AGENT_OPENCODE = opencode_default.id;
+function normalizeAgent(value) {
+  if (!value) return DEFAULT_AGENT;
+  const normalized = String(value).trim().toLowerCase();
+  if (agents.has(normalized)) return normalized;
+  return DEFAULT_AGENT;
+}
+function isKnownAgent(value) {
+  if (!value) return false;
+  const normalized = String(value).trim().toLowerCase();
+  return agents.has(normalized);
+}
+function getAgent(value) {
+  return agents.get(normalizeAgent(value));
+}
+function getAgentLabel(value) {
+  const agent = getAgent(value);
+  return agent?.label ?? DEFAULT_AGENT;
+}
+function listAgents() {
+  return Array.from(agents.values());
+}
+function isAgentInstalled(agentId) {
+  const agent = agents.get(agentId);
+  if (!agent || !agent.command) return false;
+  try {
+    execSync2(`command -v ${agent.command} > /dev/null 2>&1`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  APP_NAME,
+  APP_VERSION,
+  applyLogLevelAliasForObservability,
+  loadConfig2 as loadConfig,
+  createServer,
+  normalizeAgent,
+  isKnownAgent,
+  getAgentLabel,
+  listAgents,
+  isAgentInstalled
+};