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

package/dist/index.js

@@ -46,21 +46,36 @@ __export(index_exports, {
   UILogCollector: () => UILogCollector,
   UserManager: () => UserManager,
   anthropicLLM: () => anthropicLLM,
+  assertReadOnlySql: () => assertReadOnlySql,
+  createCodexSession: () => createCodexSession,
+  createCodingAgentSession: () => createCodingAgentSession,
   dashboardConversationHistory: () => dashboardConversationHistory,
+  describeTriggers: () => describeTriggers,
+  emitAgentEvent: () => emitAgentEvent,
   geminiLLM: () => geminiLLM,
+  getCodingAgent: () => getCodingAgent,
+  getCodingAgentsConfig: () => getCodingAgentsConfig,
   groqLLM: () => groqLLM,
   hybridRerank: () => hybridRerank,
+  listCodingAgents: () => listCodingAgents,
   llmUsageLogger: () => llmUsageLogger,
   logger: () => logger,
   normalizeScriptBody: () => normalizeScriptBody,
+  onAgentRun: () => onAgentRun,
   openaiLLM: () => openaiLLM,
   queryCache: () => queryCache,
+  registerCodingAgentCollection: () => registerCodingAgentCollection,
+  registerCodingAgents: () => registerCodingAgents,
   registerDashboardAgentCollection: () => registerDashboardAgentCollection,
   rerankChromaResults: () => rerankChromaResults,
   rerankConversationResults: () => rerankConversationResults,
   resolveScriptRecipeStore: () => resolveScriptRecipeStore,
+  runCodingAgent: () => runCodingAgent,
   runScript: () => runScript,
-  userPromptErrorLogger: () => userPromptErrorLogger
+  startAgentTriggers: () => startAgentTriggers,
+  stopAgentTriggers: () => stopAgentTriggers,
+  userPromptErrorLogger: () => userPromptErrorLogger,
+  writeBridgeShims: () => writeBridgeShims
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -841,6 +856,37 @@ var DashboardAgentAbortRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("DASHBOARD_AGENT_ABORT_REQ"),
   payload: DashboardAgentAbortRequestPayloadSchema
 });
+var CodingAgentRequestPayloadSchema = import_zod3.z.object({
+  prompt: import_zod3.z.string(),
+  /** The chat thread. One agent session per thread, and the abort key. */
+  threadId: import_zod3.z.string(),
+  projectId: import_zod3.z.string().optional(),
+  userId: import_zod3.z.string().optional(),
+  /**
+   * Which registered agent to run (see registerCodingAgents). Omit for the
+   * deployment's plain chat agent — the pre-registry behaviour.
+   */
+  agentId: import_zod3.z.string().optional(),
+  /** Which harness to run. Defaults to whatever the deployment registered. */
+  harness: import_zod3.z.string().optional(),
+  /** Continue a prior agent session — the sessionId a previous run returned. */
+  resumeId: import_zod3.z.string().optional()
+});
+var CodingAgentRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("CODING_AGENT_REQ"),
+  payload: CodingAgentRequestPayloadSchema
+});
+var CodingAgentAbortRequestPayloadSchema = import_zod3.z.object({
+  threadId: import_zod3.z.string()
+});
+var CodingAgentAbortRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string().optional(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("CODING_AGENT_ABORT_REQ"),
+  payload: CodingAgentAbortRequestPayloadSchema
+});
 var ReportCompRequestPayloadSchema = import_zod3.z.object({
   prompt: import_zod3.z.string(),
   userId: import_zod3.z.string().optional(),
@@ -9111,12 +9157,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 || import_path3.default.join(process.cwd(), ".prompts");
+    this.promptsDir = config2?.promptsDir || import_path3.default.join(process.cwd(), ".prompts");
   }
   /**
    * Load a prompt template from file system OR fallback to hardcoded prompts
@@ -10032,7 +10078,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
@@ -10042,7 +10088,7 @@ var SourceAgent = class {
      */
     this.traceSchemaEntry = null;
     this.tool = tool;
-    this.config = config;
+    this.config = config2;
     this.streamBuffer = streamBuffer;
     this.options = options || {};
   }
@@ -11642,7 +11688,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,
@@ -11688,7 +11734,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;
@@ -13357,7 +13403,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 };
   }
