@superatomai/sdk-node 0.0.52-dsp → 0.0.53-dsp

package/dist/index.mjs

@@ -782,6 +782,37 @@ var DashboardAgentAbortRequestMessageSchema = z3.object({
   type: z3.literal("DASHBOARD_AGENT_ABORT_REQ"),
   payload: DashboardAgentAbortRequestPayloadSchema
 });
+var CodingAgentRequestPayloadSchema = z3.object({
+  prompt: z3.string(),
+  /** The chat thread. One agent session per thread, and the abort key. */
+  threadId: z3.string(),
+  projectId: z3.string().optional(),
+  userId: z3.string().optional(),
+  /**
+   * Which registered agent to run (see registerCodingAgents). Omit for the
+   * deployment's plain chat agent — the pre-registry behaviour.
+   */
+  agentId: z3.string().optional(),
+  /** Which harness to run. Defaults to whatever the deployment registered. */
+  harness: z3.string().optional(),
+  /** Continue a prior agent session — the sessionId a previous run returned. */
+  resumeId: z3.string().optional()
+});
+var CodingAgentRequestMessageSchema = z3.object({
+  id: z3.string(),
+  from: MessageParticipantSchema,
+  type: z3.literal("CODING_AGENT_REQ"),
+  payload: CodingAgentRequestPayloadSchema
+});
+var CodingAgentAbortRequestPayloadSchema = z3.object({
+  threadId: z3.string()
+});
+var CodingAgentAbortRequestMessageSchema = z3.object({
+  id: z3.string().optional(),
+  from: MessageParticipantSchema,
+  type: z3.literal("CODING_AGENT_ABORT_REQ"),
+  payload: CodingAgentAbortRequestPayloadSchema
+});
 var ReportCompRequestPayloadSchema = z3.object({
   prompt: z3.string(),
   userId: z3.string().optional(),
@@ -9052,12 +9083,12 @@ answer.
 
 // src/userResponse/prompt-loader.ts
 var PromptLoader = class {
-  constructor(config) {
+  constructor(config2) {
     this.promptCache = /* @__PURE__ */ new Map();
     this.databaseRulesCache = /* @__PURE__ */ new Map();
     this.isInitialized = false;
     this.databaseType = "postgresql";
-    this.promptsDir = config?.promptsDir || path4.join(process.cwd(), ".prompts");
+    this.promptsDir = config2?.promptsDir || path4.join(process.cwd(), ".prompts");
   }
   /**
    * Load a prompt template from file system OR fallback to hardcoded prompts
@@ -9973,7 +10004,7 @@ function validateAndFixSqlQuery(query, dbType) {
 
 // src/userResponse/agents/source-agent.ts
 var SourceAgent = class {
-  constructor(tool, config, streamBuffer, options) {
+  constructor(tool, config2, streamBuffer, options) {
     this.attempts = 0;
     /**
      * Reference to this dispatch's own entry in trace.schemaNodes.sourceAgentSchemas
@@ -9983,7 +10014,7 @@ var SourceAgent = class {
      */
     this.traceSchemaEntry = null;
     this.tool = tool;
-    this.config = config;
+    this.config = config2;
     this.streamBuffer = streamBuffer;
     this.options = options || {};
   }
@@ -11583,7 +11614,7 @@ var WRITE_ANALYSIS_TOOL_DEF = {
 var MAX_SCRIPT_ATTEMPTS = 3;
 var MAX_ANALYSIS_ATTEMPTS = 3;
 var MainAgent = class {
-  constructor(externalTools, config, scriptStore, turnId, streamBuffer, workflows = [], forkMode = false, editContext, componentCatalog = [], displayPreference) {
+  constructor(externalTools, config2, scriptStore, turnId, streamBuffer, workflows = [], forkMode = false, editContext, componentCatalog = [], displayPreference) {
     this.createdFromPrompt = "";
     this.scriptState = {
       recipeId: null,
@@ -11629,7 +11660,7 @@ var MainAgent = class {
     this.displayPreference = null;
     this.externalTools = externalTools;
     this.workflows = workflows;
-    this.config = config;
+    this.config = config2;
     this.streamBuffer = streamBuffer || new StreamBuffer();
     this.scriptStore = scriptStore ?? null;
     this.turnId = turnId ?? null;
@@ -13298,7 +13329,7 @@ function validateExternalTool(externalTool, executedTools, providerName) {
   const executedTool = executedTools?.find((t) => t.id === toolId);
   return { valid: true, executedTool };
 }
-function validateAndCleanQuery(query, config) {
+function validateAndCleanQuery(query, config2) {
   if (!query) {
     return { query: null, wasModified: false };
   }
@@ -13306,12 +13337,12 @@ function validateAndCleanQuery(query, config) {
   let cleanedQuery = query;
   const queryStr = typeof query === "string" ? query : query?.sql || "";
   if (queryStr.includes("OPENJSON") || queryStr.includes("JSON_VALUE")) {
-    logger.warn(`[${config.providerName}] Query contains OPENJSON/JSON_VALUE (invalid - cannot parse tool result), setting query to null`);
+    logger.warn(`[${config2.providerName}] Query contains OPENJSON/JSON_VALUE (invalid - cannot parse tool result), setting query to null`);
     return { query: null, wasModified: true };
   }
   const { query: fixedQuery, fixed, fixes } = validateAndFixSqlQuery(queryStr);
   if (fixed) {
-    logger.warn(`[${config.providerName}] SQL fixes applied to component query: ${fixes.join("; ")}`);
+    logger.warn(`[${config2.providerName}] SQL fixes applied to component query: ${fixes.join("; ")}`);
     wasModified = true;
     if (typeof cleanedQuery === "string") {
       cleanedQuery = fixedQuery;
@@ -13319,36 +13350,36 @@ function validateAndCleanQuery(query, config) {
       cleanedQuery = { ...cleanedQuery, sql: fixedQuery };
     }
   }
-  const maxLimit = config.maxLimit ?? MAX_AGENT_QUERY_LIMIT;
+  const maxLimit = config2.maxLimit ?? MAX_AGENT_QUERY_LIMIT;
   if (typeof cleanedQuery === "string") {
-    const limitedQuery = ensureQueryLimit(cleanedQuery, config.defaultLimit, maxLimit);
+    const limitedQuery = ensureQueryLimit(cleanedQuery, config2.defaultLimit, maxLimit);
     if (limitedQuery !== cleanedQuery) wasModified = true;
     cleanedQuery = limitedQuery;
   } else if (cleanedQuery?.sql) {
-    const limitedSql = ensureQueryLimit(cleanedQuery.sql, config.defaultLimit, maxLimit);
+    const limitedSql = ensureQueryLimit(cleanedQuery.sql, config2.defaultLimit, maxLimit);
     if (limitedSql !== cleanedQuery.sql) wasModified = true;
     cleanedQuery = { ...cleanedQuery, sql: limitedSql };
   }
   return { query: cleanedQuery, wasModified };
 }
-function processComponentProps(props, executedTools, config) {
+function processComponentProps(props, executedTools, config2) {
   let cleanedProps = { ...props };
   if (cleanedProps.externalTool) {
     const { valid } = validateExternalTool(
       cleanedProps.externalTool,
       executedTools,
-      config.providerName
+      config2.providerName
     );
     if (!valid) {
       cleanedProps.externalTool = null;
     }
   }
   if (cleanedProps.query) {
-    const { query } = validateAndCleanQuery(cleanedProps.query, config);
+    const { query } = validateAndCleanQuery(cleanedProps.query, config2);
     cleanedProps.query = query;
   }
   if (cleanedProps.query && cleanedProps.externalTool) {
-    logger.info(`[${config.providerName}] Both query and externalTool exist, keeping both - frontend will decide`);
+    logger.info(`[${config2.providerName}] Both query and externalTool exist, keeping both - frontend will decide`);
   }
   return cleanedProps;
 }
@@ -13921,15 +13952,15 @@ ${carried.trim()}
   }
   /** slug of name, with a short id suffix when the bare slug is already taken. */
   async computeFileBase(name, id) {
-    const slug = this.toSlug(name);
+    const slug2 = this.toSlug(name);
     if (this.store) {
       try {
-        const taken = await this.store.fileBaseTaken(slug, id, this.projectId);
-        if (taken) return `${slug}-${id.slice(-6)}`;
+        const taken = await this.store.fileBaseTaken(slug2, id, this.projectId);
+        if (taken) return `${slug2}-${id.slice(-6)}`;
       } catch {
       }
     }
-    return slug;
+    return slug2;
   }
   toSlug(name) {
     return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed-script";
@@ -15318,8 +15349,8 @@ var schema = new Schema();
 
 // src/userResponse/services/query-execution-service.ts
 var QueryExecutionService = class {
-  constructor(config) {
-    this.config = config;
+  constructor(config2) {
+    this.config = config2;
   }
   /**
    * Get the cache key for a query
@@ -15552,12 +15583,12 @@ Fixed SQL query:`;
 
 // src/userResponse/services/tool-executor-service.ts
 var ToolExecutorService = class {
-  constructor(config) {
+  constructor(config2) {
     this.queryAttempts = /* @__PURE__ */ new Map();
     this.toolAttempts = /* @__PURE__ */ new Map();
     this.executedToolsList = [];
     this.maxAttemptsReached = false;
-    this.config = config;
+    this.config = config2;
   }
   /**
    * Reset state for a new execution
@@ -15869,13 +15900,13 @@ ${errorMsg}
 
 // src/userResponse/base-llm.ts
 var BaseLLM = class {
-  constructor(config) {
-    this.model = config?.model || this.getDefaultModel();
-    this.fastModel = config?.fastModel || this.getDefaultFastModel();
-    this.defaultLimit = config?.defaultLimit || 10;
-    this.apiKey = config?.apiKey;
-    this.modelStrategy = config?.modelStrategy || "fast";
-    this.conversationSimilarityThreshold = config?.conversationSimilarityThreshold || DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD;
+  constructor(config2) {
+    this.model = config2?.model || this.getDefaultModel();
+    this.fastModel = config2?.fastModel || this.getDefaultFastModel();
+    this.defaultLimit = config2?.defaultLimit || 10;
+    this.apiKey = config2?.apiKey;
+    this.modelStrategy = config2?.modelStrategy || "fast";
+    this.conversationSimilarityThreshold = config2?.conversationSimilarityThreshold || DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD;
     this.queryService = new QueryExecutionService({
       defaultLimit: this.defaultLimit,
       getModelForTask: (taskType) => this.getModelForTask(taskType),
@@ -17064,8 +17095,8 @@ ${executedToolsText}`);
 // src/userResponse/anthropic.ts
 dotenv.config({ quiet: true });
 var AnthropicLLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "anthropic/claude-sonnet-4-5-20250929";
@@ -17086,8 +17117,8 @@ var anthropicLLM = new AnthropicLLM();
 import dotenv2 from "dotenv";
 dotenv2.config({ quiet: true });
 var GroqLLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "groq/openai/gpt-oss-120b";
@@ -17108,8 +17139,8 @@ var groqLLM = new GroqLLM();
 import dotenv3 from "dotenv";
 dotenv3.config({ quiet: true });
 var GeminiLLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "gemini/gemini-2.5-flash";
@@ -17130,8 +17161,8 @@ var geminiLLM = new GeminiLLM();
 import dotenv4 from "dotenv";
 dotenv4.config({ quiet: true });
 var OpenAILLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "openai/gpt-4.1";
@@ -23599,6 +23630,1031 @@ async function handleDashboardAgentRequest(data, collections, sendMessage) {
   }
 }
 
+// src/codingAgent/drivers/codex.ts
+var dynamicImport = new Function("specifier", "return import(specifier)");
+var codexModulePromise = null;
+function loadCodex() {
+  if (!codexModulePromise) {
+    codexModulePromise = dynamicImport("@openai/codex-sdk").catch((err) => {
+      codexModulePromise = null;
+      throw new Error(
+        `@openai/codex-sdk is not installed, so the codex harness is unavailable. It is an optionalDependency of this SDK, so an install that could not fetch it (disk, architecture, network) will have skipped it silently \u2014 re-run the deployment's install, or 'pnpm add @openai/codex-sdk@0.149.1' to add it directly. (${err?.message ?? err})`
+      );
+    });
+  }
+  return codexModulePromise;
+}
+var ENV_ALLOWLIST = ["PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "LC_ALL", "TMPDIR", "TERM", "NODE_EXTRA_CA_CERTS"];
+var ENV_PREFIX_ALLOWLIST = ["CODEX_", "OPENAI_"];
+var DONE_POLL_MS = 250;
+var USAGE_GRACE_MS = 4e3;
+var BUFFER_CAP = 64e3;
+var EVENT_CAP = 600;
+function emptyUsage() {
+  return { inputTokens: 0, outputTokens: 0, reasoningTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, toolCalls: 0 };
+}
+function addUsage(acc, u) {
+  acc.inputTokens += u.input_tokens ?? 0;
+  acc.outputTokens += u.output_tokens ?? 0;
+  acc.reasoningTokens += u.reasoning_output_tokens ?? 0;
+  acc.cacheReadTokens += u.cached_input_tokens ?? 0;
+  acc.cacheWriteTokens += u.cache_write_input_tokens ?? 0;
+}
+function normEvent(ev, done) {
+  const it = ev.item;
+  if (!it) return null;
+  const status = it.status;
+  switch (it.type) {
+    case "agent_message":
+      return { kind: "message", id: it.id, text: it.text ?? "", done };
+    case "reasoning":
+      return { kind: "reasoning", id: it.id, text: it.text ?? "", done };
+    case "command_execution":
+      return { kind: "command", id: it.id, command: it.command ?? "", output: it.aggregated_output ?? "", status, done };
+    case "mcp_tool_call":
+      return { kind: "tool", id: it.id, tool: { server: it.server, name: it.tool ?? "tool", args: it.arguments }, status, done };
+    case "web_search":
+      return { kind: "tool", id: it.id, tool: { name: "web_search", args: { query: it.query } }, status, done };
+    case "file_change":
+      return { kind: "file", id: it.id, text: (it.changes ?? []).map((c) => `${c.kind} ${c.path}`).join(", "), status, done };
+    case "todo_list":
+      return { kind: "todo", id: it.id, text: (it.items ?? []).map((t) => `${t.completed ? "[x]" : "[ ]"} ${t.text}`).join("\n"), done };
+    case "error":
+      return { kind: "error", id: it.id, text: it.message ?? "", done };
+    default:
+      return null;
+  }
+}
+function markerFor(event) {
+  switch (event.kind) {
+    case "command":
+      return event.command ? `\u2192 ${event.command.replace(/\s+/g, " ").slice(0, 160)}` : null;
+    case "tool": {
+      const args = event.tool?.args;
+      const detail = args && typeof args === "object" ? String(args.sql ?? args.query ?? args.command ?? "").replace(/\s+/g, " ").slice(0, 140) : "";
+      return `\u2192 ${event.tool?.name ?? "tool"}${detail ? " " + detail : ""}`;
+    }
+    case "file":
+      return event.text ? `\u270E ${event.text}` : null;
+    default:
+      return null;
+  }
+}
+function buildEnv(opts) {
+  if (opts.inheritEnv) return opts.env ? { ...process.env, ...opts.env } : void 0;
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (ENV_ALLOWLIST.includes(k) || ENV_PREFIX_ALLOWLIST.some((p) => k.startsWith(p))) env[k] = v;
+  }
+  return { ...env, ...opts.env ?? {} };
+}
+function createCodexSession(opts) {
+  const model = opts.model ?? process.env.CODEX_AGENT_MODEL;
+  let thread = null;
+  let resumeId = opts.resumeId;
+  let threadId = opts.resumeId;
+  let resumeFailed = false;
+  let running = false;
+  let buf = "";
+  const eventLog = [];
+  const threadOptions = () => ({
+    ...model ? { model } : {},
+    workingDirectory: opts.cwd,
+    sandboxMode: opts.sandboxMode ?? "workspace-write",
+    // Headless: a prompt for approval would hang forever with nobody to answer it.
+    approvalPolicy: opts.approvalPolicy ?? "never",
+    networkAccessEnabled: opts.networkAccessEnabled ?? false,
+    skipGitRepoCheck: true,
+    ...opts.reasoningEffort ? { modelReasoningEffort: opts.reasoningEffort } : {}
+  });
+  async function ensureThread() {
+    if (thread) return thread;
+    const { Codex } = await loadCodex();
+    const codex = new Codex({
+      ...opts.apiKey ? { apiKey: opts.apiKey } : {},
+      ...opts.baseUrl ? { baseUrl: opts.baseUrl } : {},
+      env: buildEnv(opts),
+      // Tools reach codex as MCP servers; each server's name shows up on
+      // every tool event, so the runner can tell ours from codex's own.
+      // Only send a config override when there is something in it. An empty
+      // object is truthy, so the naive check sent config:{mcp_servers:{}} on
+      // every run — a pointless CLI override on a path that is otherwise
+      // completely default.
+      ...opts.mcpServers && Object.keys(opts.mcpServers).length || opts.extraConfig ? { config: { ...opts.mcpServers && Object.keys(opts.mcpServers).length ? { mcp_servers: opts.mcpServers } : {}, ...opts.extraConfig ?? {} } } : {}
+    });
+    thread = resumeId ? codex.resumeThread(resumeId, threadOptions()) : codex.startThread(threadOptions());
+    return thread;
+  }
+  async function runTurn(prompt, handlers, signal) {
+    const startedAt = Date.now();
+    const usage = emptyUsage();
+    let answer = "";
+    let error;
+    let status = "completed";
+    const finish = () => ({ status, answer, ms: Date.now() - startedAt, usage, error, sessionId: threadId });
+    if (signal?.aborted) {
+      status = "aborted";
+      return finish();
+    }
+    const controller = new AbortController();
+    let earlyExit = false;
+    const onCallerAbort = () => controller.abort();
+    signal?.addEventListener("abort", onCallerAbort, { once: true });
+    let poll = null;
+    let graceTimer = null;
+    if (handlers?.doneWhen) {
+      poll = setInterval(() => {
+        void (async () => {
+          try {
+            if (!await handlers.doneWhen() || earlyExit) return;
+            earlyExit = true;
+            if (poll) {
+              clearInterval(poll);
+              poll = null;
+            }
+            graceTimer = setTimeout(() => controller.abort(), USAGE_GRACE_MS);
+          } catch {
+          }
+        })();
+      }, DONE_POLL_MS);
+    }
+    const emitted = /* @__PURE__ */ new Map();
+    const emit = (chunk, narrate) => {
+      buf = (buf + chunk).slice(-BUFFER_CAP);
+      handlers?.onOutput?.(chunk);
+      if (narrate) handlers?.onNarration?.(chunk);
+    };
+    try {
+      const t = await ensureThread();
+      const streamed = await t.runStreamed(prompt, { signal: controller.signal });
+      for await (const ev of streamed.events) {
+        if (ev.type === "thread.started" && ev.thread_id) threadId = ev.thread_id;
+        if (ev.type === "turn.completed" && ev.usage) {
+          addUsage(usage, ev.usage);
+          handlers?.onUsage?.({ ...usage });
+          if (earlyExit) {
+            if (graceTimer) {
+              clearTimeout(graceTimer);
+              graceTimer = null;
+            }
+            controller.abort();
+          }
+          continue;
+        }
+        if (ev.type === "turn.failed") {
+          error = ev.error?.message ?? "codex turn failed";
+          status = "error";
+          continue;
+        }
+        if (ev.type === "error") {
+          error = ev.message ?? "codex stream error";
+          status = "error";
+          continue;
+        }
+        if (ev.type === "turn.started") {
+          const e = { kind: "turn" };
+          eventLog.push(e);
+          handlers?.onEvent?.(e);
+          continue;
+        }
+        if (ev.type !== "item.started" && ev.type !== "item.updated" && ev.type !== "item.completed") continue;
+        const done = ev.type === "item.completed";
+        const event = normEvent(ev, done);
+        if (!event) continue;
+        eventLog.push(event);
+        if (eventLog.length > EVENT_CAP) eventLog.shift();
+        handlers?.onEvent?.(event);
+        if (done && (event.kind === "tool" || event.kind === "command")) usage.toolCalls++;
+        if (event.kind === "message") {
+          const text = event.text ?? "";
+          const prev = emitted.get(event.id ?? "") ?? 0;
+          if (text.length > prev) {
+            emitted.set(event.id ?? "", text.length);
+            emit(text.slice(prev), true);
+          }
+          if (done && text) answer = text;
+          continue;
+        }
+        const key = `m:${event.id}`;
+        if (!emitted.has(key)) {
+          const marker = markerFor(event);
+          if (marker) {
+            emitted.set(key, 1);
+            emit(`
+${marker}
+`, false);
+          }
+        }
+      }
+      if (earlyExit) status = "early";
+    } catch (err) {
+      if (earlyExit) status = "early";
+      else if (signal?.aborted) status = "aborted";
+      else if (resumeId && !resumeFailed) {
+        resumeFailed = true;
+        resumeId = void 0;
+        thread = null;
+        threadId = void 0;
+        signal?.removeEventListener("abort", onCallerAbort);
+        if (poll) clearInterval(poll);
+        return runTurn(prompt, handlers, signal);
+      } else {
+        status = "error";
+        error = err?.message ?? String(err);
+      }
+    } finally {
+      if (poll) clearInterval(poll);
+      if (graceTimer) clearTimeout(graceTimer);
+      signal?.removeEventListener("abort", onCallerAbort);
+    }
+    return finish();
+  }
+  return {
+    harness: "codex",
+    kind: "events",
+    async run(prompt, handlers, signal) {
+      if (running) throw new Error("This codex session already has a turn in flight.");
+      running = true;
+      try {
+        return await runTurn(prompt, handlers, signal);
+      } finally {
+        running = false;
+      }
+    },
+    events: () => eventLog,
+    buffer: () => buf,
+    busy: () => running,
+    sessionId: () => threadId,
+    reset: () => {
+      thread = null;
+      resumeId = void 0;
+      threadId = void 0;
+      resumeFailed = false;
+      buf = "";
+      eventLog.length = 0;
+    },
+    dispose: () => {
+      thread = null;
+    }
+  };
+}
+
+// src/codingAgent/factory.ts
+function createCodingAgentSession(harness, opts) {
+  switch (harness) {
+    case "codex":
+      return createCodexSession(opts);
+    default:
+      throw new Error(`Unknown coding-agent harness: ${harness}`);
+  }
+}
+
+// src/codingAgent/registry.ts
+import * as path8 from "path";
+var agents = /* @__PURE__ */ new Map();
+var config = {
+  promptRoot: path8.join(process.cwd(), ".prompts", "coding-agents"),
+  runtimeDir: path8.join(process.cwd(), ".coding-agent-runtime"),
+  harness: "codex",
+  keepRuns: 20
+};
+function registerCodingAgents(definitions, options = {}) {
+  config = {
+    ...config,
+    ...options,
+    promptRoot: options.promptRoot || process.env.CODING_AGENT_PROMPT_DIR || config.promptRoot,
+    runtimeDir: options.runtimeDir || process.env.CODING_AGENT_RUNTIME_DIR || config.runtimeDir,
+    harness: options.harness || process.env.CODING_AGENT_HARNESS || config.harness,
+    keepRuns: options.keepRuns ?? config.keepRuns
+  };
+  for (const def of definitions) {
+    if (!def.id) throw new Error("A coding agent definition must have an id.");
+    if (def.mode === "task" && !def.output) {
+      throw new Error(`Coding agent "${def.id}" is mode 'task' but declares no output contract.`);
+    }
+    agents.set(def.id, def);
+  }
+  console.log(`\u2713 coding agents registered: ${[...agents.keys()].join(", ") || "(none)"}`);
+}
+function getCodingAgent(id) {
+  return agents.get(id);
+}
+function listCodingAgents() {
+  return [...agents.values()].map((a) => ({
+    id: a.id,
+    title: a.title,
+    description: a.description,
+    mode: a.mode
+  }));
+}
+function getCodingAgentsConfig() {
+  return config;
+}
+function resolvePromptDir(def) {
+  return def.promptDir || path8.join(config.promptRoot, def.id);
+}
+
+// src/codingAgent/runner.ts
+import * as fs8 from "fs";
+import * as fsp from "fs/promises";
+import * as path9 from "path";
+var DEFAULT_TIMEOUT_MS = 15 * 60 * 1e3;
+var inFlight = /* @__PURE__ */ new Set();
+function slug(v) {
+  return v.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80) || "unknown";
+}
+function resolveScope(def, opts) {
+  const scope = def.scope ?? (def.mode === "chat" ? "thread" : "project");
+  if (scope === "thread") {
+    const id = slug(opts.threadId || "default");
+    return { key: `thread:${id}`, dirName: path9.join("threads", id) };
+  }
+  if (scope === "user") {
+    const id = slug(opts.userId || "anonymous");
+    return { key: `user:${id}`, dirName: path9.join("users", id) };
+  }
+  return { key: "project", dirName: "_project" };
+}
+function makeRunId() {
+  const t = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..+/, "");
+  return `${t}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function statePath(scopeDir) {
+  return path9.join(scopeDir, "_state.json");
+}
+function loadState(scopeDir) {
+  try {
+    return JSON.parse(fs8.readFileSync(statePath(scopeDir), "utf-8"));
+  } catch {
+    return { turns: 0, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+function saveState(scopeDir, state) {
+  try {
+    fs8.mkdirSync(scopeDir, { recursive: true });
+    fs8.writeFileSync(statePath(scopeDir), JSON.stringify({ ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  } catch (err) {
+    logger.warn(`[CodingAgent] failed to persist session state: ${err?.message ?? err}`);
+  }
+}
+async function clearTransient(dir) {
+  await fsp.rm(path9.join(dir, "input"), { recursive: true, force: true });
+}
+function createWorkspace(dir, runId) {
+  const abs = (rel) => path9.join(dir, rel);
+  const ensureDir = async (rel) => {
+    await fsp.mkdir(path9.dirname(abs(rel)), { recursive: true });
+  };
+  return {
+    dir,
+    runId,
+    pathTo: abs,
+    async write(rel, contents) {
+      await ensureDir(rel);
+      await fsp.writeFile(abs(rel), contents, "utf-8");
+    },
+    async writeJson(rel, value) {
+      await ensureDir(rel);
+      await fsp.writeFile(abs(rel), JSON.stringify(value, null, 2), "utf-8");
+    },
+    async writeJsonl(rel, rows) {
+      await ensureDir(rel);
+      await fsp.writeFile(abs(rel), rows.map((r) => JSON.stringify(r)).join("\n") + "\n", "utf-8");
+    },
+    async read(rel) {
+      try {
+        return await fsp.readFile(abs(rel), "utf-8");
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+async function installInstructions(def, ws) {
+  const src = path9.join(resolvePromptDir(def), "system.md");
+  try {
+    await ws.write("AGENTS.md", await fsp.readFile(src, "utf-8"));
+  } catch {
+    logger.warn(`[CodingAgent:${def.id}] no system.md at ${src} \u2014 running without standing instructions`);
+  }
+}
+async function pruneRuns(agentDir, keep) {
+  if (keep <= 0) return;
+  try {
+    const entries = (await fsp.readdir(agentDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    for (const name of entries.slice(0, Math.max(0, entries.length - keep))) {
+      await fsp.rm(path9.join(agentDir, name), { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+async function runCodingAgent(agentId, options = {}) {
+  const def = getCodingAgent(agentId);
+  if (!def) {
+    const known = listCodingAgents().map((a) => a.id);
+    throw new Error(
+      `Unknown coding agent "${agentId}". Registered: ${known.join(", ") || "(none \u2014 was registerCodingAgents called?)"}`
+    );
+  }
+  const cfg = getCodingAgentsConfig();
+  const runId = makeRunId();
+  const agentDir = path9.join(cfg.runtimeDir, def.id);
+  const policy = def.session ?? {};
+  const persistentWorkspace = policy.workspace === "persistent";
+  const persistentSession = policy.scope === "persistent";
+  const { key: scopeKey, dirName } = resolveScope(def, { userId: options.userId, threadId: options.threadId });
+  const scopeDir = path9.join(agentDir, dirName);
+  const dir = options.workspaceDir || (persistentWorkspace ? scopeDir : path9.join(scopeDir, "runs", runId));
+  fs8.mkdirSync(dir, { recursive: true });
+  if (persistentWorkspace && !options.workspaceDir) {
+    fs8.mkdirSync(path9.join(dir, "memory"), { recursive: true });
+    await clearTransient(dir);
+  }
+  const lockKey = persistentWorkspace || persistentSession ? `${def.id}:${scopeKey}` : `dir:${dir}`;
+  if (inFlight.has(lockKey)) {
+    logger.info(`[CodingAgent:${def.id}] already running \u2014 skipping this run`);
+    return {
+      agentId: def.id,
+      runId,
+      workspaceDir: dir,
+      status: "skipped",
+      answer: "",
+      ms: 0,
+      usage: { inputTokens: 0, outputTokens: 0, reasoningTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, toolCalls: 0 },
+      error: "a run for this agent is already in progress"
+    };
+  }
+  inFlight.add(lockKey);
+  const state = loadState(scopeDir);
+  let resumeId = options.resumeId;
+  let turns = state.turns;
+  if (persistentSession && !resumeId) {
+    const overThreshold = policy.resetAfterTurns !== void 0 && state.turns >= policy.resetAfterTurns;
+    if (overThreshold) {
+      logger.info(
+        `[CodingAgent:${def.id}] session reset after ${state.turns} runs (resetAfterTurns=${policy.resetAfterTurns}) \u2014 memory/ carries over`
+      );
+      turns = 0;
+    } else {
+      resumeId = state.sessionId;
+    }
+  }
+  const ws = createWorkspace(dir, runId);
+  const ctx = {
+    projectId: options.projectId,
+    userId: options.userId,
+    runId,
+    workspaceDir: dir,
+    signal: options.signal,
+    onOutput: options.onOutput,
+    onEvent: options.onEvent,
+    onUsage: options.onUsage
+  };
+  const input = options.input ?? {};
+  const startedAt = Date.now();
+  const record = {
+    agentId: def.id,
+    runId,
+    workspaceDir: dir,
+    status: "error",
+    answer: "",
+    ms: 0,
+    usage: { inputTokens: 0, outputTokens: 0, reasoningTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, toolCalls: 0 }
+  };
+  try {
+    await installInstructions(def, ws);
+    if (def.prepare) await def.prepare(ws, input, ctx);
+    const outputPath = def.output ? ws.pathTo(def.output.file) : void 0;
+    if (outputPath) await fsp.rm(outputPath, { force: true });
+    const prompt = options.prompt ?? (def.buildPrompt ? await def.buildPrompt(ws, input, ctx) : outputPath ? `Carry out the task described in AGENTS.md. Write your finished result to this exact absolute path: ${outputPath}` : "Carry out the task described in AGENTS.md.");
+    const tools = { ...cfg.sharedTools ?? {}, ...def.tools ?? {} };
+    const session = createCodingAgentSession(def.harness || cfg.harness, {
+      cwd: dir,
+      model: def.model || cfg.model,
+      resumeId,
+      // undefined, not {}, when this agent has no tools — see the driver.
+      mcpServers: tools && Object.keys(tools).length ? tools : void 0,
+      ...def.networkAccessEnabled !== void 0 ? { networkAccessEnabled: def.networkAccessEnabled } : {},
+      ...def.sandboxMode ? { sandboxMode: def.sandboxMode } : {}
+    });
+    const timeout = new AbortController();
+    const timer = setTimeout(() => timeout.abort(), def.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const onOuterAbort = () => timeout.abort();
+    options.signal?.addEventListener("abort", onOuterAbort, { once: true });
+    let result;
+    try {
+      result = await session.run(
+        prompt,
+        {
+          onOutput: ctx.onOutput,
+          onEvent: ctx.onEvent,
+          onUsage: ctx.onUsage,
+          // Opt-in only: see stopOnDeliverable. Letting the turn end naturally
+          // is what makes usage reporting work at all.
+          ...outputPath && def.stopOnDeliverable ? { doneWhen: () => fs8.existsSync(outputPath) } : {}
+        },
+        timeout.signal
+      );
+    } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onOuterAbort);
+      session.dispose();
+    }
+    record.answer = result.answer;
+    record.ms = Date.now() - startedAt;
+    record.usage = result.usage;
+    record.sessionId = result.sessionId;
+    if (persistentSession && result.sessionId) {
+      saveState(scopeDir, { sessionId: result.sessionId, turns: turns + 1, updatedAt: "" });
+    }
+    if (result.status === "aborted") {
+      record.status = "aborted";
+      record.error = options.signal?.aborted ? "aborted" : "timed out";
+      return record;
+    }
+    if (result.status === "error") {
+      record.error = result.error ?? "agent failed";
+      return record;
+    }
+    const successStatus = result.status === "early" ? "early" : "completed";
+    if (!def.output) {
+      record.status = successStatus;
+      return record;
+    }
+    const raw = await ws.read(def.output.file);
+    if (raw === null) {
+      record.error = `agent finished without writing ${def.output.file}`;
+      return record;
+    }
+    let parsed;
+    try {
+      parsed = def.output.schema.parse(JSON.parse(raw));
+    } catch (err) {
+      record.error = `deliverable failed validation: ${err?.message ?? err}`;
+      return record;
+    }
+    record.output = parsed;
+    if (def.apply) {
+      record.applied = await def.apply(parsed, input, ctx);
+    }
+    record.status = successStatus;
+    return record;
+  } catch (err) {
+    record.error = err?.message ?? String(err);
+    record.ms = Date.now() - startedAt;
+    return record;
+  } finally {
+    inFlight.delete(lockKey);
+    logger.info(
+      `[CodingAgent:${def.id}] run=${runId} status=${record.status} ms=${record.ms} tokens=${record.usage.inputTokens}/${record.usage.outputTokens} tools=${record.usage.toolCalls}` + (record.applied ? ` applied="${record.applied.summary}"` : "") + (record.error ? ` error="${record.error}"` : "")
+    );
+    if (!options.workspaceDir && !persistentWorkspace) await pruneRuns(path9.join(scopeDir, "runs"), cfg.keepRuns);
+  }
+}
+
+// src/codingAgent/tools/bridge-shims.ts
+import * as fs9 from "fs";
+
+// src/codingAgent/tools/read-only-sql.ts
+var WRITE_KEYWORDS = [
+  "insert",
+  "update",
+  "delete",
+  "drop",
+  "alter",
+  "create",
+  "truncate",
+  "replace",
+  "grant",
+  "revoke",
+  "merge",
+  "upsert",
+  "call",
+  "exec",
+  "execute",
+  "copy",
+  "vacuum",
+  "analyze",
+  "comment",
+  "lock",
+  "set",
+  "commit",
+  "rollback",
+  "begin"
+];
+function stripSqlNoise(sql) {
+  return sql.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/'(?:[^']|'')*'/g, "''").replace(/"(?:[^"]|"")*"/g, '""');
+}
+function assertReadOnlySql(sql) {
+  const bare = stripSqlNoise(sql).trim();
+  if (!bare) throw new Error("Empty SQL.");
+  if (bare.replace(/;\s*$/, "").includes(";")) {
+    throw new Error('Only a single statement is allowed \u2014 remove the extra ";".');
+  }
+  if (!/^\s*(select|with)\b/i.test(bare)) {
+    throw new Error("Read-only: the statement must start with SELECT or WITH.");
+  }
+  if (/\binto\s+\w/i.test(bare)) {
+    throw new Error("Read-only: SELECT ... INTO is not allowed.");
+  }
+  for (const kw of WRITE_KEYWORDS) {
+    if (new RegExp(`\\b${kw}\\b`, "i").test(bare)) {
+      throw new Error(`Read-only: "${kw.toUpperCase()}" is not allowed. Only SELECT / WITH queries.`);
+    }
+  }
+}
+var READ_ONLY_SQL_SOURCE = `
+const WRITE_KEYWORDS = ${JSON.stringify(WRITE_KEYWORDS)};
+${stripSqlNoise.toString()}
+${assertReadOnlySql.toString().replace("export function", "function")}
+`;
+
+// src/codingAgent/tools/bridge-shims.ts
+function writeBridgeShims(ws, opts) {
+  const maxRows = opts.maxRows ?? 200;
+  const query = `#!/usr/bin/env node
+// Read-only SQL against a data source. Generated per run \u2014 do not edit.
+${READ_ONLY_SQL_SOURCE}
+const BRIDGE = ${JSON.stringify(opts.bridgeUrl)};
+const MAX_ROWS = ${maxRows};
+
+const [toolId, sql, limitArg] = process.argv.slice(2);
+if (!toolId || !sql) {
+  console.error('usage: ./query "<toolId>" "<sql>" [limit]\\nRun ./sources for the toolIds.');
+  process.exit(2);
+}
+try { assertReadOnlySql(sql); } catch (e) { console.error(String(e.message || e)); process.exit(2); }
+
+fetch(BRIDGE + '/query', {
+  method: 'POST',
+  headers: { 'content-type': 'application/json' },
+  body: JSON.stringify({ toolId, sql, limit: Math.min(Number(limitArg) || MAX_ROWS, MAX_ROWS) }),
+})
+  .then(async (r) => {
+    const text = await r.text();
+    if (!r.ok) { console.error('Query failed (' + r.status + '): ' + text.slice(0, 2000)); process.exit(1); }
+    let p; try { p = JSON.parse(text); } catch { console.log(text); return; }
+    if (p && p.error) { console.error(String(p.error)); process.exit(1); }
+    const rows = (p && (p.data || p.rows)) || p;
+    const all = Array.isArray(rows) ? rows : [rows];
+    // Capped so one careless SELECT * cannot flood the agent's context.
+    console.log(JSON.stringify({
+      count: (p && p.count) != null ? p.count : all.length,
+      truncated: all.length > MAX_ROWS,
+      rows: all.slice(0, MAX_ROWS),
+    }, null, 2));
+  })
+  .catch((e) => { console.error('Could not reach the data bridge: ' + (e && e.message)); process.exit(1); });
+`;
+  const sources = `#!/usr/bin/env node
+// The data sources you can query, and the exact toolId for ./query.
+console.log(${JSON.stringify(JSON.stringify(opts.sources, null, 2))});
+`;
+  for (const [name, body] of [["query", query], ["sources", sources]]) {
+    const p = ws.pathTo(name);
+    fs9.writeFileSync(p, body, "utf-8");
+    fs9.chmodSync(p, 493);
+  }
+}
+
+// src/codingAgent/triggers.ts
+import * as fs10 from "fs";
+import * as path10 from "path";
+function statePath2(agentId) {
+  return path10.join(getCodingAgentsConfig().runtimeDir, agentId, "_triggers.json");
+}
+function loadTriggerState(agentId) {
+  try {
+    return JSON.parse(fs10.readFileSync(statePath2(agentId), "utf-8"));
+  } catch {
+    return { counts: {} };
+  }
+}
+function saveTriggerState(agentId, state) {
+  try {
+    const p = statePath2(agentId);
+    fs10.mkdirSync(path10.dirname(p), { recursive: true });
+    fs10.writeFileSync(p, JSON.stringify(state, null, 2));
+  } catch (err) {
+    logger.warn(`[CodingAgent:${agentId}] failed to persist trigger state: ${err?.message ?? err}`);
+  }
+}
+var asArray = (t) => !t ? [] : Array.isArray(t) ? t : [t];
+var intervals = /* @__PURE__ */ new Map();
+var debounces = /* @__PURE__ */ new Map();
+var firing = /* @__PURE__ */ new Set();
+var listeners = [];
+function onAgentRun(fn) {
+  listeners.push(fn);
+  return () => {
+    const i = listeners.indexOf(fn);
+    if (i >= 0) listeners.splice(i, 1);
+  };
+}
+async function fire(agentId, reason, payload) {
+  if (firing.has(agentId)) {
+    const st = loadTriggerState(agentId);
+    saveTriggerState(agentId, { ...st, pending: true });
+    logger.info(`[CodingAgent:${agentId}] ${reason} arrived mid-run \u2014 queued`);
+    return;
+  }
+  firing.add(agentId);
+  try {
+    logger.info(`[CodingAgent:${agentId}] triggered by ${reason}`);
+    const record = await runCodingAgent(agentId, { input: payload });
+    saveTriggerState(agentId, { ...loadTriggerState(agentId), lastRunAt: (/* @__PURE__ */ new Date()).toISOString(), pending: false });
+    for (const fn of listeners) {
+      try {
+        fn(record, { agentId, reason, payload });
+      } catch {
+      }
+    }
+  } catch (err) {
+    logger.error(`[CodingAgent:${agentId}] trigger run failed: ${err?.message ?? err}`);
+  } finally {
+    firing.delete(agentId);
+    if (loadTriggerState(agentId).pending) {
+      saveTriggerState(agentId, { ...loadTriggerState(agentId), pending: false });
+      void fire(agentId, "queued work from during the last run");
+    }
+  }
+}
+function emitAgentEvent(event, payload) {
+  for (const { id } of listCodingAgents()) {
+    const def = getCodingAgent(id);
+    if (!def) continue;
+    for (const trigger of asArray(def.trigger)) {
+      if (trigger.type === "event") {
+        const names = Array.isArray(trigger.on) ? trigger.on : [trigger.on];
+        if (!names.includes(event)) continue;
+        if (!trigger.debounceMs) {
+          void fire(id, `event ${event}`, payload);
+          continue;
+        }
+        const key = `${id}:${event}`;
+        const existing = debounces.get(key);
+        if (existing) clearTimeout(existing);
+        debounces.set(key, setTimeout(() => {
+          debounces.delete(key);
+          void fire(id, `event ${event} (settled)`, payload);
+        }, trigger.debounceMs));
+        continue;
+      }
+      if (trigger.type === "count" && trigger.on === event) {
+        const state = loadTriggerState(id);
+        const next = (state.counts[event] ?? 0) + 1;
+        if (next < trigger.every) {
+          saveTriggerState(id, { ...state, counts: { ...state.counts, [event]: next } });
+          continue;
+        }
+        saveTriggerState(id, { ...state, counts: { ...state.counts, [event]: 0 } });
+        void fire(id, `${trigger.every}x ${event}`, payload);
+      }
+    }
+  }
+}
+function startAgentTriggers() {
+  stopAgentTriggers();
+  for (const { id } of listCodingAgents()) {
+    const def = getCodingAgent(id);
+    for (const trigger of asArray(def?.trigger)) {
+      if (trigger.type !== "interval") continue;
+      intervals.set(id, setInterval(() => void fire(id, `interval ${trigger.everyMs}ms`), trigger.everyMs));
+      logger.info(`[CodingAgent:${id}] interval trigger every ${trigger.everyMs}ms`);
+    }
+  }
+}
+function stopAgentTriggers() {
+  for (const t of intervals.values()) clearInterval(t);
+  intervals.clear();
+  for (const t of debounces.values()) clearTimeout(t);
+  debounces.clear();
+}
+function describeTriggers() {
+  return listCodingAgents().map(({ id }) => {
+    const def = getCodingAgent(id);
+    return {
+      agentId: id,
+      triggers: asArray(def?.trigger).map(
+        (t) => t.type === "interval" ? `every ${t.everyMs}ms` : t.type === "event" ? `on ${[t.on].flat().join(", ")}${t.debounceMs ? ` (debounce ${t.debounceMs}ms)` : ""}` : t.type === "count" ? `every ${t.every}x ${t.on}` : "manual"
+      )
+    };
+  });
+}
+
+// src/codingAgent/collection.ts
+import * as fs11 from "fs";
+import * as path11 from "path";
+function registerCodingAgentCollection(sdk, config2 = {}) {
+  const runtimeDir = config2.runtimeDir || process.env.CODING_AGENT_RUNTIME_DIR || path11.join(process.cwd(), ".coding-agent-runtime");
+  const defaultHarness = config2.harness || process.env.CODING_AGENT_HARNESS || "codex";
+  const sessions = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Set();
+  sdk.addCollection("coding-agent", "run", async (params) => {
+    const { prompt, threadId, agentId, projectId, userId, harness, resumeId, signal, onOutput, onEvent, onUsage } = params;
+    if (!prompt || !threadId) {
+      return { success: false, error: "prompt and threadId are required" };
+    }
+    if (running.has(threadId)) {
+      return { success: false, error: "This thread already has a turn in progress." };
+    }
+    running.add(threadId);
+    try {
+      if (agentId) {
+        const def = getCodingAgent(agentId);
+        if (!def) {
+          return {
+            success: false,
+            error: `Unknown agent "${agentId}". Available: ${listCodingAgents().map((a) => a.id).join(", ") || "(none registered)"}`
+          };
+        }
+        const record = await runCodingAgent(agentId, {
+          prompt,
+          projectId,
+          userId,
+          threadId,
+          signal,
+          onOutput,
+          onEvent,
+          onUsage,
+          ...resumeId ? { resumeId } : {}
+        });
+        return {
+          success: record.status === "completed" || record.status === "early",
+          status: record.status,
+          answer: record.answer,
+          ms: record.ms,
+          usage: record.usage,
+          sessionId: record.sessionId,
+          ...record.output !== void 0 ? { output: record.output } : {},
+          ...record.applied ? { applied: record.applied } : {},
+          ...record.error ? { error: record.error } : {}
+        };
+      }
+      const cwd = path11.join(runtimeDir, "threads", threadId);
+      fs11.mkdirSync(cwd, { recursive: true });
+      let session = sessions.get(threadId);
+      if (!session) {
+        session = createCodingAgentSession(harness || defaultHarness, {
+          cwd,
+          model: config2.model,
+          resumeId,
+          mcpServers: config2.mcpServers
+        });
+        sessions.set(threadId, session);
+      }
+      const result = await session.run(prompt, { onOutput, onEvent, onUsage }, signal);
+      logger.info(
+        `[CodingAgent] thread=${threadId} harness=${session.harness} status=${result.status} ms=${result.ms} tokens=${result.usage.inputTokens}/${result.usage.outputTokens} tools=${result.usage.toolCalls}`
+      );
+      return {
+        // An abort is the user's own choice, not a failure — but it is also
+        // not a completed answer, so `status` is what the UI should branch on.
+        success: result.status === "completed" || result.status === "early",
+        status: result.status,
+        answer: result.answer,
+        ms: result.ms,
+        usage: result.usage,
+        sessionId: result.sessionId,
+        ...result.error ? { error: result.error } : {}
+      };
+    } catch (error) {
+      const message = error?.message ?? String(error);
+      logger.error(`[CodingAgent] thread=${threadId} failed: ${message}`);
+      return { success: false, status: "error", error: message };
+    } finally {
+      running.delete(threadId);
+    }
+  });
+  sdk.addCollection("coding-agent", "reset", async (params) => {
+    const session = sessions.get(params?.threadId);
+    if (session) {
+      session.reset();
+      session.dispose();
+      sessions.delete(params.threadId);
+    }
+    return { success: true };
+  });
+  sdk.addCollection("coding-agent", "list", async () => ({ success: true, agents: listCodingAgents() }));
+  console.log(`\u2713 coding-agent collection registered (harness: ${defaultHarness})`);
+}
+
+// src/codingAgent/handler.ts
+var inFlightAborts3 = /* @__PURE__ */ new Map();
+var recentlyAborted3 = /* @__PURE__ */ new Map();
+var ABORT_TOMBSTONE_TTL_MS3 = 3e4;
+function setAbortTombstone3(threadId) {
+  const now = Date.now();
+  recentlyAborted3.set(threadId, now);
+  for (const [key, ts] of recentlyAborted3) {
+    if (now - ts > ABORT_TOMBSTONE_TTL_MS3) recentlyAborted3.delete(key);
+  }
+}
+function consumeAbortTombstone3(threadId) {
+  const ts = recentlyAborted3.get(threadId);
+  if (ts === void 0) return false;
+  recentlyAborted3.delete(threadId);
+  return Date.now() - ts <= ABORT_TOMBSTONE_TTL_MS3;
+}
+function handleCodingAgentAbort(data, sendMessage) {
+  const parseResult = CodingAgentAbortRequestMessageSchema.safeParse(data);
+  if (!parseResult.success) {
+    logger.warn("[CodingAgentAbort] Invalid message \u2014 ignoring");
+    return;
+  }
+  const { payload, from } = parseResult.data;
+  const { threadId } = payload;
+  const controller = inFlightAborts3.get(threadId);
+  if (controller) {
+    controller.abort();
+    inFlightAborts3.delete(threadId);
+    logger.info(`[CodingAgentAbort] Aborted in-flight run for thread ${threadId}`);
+  } else {
+    setAbortTombstone3(threadId);
+    logger.info(`[CodingAgentAbort] No in-flight run for thread ${threadId} \u2014 tombstoned`);
+  }
+  try {
+    sendMessage({
+      id: `coding_agent_aborted_${threadId}`,
+      type: "CODING_AGENT_ABORTED",
+      from: { type: "data-agent" },
+      to: { type: "runtime", id: from.id },
+      payload: { threadId }
+    });
+  } catch (err) {
+    logger.warn(`[CodingAgentAbort] Failed to send abort ack: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function handleCodingAgentRequest(data, collections, sendMessage) {
+  const parseResult = CodingAgentRequestMessageSchema.safeParse(data);
+  if (!parseResult.success) {
+    logger.error("[CodingAgentReq] Invalid message:", JSON.stringify(parseResult.error.errors));
+    return;
+  }
+  const { id, payload, from } = parseResult.data;
+  const { prompt, threadId, projectId, userId, agentId, harness, resumeId } = payload;
+  const wsId = from.id;
+  const respond = (res) => {
+    sendMessage({
+      id,
+      type: "CODING_AGENT_RES",
+      from: { type: "data-agent" },
+      to: { type: "runtime", id: wsId },
+      payload: res
+    });
+  };
+  if (!collections?.["coding-agent"]?.["run"]) {
+    respond({ success: false, error: "Coding agent is not available in this environment (collection 'coding-agent' not registered)." });
+    return;
+  }
+  const abortController = new AbortController();
+  if (consumeAbortTombstone3(threadId)) {
+    abortController.abort();
+    logger.info(`[CodingAgentReq] thread ${threadId} was pre-aborted \u2014 starting cancelled`);
+  }
+  inFlightAborts3.set(threadId, abortController);
+  let seq = 0;
+  const stream = (frame) => {
+    try {
+      sendMessage({
+        // Keyed by this request's id, not threadId — threadId repeats across
+        // every turn in a chat, so a listener that failed to clean up would
+        // keep matching future turns forever.
+        id: `coding_agent_stream_${id}`,
+        type: "CODING_AGENT_STREAM",
+        from: { type: "data-agent" },
+        to: { type: "runtime", id: wsId },
+        payload: { threadId, seq: seq++, ...frame }
+      });
+    } catch (err) {
+      logger.warn(`[CodingAgentReq] Stream send failed (socket may be closed): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  try {
+    const result = await collections["coding-agent"]["run"]({
+      prompt,
+      threadId,
+      projectId,
+      userId,
+      agentId,
+      harness,
+      resumeId,
+      signal: abortController.signal,
+      onOutput: (chunk) => stream({ chunk }),
+      onEvent: (event) => stream({ event }),
+      onUsage: (usage) => stream({ usage })
+    });
+    respond(result ?? { success: false, error: "Coding agent returned no result" });
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`[CodingAgentReq] Error: ${errorMsg}`);
+    respond({ success: false, error: abortController.signal.aborted ? "aborted" : errorMsg });
+  } finally {
+    inFlightAborts3.delete(threadId);
+  }
+}
+
 // src/reportComp/types.ts
 var DEFAULT_REPORT_COMP_MODELS = {
   anthropic: "anthropic/claude-haiku-4-5-20251001",
@@ -24097,21 +25153,21 @@ Fixed SQL query:`;
 }
 
 // src/reportComp/index.ts
-var inFlightAborts3 = /* @__PURE__ */ new Map();
-var recentlyAborted3 = /* @__PURE__ */ new Map();
-var ABORT_TOMBSTONE_TTL_MS3 = 3e4;
-function setAbortTombstone3(reportId) {
+var inFlightAborts4 = /* @__PURE__ */ new Map();
+var recentlyAborted4 = /* @__PURE__ */ new Map();
+var ABORT_TOMBSTONE_TTL_MS4 = 3e4;
+function setAbortTombstone4(reportId) {
   const now = Date.now();
-  recentlyAborted3.set(reportId, now);
-  for (const [key, ts] of recentlyAborted3) {
-    if (now - ts > ABORT_TOMBSTONE_TTL_MS3) recentlyAborted3.delete(key);
+  recentlyAborted4.set(reportId, now);
+  for (const [key, ts] of recentlyAborted4) {
+    if (now - ts > ABORT_TOMBSTONE_TTL_MS4) recentlyAborted4.delete(key);
   }
 }
-function consumeAbortTombstone3(reportId) {
-  const ts = recentlyAborted3.get(reportId);
+function consumeAbortTombstone4(reportId) {
+  const ts = recentlyAborted4.get(reportId);
   if (ts === void 0) return false;
-  recentlyAborted3.delete(reportId);
-  return Date.now() - ts <= ABORT_TOMBSTONE_TTL_MS3;
+  recentlyAborted4.delete(reportId);
+  return Date.now() - ts <= ABORT_TOMBSTONE_TTL_MS4;
 }
 function handleReportCompAbort(data, sendMessage) {
   const parseResult = ReportCompAbortRequestMessageSchema.safeParse(data);
@@ -24122,13 +25178,13 @@ function handleReportCompAbort(data, sendMessage) {
   const { payload, from } = parseResult.data;
   const { reportId } = payload;
   const wsId = from.id;
-  const controller = inFlightAborts3.get(reportId);
+  const controller = inFlightAborts4.get(reportId);
   if (controller) {
     controller.abort();
-    inFlightAborts3.delete(reportId);
+    inFlightAborts4.delete(reportId);
     logger.info(`[ReportCompAbort] Aborted in-flight run for report ${reportId}`);
   } else {
-    setAbortTombstone3(reportId);
+    setAbortTombstone4(reportId);
     logger.info(`[ReportCompAbort] No in-flight run for report ${reportId} \u2014 tombstoned`);
   }
   try {
@@ -24174,11 +25230,11 @@ var processReportCompRequest = async (data, components, _sendMessage, anthropicA
   const trace = createRunTrace();
   const abortController = new AbortController();
   if (reportId) {
-    if (consumeAbortTombstone3(reportId)) {
+    if (consumeAbortTombstone4(reportId)) {
       abortController.abort();
       logger.info(`[REPORT_COMP_REQ] reportId=${reportId} was pre-aborted \u2014 starting cancelled`);
     }
-    inFlightAborts3.set(reportId, abortController);
+    inFlightAborts4.set(reportId, abortController);
   }
   let llmResponse;
   try {
@@ -24199,7 +25255,7 @@ var processReportCompRequest = async (data, components, _sendMessage, anthropicA
       trace
     );
   } finally {
-    if (reportId) inFlightAborts3.delete(reportId);
+    if (reportId) inFlightAborts4.delete(reportId);
   }
   const wasAborted = abortController.signal.aborted || !llmResponse.success && Array.isArray(llmResponse.errors) && llmResponse.errors.includes("aborted");
   if (wasAborted) {
@@ -24400,7 +25456,7 @@ function pick(source, keys) {
   }
   return out;
 }
-function asArray(value) {
+function asArray2(value) {
   return Array.isArray(value) ? value : [];
 }
 function sanitizeField(field) {
@@ -24461,7 +25517,7 @@ function generateSanitizedSchemaDocumentation(sanitized) {
         lines.push(`Row Count: ~${entity.rowCount.toLocaleString()}`);
       }
       lines.push("Columns:");
-      for (const field of asArray(entity.fields).concat(asArray(entity.columns))) {
+      for (const field of asArray2(entity.fields).concat(asArray2(entity.columns))) {
         let line = `  - ${field.name}: ${field.type}`;
         if (field.isPrimaryKey) line += " (PRIMARY KEY)";
         if (field.isForeignKey && field.references) {
@@ -24479,7 +25535,7 @@ function generateSanitizedSchemaDocumentation(sanitized) {
     lines.push("TABLE RELATIONSHIPS:");
     lines.push("");
     for (const rel of relationships) {
-      lines.push(`${rel.from} -> ${rel.to} (${rel.type}): ${asArray(rel.keys).join(" = ")}`);
+      lines.push(`${rel.from} -> ${rel.to} (${rel.type}): ${asArray2(rel.keys).join(" = ")}`);
     }
     lines.push("");
   };
@@ -24487,10 +25543,10 @@ function generateSanitizedSchemaDocumentation(sanitized) {
   if (sources) {
     for (const source of sources) {
       renderEntities(
-        asArray(source.schema?.entities).concat(asArray(source.schema?.tables)),
+        asArray2(source.schema?.entities).concat(asArray2(source.schema?.tables)),
         `${source.name} (${source.type})`
       );
-      renderRelationships(asArray(source.schema?.relationships));
+      renderRelationships(asArray2(source.schema?.relationships));
     }
     return lines.join("\n");
   }
@@ -24498,8 +25554,8 @@ function generateSanitizedSchemaDocumentation(sanitized) {
   if (typeof sanitized.schema === "string") lines.push(`Schema: ${sanitized.schema}`);
   if (sanitized.description) lines.push(`Description: ${sanitized.description}`);
   lines.push("");
-  renderEntities(asArray(sanitized.entities).concat(asArray(sanitized.tables)));
-  renderRelationships(asArray(sanitized.relationships));
+  renderEntities(asArray2(sanitized.entities).concat(asArray2(sanitized.tables)));
+  renderRelationships(asArray2(sanitized.relationships));
   return lines.join("\n");
 }
 
@@ -24585,8 +25641,8 @@ function getLLMProviders() {
 }
 
 // src/auth/user-manager.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import os2 from "os";
 var UserManager = class {
   /**
@@ -24599,7 +25655,7 @@ var UserManager = class {
     this.hasChanged = false;
     this.syncInterval = null;
     this.isInitialized = false;
-    this.filePath = path8.join(os2.homedir(), ".superatom", "projects", projectId, "users.json");
+    this.filePath = path12.join(os2.homedir(), ".superatom", "projects", projectId, "users.json");
     this.syncIntervalMs = syncIntervalMs;
   }
   /**
@@ -24624,20 +25680,20 @@ var UserManager = class {
    */
   async loadUsersFromFile() {
     try {
-      const dir = path8.dirname(this.filePath);
-      if (!fs8.existsSync(dir)) {
+      const dir = path12.dirname(this.filePath);
+      if (!fs12.existsSync(dir)) {
         logger.info(`Creating directory structure: ${dir}`);
-        fs8.mkdirSync(dir, { recursive: true });
+        fs12.mkdirSync(dir, { recursive: true });
       }
-      if (!fs8.existsSync(this.filePath)) {
+      if (!fs12.existsSync(this.filePath)) {
         logger.info(`Users file does not exist at ${this.filePath}, creating with empty users`);
         const initialData = { users: [] };
-        fs8.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
+        fs12.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
         this.users = [];
         this.hasChanged = false;
         return;
       }
-      const fileContent = fs8.readFileSync(this.filePath, "utf-8");
+      const fileContent = fs12.readFileSync(this.filePath, "utf-8");
       const rawData = JSON.parse(fileContent);
       const validatedData = UsersDataSchema.parse(rawData);
       this.users = validatedData.users;
@@ -24656,16 +25712,16 @@ var UserManager = class {
       return;
     }
     try {
-      const dir = path8.dirname(this.filePath);
-      if (!fs8.existsSync(dir)) {
-        fs8.mkdirSync(dir, { recursive: true });
+      const dir = path12.dirname(this.filePath);
+      if (!fs12.existsSync(dir)) {
+        fs12.mkdirSync(dir, { recursive: true });
       }
       const usersToSave = this.users.map((user) => {
         const { wsIds, ...userWithoutWsIds } = user;
         return userWithoutWsIds;
       });
       const data = { users: usersToSave };
-      fs8.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
+      fs12.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
       this.hasChanged = false;
       logger.debug(`Synced ${this.users.length} users to file (wsIds excluded)`);
     } catch (error) {
@@ -24883,8 +25939,8 @@ var UserManager = class {
 };
 
 // src/dashboards/dashboard-manager.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import os3 from "os";
 var DashboardManager = class {
   /**
@@ -24893,7 +25949,7 @@ var DashboardManager = class {
    */
   constructor(projectId = "snowflake-dataset") {
     this.projectId = projectId;
-    this.dashboardsBasePath = path9.join(
+    this.dashboardsBasePath = path13.join(
       os3.homedir(),
       ".superatom",
       "projects",
@@ -24907,7 +25963,7 @@ var DashboardManager = class {
    * @returns Full path to dashboard data.json file
    */
   getDashboardPath(dashboardId) {
-    return path9.join(this.dashboardsBasePath, dashboardId, "data.json");
+    return path13.join(this.dashboardsBasePath, dashboardId, "data.json");
   }
   /**
    * Create a new dashboard
@@ -24917,13 +25973,13 @@ var DashboardManager = class {
    */
   createDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    const dashboardDir = path9.dirname(dashboardPath);
-    if (fs9.existsSync(dashboardPath)) {
+    const dashboardDir = path13.dirname(dashboardPath);
+    if (fs13.existsSync(dashboardPath)) {
       throw new Error(`Dashboard '${dashboardId}' already exists`);
     }
     const validated = DSLRendererPropsSchema.parse(dashboard);
-    fs9.mkdirSync(dashboardDir, { recursive: true });
-    fs9.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+    fs13.mkdirSync(dashboardDir, { recursive: true });
+    fs13.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
     logger.info(`Dashboard created: ${dashboardId}`);
     return validated;
   }
@@ -24934,12 +25990,12 @@ var DashboardManager = class {
    */
   getDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!fs9.existsSync(dashboardPath)) {
+    if (!fs13.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found: ${dashboardId}`);
       return null;
     }
     try {
-      const fileContent = fs9.readFileSync(dashboardPath, "utf-8");
+      const fileContent = fs13.readFileSync(dashboardPath, "utf-8");
       const dashboard = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema.parse(dashboard);
       return validated;
@@ -24953,16 +26009,16 @@ var DashboardManager = class {
    * @returns Array of dashboard objects with their IDs
    */
   getAllDashboards() {
-    if (!fs9.existsSync(this.dashboardsBasePath)) {
-      fs9.mkdirSync(this.dashboardsBasePath, { recursive: true });
+    if (!fs13.existsSync(this.dashboardsBasePath)) {
+      fs13.mkdirSync(this.dashboardsBasePath, { recursive: true });
       return [];
     }
     const dashboards = [];
     try {
-      const dashboardDirs = fs9.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = fs13.readdirSync(this.dashboardsBasePath);
       for (const dashboardId of dashboardDirs) {
         const dashboardPath = this.getDashboardPath(dashboardId);
-        if (fs9.existsSync(dashboardPath)) {
+        if (fs13.existsSync(dashboardPath)) {
           const dashboard = this.getDashboard(dashboardId);
           if (dashboard) {
             dashboards.push({ dashboardId, dashboard });
@@ -24984,13 +26040,13 @@ var DashboardManager = class {
    */
   updateDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!fs9.existsSync(dashboardPath)) {
+    if (!fs13.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for update: ${dashboardId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema.parse(dashboard);
-      fs9.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+      fs13.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
       logger.info(`Dashboard updated: ${dashboardId}`);
       return validated;
     } catch (error) {
@@ -25005,13 +26061,13 @@ var DashboardManager = class {
    */
   deleteDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    const dashboardDir = path9.dirname(dashboardPath);
-    if (!fs9.existsSync(dashboardPath)) {
+    const dashboardDir = path13.dirname(dashboardPath);
+    if (!fs13.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for deletion: ${dashboardId}`);
       return false;
     }
     try {
-      fs9.rmSync(dashboardDir, { recursive: true, force: true });
+      fs13.rmSync(dashboardDir, { recursive: true, force: true });
       logger.info(`Dashboard deleted: ${dashboardId}`);
       return true;
     } catch (error) {
@@ -25026,21 +26082,21 @@ var DashboardManager = class {
    */
   dashboardExists(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    return fs9.existsSync(dashboardPath);
+    return fs13.existsSync(dashboardPath);
   }
   /**
    * Get dashboard count
    * @returns Number of dashboards
    */
   getDashboardCount() {
-    if (!fs9.existsSync(this.dashboardsBasePath)) {
+    if (!fs13.existsSync(this.dashboardsBasePath)) {
       return 0;
     }
     try {
-      const dashboardDirs = fs9.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = fs13.readdirSync(this.dashboardsBasePath);
       return dashboardDirs.filter((dir) => {
         const dashboardPath = this.getDashboardPath(dir);
-        return fs9.existsSync(dashboardPath);
+        return fs13.existsSync(dashboardPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get dashboard count:", error);
@@ -25050,8 +26106,8 @@ var DashboardManager = class {
 };
 
 // src/reports/report-manager.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs14 from "fs";
+import path14 from "path";
 import os4 from "os";
 var ReportManager = class {
   /**
@@ -25060,7 +26116,7 @@ var ReportManager = class {
    */
   constructor(projectId = "snowflake-dataset") {
     this.projectId = projectId;
-    this.reportsBasePath = path10.join(
+    this.reportsBasePath = path14.join(
       os4.homedir(),
       ".superatom",
       "projects",
@@ -25074,7 +26130,7 @@ var ReportManager = class {
    * @returns Full path to report data.json file
    */
   getReportPath(reportId) {
-    return path10.join(this.reportsBasePath, reportId, "data.json");
+    return path14.join(this.reportsBasePath, reportId, "data.json");
   }
   /**
    * Create a new report
@@ -25084,13 +26140,13 @@ var ReportManager = class {
    */
   createReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
-    const reportDir = path10.dirname(reportPath);
-    if (fs10.existsSync(reportPath)) {
+    const reportDir = path14.dirname(reportPath);
+    if (fs14.existsSync(reportPath)) {
       throw new Error(`Report '${reportId}' already exists`);
     }
     const validated = DSLRendererPropsSchema2.parse(report);
-    fs10.mkdirSync(reportDir, { recursive: true });
-    fs10.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+    fs14.mkdirSync(reportDir, { recursive: true });
+    fs14.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
     logger.info(`Report created: ${reportId}`);
     return validated;
   }
@@ -25101,12 +26157,12 @@ var ReportManager = class {
    */
   getReport(reportId) {
     const reportPath = this.getReportPath(reportId);
-    if (!fs10.existsSync(reportPath)) {
+    if (!fs14.existsSync(reportPath)) {
       logger.warn(`Report not found: ${reportId}`);
       return null;
     }
     try {
-      const fileContent = fs10.readFileSync(reportPath, "utf-8");
+      const fileContent = fs14.readFileSync(reportPath, "utf-8");
       const report = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema2.parse(report);
       return validated;
@@ -25120,16 +26176,16 @@ var ReportManager = class {
    * @returns Array of report objects with their IDs
    */
   getAllReports() {
-    if (!fs10.existsSync(this.reportsBasePath)) {
-      fs10.mkdirSync(this.reportsBasePath, { recursive: true });
+    if (!fs14.existsSync(this.reportsBasePath)) {
+      fs14.mkdirSync(this.reportsBasePath, { recursive: true });
       return [];
     }
     const reports = [];
     try {
-      const reportDirs = fs10.readdirSync(this.reportsBasePath);
+      const reportDirs = fs14.readdirSync(this.reportsBasePath);
       for (const reportId of reportDirs) {
         const reportPath = this.getReportPath(reportId);
-        if (fs10.existsSync(reportPath)) {
+        if (fs14.existsSync(reportPath)) {
           const report = this.getReport(reportId);
           if (report) {
             reports.push({ reportId, report });
@@ -25151,13 +26207,13 @@ var ReportManager = class {
    */
   updateReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
-    if (!fs10.existsSync(reportPath)) {
+    if (!fs14.existsSync(reportPath)) {
       logger.warn(`Report not found for update: ${reportId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema2.parse(report);
-      fs10.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+      fs14.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
       logger.info(`Report updated: ${reportId}`);
       return validated;
     } catch (error) {
@@ -25172,13 +26228,13 @@ var ReportManager = class {
    */
   deleteReport(reportId) {
     const reportPath = this.getReportPath(reportId);
-    const reportDir = path10.dirname(reportPath);
-    if (!fs10.existsSync(reportPath)) {
+    const reportDir = path14.dirname(reportPath);
+    if (!fs14.existsSync(reportPath)) {
       logger.warn(`Report not found for deletion: ${reportId}`);
       return false;
     }
     try {
-      fs10.rmSync(reportDir, { recursive: true, force: true });
+      fs14.rmSync(reportDir, { recursive: true, force: true });
       logger.info(`Report deleted: ${reportId}`);
       return true;
     } catch (error) {
@@ -25193,21 +26249,21 @@ var ReportManager = class {
    */
   reportExists(reportId) {
     const reportPath = this.getReportPath(reportId);
-    return fs10.existsSync(reportPath);
+    return fs14.existsSync(reportPath);
   }
   /**
    * Get report count
    * @returns Number of reports
    */
   getReportCount() {
-    if (!fs10.existsSync(this.reportsBasePath)) {
+    if (!fs14.existsSync(this.reportsBasePath)) {
       return 0;
     }
     try {
-      const reportDirs = fs10.readdirSync(this.reportsBasePath);
+      const reportDirs = fs14.readdirSync(this.reportsBasePath);
       return reportDirs.filter((dir) => {
         const reportPath = this.getReportPath(dir);
-        return fs10.existsSync(reportPath);
+        return fs14.existsSync(reportPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get report count:", error);
@@ -25580,8 +26636,8 @@ var CleanupService = class _CleanupService {
 };
 
 // src/dashboardAgent/collection.ts
-import path11 from "path";
-import fs11 from "fs";
+import path15 from "path";
+import fs15 from "fs";
 
 // src/dashboardAgent/tools.ts
 import { Type } from "typebox";
@@ -25788,10 +26844,10 @@ function buildDashboardAgentTools(sdk, signal, trace) {
 }
 
 // src/dashboardAgent/collection.ts
-var dynamicImport = new Function("specifier", "return import(specifier)");
+var dynamicImport2 = new Function("specifier", "return import(specifier)");
 var piModulePromise = null;
 function loadPi() {
-  if (!piModulePromise) piModulePromise = dynamicImport("@earendil-works/pi-coding-agent");
+  if (!piModulePromise) piModulePromise = dynamicImport2("@earendil-works/pi-coding-agent");
   return piModulePromise;
 }
 var authAndRegistry = null;
@@ -25909,17 +26965,17 @@ function textDelta(event) {
   return null;
 }
 var runningDashboards = /* @__PURE__ */ new Set();
-function registerDashboardAgentCollection(sdk, config = {}) {
-  const piCwd = config.cwd || process.env.PI_AGENT_DIR || path11.join(process.cwd(), ".prompts", "dashboard-agent");
-  const runtimeDir = config.runtimeDir || process.env.PI_AGENT_RUNTIME_DIR || path11.join(process.cwd(), ".pi-dashboard-agent-runtime");
-  const freshSession = config.freshSession ?? process.env.PI_AGENT_FRESH_SESSION !== "false";
-  const SESSIONS_FILE = path11.join(runtimeDir, ".pi-dashboard-sessions.json");
-  const DRAFTS_DIR = path11.join(runtimeDir, "drafts");
-  const DASHBOARD_LOG_FILE = path11.join(runtimeDir, "dashboard.log");
+function registerDashboardAgentCollection(sdk, config2 = {}) {
+  const piCwd = config2.cwd || process.env.PI_AGENT_DIR || path15.join(process.cwd(), ".prompts", "dashboard-agent");
+  const runtimeDir = config2.runtimeDir || process.env.PI_AGENT_RUNTIME_DIR || path15.join(process.cwd(), ".pi-dashboard-agent-runtime");
+  const freshSession = config2.freshSession ?? process.env.PI_AGENT_FRESH_SESSION !== "false";
+  const SESSIONS_FILE = path15.join(runtimeDir, ".pi-dashboard-sessions.json");
+  const DRAFTS_DIR = path15.join(runtimeDir, "drafts");
+  const DASHBOARD_LOG_FILE = path15.join(runtimeDir, "dashboard.log");
   function appendLog(text) {
     try {
-      fs11.mkdirSync(runtimeDir, { recursive: true });
-      fs11.appendFileSync(DASHBOARD_LOG_FILE, text);
+      fs15.mkdirSync(runtimeDir, { recursive: true });
+      fs15.appendFileSync(DASHBOARD_LOG_FILE, text);
     } catch (err) {
       console.warn(`[DashboardAgent] Failed to write dashboard.log: ${err?.message ?? err}`);
     }
@@ -25931,15 +26987,15 @@ ${fullPrompt}
 --- Response ---
 `;
     try {
-      fs11.mkdirSync(runtimeDir, { recursive: true });
-      fs11.writeFileSync(DASHBOARD_LOG_FILE, header);
+      fs15.mkdirSync(runtimeDir, { recursive: true });
+      fs15.writeFileSync(DASHBOARD_LOG_FILE, header);
     } catch (err) {
       console.warn(`[DashboardAgent] Failed to write dashboard.log: ${err?.message ?? err}`);
     }
   }
   function readDraft(dashboardId) {
     try {
-      const raw = fs11.readFileSync(path11.join(DRAFTS_DIR, `${dashboardId}.json`), "utf-8");
+      const raw = fs15.readFileSync(path15.join(DRAFTS_DIR, `${dashboardId}.json`), "utf-8");
       return JSON.parse(raw);
     } catch (err) {
       console.warn(`[DashboardAgent] Failed to read draft for ${dashboardId}: ${err?.message ?? err}`);
@@ -25948,7 +27004,7 @@ ${fullPrompt}
   }
   function loadSessionMap() {
     try {
-      return JSON.parse(fs11.readFileSync(SESSIONS_FILE, "utf-8"));
+      return JSON.parse(fs15.readFileSync(SESSIONS_FILE, "utf-8"));
     } catch {
       return {};
     }
@@ -25957,8 +27013,8 @@ ${fullPrompt}
     const map = loadSessionMap();
     map[dashboardId] = sessionFile;
     try {
-      fs11.mkdirSync(piCwd, { recursive: true });
-      fs11.writeFileSync(SESSIONS_FILE, JSON.stringify(map, null, 2));
+      fs15.mkdirSync(piCwd, { recursive: true });
+      fs15.writeFileSync(SESSIONS_FILE, JSON.stringify(map, null, 2));
     } catch (err) {
       console.warn(`[DashboardAgent] Failed to persist session file for ${dashboardId}: ${err?.message ?? err}`);
     }
@@ -26030,8 +27086,8 @@ ${fullPrompt}
       const { createAgentSession, SessionManager } = await loadPi();
       const { authStorage, modelRegistry } = await getAuthAndRegistry();
       let model;
-      const explicitProvider = config.provider || process.env.PI_AGENT_PROVIDER;
-      const explicitModel = config.model || process.env.PI_AGENT_MODEL;
+      const explicitProvider = config2.provider || process.env.PI_AGENT_PROVIDER;
+      const explicitModel = config2.model || process.env.PI_AGENT_MODEL;
       if (explicitProvider || explicitModel) {
         const providerName = explicitProvider || "openrouter";
         const modelId = explicitModel || "anthropic/claude-sonnet-4.5";
@@ -26134,7 +27190,7 @@ ${turn.responseText ?? ""}`).join("\n\n");
           console.warn(`[DashboardAgent] Failed to fetch previous responses for ${dashboardId}: ${err?.message ?? err}`);
         }
       }
-      const draftPath = path11.join(DRAFTS_DIR, `${dashboardId}.json`);
+      const draftPath = path15.join(DRAFTS_DIR, `${dashboardId}.json`);
       const fullPrompt = [
         `Dashboard ID: ${dashboardId}.`,
         projectId ? `Project ID: ${projectId}.` : null,
@@ -26166,7 +27222,7 @@ ${previousResponseText}` : null,
       let sessionManager;
       if (!freshSession) {
         const existingSessionFile = loadSessionMap()[dashboardId];
-        if (existingSessionFile && fs11.existsSync(existingSessionFile)) {
+        if (existingSessionFile && fs15.existsSync(existingSessionFile)) {
           sessionManager = SessionManager.open(existingSessionFile, runtimeDir);
           console.log(`[DashboardAgent] Resuming session file ${existingSessionFile} for dashboard ${dashboardId}`);
         } else {
@@ -26247,7 +27303,7 @@ ${description}
       };
       signal?.addEventListener("abort", onAbort, { once: true });
       try {
-        fs11.unlinkSync(draftPath);
+        fs15.unlinkSync(draftPath);
       } catch {
       }
       let result;
@@ -26267,7 +27323,7 @@ ${description}
         signal?.removeEventListener("abort", onAbort);
         if (freshSession && session.sessionFile) {
           try {
-            fs11.unlinkSync(session.sessionFile);
+            fs15.unlinkSync(session.sessionFile);
           } catch (err) {
             console.warn(`[DashboardAgent] Failed to delete fresh-session file ${session.sessionFile}: ${err?.message ?? err}`);
           }
@@ -26399,7 +27455,7 @@ ${description}
 // src/index.ts
 var DEFAULT_WS_URL = "wss://ws.superatom.ai/websocket";
 var SuperatomSDK = class {
-  constructor(config) {
+  constructor(config2) {
     this.ws = null;
     this.messageHandlers = /* @__PURE__ */ new Map();
     this.messageTypeHandlers = /* @__PURE__ */ new Map();
@@ -26426,39 +27482,39 @@ var SuperatomSDK = class {
     // since an outage of unknown length shouldn't grow this without limit.
     this.pendingOutbox = [];
     this.MAX_OUTBOX_SIZE = 50;
-    if (config.logLevel) {
-      logger.setLogLevel(config.logLevel);
-    }
-    this.apiKey = config.apiKey;
-    this.projectId = config.projectId;
-    this.type = config.type || "data-agent";
-    this.bundleDir = config.bundleDir;
-    this.url = config.url || process.env.SA_WEBSOCKET_URL || DEFAULT_WS_URL;
-    this.anthropicApiKey = config.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY || "";
-    this.groqApiKey = config.GROQ_API_KEY || process.env.GROQ_API_KEY || "";
-    this.geminiApiKey = config.GEMINI_API_KEY || process.env.GEMINI_API_KEY || "";
-    this.openaiApiKey = config.OPENAI_API_KEY || process.env.OPENAI_API_KEY || "";
-    this.llmProviders = config.LLM_PROVIDERS || getLLMProviders();
-    this.databaseType = config.databaseType || "postgresql";
-    setFmtConfig({ locale: config.locale, currency: config.currency });
-    this.modelStrategy = config.modelStrategy || "fast";
-    this.mainAgentModel = config.mainAgentModel || "anthropic/claude-sonnet-4-5-20250929";
-    this.sourceAgentModel = config.sourceAgentModel || "anthropic/claude-sonnet-4-5-20250929";
-    this.dashCompModels = config.dashCompModels;
-    this.conversationSimilarityThreshold = config.conversationSimilarityThreshold ?? 0.8;
+    if (config2.logLevel) {
+      logger.setLogLevel(config2.logLevel);
+    }
+    this.apiKey = config2.apiKey;
+    this.projectId = config2.projectId;
+    this.type = config2.type || "data-agent";
+    this.bundleDir = config2.bundleDir;
+    this.url = config2.url || process.env.SA_WEBSOCKET_URL || DEFAULT_WS_URL;
+    this.anthropicApiKey = config2.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY || "";
+    this.groqApiKey = config2.GROQ_API_KEY || process.env.GROQ_API_KEY || "";
+    this.geminiApiKey = config2.GEMINI_API_KEY || process.env.GEMINI_API_KEY || "";
+    this.openaiApiKey = config2.OPENAI_API_KEY || process.env.OPENAI_API_KEY || "";
+    this.llmProviders = config2.LLM_PROVIDERS || getLLMProviders();
+    this.databaseType = config2.databaseType || "postgresql";
+    setFmtConfig({ locale: config2.locale, currency: config2.currency });
+    this.modelStrategy = config2.modelStrategy || "fast";
+    this.mainAgentModel = config2.mainAgentModel || "anthropic/claude-sonnet-4-5-20250929";
+    this.sourceAgentModel = config2.sourceAgentModel || "anthropic/claude-sonnet-4-5-20250929";
+    this.dashCompModels = config2.dashCompModels;
+    this.conversationSimilarityThreshold = config2.conversationSimilarityThreshold ?? 0.8;
     this.applyModelStrategy(this.modelStrategy);
     this.applyConversationSimilarityThreshold(this.conversationSimilarityThreshold);
-    if (config.queryCacheTTL !== void 0) {
-      queryCache.setTTL(config.queryCacheTTL);
+    if (config2.queryCacheTTL !== void 0) {
+      queryCache.setTTL(config2.queryCacheTTL);
     }
-    if (config.dashboardHistoryTTL !== void 0) {
-      dashboardConversationHistory.setTTL(config.dashboardHistoryTTL);
+    if (config2.dashboardHistoryTTL !== void 0) {
+      dashboardConversationHistory.setTTL(config2.dashboardHistoryTTL);
     }
     logger.info(`Initializing Superatom SDK for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, database type: ${this.databaseType}, model strategy: ${this.modelStrategy}, query cache TTL: ${queryCache.getTTL()} minutes`);
     this.userManager = new UserManager(this.projectId, 5e3);
     this.dashboardManager = new DashboardManager(this.projectId);
     this.reportManager = new ReportManager(this.projectId);
-    this.initializePromptLoader(config.promptsDir).catch((error) => {
+    this.initializePromptLoader(config2.promptsDir).catch((error) => {
       logger.error("Failed to initialize PromptLoader:", error);
     });
     this.initializeUserManager().catch((error) => {
@@ -26687,6 +27743,14 @@ var SuperatomSDK = class {
         case "DASHBOARD_AGENT_ABORT_REQ":
           handleDashboardAgentAbort(parsed, (msg) => this.send(msg));
           break;
+        case "CODING_AGENT_REQ":
+          handleCodingAgentRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
+            logger.error("Failed to handle coding agent request:", error);
+          });
+          break;
+        case "CODING_AGENT_ABORT_REQ":
+          handleCodingAgentAbort(parsed, (msg) => this.send(msg));
+          break;
         case "REPORT_COMP_REQ":
           handleReportCompRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.dashCompModels).catch((error) => {
             logger.error("Failed to handle report comp request:", error);
@@ -27024,20 +28088,35 @@ export {
   UILogCollector,
   UserManager,
   anthropicLLM,
+  assertReadOnlySql,
+  createCodexSession,
+  createCodingAgentSession,
   dashboardConversationHistory,
+  describeTriggers,
+  emitAgentEvent,
   geminiLLM,
+  getCodingAgent,
+  getCodingAgentsConfig,
   groqLLM,
   hybridRerank,
+  listCodingAgents,
   llmUsageLogger,
   logger,
   normalizeScriptBody,
+  onAgentRun,
   openaiLLM,
   queryCache,
+  registerCodingAgentCollection,
+  registerCodingAgents,
   registerDashboardAgentCollection,
   rerankChromaResults,
   rerankConversationResults,
   resolveScriptRecipeStore,
+  runCodingAgent,
   runScript,
-  userPromptErrorLogger
+  startAgentTriggers,
+  stopAgentTriggers,
+  userPromptErrorLogger,
+  writeBridgeShims
 };
 //# sourceMappingURL=index.mjs.map