@@ -13365,12 +13411,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;
@@ -13378,36 +13424,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;
 }
@@ -13980,15 +14026,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";
@@ -15377,8 +15423,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
@@ -15611,12 +15657,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
@@ -15928,13 +15974,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),
@@ -17123,8 +17169,8 @@ ${executedToolsText}`);
 // src/userResponse/anthropic.ts
 import_dotenv.default.config({ quiet: true });
 var AnthropicLLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "anthropic/claude-sonnet-4-5-20250929";
@@ -17145,8 +17191,8 @@ var anthropicLLM = new AnthropicLLM();
 var import_dotenv2 = __toESM(require("dotenv"));
 import_dotenv2.default.config({ quiet: true });
 var GroqLLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "groq/openai/gpt-oss-120b";
@@ -17167,8 +17213,8 @@ var groqLLM = new GroqLLM();
 var import_dotenv3 = __toESM(require("dotenv"));
 import_dotenv3.default.config({ quiet: true });
 var GeminiLLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "gemini/gemini-2.5-flash";
@@ -17189,8 +17235,8 @@ var geminiLLM = new GeminiLLM();
 var import_dotenv4 = __toESM(require("dotenv"));
 import_dotenv4.default.config({ quiet: true });
 var OpenAILLM = class extends BaseLLM {
-  constructor(config) {
-    super(config);
+  constructor(config2) {
+    super(config2);
   }
   getDefaultModel() {
     return "openai/gpt-4.1";
@@ -23658,6 +23704,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
+var path8 = __toESM(require("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
+var fs8 = __toESM(require("fs"));
+var fsp = __toESM(require("fs/promises"));
+var path9 = __toESM(require("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
+var fs9 = __toESM(require("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
+var fs10 = __toESM(require("fs"));
+var path10 = __toESM(require("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
+var fs11 = __toESM(require("fs"));
+var path11 = __toESM(require("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",
@@ -24156,21 +25227,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);
@@ -24181,13 +25252,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 {
@@ -24233,11 +25304,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 {
@@ -24258,7 +25329,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) {
@@ -24459,7 +25530,7 @@ function pick(source, keys) {
   }
   return out;
 }
-function asArray(value) {
+function asArray2(value) {
   return Array.isArray(value) ? value : [];
 }
 function sanitizeField(field) {
@@ -24520,7 +25591,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) {
@@ -24538,7 +25609,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("");
   };
@@ -24546,10 +25617,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");
   }
@@ -24557,8 +25628,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");
 }
 
@@ -25847,10 +26918,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;
@@ -25968,10 +27039,10 @@ function textDelta(event) {
   return null;
 }
 var runningDashboards = /* @__PURE__ */ new Set();
-function registerDashboardAgentCollection(sdk, config = {}) {
-  const piCwd = config.cwd || process.env.PI_AGENT_DIR || import_path8.default.join(process.cwd(), ".prompts", "dashboard-agent");
-  const runtimeDir = config.runtimeDir || process.env.PI_AGENT_RUNTIME_DIR || import_path8.default.join(process.cwd(), ".pi-dashboard-agent-runtime");
-  const freshSession = config.freshSession ?? process.env.PI_AGENT_FRESH_SESSION !== "false";
+function registerDashboardAgentCollection(sdk, config2 = {}) {
+  const piCwd = config2.cwd || process.env.PI_AGENT_DIR || import_path8.default.join(process.cwd(), ".prompts", "dashboard-agent");
+  const runtimeDir = config2.runtimeDir || process.env.PI_AGENT_RUNTIME_DIR || import_path8.default.join(process.cwd(), ".pi-dashboard-agent-runtime");
+  const freshSession = config2.freshSession ?? process.env.PI_AGENT_FRESH_SESSION !== "false";
   const SESSIONS_FILE = import_path8.default.join(runtimeDir, ".pi-dashboard-sessions.json");
   const DRAFTS_DIR = import_path8.default.join(runtimeDir, "drafts");
   const DASHBOARD_LOG_FILE = import_path8.default.join(runtimeDir, "dashboard.log");
@@ -26089,8 +27160,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";
@@ -26458,7 +27529,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();
@@ -26485,39 +27556,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) => {
@@ -26746,6 +27817,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);
@@ -27084,20 +28163,35 @@ var SuperatomSDK = class {
   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.js.map