@openbuilder/cli 0.50.44 → 0.50.49

package/dist/index.js

@@ -1,2004 +1,38 @@
 // OpenBuilder CLI - Built with Rollup
+import * as Sentry from '@sentry/node';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { Codex } from '@openai/codex-sdk';
-import { a as streamLog, f as fileLog, i as initRunnerLogger, s as setFileLoggerTuiMode, b as getLogger$1 } from './chunks/runner-logger-instance-nDWv2h2T.js';
+import { a as streamLog, f as fileLog, i as initRunnerLogger, s as setFileLoggerTuiMode, b as getLogger } from './chunks/runner-logger-instance-nDWv2h2T.js';
 import { config as config$1 } from 'dotenv';
-import require$$1, { resolve, relative, isAbsolute, dirname, join as join$1 } from 'node:path';
+import path$1, { resolve, relative, isAbsolute, dirname, join as join$1 } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { generateText, streamText } from 'ai';
-import 'zod/v4';
-import 'zod/v3';
-import { parse } from 'jsonc-parser';
-import { z } from 'zod';
-import { existsSync, mkdirSync as mkdirSync$1 } from 'fs';
-import { existsSync as existsSync$1, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { readFile } from 'fs/promises';
-import * as path from 'path';
-import { join } from 'path';
-import WebSocket$1, { WebSocketServer, WebSocket } from 'ws';
-import { drizzle } from 'drizzle-orm/node-postgres';
-import pg from 'pg';
-import { pgTable, timestamp, boolean, text, uuid, index, uniqueIndex, integer, jsonb } from 'drizzle-orm/pg-core';
-import { sql, eq, and, desc, isNull } from 'drizzle-orm';
-import { randomUUID, createHash } from 'crypto';
-import { migrate } from 'drizzle-orm/node-postgres/migrator';
-import { ak as addBreadcrumb, aa as captureException, a as getActiveSpan, a0 as getTraceData, ap as startInactiveSpan, bh as flush, bn as continueTrace, af as startSpan, by as setTag, bF as count, bG as distribution, bH as info, bI as fmt } from './chunks/exports-ij9sv4UM.js';
-import os__default from 'node:os';
-import { randomUUID as randomUUID$1 } from 'node:crypto';
-import express from 'express';
-import { spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { createServer, createConnection } from 'node:net';
-import { readFile as readFile$1, rm, writeFile, readdir } from 'node:fs/promises';
-import { simpleGit } from 'simple-git';
-import * as os from 'os';
-import { tunnelManager } from './chunks/manager-CvGX9qqe.js';
-import 'chalk';
-import 'node:util';
-import 'http';
-import 'http-proxy';
-import 'zlib';
-
-// src/errors/ai-sdk-error.ts
-var marker = "vercel.ai.error";
-var symbol = Symbol.for(marker);
-var _a;
-var _AISDKError = class _AISDKError extends Error {
-  /**
-   * Creates an AI SDK Error.
-   *
-   * @param {Object} params - The parameters for creating the error.
-   * @param {string} params.name - The name of the error.
-   * @param {string} params.message - The error message.
-   * @param {unknown} [params.cause] - The underlying cause of the error.
-   */
-  constructor({
-    name: name14,
-    message,
-    cause
-  }) {
-    super(message);
-    this[_a] = true;
-    this.name = name14;
-    this.cause = cause;
-  }
-  /**
-   * Checks if the given error is an AI SDK Error.
-   * @param {unknown} error - The error to check.
-   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
-   */
-  static isInstance(error) {
-    return _AISDKError.hasMarker(error, marker);
-  }
-  static hasMarker(error, marker15) {
-    const markerSymbol = Symbol.for(marker15);
-    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
-  }
-};
-_a = symbol;
-var AISDKError = _AISDKError;
-
-// src/errors/api-call-error.ts
-var name = "AI_APICallError";
-var marker2 = `vercel.ai.error.${name}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
-var APICallError = class extends AISDKError {
-  constructor({
-    message,
-    url,
-    requestBodyValues,
-    statusCode,
-    responseHeaders,
-    responseBody,
-    cause,
-    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
-    statusCode === 409 || // conflict
-    statusCode === 429 || // too many requests
-    statusCode >= 500),
-    // server error
-    data
-  }) {
-    super({ name, message, cause });
-    this[_a2] = true;
-    this.url = url;
-    this.requestBodyValues = requestBodyValues;
-    this.statusCode = statusCode;
-    this.responseHeaders = responseHeaders;
-    this.responseBody = responseBody;
-    this.isRetryable = isRetryable;
-    this.data = data;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker2);
-  }
-};
-_a2 = symbol2;
-
-// src/errors/invalid-argument-error.ts
-var name3 = "AI_InvalidArgumentError";
-var marker4 = `vercel.ai.error.${name3}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var InvalidArgumentError = class extends AISDKError {
-  constructor({
-    message,
-    cause,
-    argument
-  }) {
-    super({ name: name3, message, cause });
-    this[_a4] = true;
-    this.argument = argument;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-
-// src/errors/load-api-key-error.ts
-var name7 = "AI_LoadAPIKeyError";
-var marker8 = `vercel.ai.error.${name7}`;
-var symbol8 = Symbol.for(marker8);
-var _a8;
-var LoadAPIKeyError = class extends AISDKError {
-  // used in isInstance
-  constructor({ message }) {
-    super({ name: name7, message });
-    this[_a8] = true;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker8);
-  }
-};
-_a8 = symbol8;
-
-// src/errors/no-such-model-error.ts
-var name10 = "AI_NoSuchModelError";
-var marker11 = `vercel.ai.error.${name10}`;
-var symbol11 = Symbol.for(marker11);
-var _a11;
-var NoSuchModelError = class extends AISDKError {
-  constructor({
-    errorName = name10,
-    modelId,
-    modelType,
-    message = `No such ${modelType}: ${modelId}`
-  }) {
-    super({ name: errorName, message });
-    this[_a11] = true;
-    this.modelId = modelId;
-    this.modelType = modelType;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker11);
-  }
-};
-_a11 = symbol11;
-
-// src/combine-headers.ts
-var createIdGenerator = ({
-  prefix,
-  size = 16,
-  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  separator = "-"
-} = {}) => {
-  const generator = () => {
-    const alphabetLength = alphabet.length;
-    const chars = new Array(size);
-    for (let i = 0; i < size; i++) {
-      chars[i] = alphabet[Math.random() * alphabetLength | 0];
-    }
-    return chars.join("");
-  };
-  if (prefix == null) {
-    return generator;
-  }
-  if (alphabet.includes(separator)) {
-    throw new InvalidArgumentError({
-      argument: "separator",
-      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
-    });
-  }
-  return () => `${prefix}${separator}${generator()}`;
-};
-var generateId = createIdGenerator();
-new Set(
-  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
-);
-
-// src/claude-code-provider.ts
-
-// src/convert-to-claude-code-messages.ts
-var IMAGE_URL_WARNING = "Image URLs are not supported by this provider; supply base64/data URLs.";
-var IMAGE_CONVERSION_WARNING = "Unable to convert image content; supply base64/data URLs.";
-function normalizeBase64(base64) {
-  return base64.replace(/\s+/g, "");
-}
-function isImageMimeType(mimeType) {
-  return typeof mimeType === "string" && mimeType.trim().toLowerCase().startsWith("image/");
-}
-function createImageContent(mediaType, data) {
-  const trimmedType = mediaType.trim();
-  const trimmedData = normalizeBase64(data.trim());
-  if (!trimmedType || !trimmedData) {
-    return void 0;
-  }
-  return {
-    type: "image",
-    source: {
-      type: "base64",
-      media_type: trimmedType,
-      data: trimmedData
-    }
-  };
-}
-function extractMimeType(candidate) {
-  if (typeof candidate === "string" && candidate.trim()) {
-    return candidate.trim();
-  }
-  return void 0;
-}
-function parseObjectImage(imageObj, fallbackMimeType) {
-  const data = typeof imageObj.data === "string" ? imageObj.data : void 0;
-  const mimeType = extractMimeType(
-    imageObj.mimeType ?? imageObj.mediaType ?? imageObj.media_type ?? fallbackMimeType
-  );
-  if (!data || !mimeType) {
-    return void 0;
-  }
-  return createImageContent(mimeType, data);
-}
-function parseStringImage(value, fallbackMimeType) {
-  const trimmed = value.trim();
-  if (/^https?:\/\//i.test(trimmed)) {
-    return { warning: IMAGE_URL_WARNING };
-  }
-  const dataUrlMatch = trimmed.match(/^data:([^;]+);base64,(.+)$/i);
-  if (dataUrlMatch) {
-    const [, mediaType, data] = dataUrlMatch;
-    const content = createImageContent(mediaType, data);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
-  }
-  const base64Match = trimmed.match(/^base64:([^,]+),(.+)$/i);
-  if (base64Match) {
-    const [, explicitMimeType, data] = base64Match;
-    const content = createImageContent(explicitMimeType, data);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
-  }
-  if (fallbackMimeType) {
-    const content = createImageContent(fallbackMimeType, trimmed);
-    if (content) {
-      return { content };
-    }
-  }
-  return { warning: IMAGE_CONVERSION_WARNING };
-}
-function parseImagePart(part) {
-  if (!part || typeof part !== "object") {
-    return { warning: IMAGE_CONVERSION_WARNING };
-  }
-  const imageValue = part.image;
-  const mimeType = extractMimeType(part.mimeType);
-  if (typeof imageValue === "string") {
-    return parseStringImage(imageValue, mimeType);
-  }
-  if (imageValue && typeof imageValue === "object") {
-    const content = parseObjectImage(imageValue, mimeType);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
-  }
-  return { warning: IMAGE_CONVERSION_WARNING };
-}
-function convertBinaryToBase64(data) {
-  if (typeof Buffer !== "undefined") {
-    const buffer = data instanceof Uint8Array ? Buffer.from(data) : Buffer.from(new Uint8Array(data));
-    return buffer.toString("base64");
-  }
-  if (typeof btoa === "function") {
-    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-    let binary = "";
-    const chunkSize = 32768;
-    for (let i = 0; i < bytes.length; i += chunkSize) {
-      const chunk = bytes.subarray(i, i + chunkSize);
-      binary += String.fromCharCode(...chunk);
-    }
-    return btoa(binary);
-  }
-  return void 0;
-}
-function parseFilePart(part) {
-  const mimeType = extractMimeType(part.mediaType ?? part.mimeType);
-  if (!mimeType || !isImageMimeType(mimeType)) {
-    return {};
-  }
-  const data = part.data;
-  if (typeof data === "string") {
-    const content = createImageContent(mimeType, data);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
-  }
-  if (data instanceof Uint8Array || typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
-    const base64 = convertBinaryToBase64(data);
-    if (!base64) {
-      return { warning: IMAGE_CONVERSION_WARNING };
-    }
-    const content = createImageContent(mimeType, base64);
-    return content ? { content } : { warning: IMAGE_CONVERSION_WARNING };
-  }
-  return { warning: IMAGE_CONVERSION_WARNING };
-}
-function convertToClaudeCodeMessages(prompt, mode = { type: "regular" }, jsonSchema) {
-  const messages = [];
-  const warnings = [];
-  let systemPrompt;
-  const streamingSegments = [];
-  const imageMap = /* @__PURE__ */ new Map();
-  let hasImageParts = false;
-  const addSegment = (formatted) => {
-    streamingSegments.push({ formatted });
-    return streamingSegments.length - 1;
-  };
-  const addImageForSegment = (segmentIndex, content) => {
-    hasImageParts = true;
-    if (!imageMap.has(segmentIndex)) {
-      imageMap.set(segmentIndex, []);
-    }
-    imageMap.get(segmentIndex)?.push(content);
-  };
-  for (const message of prompt) {
-    switch (message.role) {
-      case "system":
-        systemPrompt = message.content;
-        if (typeof message.content === "string" && message.content.trim().length > 0) {
-          addSegment(message.content);
-        } else {
-          addSegment("");
-        }
-        break;
-      case "user":
-        if (typeof message.content === "string") {
-          messages.push(message.content);
-          addSegment(`Human: ${message.content}`);
-        } else {
-          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-          const segmentIndex = addSegment(textParts ? `Human: ${textParts}` : "");
-          if (textParts) {
-            messages.push(textParts);
-          }
-          for (const part of message.content) {
-            if (part.type === "image") {
-              const { content, warning } = parseImagePart(part);
-              if (content) {
-                addImageForSegment(segmentIndex, content);
-              } else if (warning) {
-                warnings.push(warning);
-              }
-            } else if (part.type === "file") {
-              const { content, warning } = parseFilePart(part);
-              if (content) {
-                addImageForSegment(segmentIndex, content);
-              } else if (warning) {
-                warnings.push(warning);
-              }
-            }
-          }
-        }
-        break;
-      case "assistant": {
-        let assistantContent = "";
-        if (typeof message.content === "string") {
-          assistantContent = message.content;
-        } else {
-          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-          if (textParts) {
-            assistantContent = textParts;
-          }
-          const toolCalls = message.content.filter((part) => part.type === "tool-call");
-          if (toolCalls.length > 0) {
-            assistantContent += `
-[Tool calls made]`;
-          }
-        }
-        const formattedAssistant = `Assistant: ${assistantContent}`;
-        messages.push(formattedAssistant);
-        addSegment(formattedAssistant);
-        break;
-      }
-      case "tool":
-        for (const tool3 of message.content) {
-          const resultText = tool3.output.type === "text" ? tool3.output.value : JSON.stringify(tool3.output.value);
-          const formattedToolResult = `Tool Result (${tool3.toolName}): ${resultText}`;
-          messages.push(formattedToolResult);
-          addSegment(formattedToolResult);
-        }
-        break;
-    }
-  }
-  let finalPrompt = "";
-  if (systemPrompt) {
-    finalPrompt = systemPrompt;
-  }
-  if (messages.length > 0) {
-    const formattedMessages = [];
-    for (let i = 0; i < messages.length; i++) {
-      const msg = messages[i];
-      if (msg.startsWith("Assistant:") || msg.startsWith("Tool Result")) {
-        formattedMessages.push(msg);
-      } else {
-        formattedMessages.push(`Human: ${msg}`);
-      }
-    }
-    if (finalPrompt) {
-      const joinedMessages = formattedMessages.join("\n\n");
-      finalPrompt = joinedMessages ? `${finalPrompt}
-
-${joinedMessages}` : finalPrompt;
-    } else {
-      finalPrompt = formattedMessages.join("\n\n");
-    }
-  }
-  let streamingParts = [];
-  const imagePartsInOrder = [];
-  const appendImagesForIndex = (index) => {
-    const images = imageMap.get(index);
-    if (!images) {
-      return;
-    }
-    images.forEach((image) => {
-      streamingParts.push(image);
-      imagePartsInOrder.push(image);
-    });
-  };
-  if (streamingSegments.length > 0) {
-    let accumulatedText = "";
-    let emittedText = false;
-    const flushText = () => {
-      if (!accumulatedText) {
-        return;
-      }
-      streamingParts.push({ type: "text", text: accumulatedText });
-      accumulatedText = "";
-      emittedText = true;
-    };
-    streamingSegments.forEach((segment, index) => {
-      const segmentText = segment.formatted;
-      if (segmentText) {
-        if (!accumulatedText) {
-          accumulatedText = emittedText ? `
-
-${segmentText}` : segmentText;
-        } else {
-          accumulatedText += `
-
-${segmentText}`;
-        }
-      }
-      if (imageMap.has(index)) {
-        flushText();
-        appendImagesForIndex(index);
-      }
-    });
-    flushText();
-  }
-  if (mode?.type === "object-json" && jsonSchema) {
-    const schemaStr = JSON.stringify(jsonSchema, null, 2);
-    finalPrompt = `CRITICAL: You MUST respond with ONLY a JSON object. NO other text, NO explanations, NO questions.
-
-Your response MUST start with { and end with }
-
-The JSON MUST match this EXACT schema:
-${schemaStr}
-
-Now, based on the following conversation, generate ONLY the JSON object with the exact fields specified above:
-
-${finalPrompt}
-
-Remember: Your ENTIRE response must be ONLY the JSON object, starting with { and ending with }`;
-    streamingParts = [{ type: "text", text: finalPrompt }, ...imagePartsInOrder];
-  }
-  return {
-    messagesPrompt: finalPrompt,
-    systemPrompt,
-    ...warnings.length > 0 && { warnings },
-    streamingContentParts: streamingParts.length > 0 ? streamingParts : [
-      { type: "text", text: finalPrompt },
-      ...imagePartsInOrder
-    ],
-    hasImageParts
-  };
-}
-function extractJson(text) {
-  let content = text.trim();
-  const fenceMatch = /```(?:json)?\s*([\s\S]*?)\s*```/i.exec(content);
-  if (fenceMatch) {
-    content = fenceMatch[1];
-  }
-  const varMatch = /^\s*(?:const|let|var)\s+\w+\s*=\s*([\s\S]*)/i.exec(content);
-  if (varMatch) {
-    content = varMatch[1];
-    if (content.trim().endsWith(";")) {
-      content = content.trim().slice(0, -1);
-    }
-  }
-  const firstObj = content.indexOf("{");
-  const firstArr = content.indexOf("[");
-  if (firstObj === -1 && firstArr === -1) {
-    return text;
-  }
-  const start = firstArr === -1 ? firstObj : firstObj === -1 ? firstArr : Math.min(firstObj, firstArr);
-  content = content.slice(start);
-  const tryParse = (value) => {
-    const errors = [];
-    try {
-      const result = parse(value, errors, { allowTrailingComma: true });
-      if (errors.length === 0) {
-        return JSON.stringify(result, null, 2);
-      }
-    } catch {
-    }
-    return void 0;
-  };
-  const parsed = tryParse(content);
-  if (parsed !== void 0) {
-    return parsed;
-  }
-  const openChar = content[0];
-  const closeChar = openChar === "{" ? "}" : "]";
-  const closingPositions = [];
-  let depth = 0;
-  let inString = false;
-  let escapeNext = false;
-  for (let i = 0; i < content.length; i++) {
-    const char = content[i];
-    if (escapeNext) {
-      escapeNext = false;
-      continue;
-    }
-    if (char === "\\") {
-      escapeNext = true;
-      continue;
-    }
-    if (char === '"' && !inString) {
-      inString = true;
-      continue;
-    }
-    if (char === '"' && inString) {
-      inString = false;
-      continue;
-    }
-    if (inString) continue;
-    if (char === openChar) {
-      depth++;
-    } else if (char === closeChar) {
-      depth--;
-      if (depth === 0) {
-        closingPositions.push(i + 1);
-      }
-    }
-  }
-  for (let i = closingPositions.length - 1; i >= 0; i--) {
-    const attempt = tryParse(content.slice(0, closingPositions[i]));
-    if (attempt !== void 0) {
-      return attempt;
-    }
-  }
-  const searchStart = Math.max(0, content.length - 1e3);
-  for (let end = content.length - 1; end > searchStart; end--) {
-    const attempt = tryParse(content.slice(0, end));
-    if (attempt !== void 0) {
-      return attempt;
-    }
-  }
-  return text;
-}
-function createAPICallError({
-  message,
-  code,
-  exitCode,
-  stderr,
-  promptExcerpt,
-  isRetryable = false
-}) {
-  const metadata = {
-    code,
-    exitCode,
-    stderr,
-    promptExcerpt
-  };
-  return new APICallError({
-    message,
-    isRetryable,
-    url: "claude-code-cli://command",
-    requestBodyValues: promptExcerpt ? { prompt: promptExcerpt } : void 0,
-    data: metadata
-  });
-}
-function createAuthenticationError({ message }) {
-  return new LoadAPIKeyError({
-    message: message || "Authentication failed. Please ensure Claude Code SDK is properly authenticated."
-  });
-}
-function createTimeoutError({
-  message,
-  promptExcerpt,
-  timeoutMs
-}) {
-  const metadata = {
-    code: "TIMEOUT",
-    promptExcerpt
-  };
-  return new APICallError({
-    message,
-    isRetryable: true,
-    url: "claude-code-cli://command",
-    requestBodyValues: promptExcerpt ? { prompt: promptExcerpt } : void 0,
-    data: timeoutMs !== void 0 ? { ...metadata, timeoutMs } : metadata
-  });
-}
-
-// src/map-claude-code-finish-reason.ts
-function mapClaudeCodeFinishReason(subtype) {
-  switch (subtype) {
-    case "success":
-      return "stop";
-    case "error_max_turns":
-      return "length";
-    case "error_during_execution":
-      return "error";
-    default:
-      return "stop";
-  }
-}
-var loggerFunctionSchema = z.object({
-  debug: z.any().refine((val) => typeof val === "function", {
-    message: "debug must be a function"
-  }),
-  info: z.any().refine((val) => typeof val === "function", {
-    message: "info must be a function"
-  }),
-  warn: z.any().refine((val) => typeof val === "function", {
-    message: "warn must be a function"
-  }),
-  error: z.any().refine((val) => typeof val === "function", {
-    message: "error must be a function"
-  })
-});
-var claudeCodeSettingsSchema = z.object({
-  pathToClaudeCodeExecutable: z.string().optional(),
-  customSystemPrompt: z.string().optional(),
-  appendSystemPrompt: z.string().optional(),
-  systemPrompt: z.union([
-    z.string(),
-    z.object({
-      type: z.literal("preset"),
-      preset: z.literal("claude_code"),
-      append: z.string().optional()
-    })
-  ]).optional(),
-  maxTurns: z.number().int().min(1).max(100).optional(),
-  maxThinkingTokens: z.number().int().positive().max(1e5).optional(),
-  cwd: z.string().refine(
-    (val) => {
-      if (typeof process === "undefined" || !process.versions?.node) {
-        return true;
-      }
-      return !val || existsSync(val);
-    },
-    { message: "Working directory must exist" }
-  ).optional(),
-  executable: z.enum(["bun", "deno", "node"]).optional(),
-  executableArgs: z.array(z.string()).optional(),
-  permissionMode: z.enum(["default", "acceptEdits", "bypassPermissions", "plan"]).optional(),
-  permissionPromptToolName: z.string().optional(),
-  continue: z.boolean().optional(),
-  resume: z.string().optional(),
-  allowedTools: z.array(z.string()).optional(),
-  disallowedTools: z.array(z.string()).optional(),
-  settingSources: z.array(z.enum(["user", "project", "local"])).optional(),
-  streamingInput: z.enum(["auto", "always", "off"]).optional(),
-  // Hooks and tool-permission callback (permissive validation of shapes)
-  canUseTool: z.any().refine((v) => v === void 0 || typeof v === "function", {
-    message: "canUseTool must be a function"
-  }).optional(),
-  hooks: z.record(
-    z.string(),
-    z.array(
-      z.object({
-        matcher: z.string().optional(),
-        hooks: z.array(z.any()).nonempty()
-      })
-    )
-  ).optional(),
-  mcpServers: z.record(
-    z.string(),
-    z.union([
-      // McpStdioServerConfig
-      z.object({
-        type: z.literal("stdio").optional(),
-        command: z.string(),
-        args: z.array(z.string()).optional(),
-        env: z.record(z.string(), z.string()).optional()
-      }),
-      // McpSSEServerConfig
-      z.object({
-        type: z.literal("sse"),
-        url: z.string(),
-        headers: z.record(z.string(), z.string()).optional()
-      }),
-      // McpHttpServerConfig
-      z.object({
-        type: z.literal("http"),
-        url: z.string(),
-        headers: z.record(z.string(), z.string()).optional()
-      }),
-      // McpSdkServerConfig (in-process custom tools)
-      z.object({
-        type: z.literal("sdk"),
-        name: z.string(),
-        instance: z.any()
-      })
-    ])
-  ).optional(),
-  verbose: z.boolean().optional(),
-  logger: z.union([z.literal(false), loggerFunctionSchema]).optional(),
-  env: z.record(z.string(), z.string().optional()).optional(),
-  additionalDirectories: z.array(z.string()).optional(),
-  agents: z.record(
-    z.string(),
-    z.object({
-      description: z.string(),
-      tools: z.array(z.string()).optional(),
-      prompt: z.string(),
-      model: z.enum(["sonnet", "opus", "haiku", "inherit"]).optional()
-    })
-  ).optional(),
-  includePartialMessages: z.boolean().optional(),
-  fallbackModel: z.string().optional(),
-  forkSession: z.boolean().optional(),
-  stderr: z.any().refine((val) => val === void 0 || typeof val === "function", {
-    message: "stderr must be a function"
-  }).optional(),
-  strictMcpConfig: z.boolean().optional(),
-  extraArgs: z.record(z.string(), z.union([z.string(), z.null()])).optional(),
-  queryFunction: z.any().refine((val) => val === void 0 || typeof val === "function", {
-    message: "queryFunction must be a function"
-  }).optional()
-}).strict();
-function validateModelId(modelId) {
-  const knownModels = ["opus", "sonnet", "haiku"];
-  if (!modelId || modelId.trim() === "") {
-    throw new Error("Model ID cannot be empty");
-  }
-  if (!knownModels.includes(modelId)) {
-    return `Unknown model ID: '${modelId}'. Proceeding with custom model. Known models are: ${knownModels.join(", ")}`;
-  }
-  return void 0;
-}
-function validateSettings(settings) {
-  const warnings = [];
-  const errors = [];
-  try {
-    const result = claudeCodeSettingsSchema.safeParse(settings);
-    if (!result.success) {
-      const errorObject = result.error;
-      const issues = errorObject.errors || errorObject.issues || [];
-      issues.forEach((err) => {
-        const path = err.path.join(".");
-        errors.push(`${path ? `${path}: ` : ""}${err.message}`);
-      });
-      return { valid: false, warnings, errors };
-    }
-    const validSettings = result.data;
-    if (validSettings.maxTurns && validSettings.maxTurns > 20) {
-      warnings.push(
-        `High maxTurns value (${validSettings.maxTurns}) may lead to long-running conversations`
-      );
-    }
-    if (validSettings.maxThinkingTokens && validSettings.maxThinkingTokens > 5e4) {
-      warnings.push(
-        `Very high maxThinkingTokens (${validSettings.maxThinkingTokens}) may increase response time`
-      );
-    }
-    if (validSettings.allowedTools && validSettings.disallowedTools) {
-      warnings.push(
-        "Both allowedTools and disallowedTools are specified. Only allowedTools will be used."
-      );
-    }
-    const validateToolNames = (tools, type) => {
-      tools.forEach((tool3) => {
-        if (!/^[a-zA-Z_][a-zA-Z0-9_]*(\([^)]*\))?$/.test(tool3) && !tool3.startsWith("mcp__")) {
-          warnings.push(`Unusual ${type} tool name format: '${tool3}'`);
-        }
-      });
-    };
-    if (validSettings.allowedTools) {
-      validateToolNames(validSettings.allowedTools, "allowed");
-    }
-    if (validSettings.disallowedTools) {
-      validateToolNames(validSettings.disallowedTools, "disallowed");
-    }
-    return { valid: true, warnings, errors };
-  } catch (error) {
-    errors.push(`Validation error: ${error instanceof Error ? error.message : String(error)}`);
-    return { valid: false, warnings, errors };
-  }
-}
-function validatePrompt(prompt) {
-  const MAX_PROMPT_LENGTH = 1e5;
-  if (prompt.length > MAX_PROMPT_LENGTH) {
-    return `Very long prompt (${prompt.length} characters) may cause performance issues or timeouts`;
-  }
-  return void 0;
-}
-function validateSessionId(sessionId) {
-  if (sessionId && !/^[a-zA-Z0-9-_]+$/.test(sessionId)) {
-    return `Unusual session ID format. This may cause issues with session resumption.`;
-  }
-  return void 0;
-}
-
-// src/logger.ts
-var defaultLogger = {
-  debug: (message) => console.debug(`[DEBUG] ${message}`),
-  info: (message) => console.info(`[INFO] ${message}`),
-  warn: (message) => console.warn(`[WARN] ${message}`),
-  error: (message) => console.error(`[ERROR] ${message}`)
-};
-var noopLogger = {
-  debug: () => {
-  },
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
-  }
-};
-function getLogger(logger) {
-  if (logger === false) {
-    return noopLogger;
-  }
-  if (logger === void 0) {
-    return defaultLogger;
-  }
-  return logger;
-}
-function createVerboseLogger(logger, verbose = false) {
-  if (verbose) {
-    return logger;
-  }
-  return {
-    debug: () => {
-    },
-    // No-op when not verbose
-    info: () => {
-    },
-    // No-op when not verbose
-    warn: logger.warn.bind(logger),
-    error: logger.error.bind(logger)
-  };
-}
-var CLAUDE_CODE_TRUNCATION_WARNING = "Claude Code SDK output ended unexpectedly; returning truncated response from buffered text. Await upstream fix to avoid data loss.";
-var MIN_TRUNCATION_LENGTH = 512;
-function isClaudeCodeTruncationError(error, bufferedText) {
-  const isSyntaxError = error instanceof SyntaxError || // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  typeof error?.name === "string" && // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  error.name.toLowerCase() === "syntaxerror";
-  if (!isSyntaxError) {
-    return false;
-  }
-  if (!bufferedText) {
-    return false;
-  }
-  const rawMessage = typeof error?.message === "string" ? error.message : "";
-  const message = rawMessage.toLowerCase();
-  const truncationIndicators = [
-    "unexpected end of json input",
-    "unexpected end of input",
-    "unexpected end of string",
-    "unexpected eof",
-    "end of file",
-    "unterminated string",
-    "unterminated string constant"
-  ];
-  if (!truncationIndicators.some((indicator) => message.includes(indicator))) {
-    return false;
-  }
-  if (bufferedText.length < MIN_TRUNCATION_LENGTH) {
-    return false;
-  }
-  return true;
-}
-function isAbortError(err) {
-  if (err && typeof err === "object") {
-    const e = err;
-    if (typeof e.name === "string" && e.name === "AbortError") return true;
-    if (typeof e.code === "string" && e.code.toUpperCase() === "ABORT_ERR") return true;
-  }
-  return false;
-}
-var STREAMING_FEATURE_WARNING = "Claude Agent SDK features (hooks/MCP/images) require streaming input. Set `streamingInput: 'always'` or provide `canUseTool` (auto streams only when canUseTool is set).";
-function toAsyncIterablePrompt(messagesPrompt, outputStreamEnded, sessionId, contentParts) {
-  const content = contentParts && contentParts.length > 0 ? contentParts : [{ type: "text", text: messagesPrompt }];
-  const msg = {
-    type: "user",
-    message: {
-      role: "user",
-      content
-    },
-    parent_tool_use_id: null,
-    session_id: sessionId ?? ""
-  };
-  return {
-    async *[Symbol.asyncIterator]() {
-      yield msg;
-      await outputStreamEnded;
-    }
-  };
-}
-var modelMap = {
-  opus: "opus",
-  sonnet: "sonnet",
-  haiku: "haiku"
-};
-var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
-  specificationVersion = "v2";
-  defaultObjectGenerationMode = "json";
-  supportsImageUrls = false;
-  supportedUrls = {};
-  supportsStructuredOutputs = false;
-  // Fallback/magic string constants
-  static UNKNOWN_TOOL_NAME = "unknown-tool";
-  // Tool input safety limits
-  static MAX_TOOL_INPUT_SIZE = 1048576;
-  // 1MB hard limit
-  static MAX_TOOL_INPUT_WARN = 102400;
-  // 100KB warning threshold
-  static MAX_DELTA_CALC_SIZE = 1e4;
-  // 10KB delta computation threshold
-  modelId;
-  settings;
-  sessionId;
-  modelValidationWarning;
-  settingsValidationWarnings;
-  logger;
-  queryFn;
-  constructor(options) {
-    this.modelId = options.id;
-    this.settings = options.settings ?? {};
-    this.settingsValidationWarnings = options.settingsValidationWarnings ?? [];
-    this.queryFn = this.settings.queryFunction ?? query;
-    const baseLogger = getLogger(this.settings.logger);
-    this.logger = createVerboseLogger(baseLogger, this.settings.verbose ?? false);
-    if (!this.modelId || typeof this.modelId !== "string" || this.modelId.trim() === "") {
-      throw new NoSuchModelError({
-        modelId: this.modelId,
-        modelType: "languageModel"
-      });
-    }
-    this.modelValidationWarning = validateModelId(this.modelId);
-    if (this.modelValidationWarning) {
-      this.logger.warn(`Claude Code Model: ${this.modelValidationWarning}`);
-    }
-  }
-  get provider() {
-    return "claude-code";
-  }
-  getModel() {
-    const mapped = modelMap[this.modelId];
-    return mapped ?? this.modelId;
-  }
-  extractToolUses(content) {
-    if (!Array.isArray(content)) {
-      return [];
-    }
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_use"
-    ).map((item) => {
-      const { id, name, input } = item;
-      return {
-        id: typeof id === "string" && id.length > 0 ? id : generateId(),
-        name: typeof name === "string" && name.length > 0 ? name : _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME,
-        input
-      };
-    });
-  }
-  extractToolResults(content) {
-    if (!Array.isArray(content)) {
-      return [];
-    }
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_result"
-    ).map((item) => {
-      const { tool_use_id, content: content2, is_error, name } = item;
-      return {
-        id: typeof tool_use_id === "string" && tool_use_id.length > 0 ? tool_use_id : generateId(),
-        name: typeof name === "string" && name.length > 0 ? name : void 0,
-        result: content2,
-        isError: Boolean(is_error)
-      };
-    });
-  }
-  extractToolErrors(content) {
-    if (!Array.isArray(content)) {
-      return [];
-    }
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_error"
-    ).map((item) => {
-      const { tool_use_id, error, name } = item;
-      return {
-        id: typeof tool_use_id === "string" && tool_use_id.length > 0 ? tool_use_id : generateId(),
-        name: typeof name === "string" && name.length > 0 ? name : void 0,
-        error
-      };
-    });
-  }
-  serializeToolInput(input) {
-    if (typeof input === "string") {
-      return this.checkInputSize(input);
-    }
-    if (input === void 0) {
-      return "";
-    }
-    try {
-      const serialized = JSON.stringify(input);
-      return this.checkInputSize(serialized);
-    } catch {
-      const fallback = String(input);
-      return this.checkInputSize(fallback);
-    }
-  }
-  checkInputSize(str) {
-    const length = str.length;
-    if (length > _ClaudeCodeLanguageModel.MAX_TOOL_INPUT_SIZE) {
-      throw new Error(
-        `Tool input exceeds maximum size of ${_ClaudeCodeLanguageModel.MAX_TOOL_INPUT_SIZE} bytes (got ${length} bytes). This may indicate a malformed request or an attempt to process excessively large data.`
-      );
-    }
-    if (length > _ClaudeCodeLanguageModel.MAX_TOOL_INPUT_WARN) {
-      this.logger.warn(
-        `[claude-code] Large tool input detected: ${length} bytes. Performance may be impacted. Consider chunking or reducing input size.`
-      );
-    }
-    return str;
-  }
-  normalizeToolResult(result) {
-    if (typeof result === "string") {
-      try {
-        return JSON.parse(result);
-      } catch {
-        return result;
-      }
-    }
-    return result;
-  }
-  generateAllWarnings(options, prompt) {
-    const warnings = [];
-    const unsupportedParams = [];
-    if (options.temperature !== void 0) unsupportedParams.push("temperature");
-    if (options.topP !== void 0) unsupportedParams.push("topP");
-    if (options.topK !== void 0) unsupportedParams.push("topK");
-    if (options.presencePenalty !== void 0) unsupportedParams.push("presencePenalty");
-    if (options.frequencyPenalty !== void 0) unsupportedParams.push("frequencyPenalty");
-    if (options.stopSequences !== void 0 && options.stopSequences.length > 0)
-      unsupportedParams.push("stopSequences");
-    if (options.seed !== void 0) unsupportedParams.push("seed");
-    if (unsupportedParams.length > 0) {
-      for (const param of unsupportedParams) {
-        warnings.push({
-          type: "unsupported-setting",
-          setting: param,
-          details: `Claude Code SDK does not support the ${param} parameter. It will be ignored.`
-        });
-      }
-    }
-    if (this.modelValidationWarning) {
-      warnings.push({
-        type: "other",
-        message: this.modelValidationWarning
-      });
-    }
-    this.settingsValidationWarnings.forEach((warning) => {
-      warnings.push({
-        type: "other",
-        message: warning
-      });
-    });
-    const promptWarning = validatePrompt(prompt);
-    if (promptWarning) {
-      warnings.push({
-        type: "other",
-        message: promptWarning
-      });
-    }
-    return warnings;
-  }
-  handleJsonExtraction(text, warnings) {
-    const extracted = extractJson(text);
-    const validation = this.validateJsonExtraction(text, extracted);
-    if (!validation.valid && validation.warning) {
-      warnings.push(validation.warning);
-    }
-    return extracted;
-  }
-  createQueryOptions(abortController) {
-    const opts = {
-      model: this.getModel(),
-      abortController,
-      resume: this.settings.resume ?? this.sessionId,
-      pathToClaudeCodeExecutable: this.settings.pathToClaudeCodeExecutable,
-      maxTurns: this.settings.maxTurns,
-      maxThinkingTokens: this.settings.maxThinkingTokens,
-      cwd: this.settings.cwd,
-      executable: this.settings.executable,
-      executableArgs: this.settings.executableArgs,
-      permissionMode: this.settings.permissionMode,
-      permissionPromptToolName: this.settings.permissionPromptToolName,
-      continue: this.settings.continue,
-      allowedTools: this.settings.allowedTools,
-      disallowedTools: this.settings.disallowedTools,
-      mcpServers: this.settings.mcpServers,
-      canUseTool: this.settings.canUseTool
-    };
-    if (this.settings.systemPrompt !== void 0) {
-      opts.systemPrompt = this.settings.systemPrompt;
-    } else if (this.settings.customSystemPrompt !== void 0) {
-      this.logger.warn(
-        "[claude-code] 'customSystemPrompt' is deprecated and will be removed in a future major release. Please use 'systemPrompt' instead (string or { type: 'preset', preset: 'claude_code', append? })."
-      );
-      opts.systemPrompt = this.settings.customSystemPrompt;
-    } else if (this.settings.appendSystemPrompt !== void 0) {
-      this.logger.warn(
-        "[claude-code] 'appendSystemPrompt' is deprecated and will be removed in a future major release. Please use 'systemPrompt: { type: 'preset', preset: 'claude_code', append: <text> }' instead."
-      );
-      opts.systemPrompt = {
-        type: "preset",
-        preset: "claude_code",
-        append: this.settings.appendSystemPrompt
-      };
-    }
-    if (this.settings.settingSources !== void 0) {
-      opts.settingSources = this.settings.settingSources;
-    }
-    if (this.settings.additionalDirectories !== void 0) {
-      opts.additionalDirectories = this.settings.additionalDirectories;
-    }
-    if (this.settings.agents !== void 0) {
-      opts.agents = this.settings.agents;
-    }
-    if (this.settings.includePartialMessages !== void 0) {
-      opts.includePartialMessages = this.settings.includePartialMessages;
-    }
-    if (this.settings.fallbackModel !== void 0) {
-      opts.fallbackModel = this.settings.fallbackModel;
-    }
-    if (this.settings.forkSession !== void 0) {
-      opts.forkSession = this.settings.forkSession;
-    }
-    if (this.settings.stderr !== void 0) {
-      opts.stderr = this.settings.stderr;
-    }
-    if (this.settings.strictMcpConfig !== void 0) {
-      opts.strictMcpConfig = this.settings.strictMcpConfig;
-    }
-    if (this.settings.extraArgs !== void 0) {
-      opts.extraArgs = this.settings.extraArgs;
-    }
-    if (this.settings.hooks) {
-      opts.hooks = this.settings.hooks;
-    }
-    if (this.settings.env !== void 0) {
-      opts.env = { ...process.env, ...this.settings.env };
-    }
-    return opts;
-  }
-  handleClaudeCodeError(error, messagesPrompt) {
-    if (isAbortError(error)) {
-      throw error;
-    }
-    const isErrorWithMessage = (err) => {
-      return typeof err === "object" && err !== null && "message" in err;
-    };
-    const isErrorWithCode = (err) => {
-      return typeof err === "object" && err !== null;
-    };
-    const authErrorPatterns = [
-      "not logged in",
-      "authentication",
-      "unauthorized",
-      "auth failed",
-      "please login",
-      "claude login"
-    ];
-    const errorMessage = isErrorWithMessage(error) && error.message ? error.message.toLowerCase() : "";
-    const exitCode = isErrorWithCode(error) && typeof error.exitCode === "number" ? error.exitCode : void 0;
-    const isAuthError = authErrorPatterns.some((pattern) => errorMessage.includes(pattern)) || exitCode === 401;
-    if (isAuthError) {
-      return createAuthenticationError({
-        message: isErrorWithMessage(error) && error.message ? error.message : "Authentication failed. Please ensure Claude Code SDK is properly authenticated."
-      });
-    }
-    const errorCode = isErrorWithCode(error) && typeof error.code === "string" ? error.code : "";
-    if (errorCode === "ETIMEDOUT" || errorMessage.includes("timeout")) {
-      return createTimeoutError({
-        message: isErrorWithMessage(error) && error.message ? error.message : "Request timed out",
-        promptExcerpt: messagesPrompt.substring(0, 200)
-        // Don't specify timeoutMs since we don't know the actual timeout value
-        // It's controlled by the consumer via AbortSignal
-      });
-    }
-    const isRetryable = errorCode === "ENOENT" || errorCode === "ECONNREFUSED" || errorCode === "ETIMEDOUT" || errorCode === "ECONNRESET";
-    return createAPICallError({
-      message: isErrorWithMessage(error) && error.message ? error.message : "Claude Code SDK error",
-      code: errorCode || void 0,
-      exitCode,
-      stderr: isErrorWithCode(error) && typeof error.stderr === "string" ? error.stderr : void 0,
-      promptExcerpt: messagesPrompt.substring(0, 200),
-      isRetryable
-    });
-  }
-  setSessionId(sessionId) {
-    this.sessionId = sessionId;
-    const warning = validateSessionId(sessionId);
-    if (warning) {
-      this.logger.warn(`Claude Code Session: ${warning}`);
-    }
-  }
-  validateJsonExtraction(originalText, extractedJson) {
-    if (extractedJson === originalText) {
-      return {
-        valid: false,
-        warning: {
-          type: "other",
-          message: "JSON extraction from model response may be incomplete or modified. The model may not have returned valid JSON."
-        }
-      };
-    }
-    try {
-      JSON.parse(extractedJson);
-      return { valid: true };
-    } catch {
-      return {
-        valid: false,
-        warning: {
-          type: "other",
-          message: "JSON extraction resulted in invalid JSON. The response may be malformed."
-        }
-      };
-    }
-  }
-  async doGenerate(options) {
-    this.logger.debug(`[claude-code] Starting doGenerate request with model: ${this.modelId}`);
-    const mode = options.responseFormat?.type === "json" ? { type: "object-json" } : { type: "regular" };
-    this.logger.debug(
-      `[claude-code] Request mode: ${mode.type}, response format: ${options.responseFormat?.type ?? "none"}`
-    );
-    const {
-      messagesPrompt,
-      warnings: messageWarnings,
-      streamingContentParts,
-      hasImageParts
-    } = convertToClaudeCodeMessages(
-      options.prompt,
-      mode,
-      options.responseFormat?.type === "json" ? options.responseFormat.schema : void 0
-    );
-    this.logger.debug(
-      `[claude-code] Converted ${options.prompt.length} messages, hasImageParts: ${hasImageParts}`
-    );
-    const abortController = new AbortController();
-    let abortListener;
-    if (options.abortSignal?.aborted) {
-      abortController.abort(options.abortSignal.reason);
-    } else if (options.abortSignal) {
-      abortListener = () => abortController.abort(options.abortSignal?.reason);
-      options.abortSignal.addEventListener("abort", abortListener, { once: true });
-    }
-    const queryOptions = this.createQueryOptions(abortController);
-    let text = "";
-    let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-    let finishReason = "stop";
-    let wasTruncated = false;
-    let costUsd;
-    let durationMs;
-    let rawUsage;
-    const warnings = this.generateAllWarnings(
-      options,
-      messagesPrompt
-    );
-    if (messageWarnings) {
-      messageWarnings.forEach((warning) => {
-        warnings.push({
-          type: "other",
-          message: warning
-        });
-      });
-    }
-    const modeSetting = this.settings.streamingInput ?? "auto";
-    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!this.settings.canUseTool;
-    if (!wantsStreamInput && hasImageParts) {
-      warnings.push({
-        type: "other",
-        message: STREAMING_FEATURE_WARNING
-      });
-    }
-    let done = () => {
-    };
-    const outputStreamEnded = new Promise((resolve) => {
-      done = () => resolve(void 0);
-    });
-    try {
-      if (this.settings.canUseTool && this.settings.permissionPromptToolName) {
-        throw new Error(
-          "canUseTool requires streamingInput mode ('auto' or 'always') and cannot be used with permissionPromptToolName (SDK constraint). Set streamingInput: 'auto' (or 'always') and remove permissionPromptToolName, or remove canUseTool."
-        );
-      }
-      const sdkPrompt = wantsStreamInput ? toAsyncIterablePrompt(
-        messagesPrompt,
-        outputStreamEnded,
-        this.settings.resume ?? this.sessionId,
-        streamingContentParts
-      ) : messagesPrompt;
-      this.logger.debug(
-        `[claude-code] Executing query with streamingInput: ${wantsStreamInput}, session: ${this.settings.resume ?? this.sessionId ?? "new"}`
-      );
-      const response = this.queryFn({
-        prompt: sdkPrompt,
-        options: queryOptions
-      });
-      for await (const message of response) {
-        this.logger.debug(`[claude-code] Received message type: ${message.type}`);
-        if (message.type === "assistant") {
-          text += message.message.content.map((c) => c.type === "text" ? c.text : "").join("");
-        } else if (message.type === "result") {
-          done();
-          this.setSessionId(message.session_id);
-          costUsd = message.total_cost_usd;
-          durationMs = message.duration_ms;
-          this.logger.info(
-            `[claude-code] Request completed - Session: ${message.session_id}, Cost: $${costUsd?.toFixed(4) ?? "N/A"}, Duration: ${durationMs ?? "N/A"}ms`
-          );
-          if ("usage" in message) {
-            rawUsage = message.usage;
-            usage = {
-              inputTokens: (message.usage.cache_creation_input_tokens ?? 0) + (message.usage.cache_read_input_tokens ?? 0) + (message.usage.input_tokens ?? 0),
-              outputTokens: message.usage.output_tokens ?? 0,
-              totalTokens: (message.usage.cache_creation_input_tokens ?? 0) + (message.usage.cache_read_input_tokens ?? 0) + (message.usage.input_tokens ?? 0) + (message.usage.output_tokens ?? 0)
-            };
-            this.logger.debug(
-              `[claude-code] Token usage - Input: ${usage.inputTokens}, Output: ${usage.outputTokens}, Total: ${usage.totalTokens}`
-            );
-          }
-          finishReason = mapClaudeCodeFinishReason(message.subtype);
-          this.logger.debug(`[claude-code] Finish reason: ${finishReason}`);
-        } else if (message.type === "system" && message.subtype === "init") {
-          this.setSessionId(message.session_id);
-          this.logger.info(`[claude-code] Session initialized: ${message.session_id}`);
-        }
-      }
-    } catch (error) {
-      done();
-      this.logger.debug(
-        `[claude-code] Error during doGenerate: ${error instanceof Error ? error.message : String(error)}`
-      );
-      if (isAbortError(error)) {
-        this.logger.debug("[claude-code] Request aborted by user");
-        throw options.abortSignal?.aborted ? options.abortSignal.reason : error;
-      }
-      if (isClaudeCodeTruncationError(error, text)) {
-        this.logger.warn(
-          `[claude-code] Detected truncated response, returning ${text.length} characters of buffered text`
-        );
-        wasTruncated = true;
-        finishReason = "length";
-        warnings.push({
-          type: "other",
-          message: CLAUDE_CODE_TRUNCATION_WARNING
-        });
-      } else {
-        throw this.handleClaudeCodeError(error, messagesPrompt);
-      }
-    } finally {
-      if (options.abortSignal && abortListener) {
-        options.abortSignal.removeEventListener("abort", abortListener);
-      }
-    }
-    if (options.responseFormat?.type === "json" && text) {
-      text = this.handleJsonExtraction(text, warnings);
-    }
-    return {
-      content: [{ type: "text", text }],
-      usage,
-      finishReason,
-      warnings,
-      response: {
-        id: generateId(),
-        timestamp: /* @__PURE__ */ new Date(),
-        modelId: this.modelId
-      },
-      request: {
-        body: messagesPrompt
-      },
-      providerMetadata: {
-        "claude-code": {
-          ...this.sessionId !== void 0 && { sessionId: this.sessionId },
-          ...costUsd !== void 0 && { costUsd },
-          ...durationMs !== void 0 && { durationMs },
-          ...rawUsage !== void 0 && { rawUsage },
-          ...wasTruncated && { truncated: true }
-        }
-      }
-    };
-  }
-  async doStream(options) {
-    this.logger.debug(`[claude-code] Starting doStream request with model: ${this.modelId}`);
-    const mode = options.responseFormat?.type === "json" ? { type: "object-json" } : { type: "regular" };
-    this.logger.debug(
-      `[claude-code] Stream mode: ${mode.type}, response format: ${options.responseFormat?.type ?? "none"}`
-    );
-    const {
-      messagesPrompt,
-      warnings: messageWarnings,
-      streamingContentParts,
-      hasImageParts
-    } = convertToClaudeCodeMessages(
-      options.prompt,
-      mode,
-      options.responseFormat?.type === "json" ? options.responseFormat.schema : void 0
-    );
-    this.logger.debug(
-      `[claude-code] Converted ${options.prompt.length} messages for streaming, hasImageParts: ${hasImageParts}`
-    );
-    const abortController = new AbortController();
-    let abortListener;
-    if (options.abortSignal?.aborted) {
-      abortController.abort(options.abortSignal.reason);
-    } else if (options.abortSignal) {
-      abortListener = () => abortController.abort(options.abortSignal?.reason);
-      options.abortSignal.addEventListener("abort", abortListener, { once: true });
-    }
-    const queryOptions = this.createQueryOptions(abortController);
-    const warnings = this.generateAllWarnings(
-      options,
-      messagesPrompt
-    );
-    if (messageWarnings) {
-      messageWarnings.forEach((warning) => {
-        warnings.push({
-          type: "other",
-          message: warning
-        });
-      });
-    }
-    const modeSetting = this.settings.streamingInput ?? "auto";
-    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!this.settings.canUseTool;
-    if (!wantsStreamInput && hasImageParts) {
-      warnings.push({
-        type: "other",
-        message: STREAMING_FEATURE_WARNING
-      });
-    }
-    const stream = new ReadableStream({
-      start: async (controller) => {
-        let done = () => {
-        };
-        const outputStreamEnded = new Promise((resolve) => {
-          done = () => resolve(void 0);
-        });
-        const toolStates = /* @__PURE__ */ new Map();
-        const streamWarnings = [];
-        const closeToolInput = (toolId, state) => {
-          if (!state.inputClosed && state.inputStarted) {
-            controller.enqueue({
-              type: "tool-input-end",
-              id: toolId
-            });
-            state.inputClosed = true;
-          }
-        };
-        const emitToolCall = (toolId, state) => {
-          if (state.callEmitted) {
-            return;
-          }
-          closeToolInput(toolId, state);
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId: toolId,
-            toolName: state.name,
-            input: state.lastSerializedInput ?? "",
-            providerExecuted: true,
-            dynamic: true,
-            // V3 field: indicates tool is provider-defined (not in user's tools map)
-            providerMetadata: {
-              "claude-code": {
-                // rawInput preserves the original serialized format before AI SDK normalization.
-                // Use this if you need the exact string sent to the Claude CLI, which may differ
-                // from the `input` field after AI SDK processing.
-                rawInput: state.lastSerializedInput ?? ""
-              }
-            }
-          });
-          state.callEmitted = true;
-        };
-        const finalizeToolCalls = () => {
-          for (const [toolId, state] of toolStates) {
-            emitToolCall(toolId, state);
-          }
-          toolStates.clear();
-        };
-        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-        let accumulatedText = "";
-        let textPartId;
-        try {
-          controller.enqueue({ type: "stream-start", warnings });
-          if (this.settings.canUseTool && this.settings.permissionPromptToolName) {
-            throw new Error(
-              "canUseTool requires streamingInput mode ('auto' or 'always') and cannot be used with permissionPromptToolName (SDK constraint). Set streamingInput: 'auto' (or 'always') and remove permissionPromptToolName, or remove canUseTool."
-            );
-          }
-          const sdkPrompt = wantsStreamInput ? toAsyncIterablePrompt(
-            messagesPrompt,
-            outputStreamEnded,
-            this.settings.resume ?? this.sessionId,
-            streamingContentParts
-          ) : messagesPrompt;
-          this.logger.debug(
-            `[claude-code] Starting stream query with streamingInput: ${wantsStreamInput}, session: ${this.settings.resume ?? this.sessionId ?? "new"}`
-          );
-          const response = this.queryFn({
-            prompt: sdkPrompt,
-            options: queryOptions
-          });
-          for await (const message of response) {
-            this.logger.debug(`[claude-code] Stream received message type: ${message.type}`);
-            if (message.type === "assistant") {
-              if (!message.message?.content) {
-                this.logger.warn(
-                  `[claude-code] Unexpected assistant message structure: missing content field. Message type: ${message.type}. This may indicate an SDK protocol violation.`
-                );
-                continue;
-              }
-              const content = message.message.content;
-              for (const tool3 of this.extractToolUses(content)) {
-                const toolId = tool3.id;
-                let state = toolStates.get(toolId);
-                if (!state) {
-                  state = {
-                    name: tool3.name,
-                    inputStarted: false,
-                    inputClosed: false,
-                    callEmitted: false
-                  };
-                  toolStates.set(toolId, state);
-                  this.logger.debug(
-                    `[claude-code] New tool use detected - Tool: ${tool3.name}, ID: ${toolId}`
-                  );
-                }
-                state.name = tool3.name;
-                if (!state.inputStarted) {
-                  this.logger.debug(
-                    `[claude-code] Tool input started - Tool: ${tool3.name}, ID: ${toolId}`
-                  );
-                  controller.enqueue({
-                    type: "tool-input-start",
-                    id: toolId,
-                    toolName: tool3.name,
-                    providerExecuted: true,
-                    dynamic: true
-                    // V3 field: indicates tool is provider-defined
-                  });
-                  state.inputStarted = true;
-                }
-                const serializedInput = this.serializeToolInput(tool3.input);
-                if (serializedInput) {
-                  let deltaPayload = "";
-                  if (state.lastSerializedInput === void 0) {
-                    if (serializedInput.length <= _ClaudeCodeLanguageModel.MAX_DELTA_CALC_SIZE) {
-                      deltaPayload = serializedInput;
-                    }
-                  } else if (serializedInput.length <= _ClaudeCodeLanguageModel.MAX_DELTA_CALC_SIZE && state.lastSerializedInput.length <= _ClaudeCodeLanguageModel.MAX_DELTA_CALC_SIZE && serializedInput.startsWith(state.lastSerializedInput)) {
-                    deltaPayload = serializedInput.slice(state.lastSerializedInput.length);
-                  } else if (serializedInput !== state.lastSerializedInput) {
-                    deltaPayload = "";
-                  }
-                  if (deltaPayload) {
-                    controller.enqueue({
-                      type: "tool-input-delta",
-                      id: toolId,
-                      delta: deltaPayload
-                    });
-                  }
-                  state.lastSerializedInput = serializedInput;
-                }
-              }
-              const text = content.map((c) => c.type === "text" ? c.text : "").join("");
-              if (text) {
-                accumulatedText += text;
-                if (options.responseFormat?.type !== "json") {
-                  if (!textPartId) {
-                    textPartId = generateId();
-                    controller.enqueue({
-                      type: "text-start",
-                      id: textPartId
-                    });
-                  }
-                  controller.enqueue({
-                    type: "text-delta",
-                    id: textPartId,
-                    delta: text
-                  });
-                }
-              }
-            } else if (message.type === "user") {
-              if (!message.message?.content) {
-                this.logger.warn(
-                  `[claude-code] Unexpected user message structure: missing content field. Message type: ${message.type}. This may indicate an SDK protocol violation.`
-                );
-                continue;
-              }
-              const content = message.message.content;
-              for (const result of this.extractToolResults(content)) {
-                let state = toolStates.get(result.id);
-                const toolName = result.name ?? state?.name ?? _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
-                this.logger.debug(
-                  `[claude-code] Tool result received - Tool: ${toolName}, ID: ${result.id}`
-                );
-                if (!state) {
-                  this.logger.warn(
-                    `[claude-code] Received tool result for unknown tool ID: ${result.id}`
-                  );
-                  state = {
-                    name: toolName,
-                    inputStarted: false,
-                    inputClosed: false,
-                    callEmitted: false
-                  };
-                  toolStates.set(result.id, state);
-                  if (!state.inputStarted) {
-                    controller.enqueue({
-                      type: "tool-input-start",
-                      id: result.id,
-                      toolName,
-                      providerExecuted: true,
-                      dynamic: true
-                      // V3 field: indicates tool is provider-defined
-                    });
-                    state.inputStarted = true;
-                  }
-                  if (!state.inputClosed) {
-                    controller.enqueue({
-                      type: "tool-input-end",
-                      id: result.id
-                    });
-                    state.inputClosed = true;
-                  }
-                }
-                state.name = toolName;
-                const normalizedResult = this.normalizeToolResult(result.result);
-                const rawResult = typeof result.result === "string" ? result.result : (() => {
-                  try {
-                    return JSON.stringify(result.result);
-                  } catch {
-                    return String(result.result);
-                  }
-                })();
-                emitToolCall(result.id, state);
-                controller.enqueue({
-                  type: "tool-result",
-                  toolCallId: result.id,
-                  toolName,
-                  result: normalizedResult,
-                  isError: result.isError,
-                  providerExecuted: true,
-                  dynamic: true,
-                  // V3 field: indicates tool is provider-defined
-                  providerMetadata: {
-                    "claude-code": {
-                      // rawResult preserves the original CLI output string before JSON parsing.
-                      // Use this when you need the exact string returned by the tool, especially
-                      // if the `result` field has been parsed/normalized and you need the original format.
-                      rawResult
-                    }
-                  }
-                });
-              }
-              for (const error of this.extractToolErrors(content)) {
-                let state = toolStates.get(error.id);
-                const toolName = error.name ?? state?.name ?? _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
-                this.logger.debug(
-                  `[claude-code] Tool error received - Tool: ${toolName}, ID: ${error.id}`
-                );
-                if (!state) {
-                  this.logger.warn(
-                    `[claude-code] Received tool error for unknown tool ID: ${error.id}`
-                  );
-                  state = {
-                    name: toolName,
-                    inputStarted: true,
-                    inputClosed: true,
-                    callEmitted: false
-                  };
-                  toolStates.set(error.id, state);
-                }
-                emitToolCall(error.id, state);
-                const rawError = typeof error.error === "string" ? error.error : typeof error.error === "object" && error.error !== null ? (() => {
-                  try {
-                    return JSON.stringify(error.error);
-                  } catch {
-                    return String(error.error);
-                  }
-                })() : String(error.error);
-                controller.enqueue({
-                  type: "tool-error",
-                  toolCallId: error.id,
-                  toolName,
-                  error: rawError,
-                  providerExecuted: true,
-                  dynamic: true,
-                  // V3 field: indicates tool is provider-defined
-                  providerMetadata: {
-                    "claude-code": {
-                      rawError
-                    }
-                  }
-                });
-              }
-            } else if (message.type === "result") {
-              done();
-              this.logger.info(
-                `[claude-code] Stream completed - Session: ${message.session_id}, Cost: $${message.total_cost_usd?.toFixed(4) ?? "N/A"}, Duration: ${message.duration_ms ?? "N/A"}ms`
-              );
-              let rawUsage;
-              if ("usage" in message) {
-                rawUsage = message.usage;
-                usage = {
-                  inputTokens: (message.usage.cache_creation_input_tokens ?? 0) + (message.usage.cache_read_input_tokens ?? 0) + (message.usage.input_tokens ?? 0),
-                  outputTokens: message.usage.output_tokens ?? 0,
-                  totalTokens: (message.usage.cache_creation_input_tokens ?? 0) + (message.usage.cache_read_input_tokens ?? 0) + (message.usage.input_tokens ?? 0) + (message.usage.output_tokens ?? 0)
-                };
-                this.logger.debug(
-                  `[claude-code] Stream token usage - Input: ${usage.inputTokens}, Output: ${usage.outputTokens}, Total: ${usage.totalTokens}`
-                );
-              }
-              const finishReason = mapClaudeCodeFinishReason(
-                message.subtype
-              );
-              this.logger.debug(`[claude-code] Stream finish reason: ${finishReason}`);
-              this.setSessionId(message.session_id);
-              if (options.responseFormat?.type === "json" && accumulatedText) {
-                const extractedJson = this.handleJsonExtraction(accumulatedText, streamWarnings);
-                const jsonTextId = generateId();
-                controller.enqueue({
-                  type: "text-start",
-                  id: jsonTextId
-                });
-                controller.enqueue({
-                  type: "text-delta",
-                  id: jsonTextId,
-                  delta: extractedJson
-                });
-                controller.enqueue({
-                  type: "text-end",
-                  id: jsonTextId
-                });
-              } else if (textPartId) {
-                controller.enqueue({
-                  type: "text-end",
-                  id: textPartId
-                });
-              }
-              finalizeToolCalls();
-              const warningsJson = this.serializeWarningsForMetadata(streamWarnings);
-              controller.enqueue({
-                type: "finish",
-                finishReason,
-                usage,
-                providerMetadata: {
-                  "claude-code": {
-                    sessionId: message.session_id,
-                    ...message.total_cost_usd !== void 0 && {
-                      costUsd: message.total_cost_usd
-                    },
-                    ...message.duration_ms !== void 0 && { durationMs: message.duration_ms },
-                    ...rawUsage !== void 0 && { rawUsage },
-                    // JSON validation warnings are collected during streaming and included
-                    // in providerMetadata since the AI SDK's finish event doesn't support
-                    // a top-level warnings field (unlike stream-start which was already emitted)
-                    ...streamWarnings.length > 0 && {
-                      warnings: warningsJson
-                    }
-                  }
-                }
-              });
-            } else if (message.type === "system" && message.subtype === "init") {
-              this.setSessionId(message.session_id);
-              this.logger.info(`[claude-code] Stream session initialized: ${message.session_id}`);
-              controller.enqueue({
-                type: "response-metadata",
-                id: message.session_id,
-                timestamp: /* @__PURE__ */ new Date(),
-                modelId: this.modelId
-              });
-            }
-          }
-          finalizeToolCalls();
-          this.logger.debug("[claude-code] Stream finalized, closing stream");
-          controller.close();
-        } catch (error) {
-          done();
-          this.logger.debug(
-            `[claude-code] Error during doStream: ${error instanceof Error ? error.message : String(error)}`
-          );
-          if (isClaudeCodeTruncationError(error, accumulatedText)) {
-            this.logger.warn(
-              `[claude-code] Detected truncated stream response, returning ${accumulatedText.length} characters of buffered text`
-            );
-            const truncationWarning = {
-              type: "other",
-              message: CLAUDE_CODE_TRUNCATION_WARNING
-            };
-            streamWarnings.push(truncationWarning);
-            const emitJsonText = () => {
-              const extractedJson = this.handleJsonExtraction(accumulatedText, streamWarnings);
-              const jsonTextId = generateId();
-              controller.enqueue({
-                type: "text-start",
-                id: jsonTextId
-              });
-              controller.enqueue({
-                type: "text-delta",
-                id: jsonTextId,
-                delta: extractedJson
-              });
-              controller.enqueue({
-                type: "text-end",
-                id: jsonTextId
-              });
-            };
-            if (options.responseFormat?.type === "json") {
-              emitJsonText();
-            } else if (textPartId) {
-              controller.enqueue({
-                type: "text-end",
-                id: textPartId
-              });
-            } else if (accumulatedText) {
-              const fallbackTextId = generateId();
-              controller.enqueue({
-                type: "text-start",
-                id: fallbackTextId
-              });
-              controller.enqueue({
-                type: "text-delta",
-                id: fallbackTextId,
-                delta: accumulatedText
-              });
-              controller.enqueue({
-                type: "text-end",
-                id: fallbackTextId
-              });
-            }
-            finalizeToolCalls();
-            const warningsJson = this.serializeWarningsForMetadata(streamWarnings);
-            controller.enqueue({
-              type: "finish",
-              finishReason: "length",
-              usage,
-              providerMetadata: {
-                "claude-code": {
-                  ...this.sessionId !== void 0 && { sessionId: this.sessionId },
-                  truncated: true,
-                  ...streamWarnings.length > 0 && {
-                    warnings: warningsJson
-                  }
-                }
-              }
-            });
-            controller.close();
-            return;
-          }
-          finalizeToolCalls();
-          let errorToEmit;
-          if (isAbortError(error)) {
-            errorToEmit = options.abortSignal?.aborted ? options.abortSignal.reason : error;
-          } else {
-            errorToEmit = this.handleClaudeCodeError(error, messagesPrompt);
-          }
-          controller.enqueue({
-            type: "error",
-            error: errorToEmit
-          });
-          controller.close();
-        } finally {
-          if (options.abortSignal && abortListener) {
-            options.abortSignal.removeEventListener("abort", abortListener);
-          }
-        }
-      },
-      cancel: () => {
-        if (options.abortSignal && abortListener) {
-          options.abortSignal.removeEventListener("abort", abortListener);
-        }
-      }
-    });
-    return {
-      stream,
-      request: {
-        body: messagesPrompt
-      }
-    };
-  }
-  serializeWarningsForMetadata(warnings) {
-    const result = warnings.map((w) => {
-      const base = { type: w.type };
-      if ("message" in w) {
-        const m = w.message;
-        if (m !== void 0) base.message = String(m);
-      }
-      if (w.type === "unsupported-setting") {
-        const setting = w.setting;
-        if (setting !== void 0) base.setting = String(setting);
-        if ("details" in w) {
-          const d = w.details;
-          if (d !== void 0) base.details = String(d);
-        }
-      }
-      return base;
-    });
-    return result;
-  }
-};
-
-// src/claude-code-provider.ts
-function createClaudeCode(options = {}) {
-  const logger = getLogger(options.defaultSettings?.logger);
-  if (options.defaultSettings) {
-    const validation = validateSettings(options.defaultSettings);
-    if (!validation.valid) {
-      throw new Error(`Invalid default settings: ${validation.errors.join(", ")}`);
-    }
-    if (validation.warnings.length > 0) {
-      validation.warnings.forEach((warning) => logger.warn(`Claude Code Provider: ${warning}`));
-    }
-  }
-  const createModel = (modelId, settings = {}) => {
-    const mergedSettings = {
-      ...options.defaultSettings,
-      ...settings
-    };
-    const validation = validateSettings(mergedSettings);
-    if (!validation.valid) {
-      throw new Error(`Invalid settings: ${validation.errors.join(", ")}`);
-    }
-    return new ClaudeCodeLanguageModel({
-      id: modelId,
-      settings: mergedSettings,
-      settingsValidationWarnings: validation.warnings
-    });
-  };
-  const provider = function(modelId, settings) {
-    if (new.target) {
-      throw new Error("The Claude Code model function cannot be called with the new keyword.");
-    }
-    return createModel(modelId, settings);
-  };
-  provider.languageModel = createModel;
-  provider.chat = createModel;
-  provider.textEmbeddingModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "textEmbeddingModel"
-    });
-  };
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "imageModel"
-    });
-  };
-  return provider;
-}
-var claudeCode = createClaudeCode();
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { readFile } from 'fs/promises';
+import * as path from 'path';
+import { join } from 'path';
+import WebSocket$1, { WebSocketServer, WebSocket } from 'ws';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import pg from 'pg';
+import { pgTable, timestamp, boolean, text, uuid, index, uniqueIndex, integer, jsonb } from 'drizzle-orm/pg-core';
+import { sql, eq, and, desc, isNull } from 'drizzle-orm';
+import { randomUUID, createHash } from 'crypto';
+import { migrate } from 'drizzle-orm/node-postgres/migrator';
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import os$1, { homedir } from 'node:os';
+import { randomUUID as randomUUID$1 } from 'node:crypto';
+import express from 'express';
+import { createServer, createConnection } from 'node:net';
+import { readFile as readFile$1, rm, writeFile, readdir } from 'node:fs/promises';
+import { simpleGit } from 'simple-git';
+import * as os from 'os';
+import { existsSync as existsSync$1, mkdirSync as mkdirSync$1 } from 'fs';
+import { tunnelManager } from './chunks/manager-CvGX9qqe.js';
+import 'chalk';
+import 'http';
+import 'http-proxy';
+import 'zlib';
 
 /**
  * Creates a permission handler that restricts Claude to a specific project directory
@@ -2168,7 +202,8 @@ var init_tags$1 = __esm$1({
             description: "Anthropic Claude - Balanced performance and speed",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-sonnet-4-5"
+            model: "claude-sonnet-4-5",
+            sdk: "agent"
           },
           {
             value: "claude-opus-4-5",
@@ -2176,7 +211,8 @@ var init_tags$1 = __esm$1({
             description: "Anthropic Claude - Most capable for complex tasks",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-opus-4-5"
+            model: "claude-opus-4-5",
+            sdk: "agent"
           },
           {
             value: "claude-haiku-4-5",
@@ -2184,7 +220,8 @@ var init_tags$1 = __esm$1({
             description: "Anthropic Claude - Fastest, good for iterations",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-haiku-4-5"
+            model: "claude-haiku-4-5",
+            sdk: "agent"
           },
           {
             value: "gpt-5.2-codex",
@@ -2192,7 +229,35 @@ var init_tags$1 = __esm$1({
             description: "OpenAI Codex - Advanced code generation",
             logo: "/openai.png",
             provider: "openai-codex",
-            model: "openai/gpt-5.2-codex"
+            model: "openai/gpt-5.2-codex",
+            sdk: "agent"
+          },
+          {
+            value: "factory-droid-opus",
+            label: "Factory Droid (Opus)",
+            description: "Factory Droid SDK with Claude Opus 4.5",
+            logo: "/factory.svg",
+            provider: "factory-droid",
+            model: "claude-opus-4-5-20251101",
+            sdk: "droid"
+          },
+          {
+            value: "factory-droid-codex",
+            label: "Factory Droid (Codex)",
+            description: "Factory Droid SDK with GPT-5.2 Codex",
+            logo: "/factory.svg",
+            provider: "factory-droid",
+            model: "gpt-5.2-codex",
+            sdk: "droid"
+          },
+          {
+            value: "factory-droid-glm",
+            label: "Factory Droid (GLM)",
+            description: "Factory Droid SDK with GLM 4.7",
+            logo: "/factory.svg",
+            provider: "factory-droid",
+            model: "glm-4.7",
+            sdk: "droid"
           }
         ]
       },
@@ -3235,6 +1300,94 @@ var init_codex_strategy$1 = __esm$1({
   }
 });
 
+// src/lib/agents/droid-strategy.ts
+var droid_strategy_exports$1 = {};
+__export$1(droid_strategy_exports$1, {
+  default: () => droid_strategy_default$1
+});
+function buildDroidSections$1(context) {
+  const sections = [];
+  if (context.tags && context.tags.length > 0) {
+    const resolved = resolveTags$1(context.tags);
+    const tagPrompt = generatePromptFromTags$1(resolved, context.projectName, context.isNewProject);
+    if (tagPrompt) {
+      sections.push(tagPrompt);
+    }
+  }
+  if (context.isNewProject) {
+    sections.push(`## New Project Setup
+
+- Project name: ${context.projectName}
+- Location: ${context.workingDirectory}
+- Operation type: ${context.operationType}
+
+The template has already been downloaded. Install dependencies and customize the scaffold to satisfy the request.`);
+  } else {
+    let existingProjectSection = `## Existing Project Context
+
+- Project location: ${context.workingDirectory}
+- Operation type: ${context.operationType}
+
+Review the current codebase and apply the requested changes without re-scaffolding.`;
+    if (context.conversationHistory && context.conversationHistory.length > 0) {
+      existingProjectSection += `
+
+**Recent Conversation History:**
+`;
+      context.conversationHistory.forEach((msg, index2) => {
+        const roleLabel = msg.role === "user" ? "User" : "Assistant";
+        const content = msg.content.length > 500 ? msg.content.substring(0, 500) + "...[truncated]" : msg.content;
+        existingProjectSection += `${index2 + 1}. ${roleLabel}:
+${content}
+
+`;
+      });
+    }
+    sections.push(existingProjectSection);
+  }
+  sections.push(`## Workspace Rules
+- Use relative paths within the project.
+- Work inside the existing project structure.
+- Provide complete file contents without placeholders.`);
+  if (context.fileTree) {
+    sections.push(`## Project Structure
+${context.fileTree}`);
+  }
+  if (context.templateName) {
+    sections.push(`## Template
+- Name: ${context.templateName}
+- Framework: ${context.templateFramework ?? "unknown"}`);
+  }
+  return sections;
+}
+function buildFullPrompt3$1(context, basePrompt) {
+  if (!context.isNewProject) {
+    return basePrompt;
+  }
+  return `${basePrompt}
+
+CRITICAL: The template has already been prepared in ${context.workingDirectory}. Do not scaffold a new project.`;
+}
+var droidStrategy$1, droid_strategy_default$1;
+var init_droid_strategy$1 = __esm$1({
+  "src/lib/agents/droid-strategy.ts"() {
+    init_resolver$1();
+    droidStrategy$1 = {
+      buildSystemPromptSections: buildDroidSections$1,
+      buildFullPrompt: buildFullPrompt3$1,
+      shouldDownloadTemplate(context) {
+        return context.isNewProject && !context.skipTemplates;
+      },
+      postTemplateSelected(context, template) {
+        context.templateName = template.name;
+        context.templateFramework = template.framework;
+        context.fileTree = template.fileTree;
+      }
+    };
+    droid_strategy_default$1 = droidStrategy$1;
+  }
+});
+
 // src/lib/prompts.ts
 var CLAUDE_SYSTEM_PROMPT = `You are an elite coding assistant specialized in building visually stunning, production-ready JavaScript applications.
 
@@ -4065,12 +2218,18 @@ async function ensureRegistry$1() {
   if (initialized$1) {
     return;
   }
-  const [{ default: claudeStrategy2 }, { default: codexStrategy2 }] = await Promise.all([
+  const [
+    { default: claudeStrategy2 },
+    { default: codexStrategy2 },
+    { default: droidStrategy2 }
+  ] = await Promise.all([
     Promise.resolve().then(() => (init_claude_strategy$1(), claude_strategy_exports$1)),
-    Promise.resolve().then(() => (init_codex_strategy$1(), codex_strategy_exports$1))
+    Promise.resolve().then(() => (init_codex_strategy$1(), codex_strategy_exports$1)),
+    Promise.resolve().then(() => (init_droid_strategy$1(), droid_strategy_exports$1))
   ]);
   registerAgentStrategy$1("claude-code", claudeStrategy2);
   registerAgentStrategy$1("openai-codex", codexStrategy2);
+  registerAgentStrategy$1("factory-droid", droidStrategy2);
   initialized$1 = true;
 }
 async function resolveAgentStrategy$1(agentId) {
@@ -4133,7 +2292,7 @@ var BuildLogger$1 = class BuildLogger {
     if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
       try {
         if (level === "warn" || level === "error") {
-          addBreadcrumb({
+          Sentry.addBreadcrumb({
             category: `build-logger.${context}`,
             message,
             level: level === "error" ? "error" : "warning",
@@ -5605,7 +3764,7 @@ var BuildWebSocketServer = class {
       pingInterval,
       userId: runnerUserId
     });
-    addBreadcrumb({
+    Sentry.addBreadcrumb({
       category: "websocket",
       message: `Runner connected: ${runnerId}`,
       level: "info"
@@ -5639,7 +3798,7 @@ var BuildWebSocketServer = class {
         }
       } catch (error) {
         this.runnerTotalErrors++;
-        captureException(error, {
+        Sentry.captureException(error, {
           tags: { runnerId, source: "websocket_message" },
           level: "error"
         });
@@ -5656,7 +3815,7 @@ var BuildWebSocketServer = class {
       httpProxyManager.cancelRequestsForRunner(runnerId);
       hmrProxyManager$1.disconnectRunner(runnerId);
       this.cleanupRunnerProcesses(runnerId);
-      addBreadcrumb({
+      Sentry.addBreadcrumb({
         category: "websocket",
         message: `Runner disconnected: ${runnerId}`,
         level: "info",
@@ -5666,7 +3825,7 @@ var BuildWebSocketServer = class {
     ws.on("error", (error) => {
       buildLogger$2.websocket.error("Runner socket error", error, { runnerId });
       this.runnerTotalErrors++;
-      captureException(error, {
+      Sentry.captureException(error, {
         tags: { runnerId, source: "websocket_error" },
         level: "error"
       });
@@ -5707,10 +3866,10 @@ var BuildWebSocketServer = class {
       return false;
     }
     try {
-      const activeSpan = getActiveSpan();
+      const activeSpan = Sentry.getActiveSpan();
       const hasTrace = !!activeSpan;
       if (activeSpan) {
-        const traceData = getTraceData();
+        const traceData = Sentry.getTraceData();
         if (traceData["sentry-trace"]) {
           command._sentry = {
             trace: traceData["sentry-trace"],
@@ -5727,7 +3886,7 @@ var BuildWebSocketServer = class {
       return true;
     } catch (error) {
       this.runnerTotalErrors++;
-      captureException(error, {
+      Sentry.captureException(error, {
         tags: { runnerId, commandType: command.type },
         level: "error"
       });
@@ -5793,7 +3952,7 @@ var BuildWebSocketServer = class {
     for (const [runnerId, conn] of this.runnerConnections.entries()) {
       if (now - conn.lastHeartbeat > this.RUNNER_HEARTBEAT_TIMEOUT) {
         buildLogger$2.websocket.runnerStaleRemoved(runnerId);
-        addBreadcrumb({
+        Sentry.addBreadcrumb({
           category: "websocket",
           message: `Stale runner connection removed: ${runnerId}`,
           level: "warning",
@@ -5836,7 +3995,7 @@ var BuildWebSocketServer = class {
         runnerId,
         projectIds
       });
-      addBreadcrumb({
+      Sentry.addBreadcrumb({
         category: "websocket",
         message: `Cleaned up processes for disconnected runner`,
         level: "info",
@@ -5851,7 +4010,7 @@ var BuildWebSocketServer = class {
       }
     } catch (error) {
       buildLogger$2.websocket.error("Failed to cleanup runner processes", error, { runnerId });
-      captureException(error, {
+      Sentry.captureException(error, {
         tags: { runnerId, source: "runner_cleanup" },
         level: "error"
       });
@@ -6002,10 +4161,10 @@ var BuildWebSocketServer = class {
         updates: []
       });
     }
-    const activeSpan = getActiveSpan();
+    const activeSpan = Sentry.getActiveSpan();
     const traceContext = activeSpan ? {
-      trace: getTraceData()["sentry-trace"],
-      baggage: getTraceData().baggage
+      trace: Sentry.getTraceData()["sentry-trace"],
+      baggage: Sentry.getTraceData().baggage
     } : void 0;
     const batch = this.pendingUpdates.get(key);
     batch.updates.push({
@@ -6037,10 +4196,10 @@ var BuildWebSocketServer = class {
         updates: []
       });
     }
-    const activeSpan = getActiveSpan();
+    const activeSpan = Sentry.getActiveSpan();
     const traceContext = activeSpan ? {
-      trace: getTraceData()["sentry-trace"],
-      baggage: getTraceData().baggage
+      trace: Sentry.getTraceData()["sentry-trace"],
+      baggage: Sentry.getTraceData().baggage
     } : void 0;
     const batch = this.pendingUpdates.get(key);
     batch.updates.push({
@@ -6483,41 +4642,41 @@ var AVAILABLE_ICONS = [
 ];
 
 var AgentCore = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AVAILABLE_ICONS: AVAILABLE_ICONS,
-  CLAUDE_SYSTEM_PROMPT: CLAUDE_SYSTEM_PROMPT,
-  CODEX_SYSTEM_PROMPT: CODEX_SYSTEM_PROMPT,
-  DEFAULT_AGENT_ID: DEFAULT_AGENT_ID,
-  DEFAULT_CLAUDE_MODEL_ID: DEFAULT_CLAUDE_MODEL_ID,
-  DEFAULT_OPENCODE_MODEL_ID: DEFAULT_OPENCODE_MODEL_ID,
-  GITHUB_CHAT_MESSAGES: GITHUB_CHAT_MESSAGES,
-  LEGACY_MODEL_MAP: LEGACY_MODEL_MAP,
-  MODEL_METADATA: MODEL_METADATA,
-  NEONDB_CHAT_MESSAGES: NEONDB_CHAT_MESSAGES,
-  ProjectMetadataSchema: ProjectMetadataSchema,
-  ProjectNamingSchema: ProjectNamingSchema,
-  TemplateAnalysisSchema: TemplateAnalysisSchema,
-  buildLogger: buildLogger$2,
-  buildWebSocketServer: buildWebSocketServer,
-  db: db,
-  getDb: getDb,
-  getModelLabel: getModelLabel,
-  initializeDatabase: initializeDatabase,
-  isRunnerCommand: isRunnerCommand,
-  isRunnerEvent: isRunnerEvent,
-  normalizeModelId: normalizeModelId,
-  parseModelId: parseModelId,
-  resetDatabase: resetDatabase,
-  resolveAgentStrategy: resolveAgentStrategy$1,
-  runMigrations: runMigrations,
-  setTemplatesPath: setTemplatesPath$1
+    __proto__: null,
+    AVAILABLE_ICONS: AVAILABLE_ICONS,
+    CLAUDE_SYSTEM_PROMPT: CLAUDE_SYSTEM_PROMPT,
+    CODEX_SYSTEM_PROMPT: CODEX_SYSTEM_PROMPT,
+    DEFAULT_AGENT_ID: DEFAULT_AGENT_ID,
+    DEFAULT_CLAUDE_MODEL_ID: DEFAULT_CLAUDE_MODEL_ID,
+    DEFAULT_OPENCODE_MODEL_ID: DEFAULT_OPENCODE_MODEL_ID,
+    GITHUB_CHAT_MESSAGES: GITHUB_CHAT_MESSAGES,
+    LEGACY_MODEL_MAP: LEGACY_MODEL_MAP,
+    MODEL_METADATA: MODEL_METADATA,
+    NEONDB_CHAT_MESSAGES: NEONDB_CHAT_MESSAGES,
+    ProjectMetadataSchema: ProjectMetadataSchema,
+    ProjectNamingSchema: ProjectNamingSchema,
+    TemplateAnalysisSchema: TemplateAnalysisSchema,
+    buildLogger: buildLogger$2,
+    buildWebSocketServer: buildWebSocketServer,
+    db: db,
+    getDb: getDb,
+    getModelLabel: getModelLabel,
+    initializeDatabase: initializeDatabase,
+    isRunnerCommand: isRunnerCommand,
+    isRunnerEvent: isRunnerEvent,
+    normalizeModelId: normalizeModelId,
+    parseModelId: parseModelId,
+    resetDatabase: resetDatabase,
+    resolveAgentStrategy: resolveAgentStrategy$1,
+    runMigrations: runMigrations,
+    setTemplatesPath: setTemplatesPath$1
 });
 
 /**
  * Native Claude Agent SDK Integration
  *
  * This is the default SDK integration for AI-powered builds.
- * For multi-provider support, set USE_OPENCODE_SDK=1 to use opencode-sdk.ts instead.
+ * For multi-provider support, set ENABLE_OPENCODE_SDK=true to use opencode-sdk.ts instead.
  *
  * This module provides direct integration with the official @anthropic-ai/claude-agent-sdk
  * without going through the AI SDK or community provider layers.
@@ -6661,7 +4820,7 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         }
         const appendedSystemPrompt = systemPromptSegments.join('\n\n');
         // Ensure working directory exists
-        if (!existsSync$1(workingDirectory)) {
+        if (!existsSync(workingDirectory)) {
             console.log(`[native-sdk] Creating working directory: ${workingDirectory}`);
             mkdirSync(workingDirectory, { recursive: true });
         }
@@ -6743,18 +4902,11 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         }
         catch (error) {
             debugLog$4(`[runner] [native-sdk] ❌ Error: ${error instanceof Error ? error.message : String(error)}\n`);
-            captureException(error);
+            Sentry.captureException(error);
             throw error;
         }
     };
 }
-/**
- * Feature flag to control which implementation to use
- *
- * Default: Native SDK is enabled (true)
- * Set USE_LEGACY_AI_SDK=1 to use the old AI SDK + community provider path
- */
-const USE_NATIVE_SDK = process.env.USE_LEGACY_AI_SDK !== '1';
 
 /**
  * OpenCode SDK Integration
@@ -6939,7 +5091,7 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
         debugLog$3(`[runner] [opencode-sdk] Working dir: ${workingDirectory}`);
         debugLog$3(`[runner] [opencode-sdk] Prompt length: ${prompt.length}`);
         // Ensure working directory exists
-        if (!existsSync$1(workingDirectory)) {
+        if (!existsSync(workingDirectory)) {
             console.log(`[opencode-sdk] Creating working directory: ${workingDirectory}`);
             mkdirSync(workingDirectory, { recursive: true });
         }
@@ -6963,7 +5115,7 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
         let sessionId = null;
         // Start Sentry AI agent span for the entire OpenCode query
         // This provides visibility into AI operations in Sentry's trace view
-        const aiSpan = startInactiveSpan({
+        const aiSpan = Sentry.startInactiveSpan({
             name: 'opencode.query',
             op: 'ai.pipeline',
             attributes: {
@@ -7102,193 +5254,566 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
                     }
                 }
             }
-            finally {
-                reader.releaseLock();
-            }
-            // Ensure prompt request completed
-            const promptResponse = await promptPromise;
-            if (!promptResponse.ok) {
-                const error = await promptResponse.text();
-                console.error(`[opencode-sdk] Prompt request failed: ${error}`);
+            finally {
+                reader.releaseLock();
+            }
+            // Ensure prompt request completed
+            const promptResponse = await promptPromise;
+            if (!promptResponse.ok) {
+                const error = await promptResponse.text();
+                console.error(`[opencode-sdk] Prompt request failed: ${error}`);
+            }
+            // Yield final result if not already done
+            if (!completed) {
+                yield {
+                    type: 'result',
+                    result: 'completed',
+                    session_id: sessionId ?? undefined,
+                    subtype: 'success',
+                };
+            }
+            debugLog$3('[runner] [opencode-sdk] Query complete');
+            // Update span with final metrics
+            aiSpan?.setAttribute('opencode.tool_calls', toolCallCount);
+            aiSpan?.setAttribute('opencode.messages', messageCount);
+            aiSpan?.setStatus({ code: 1 }); // OK status
+        }
+        catch (error) {
+            debugLog$3(`[runner] [opencode-sdk] Error: ${error instanceof Error ? error.message : String(error)}`);
+            Sentry.captureException(error);
+            // Mark span as errored
+            aiSpan?.setStatus({ code: 2, message: error instanceof Error ? error.message : String(error) });
+            // Yield error result
+            yield {
+                type: 'result',
+                result: error instanceof Error ? error.message : String(error),
+                session_id: sessionId || undefined,
+                subtype: 'error',
+            };
+            throw error;
+        }
+        finally {
+            // End the AI span
+            aiSpan?.end();
+        }
+    };
+}
+/**
+ * Feature flag to control which implementation to use
+ *
+ * Default: Claude Agent SDK (native)
+ * Set ENABLE_OPENCODE_SDK=true to enable OpenCode multi-provider support
+ * Note: OPENCODE_URL must also be set to the OpenCode service URL
+ */
+const ENABLE_OPENCODE_SDK = process.env.ENABLE_OPENCODE_SDK === 'true' && !!process.env.OPENCODE_URL;
+
+class JsonLineParser {
+    buffer = "";
+    parse(chunk) {
+        this.buffer += chunk;
+        const events = [];
+        const lines = this.buffer.split("\n");
+        // Keep the last incomplete line in buffer
+        this.buffer = lines.pop() || "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const event = JSON.parse(trimmed);
+                events.push(event);
+            }
+            catch {
+                // Skip malformed lines
+                console.error("[Parser] Failed to parse line:", trimmed.slice(0, 100));
+            }
+        }
+        return events;
+    }
+    flush() {
+        if (!this.buffer.trim())
+            return [];
+        try {
+            const event = JSON.parse(this.buffer);
+            this.buffer = "";
+            return [event];
+        }
+        catch {
+            this.buffer = "";
+            return [];
+        }
+    }
+    reset() {
+        this.buffer = "";
+    }
+}
+
+function findDroidPath() {
+    // Check common installation locations
+    const candidates = [
+        join$1(homedir(), ".local", "bin", "droid"),
+        join$1(homedir(), ".factory", "bin", "droid"),
+        "/usr/local/bin/droid",
+        "/opt/homebrew/bin/droid",
+        "droid", // Fall back to PATH lookup
+    ];
+    for (const candidate of candidates) {
+        if (candidate === "droid" || existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return "droid"; // Let it fail with a clear error if not found
+}
+class DroidSession extends EventEmitter {
+    parser = new JsonLineParser();
+    sessionId = null;
+    startTime = null;
+    options;
+    droidPath;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        this.droidPath = findDroidPath();
+        this.startTime = Date.now();
+    }
+    buildArgs(prompt, overrides) {
+        const args = ["exec", "--output-format", "stream-json"];
+        // Custom droid (must come before other flags)
+        if (overrides?.droid) {
+            args.push("--droid", overrides.droid);
+        }
+        if (this.options.autonomyLevel) {
+            args.push("--auto", this.options.autonomyLevel);
+        }
+        else {
+            args.push("--auto", "high");
+        }
+        // Model: override > fallback
+        const model = overrides?.model || this.options.model;
+        if (model) {
+            args.push("-m", model);
+        }
+        // Reasoning: override > fallback
+        const reasoning = overrides?.reasoningEffort || this.options.reasoningEffort;
+        if (reasoning) {
+            args.push("-r", reasoning);
+        }
+        // Spec mode
+        if (overrides?.useSpec) {
+            args.push("--use-spec");
+            if (overrides.specModel) {
+                args.push("--spec-model", overrides.specModel);
+            }
+            if (overrides.specReasoningEffort) {
+                args.push("--spec-reasoning-effort", overrides.specReasoningEffort);
+            }
+        }
+        // Tool controls: override > session defaults
+        const enabledTools = overrides?.enabledTools || this.options.enabledTools;
+        if (enabledTools?.length) {
+            args.push("--enabled-tools", enabledTools.join(","));
+        }
+        const disabledTools = overrides?.disabledTools || this.options.disabledTools;
+        if (disabledTools?.length) {
+            args.push("--disabled-tools", disabledTools.join(","));
+        }
+        // Use session-id for multi-turn conversation
+        if (this.sessionId) {
+            args.push("-s", this.sessionId);
+        }
+        // Prepend system prompt to the first message only (when no session exists yet)
+        let finalPrompt = prompt;
+        if (this.options.systemPrompt && !this.sessionId) {
+            finalPrompt = `${this.options.systemPrompt}\n\n---\n\nTask: ${prompt}`;
+        }
+        args.push(finalPrompt);
+        return args;
+    }
+    async *send(prompt, options) {
+        const args = this.buildArgs(prompt, options);
+        const cwd = this.options.cwd || process.cwd();
+        const effectiveModel = options?.model || this.options.model || "default";
+        const effectiveReasoning = options?.reasoningEffort || this.options.reasoningEffort || "default";
+        const extras = [];
+        if (options?.useSpec)
+            extras.push("spec");
+        if (options?.droid)
+            extras.push(`droid=${options.droid}`);
+        const extraInfo = extras.length ? ` [${extras.join(", ")}]` : "";
+        console.log(`[DroidSession] Running (model=${effectiveModel}, reasoning=${effectiveReasoning})${extraInfo}:`, this.droidPath, args.slice(0, 5).join(" "), "...");
+        const child = spawn(this.droidPath, args, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.parser.reset();
+        let finalResult = null;
+        let resolveNext = null;
+        const eventQueue = [];
+        const pushEvent = (event) => {
+            if (resolveNext) {
+                resolveNext(event);
+                resolveNext = null;
+            }
+            else {
+                eventQueue.push(event);
+            }
+        };
+        child.stdout?.on("data", (data) => {
+            const events = this.parser.parse(data.toString());
+            for (const event of events) {
+                // Capture session ID from init event
+                if (event.type === "system" && event.subtype === "init") {
+                    this.sessionId = event.session_id;
+                }
+                this.emit("event", event);
+                pushEvent(event);
+            }
+        });
+        child.stderr?.on("data", (data) => {
+            console.error("[DroidSession] stderr:", data.toString());
+        });
+        const processEnded = new Promise((resolve, reject) => {
+            child.on("close", (code) => {
+                // Flush any remaining data
+                const remaining = this.parser.flush();
+                for (const event of remaining) {
+                    pushEvent(event);
+                }
+                this.emit("close", code);
+                resolve();
+            });
+            child.on("error", (err) => {
+                console.error("[DroidSession] Process error:", err);
+                this.emit("error", err);
+                reject(err);
+            });
+        });
+        const nextEvent = () => {
+            if (eventQueue.length > 0) {
+                return Promise.resolve(eventQueue.shift());
+            }
+            return new Promise((resolve) => {
+                resolveNext = resolve;
+            });
+        };
+        // Yield events until completion
+        while (true) {
+            const event = await Promise.race([
+                nextEvent(),
+                processEnded.then(() => null),
+            ]);
+            if (!event) {
+                // Process ended without completion event
+                if (!finalResult) {
+                    throw new Error("Process ended without completion");
+                }
+                break;
+            }
+            yield event;
+            if (event.type === "completion") {
+                finalResult = {
+                    success: true,
+                    text: event.finalText,
+                    sessionId: event.session_id,
+                    numTurns: event.numTurns,
+                    durationMs: event.durationMs,
+                };
+                break;
+            }
+        }
+        return finalResult;
+    }
+    async close() {
+        this.sessionId = null;
+        this.startTime = null;
+        this.parser.reset();
+    }
+    isAlive() {
+        return this.sessionId !== null;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getUptime() {
+        if (!this.startTime)
+            return 0;
+        return Date.now() - this.startTime;
+    }
+    getModel() {
+        return this.options.model || "default";
+    }
+    getCwd() {
+        return this.options.cwd || process.cwd();
+    }
+    updateOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+}
+
+/**
+ * Factory Droid SDK Integration
+ *
+ * This module provides integration with the Factory Droid SDK (droid-sdk)
+ * for AI-powered builds. It wraps the DroidSession class and transforms
+ * DroidEvents into the standard TransformedMessage format used by the runner.
+ *
+ * Enable by setting agent to 'factory-droid' in build requests.
+ */
+const debugLog$2 = (message) => {
+    if (process.env.SILENT_MODE !== '1' && process.env.DEBUG_BUILD === '1') {
+        console.log(message);
+    }
+};
+/**
+ * Transform a DroidEvent to our internal TransformedMessage format
+ */
+function transformDroidEvent(event) {
+    switch (event.type) {
+        case 'system': {
+            // System init event - emit session info
+            if (event.subtype === 'init') {
+                return {
+                    type: 'system',
+                    subtype: 'init',
+                    session_id: event.session_id,
+                };
+            }
+            return null;
+        }
+        case 'message': {
+            // Message events from assistant
+            if (event.role === 'assistant') {
+                let text = event.text || '';
+                // Filter out TodoWrite JSON that might be embedded in message text
+                // The droid CLI sometimes echoes the todo list as JSON in its message
+                if (text.includes('[{"activeForm"') || text.includes('[{"content"')) {
+                    // Try to remove JSON array that looks like todos
+                    text = text.replace(/\[(\s*\{[^[\]]*"(activeForm|content|status)"[^[\]]*\}\s*,?\s*)+\]/g, '').trim();
+                }
+                // Skip empty messages after filtering
+                if (!text) {
+                    return null;
+                }
+                return {
+                    type: 'assistant',
+                    message: {
+                        id: event.id,
+                        content: [{ type: 'text', text }],
+                    },
+                };
+            }
+            return null;
+        }
+        case 'tool_call': {
+            // Tool call events - map to tool_use format
+            let input = event.parameters;
+            // Special handling for TodoWrite - droid CLI may send different formats,
+            // but UI expects array format: { todos: [{ content, status, activeForm? }] }
+            if (event.toolName === 'TodoWrite' && input) {
+                const rawInput = input;
+                // Case 1: todos is already an array (pass through with normalization)
+                if (Array.isArray(rawInput.todos)) {
+                    const normalizedTodos = rawInput.todos.map((item) => ({
+                        content: item.content || item.activeForm || 'Untitled task',
+                        status: item.status || 'pending',
+                        activeForm: item.activeForm,
+                    }));
+                    input = { todos: normalizedTodos };
+                    process.stderr.write(`[runner] [droid-sdk] TodoWrite: ${normalizedTodos.length} todos (already array)\n`);
+                }
+                // Case 2: todos is a string (needs parsing)
+                else if (typeof rawInput.todos === 'string') {
+                    const rawTodos = rawInput.todos;
+                    let parsedTodos = [];
+                    // Try to parse as JSON first (droid may send serialized array)
+                    const trimmed = rawTodos.trim();
+                    if (trimmed.startsWith('[')) {
+                        try {
+                            const jsonParsed = JSON.parse(trimmed);
+                            if (Array.isArray(jsonParsed)) {
+                                parsedTodos = jsonParsed.map((item) => ({
+                                    content: item.content || item.activeForm || 'Untitled task',
+                                    status: item.status || 'pending',
+                                    activeForm: item.activeForm,
+                                }));
+                                process.stderr.write(`[runner] [droid-sdk] TodoWrite: ${parsedTodos.length} todos parsed from JSON string\n`);
+                            }
+                        }
+                        catch {
+                            // Not valid JSON, fall through to line-by-line parsing
+                        }
+                    }
+                    // If JSON parsing didn't work, try numbered format: "1. [completed] Task"
+                    if (parsedTodos.length === 0) {
+                        const lines = rawTodos.split('\n').filter((l) => l.trim());
+                        parsedTodos = lines.map((line) => {
+                            const match = line.match(/^\d+\.\s*\[(\w+)\]\s*(.+)$/);
+                            if (match) {
+                                return {
+                                    content: match[2].trim(),
+                                    status: match[1].toLowerCase(),
+                                };
+                            }
+                            return {
+                                content: line.replace(/^\d+\.\s*/, '').trim(),
+                                status: 'pending',
+                            };
+                        });
+                        process.stderr.write(`[runner] [droid-sdk] TodoWrite: ${parsedTodos.length} todos parsed from numbered format\n`);
+                    }
+                    input = { todos: parsedTodos };
+                }
+            }
+            return {
+                type: 'assistant',
+                message: {
+                    id: event.messageId,
+                    content: [{
+                            type: 'tool_use',
+                            id: event.toolId,
+                            name: event.toolName,
+                            input,
+                        }],
+                },
+            };
+        }
+        case 'tool_result': {
+            // Tool result events - map to tool_result format
+            return {
+                type: 'user',
+                message: {
+                    id: event.messageId,
+                    content: [{
+                            type: 'tool_result',
+                            tool_use_id: event.toolId,
+                            content: event.value,
+                            is_error: event.isError,
+                        }],
+                },
+            };
+        }
+        case 'completion': {
+            // Completion event - final result
+            return {
+                type: 'result',
+                result: event.finalText,
+                session_id: event.session_id,
+                usage: {
+                    numTurns: event.numTurns,
+                    durationMs: event.durationMs,
+                },
+            };
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * Create a Factory Droid query function
+ *
+ * This implements the same BuildQueryFn interface as createNativeClaudeQuery
+ * but uses the Factory Droid SDK instead.
+ */
+function createDroidQuery(modelId) {
+    return async function* droidQuery(prompt, workingDirectory, systemPrompt, _agent, _codexThreadId, _messageParts) {
+        debugLog$2('[runner] [droid-sdk] Starting Factory Droid query');
+        debugLog$2(`[runner] [droid-sdk] Model: ${modelId || 'default'}`);
+        debugLog$2(`[runner] [droid-sdk] Working dir: ${workingDirectory}`);
+        debugLog$2(`[runner] [droid-sdk] Prompt length: ${prompt.length}`);
+        // Build combined system prompt
+        const systemPromptSegments = [CLAUDE_SYSTEM_PROMPT.trim()];
+        if (systemPrompt && systemPrompt.trim().length > 0) {
+            systemPromptSegments.push(systemPrompt.trim());
+        }
+        const combinedSystemPrompt = systemPromptSegments.join('\n\n');
+        // Ensure working directory exists
+        if (!existsSync(workingDirectory)) {
+            console.log(`[droid-sdk] Creating working directory: ${workingDirectory}`);
+            mkdirSync(workingDirectory, { recursive: true });
+        }
+        // Configure DroidSession options
+        const sessionOptions = {
+            model: modelId,
+            cwd: workingDirectory,
+            autonomyLevel: 'high',
+            systemPrompt: combinedSystemPrompt,
+        };
+        // Force log to stderr so it shows in TUI mode
+        process.stderr.write(`[runner] [droid-sdk] Creating DroidSession with model=${modelId || 'default'}, cwd=${workingDirectory}\n`);
+        const session = new DroidSession(sessionOptions);
+        // Listen for error events from the session (these bubble up from the child process)
+        session.on('error', (err) => {
+            process.stderr.write(`[runner] [droid-sdk] Session error event: ${err.message}\n`);
+            if (err.stack) {
+                process.stderr.write(`[runner] [droid-sdk] Stack: ${err.stack}\n`);
             }
-            // Yield final result if not already done
-            if (!completed) {
-                yield {
-                    type: 'result',
-                    result: 'completed',
-                    session_id: sessionId ?? undefined,
-                    subtype: 'success',
-                };
+        });
+        session.on('close', (code) => {
+            process.stderr.write(`[runner] [droid-sdk] Session closed with code: ${code}\n`);
+        });
+        let messageCount = 0;
+        let toolCallCount = 0;
+        let lastEventType = '';
+        try {
+            process.stderr.write(`[runner] [droid-sdk] Sending prompt to Droid (${prompt.length} chars)\n`);
+            // Stream events from the Droid SDK
+            for await (const event of session.send(prompt)) {
+                messageCount++;
+                lastEventType = event.type;
+                // Log every event type to track progress
+                if (event.type === 'tool_call') {
+                    toolCallCount++;
+                    process.stderr.write(`[runner] [droid-sdk] Event #${messageCount}: tool_call - ${event.toolName}\n`);
+                }
+                else if (event.type === 'tool_result') {
+                    const toolResult = event;
+                    const status = toolResult.isError ? 'ERROR' : 'OK';
+                    const preview = (toolResult.value || '').substring(0, 50);
+                    process.stderr.write(`[runner] [droid-sdk] Event #${messageCount}: tool_result [${status}] ${preview}...\n`);
+                }
+                else {
+                    process.stderr.write(`[runner] [droid-sdk] Event #${messageCount}: ${event.type}\n`);
+                }
+                // Transform Droid event to our internal format
+                const transformed = transformDroidEvent(event);
+                if (transformed) {
+                    yield transformed;
+                }
+                // Log completion
+                if (event.type === 'completion') {
+                    process.stderr.write(`[runner] [droid-sdk] ✅ Query complete - ${event.numTurns} turns, ${event.durationMs}ms\n`);
+                }
             }
-            debugLog$3('[runner] [opencode-sdk] Query complete');
-            // Update span with final metrics
-            aiSpan?.setAttribute('opencode.tool_calls', toolCallCount);
-            aiSpan?.setAttribute('opencode.messages', messageCount);
-            aiSpan?.setStatus({ code: 1 }); // OK status
+            process.stderr.write(`[runner] [droid-sdk] Stream finished - ${messageCount} events, ${toolCallCount} tool calls, last event: ${lastEventType}\n`);
         }
         catch (error) {
-            debugLog$3(`[runner] [opencode-sdk] Error: ${error instanceof Error ? error.message : String(error)}`);
-            captureException(error);
-            // Mark span as errored
-            aiSpan?.setStatus({ code: 2, message: error instanceof Error ? error.message : String(error) });
-            // Yield error result
-            yield {
-                type: 'result',
-                result: error instanceof Error ? error.message : String(error),
-                session_id: sessionId || undefined,
-                subtype: 'error',
-            };
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : '';
+            // Force write to stderr to bypass TUI silent mode
+            process.stderr.write(`\n[runner] [droid-sdk] ❌ Error: ${errorMessage}\n`);
+            process.stderr.write(`[runner] [droid-sdk] Stack: ${errorStack}\n`);
+            process.stderr.write(`[runner] [droid-sdk] Model: ${modelId || 'default'}\n`);
+            process.stderr.write(`[runner] [droid-sdk] Working dir: ${workingDirectory}\n`);
+            process.stderr.write(`[runner] [droid-sdk] Events received: ${messageCount}\n`);
+            process.stderr.write(`[runner] [droid-sdk] Tool calls: ${toolCallCount}\n`);
+            process.stderr.write(`[runner] [droid-sdk] Last event type: ${lastEventType}\n\n`);
+            Sentry.captureException(error, {
+                extra: {
+                    modelId,
+                    workingDirectory,
+                    promptLength: prompt.length,
+                    eventsReceived: messageCount,
+                    toolCalls: toolCallCount,
+                }
+            });
             throw error;
         }
         finally {
-            // End the AI span
-            aiSpan?.end();
+            // Cleanup session
+            await session.close();
         }
     };
 }
-/**
- * Feature flag to control which implementation to use
- *
- * Default: Claude Agent SDK (native)
- * Set USE_OPENCODE_SDK=1 to enable OpenCode multi-provider support
- * Note: OPENCODE_URL must also be set to the OpenCode service URL
- */
-const USE_OPENCODE_SDK = process.env.USE_OPENCODE_SDK === '1' && !!process.env.OPENCODE_URL;
-
-// src/lib/claude/tools.ts
-var genericInput = z.any();
-var genericObject = z.record(z.string(), z.any());
-var dynamicMcpTool = {
-  description: "Generic MCP tool passthrough",
-  type: "dynamic",
-  inputSchema: genericObject
-};
-var fallbackTool = {
-  description: "Fallback Claude CLI tool",
-  inputSchema: genericInput
-};
-var builtinTools = {
-  Agent: {
-    description: "Launches a nested Claude agent",
-    inputSchema: genericObject
-  },
-  Bash: {
-    description: "Execute shell commands via Claude CLI",
-    inputSchema: genericObject
-  },
-  BashOutput: {
-    description: "Fetch output from a background bash process",
-    inputSchema: genericObject
-  },
-  ExitPlanMode: {
-    description: "Exit plan/approval mode with a summary",
-    inputSchema: genericObject
-  },
-  Read: {
-    description: "Read file contents",
-    inputSchema: genericObject
-  },
-  Write: {
-    description: "Write entire file contents",
-    inputSchema: genericObject
-  },
-  Edit: {
-    description: "Edit part of a file by replacing text",
-    inputSchema: genericObject
-  },
-  Glob: {
-    description: "Match files using glob patterns",
-    inputSchema: genericObject
-  },
-  Grep: {
-    description: "Search files for a regex pattern",
-    inputSchema: genericObject
-  },
-  KillShell: {
-    description: "Stop a running bash session",
-    inputSchema: genericObject
-  },
-  ListMcpResources: {
-    description: "Enumerate MCP resources",
-    inputSchema: genericObject
-  },
-  Mcp: {
-    description: "Invoke an MCP tool",
-    inputSchema: genericObject
-  },
-  NotebookEdit: {
-    description: "Edit Jupyter notebooks",
-    inputSchema: genericObject
-  },
-  ReadMcpResource: {
-    description: "Read a particular MCP resource",
-    inputSchema: genericObject
-  },
-  TimeMachine: {
-    description: "Rewind conversation with a course correction",
-    inputSchema: genericObject
-  },
-  TodoWrite: {
-    description: "Emit TODO status updates",
-    inputSchema: genericObject
-  },
-  WebFetch: {
-    description: "Fetch and summarize a URL",
-    inputSchema: genericObject
-  },
-  WebSearch: {
-    description: "Search the web with constraints",
-    inputSchema: genericObject
-  },
-  MultipleChoiceQuestion: {
-    description: "Ask the user a multiple choice question",
-    inputSchema: genericObject
-  },
-  // Common aliases seen in telemetry/logs
-  LS: {
-    description: "List files in the working directory",
-    inputSchema: genericObject
-  },
-  TodoRead: {
-    description: "Read TODO state emitted from runner",
-    inputSchema: genericObject
-  }
-};
-var proxyHandler = {
-  get(target, prop) {
-    if (typeof prop !== "string") {
-      return Reflect.get(target, prop);
-    }
-    if (Reflect.has(target, prop)) {
-      return Reflect.get(target, prop);
-    }
-    if (prop.startsWith("mcp__")) {
-      return dynamicMcpTool;
-    }
-    return fallbackTool;
-  },
-  has(target, prop) {
-    if (typeof prop === "string") {
-      if (Reflect.has(target, prop) || prop.startsWith("mcp__")) {
-        return true;
-      }
-    }
-    return Reflect.has(target, prop);
-  },
-  ownKeys(target) {
-    return Reflect.ownKeys(target);
-  },
-  getOwnPropertyDescriptor(target, prop) {
-    if (Reflect.has(target, prop)) {
-      return Object.getOwnPropertyDescriptor(target, prop);
-    }
-    return void 0;
-  }
-};
-function createClaudeToolRegistry() {
-  return new Proxy(builtinTools, proxyHandler);
-}
-var CLAUDE_CLI_TOOL_REGISTRY = createClaudeToolRegistry();
 
 // src/lib/logging/build-logger.ts
 var BuildLogger = class {
@@ -7344,7 +5869,7 @@ var BuildLogger = class {
     if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
       try {
         if (level === "warn" || level === "error") {
-          addBreadcrumb({
+          Sentry.addBreadcrumb({
             category: `build-logger.${context}`,
             message,
             level: level === "error" ? "error" : "warning",
@@ -7730,7 +6255,8 @@ var init_tags = __esm({
             description: "Anthropic Claude - Balanced performance and speed",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-sonnet-4-5"
+            model: "claude-sonnet-4-5",
+            sdk: "agent"
           },
           {
             value: "claude-opus-4-5",
@@ -7738,7 +6264,8 @@ var init_tags = __esm({
             description: "Anthropic Claude - Most capable for complex tasks",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-opus-4-5"
+            model: "claude-opus-4-5",
+            sdk: "agent"
           },
           {
             value: "claude-haiku-4-5",
@@ -7746,7 +6273,8 @@ var init_tags = __esm({
             description: "Anthropic Claude - Fastest, good for iterations",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-haiku-4-5"
+            model: "claude-haiku-4-5",
+            sdk: "agent"
           },
           {
             value: "gpt-5.2-codex",
@@ -7754,7 +6282,35 @@ var init_tags = __esm({
             description: "OpenAI Codex - Advanced code generation",
             logo: "/openai.png",
             provider: "openai-codex",
-            model: "openai/gpt-5.2-codex"
+            model: "openai/gpt-5.2-codex",
+            sdk: "agent"
+          },
+          {
+            value: "factory-droid-opus",
+            label: "Factory Droid (Opus)",
+            description: "Factory Droid SDK with Claude Opus 4.5",
+            logo: "/factory.svg",
+            provider: "factory-droid",
+            model: "claude-opus-4-5-20251101",
+            sdk: "droid"
+          },
+          {
+            value: "factory-droid-codex",
+            label: "Factory Droid (Codex)",
+            description: "Factory Droid SDK with GPT-5.2 Codex",
+            logo: "/factory.svg",
+            provider: "factory-droid",
+            model: "gpt-5.2-codex",
+            sdk: "droid"
+          },
+          {
+            value: "factory-droid-glm",
+            label: "Factory Droid (GLM)",
+            description: "Factory Droid SDK with GLM 4.7",
+            logo: "/factory.svg",
+            provider: "factory-droid",
+            model: "glm-4.7",
+            sdk: "droid"
           }
         ]
       },
@@ -8755,45 +7311,133 @@ STEP 5: VERIFY BUILD
 
 After successful build, include final JSON code block with all tasks "completed"
 
-CRITICAL: Complete ALL 5 steps in this single session.
-Each bash command runs in a fresh shell - prefix with "cd ${context.projectName} &&"
-Only respond "Implementation complete" after ALL steps are verified.`;
+CRITICAL: Complete ALL 5 steps in this single session.
+Each bash command runs in a fresh shell - prefix with "cd ${context.projectName} &&"
+Only respond "Implementation complete" after ALL steps are verified.`;
+}
+var codexStrategy, codex_strategy_default;
+var init_codex_strategy = __esm({
+  "src/lib/agents/codex-strategy.ts"() {
+    init_template_catalog();
+    init_events();
+    init_load_template_context();
+    init_resolver();
+    codexStrategy = {
+      buildSystemPromptSections: buildCodexSections,
+      buildFullPrompt: buildFullPrompt2,
+      shouldDownloadTemplate() {
+        return false;
+      },
+      resolveWorkingDirectory(context) {
+        if (!context.isNewProject) {
+          return context.workingDirectory;
+        }
+        return getParentDirectory(context.workingDirectory);
+      },
+      async getTemplateSelectionContext(context) {
+        return loadTemplateSelectionContext2(context);
+      },
+      processRunnerEvent(state, event) {
+        if (!state || typeof state !== "object") {
+          return state;
+        }
+        const codexLike = state;
+        if (!Array.isArray(codexLike?.phases)) {
+          return state;
+        }
+        const next = processCodexEvent(codexLike, event);
+        return next;
+      }
+    };
+    codex_strategy_default = codexStrategy;
+  }
+});
+
+// src/lib/agents/droid-strategy.ts
+var droid_strategy_exports = {};
+__export(droid_strategy_exports, {
+  default: () => droid_strategy_default
+});
+function buildDroidSections(context) {
+  const sections = [];
+  if (context.tags && context.tags.length > 0) {
+    const resolved = resolveTags(context.tags);
+    const tagPrompt = generatePromptFromTags(resolved, context.projectName, context.isNewProject);
+    if (tagPrompt) {
+      sections.push(tagPrompt);
+    }
+  }
+  if (context.isNewProject) {
+    sections.push(`## New Project Setup
+
+- Project name: ${context.projectName}
+- Location: ${context.workingDirectory}
+- Operation type: ${context.operationType}
+
+The template has already been downloaded. Install dependencies and customize the scaffold to satisfy the request.`);
+  } else {
+    let existingProjectSection = `## Existing Project Context
+
+- Project location: ${context.workingDirectory}
+- Operation type: ${context.operationType}
+
+Review the current codebase and apply the requested changes without re-scaffolding.`;
+    if (context.conversationHistory && context.conversationHistory.length > 0) {
+      existingProjectSection += `
+
+**Recent Conversation History:**
+`;
+      context.conversationHistory.forEach((msg, index) => {
+        const roleLabel = msg.role === "user" ? "User" : "Assistant";
+        const content = msg.content.length > 500 ? msg.content.substring(0, 500) + "...[truncated]" : msg.content;
+        existingProjectSection += `${index + 1}. ${roleLabel}:
+${content}
+
+`;
+      });
+    }
+    sections.push(existingProjectSection);
+  }
+  sections.push(`## Workspace Rules
+- Use relative paths within the project.
+- Work inside the existing project structure.
+- Provide complete file contents without placeholders.`);
+  if (context.fileTree) {
+    sections.push(`## Project Structure
+${context.fileTree}`);
+  }
+  if (context.templateName) {
+    sections.push(`## Template
+- Name: ${context.templateName}
+- Framework: ${context.templateFramework ?? "unknown"}`);
+  }
+  return sections;
+}
+function buildFullPrompt3(context, basePrompt) {
+  if (!context.isNewProject) {
+    return basePrompt;
+  }
+  return `${basePrompt}
+
+CRITICAL: The template has already been prepared in ${context.workingDirectory}. Do not scaffold a new project.`;
 }
-var codexStrategy, codex_strategy_default;
-var init_codex_strategy = __esm({
-  "src/lib/agents/codex-strategy.ts"() {
-    init_template_catalog();
-    init_events();
-    init_load_template_context();
+var droidStrategy, droid_strategy_default;
+var init_droid_strategy = __esm({
+  "src/lib/agents/droid-strategy.ts"() {
     init_resolver();
-    codexStrategy = {
-      buildSystemPromptSections: buildCodexSections,
-      buildFullPrompt: buildFullPrompt2,
-      shouldDownloadTemplate() {
-        return false;
-      },
-      resolveWorkingDirectory(context) {
-        if (!context.isNewProject) {
-          return context.workingDirectory;
-        }
-        return getParentDirectory(context.workingDirectory);
-      },
-      async getTemplateSelectionContext(context) {
-        return loadTemplateSelectionContext2(context);
+    droidStrategy = {
+      buildSystemPromptSections: buildDroidSections,
+      buildFullPrompt: buildFullPrompt3,
+      shouldDownloadTemplate(context) {
+        return context.isNewProject && !context.skipTemplates;
       },
-      processRunnerEvent(state, event) {
-        if (!state || typeof state !== "object") {
-          return state;
-        }
-        const codexLike = state;
-        if (!Array.isArray(codexLike?.phases)) {
-          return state;
-        }
-        const next = processCodexEvent(codexLike, event);
-        return next;
+      postTemplateSelected(context, template) {
+        context.templateName = template.name;
+        context.templateFramework = template.framework;
+        context.fileTree = template.fileTree;
       }
     };
-    codex_strategy_default = codexStrategy;
+    droid_strategy_default = droidStrategy;
   }
 });
 
@@ -8816,12 +7460,18 @@ async function ensureRegistry() {
   if (initialized) {
     return;
   }
-  const [{ default: claudeStrategy2 }, { default: codexStrategy2 }] = await Promise.all([
+  const [
+    { default: claudeStrategy2 },
+    { default: codexStrategy2 },
+    { default: droidStrategy2 }
+  ] = await Promise.all([
     Promise.resolve().then(() => (init_claude_strategy(), claude_strategy_exports)),
-    Promise.resolve().then(() => (init_codex_strategy(), codex_strategy_exports))
+    Promise.resolve().then(() => (init_codex_strategy(), codex_strategy_exports)),
+    Promise.resolve().then(() => (init_droid_strategy(), droid_strategy_exports))
   ]);
   registerAgentStrategy("claude-code", claudeStrategy2);
   registerAgentStrategy("openai-codex", codexStrategy2);
+  registerAgentStrategy("factory-droid", droidStrategy2);
   initialized = true;
 }
 async function resolveAgentStrategy(agentId) {
@@ -8830,9 +7480,9 @@ async function resolveAgentStrategy(agentId) {
 }
 
 // Debug logging helper - suppressed in TUI mode (SILENT_MODE=1)
-const debugLog$2 = (message) => {
+const debugLog$1 = (message) => {
     if (process.env.SILENT_MODE !== '1' && process.env.DEBUG_BUILD === '1') {
-        debugLog$2();
+        debugLog$1();
     }
 };
 /**
@@ -8843,7 +7493,7 @@ async function createBuildStream(options) {
     // For Codex on NEW projects, use parent directory as CWD (Codex will create the project dir)
     // For everything else, use the project directory
     const strategy = await resolveAgentStrategy(agent);
-    const projectName = options.projectName || require$$1.basename(workingDirectory);
+    const projectName = options.projectName || path$1.basename(workingDirectory);
     const strategyContext = {
         projectId: options.projectId,
         projectName,
@@ -8858,7 +7508,7 @@ async function createBuildStream(options) {
         if (process.env.DEBUG_BUILD === '1')
             console.log(`[engine] Strategy adjusted CWD to: ${actualWorkingDir}`);
     }
-    else if (!existsSync$1(workingDirectory)) {
+    else if (!existsSync(workingDirectory)) {
         mkdirSync(workingDirectory, { recursive: true });
     }
     if (!resolvedDir) {
@@ -8877,19 +7527,19 @@ async function createBuildStream(options) {
     // Pass prompt, working directory, and system prompt to the query function
     // The buildQuery wrapper will configure the SDK with all options
     // Use actualWorkingDir so the query function gets the correct CWD
-    debugLog$2();
+    debugLog$1();
     const generator = query(fullPrompt, actualWorkingDir, systemPrompt, agent, options.codexThreadId, messageParts);
-    debugLog$2();
+    debugLog$1();
     // Create a ReadableStream from the AsyncGenerator
     const stream = new ReadableStream({
         async start(controller) {
-            debugLog$2();
+            debugLog$1();
             let chunkCount = 0;
             try {
                 for await (const chunk of generator) {
                     chunkCount++;
                     if (chunkCount % 5 === 0) {
-                        debugLog$2(`[runner] [build-engine] Processed ${chunkCount} chunks from generator\n`);
+                        debugLog$1(`[runner] [build-engine] Processed ${chunkCount} chunks from generator\n`);
                     }
                     // Convert chunk to appropriate format
                     if (typeof chunk === 'string') {
@@ -8902,11 +7552,11 @@ async function createBuildStream(options) {
                         controller.enqueue(new TextEncoder().encode(JSON.stringify(chunk)));
                     }
                 }
-                debugLog$2(`[runner] [build-engine] ✅ Generator exhausted after ${chunkCount} chunks, closing stream\n`);
+                debugLog$1(`[runner] [build-engine] ✅ Generator exhausted after ${chunkCount} chunks, closing stream\n`);
                 controller.close();
             }
             catch (error) {
-                debugLog$2();
+                debugLog$1();
                 controller.error(error);
             }
             finally {
@@ -8915,7 +7565,7 @@ async function createBuildStream(options) {
             }
         },
     });
-    debugLog$2();
+    debugLog$1();
     return stream;
 }
 
@@ -9134,7 +7784,7 @@ function classifyStartupError(error, processInfo) {
             suggestion: 'Check file permissions and ownership'
         };
     }
-    if (processInfo.cwd && !existsSync$1(processInfo.cwd)) {
+    if (processInfo.cwd && !existsSync(processInfo.cwd)) {
         return {
             reason: FailureReason.DIRECTORY_MISSING,
             message: `Working directory does not exist: ${processInfo.cwd}`,
@@ -9198,7 +7848,7 @@ function startDevServer(options) {
     buildLogger$1.processManager.processStarting(projectId, command, cwd);
     const emitter = new EventEmitter();
     // Verify CWD exists
-    if (!existsSync$1(cwd)) {
+    if (!existsSync(cwd)) {
         const error = new Error(`Working directory does not exist: ${cwd}`);
         buildLogger$1.processManager.error('Failed to spawn process', error, { projectId });
         emitter.emit('error', error);
@@ -9435,7 +8085,7 @@ async function waitForPortRelease(port, maxWaitMs = 10000, pollIntervalMs = 500)
  */
 function fixPackageJsonPort(cwd, targetPort) {
     const packageJsonPath = join$1(cwd, 'package.json');
-    if (!existsSync$1(packageJsonPath)) {
+    if (!existsSync(packageJsonPath)) {
         buildLogger$1.log('debug', 'process-manager', 'No package.json found to fix', { cwd });
         return false;
     }
@@ -9562,19 +8212,19 @@ async function stopAllDevServers(tunnelManager) {
 }
 
 var processManager = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  get FailureReason () { return FailureReason; },
-  get ProcessState () { return ProcessState; },
-  checkPortInUse: checkPortInUse,
-  findAvailablePort: findAvailablePort,
-  getAllActiveProjectIds: getAllActiveProjectIds,
-  runHealthCheck: runHealthCheck,
-  setSilentMode: setSilentMode$1,
-  startDevServer: startDevServer,
-  startDevServerAsync: startDevServerAsync,
-  stopAllDevServers: stopAllDevServers,
-  stopDevServer: stopDevServer,
-  waitForPortRelease: waitForPortRelease
+    __proto__: null,
+    get FailureReason () { return FailureReason; },
+    get ProcessState () { return ProcessState; },
+    checkPortInUse: checkPortInUse,
+    findAvailablePort: findAvailablePort,
+    getAllActiveProjectIds: getAllActiveProjectIds,
+    runHealthCheck: runHealthCheck,
+    setSilentMode: setSilentMode$1,
+    startDevServer: startDevServer,
+    startDevServerAsync: startDevServerAsync,
+    stopAllDevServers: stopAllDevServers,
+    stopDevServer: stopDevServer,
+    waitForPortRelease: waitForPortRelease
 });
 
 /**
@@ -9584,7 +8234,7 @@ var processManager = /*#__PURE__*/Object.freeze({
 function getWorkspaceRoot() {
     // Check environment variable first
     const envWorkspace = process.env.WORKSPACE_ROOT;
-    if (envWorkspace && existsSync$1(envWorkspace)) {
+    if (envWorkspace && existsSync(envWorkspace)) {
         return resolve(envWorkspace);
     }
     // Default to a workspace directory in the user's home
@@ -9897,296 +8547,6 @@ function transformAgentMessageToSSE(agentMessage) {
     return events;
 }
 
-// Debug logging helper - suppressed in TUI mode (SILENT_MODE=1)
-const debugLog$1 = (message) => {
-    if (process.env.SILENT_MODE !== '1' && process.env.DEBUG_BUILD === '1') {
-        debugLog$1();
-    }
-};
-/**
- * Truncate strings for logging to prevent excessive output
- */
-function truncate$1(str, maxLength = 200) {
-    if (str.length <= maxLength)
-        return str;
-    return str.substring(0, maxLength) + '...';
-}
-/**
- * Truncate JSON objects for logging
- */
-function truncateJSON$1(obj, maxLength = 200) {
-    const json = JSON.stringify(obj, null, 2);
-    return truncate$1(json, maxLength);
-}
-/**
- * Transforms AI SDK stream events into messages compatible with our message transformer
- */
-async function* transformAISDKStream(stream) {
-    const DEBUG = process.env.DEBUG_BUILD === '1';
-    let currentMessageId = `msg-${Date.now()}`; // Always have a default ID
-    let currentTextContent = '';
-    const toolInputBuffer = new Map();
-    const toolResults = new Map();
-    let eventCount = 0;
-    let yieldCount = 0;
-    // Track active tool spans for proper duration measurement
-    const activeToolSpans = new Map();
-    // ALWAYS log start - write to stderr to bypass TUI console interceptor
-    debugLog$1();
-    streamLog.info('━━━ STREAM TRANSFORMATION STARTED ━━━');
-    for await (const part of stream) {
-        eventCount++;
-        // Log ALL events to file (first 50)
-        if (eventCount <= 50) {
-            streamLog.event(eventCount, part.type, part);
-        }
-        // DEBUG: Log first 20 events with full JSON to see what we're actually getting
-        if (DEBUG && eventCount <= 20) {
-            debugLog$1(`[runner] [ai-sdk-adapter] Event #${eventCount}: type="${part.type}"\n`);
-            debugLog$1(`[runner] [ai-sdk-adapter]   Full JSON: ${truncateJSON$1(part, 500)}\n`);
-        }
-        if (DEBUG)
-            console.log('[ai-sdk-adapter] Event:', part.type, part);
-        // DEBUG: Log every 10 events to show progress
-        if (DEBUG && eventCount % 10 === 0) {
-            debugLog$1();
-        }
-        switch (part.type) {
-            case 'start':
-            case 'start-step':
-                // Update message ID if provided
-                if (part.id) {
-                    currentMessageId = part.id;
-                    if (DEBUG)
-                        debugLog$1();
-                }
-                break;
-            case 'text-start':
-                // Capture message ID from text-start event
-                if (part.id) {
-                    currentMessageId = part.id;
-                    if (DEBUG)
-                        debugLog$1();
-                }
-                break;
-            case 'text-delta':
-                // Just accumulate text content - DON'T yield for every token!
-                // We'll only yield when there's a tool call or the message finishes
-                const textChunk = part.delta ?? part.text ?? part.textDelta;
-                if (typeof textChunk === 'string') {
-                    currentTextContent += textChunk;
-                    // Update message ID if provided in the event
-                    if (part.id) {
-                        currentMessageId = part.id;
-                    }
-                }
-                break;
-            case 'tool-input-start':
-                // Start buffering tool input
-                toolInputBuffer.set(part.id, {
-                    name: part.toolName,
-                    input: '',
-                });
-                break;
-            case 'tool-input-delta':
-                // Accumulate tool input
-                const buffer = toolInputBuffer.get(part.id);
-                if (buffer) {
-                    buffer.input += part.delta || '';
-                }
-                break;
-            case 'tool-input-end':
-            case 'tool-call':
-                // Tool call is complete - emit it
-                const toolCallId = part.toolCallId || part.id;
-                const toolName = part.toolName;
-                let toolInput = part.args || part.input;
-                // If we have buffered input, parse it
-                if (!toolInput && toolInputBuffer.has(toolCallId) && typeof toolCallId === 'string') {
-                    const buffered = toolInputBuffer.get(toolCallId);
-                    if (buffered?.input) {
-                        if (typeof buffered.input === 'string') {
-                            try {
-                                toolInput = JSON.parse(buffered.input);
-                            }
-                            catch {
-                                toolInput = { raw: buffered.input };
-                            }
-                        }
-                        try {
-                            toolInput = JSON.parse(buffered.input);
-                        }
-                        catch {
-                            toolInput = { raw: buffered.input };
-                        }
-                    }
-                    toolInputBuffer.delete(toolCallId);
-                }
-                if (toolName) {
-                    // First, yield any accumulated text as a separate message
-                    if (currentTextContent.trim().length > 0) {
-                        const textMessage = {
-                            type: 'assistant',
-                            message: {
-                                id: currentMessageId,
-                                content: [{ type: 'text', text: currentTextContent }],
-                            },
-                        };
-                        yieldCount++;
-                        debugLog$1(`[runner] [ai-sdk-adapter] 💬 Yielding text before tool: ${currentTextContent.length} chars\n`);
-                        yield textMessage;
-                        // Reset so it's not included in the tool message
-                        currentTextContent = '';
-                    }
-                    // Now yield the tool call as a separate message
-                    const toolMessage = {
-                        type: 'assistant',
-                        message: {
-                            id: `${currentMessageId}-tool-${toolCallId}`,
-                            content: [
-                                {
-                                    type: 'tool_use',
-                                    id: toolCallId,
-                                    name: toolName,
-                                    input: toolInput || {},
-                                },
-                            ],
-                        },
-                    };
-                    yieldCount++;
-                    debugLog$1();
-                    debugLog$1(`[runner] [ai-sdk-adapter]   Tool input: ${truncateJSON$1(toolInput)}\n`);
-                    // Log to file
-                    streamLog.yield('tool-call', { toolName, toolCallId, toolInput, message: toolMessage });
-                    yield toolMessage;
-                }
-                break;
-            case 'tool-result':
-                // Store tool result
-                const resultId = part.toolCallId;
-                const toolResult = part.result ?? part.output;
-                toolResults.set(resultId, toolResult);
-                // Emit tool result as a user message
-                const resultMessage = {
-                    type: 'user',
-                    message: {
-                        id: `result-${resultId}`,
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: resultId,
-                                content: JSON.stringify(toolResult),
-                            },
-                        ],
-                    },
-                };
-                yieldCount++;
-                debugLog$1(`[runner] [ai-sdk-adapter] 📥 Tool result for: ${part.toolName || resultId}\n`);
-                // Special handling for verbose tool results
-                if (part.toolName === 'TodoWrite') {
-                    debugLog$1();
-                }
-                else {
-                    debugLog$1(`[runner] [ai-sdk-adapter]   Result: ${truncateJSON$1(toolResult)}\n`);
-                }
-                yield resultMessage;
-                break;
-            case 'tool-error':
-                // Emit tool error as a user message
-                const errorId = part.toolCallId || part.id;
-                const errorMessage = {
-                    type: 'user',
-                    message: {
-                        id: `error-${errorId}`,
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: errorId,
-                                content: JSON.stringify({ error: part.error }),
-                                is_error: true,
-                            },
-                        ],
-                    },
-                };
-                yieldCount++;
-                debugLog$1(`[runner] [ai-sdk-adapter] ⚠️  Tool error: ${part.toolName || errorId}\n`);
-                debugLog$1(`[runner] [ai-sdk-adapter]   Error: ${truncate$1(JSON.stringify(part.error), 150)}\n`);
-                yield errorMessage;
-                break;
-            case 'text-end':
-                // Text block is complete - yield the accumulated text
-                if (currentTextContent.trim().length > 0) {
-                    const message = {
-                        type: 'assistant',
-                        message: {
-                            id: currentMessageId,
-                            content: [{ type: 'text', text: currentTextContent }],
-                        },
-                    };
-                    yieldCount++;
-                    debugLog$1(`[runner] [ai-sdk-adapter] Yielding complete text block: ${currentTextContent.length} chars\n`);
-                    yield message;
-                    // Reset text content for next block
-                    currentTextContent = '';
-                }
-                break;
-            case 'finish':
-            case 'finish-step':
-                // Final message - yield any remaining text
-                if (currentTextContent.trim().length > 0) {
-                    yieldCount++;
-                    if (DEBUG)
-                        debugLog$1(`[runner] [ai-sdk-adapter] Yielding final text: ${currentTextContent.length} chars\n`);
-                    yield {
-                        type: 'assistant',
-                        message: {
-                            id: currentMessageId,
-                            content: [{ type: 'text', text: currentTextContent }],
-                        },
-                    };
-                }
-                break;
-            case 'error':
-                // Emit error
-                const errorPayload = part.error ?? { message: 'Unknown Claude stream error' };
-                const errorText = typeof errorPayload === 'object' && errorPayload !== null
-                    ? JSON.stringify(errorPayload)
-                    : String(errorPayload);
-                const wrappedError = new Error(`Claude stream error: ${errorText}`);
-                Object.assign(wrappedError, { cause: errorPayload });
-                debugLog$1();
-                throw wrappedError;
-            // Ignore other event types
-            case 'stream-start':
-            case 'response-metadata':
-                break;
-            default:
-                // Log unknown event types for debugging
-                if (process.env.DEBUG_BUILD === '1') {
-                    console.log('[ai-sdk-adapter] Unknown event type:', part.type);
-                }
-                break;
-        }
-    }
-    // Clean up any orphaned tool spans (tool calls that never received results)
-    if (activeToolSpans.size > 0) {
-        debugLog$1(`[runner] [ai-sdk-adapter] ⚠️  Cleaning up ${activeToolSpans.size} orphaned tool spans\n`);
-        for (const [toolId, span] of activeToolSpans) {
-            span.setStatus({ code: 2, message: 'Tool execution incomplete - no result received' });
-            span.end();
-            debugLog$1();
-        }
-        activeToolSpans.clear();
-    }
-    // DEBUG: Log completion stats
-    if (DEBUG) {
-        debugLog$1();
-    }
-    streamLog.info('━━━ STREAM TRANSFORMATION COMPLETE ━━━');
-    streamLog.info(`Total events: ${eventCount}`);
-    streamLog.info(`Total yields: ${yieldCount}`);
-}
-
 /**
  * Adapter to transform Codex SDK events into the unified format expected by message transformer
  *
@@ -11076,10 +9436,10 @@ async function selectTemplateFromPrompt(userPrompt) {
 }
 
 var config = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getAllTemplates: getAllTemplates,
-  loadTemplateConfig: loadTemplateConfig,
-  selectTemplateFromPrompt: selectTemplateFromPrompt
+    __proto__: null,
+    getAllTemplates: getAllTemplates,
+    loadTemplateConfig: loadTemplateConfig,
+    selectTemplateFromPrompt: selectTemplateFromPrompt
 });
 
 /**
@@ -11097,7 +9457,7 @@ async function downloadTemplate(template, targetPath) {
         console.log(`   Target: ${targetPath}`);
     // Check if target already exists and add random suffix if needed
     let finalTargetPath = targetPath;
-    if (existsSync$1(targetPath)) {
+    if (existsSync(targetPath)) {
         // Generate a unique 4-character suffix
         const randomSuffix = Math.random().toString(36).substring(2, 6);
         finalTargetPath = `${targetPath}-${randomSuffix}`;
@@ -11169,12 +9529,12 @@ async function downloadTemplateWithGit(template, targetPath) {
         // Handle multi-package projects with client/server subdirectories
         const clientPkgPath = join$1(targetPath, 'client', 'package.json');
         const serverPkgPath = join$1(targetPath, 'server', 'package.json');
-        if (existsSync$1(clientPkgPath)) {
+        if (existsSync(clientPkgPath)) {
             await updatePackageName(join$1(targetPath, 'client'), `${projectName}-client`);
             await removeHardcodedPorts(join$1(targetPath, 'client'));
             await ensureVitePortConfig(join$1(targetPath, 'client'));
         }
-        if (existsSync$1(serverPkgPath)) {
+        if (existsSync(serverPkgPath)) {
             await updatePackageName(join$1(targetPath, 'server'), `${projectName}-server`);
             await removeHardcodedPorts(join$1(targetPath, 'server'));
             await ensureVitePortConfig(join$1(targetPath, 'server'));
@@ -11209,7 +9569,7 @@ shamefully-hoist=false
  */
 async function updatePackageName(projectPath, newName) {
     const pkgPath = join$1(projectPath, 'package.json');
-    if (!existsSync$1(pkgPath)) {
+    if (!existsSync(pkgPath)) {
         if (process.env.DEBUG_BUILD === '1')
             console.log(`   No package.json found in ${projectPath}, skipping name update`);
         return;
@@ -11232,7 +9592,7 @@ async function updatePackageName(projectPath, newName) {
  */
 async function removeHardcodedPorts(projectPath) {
     const pkgPath = join$1(projectPath, 'package.json');
-    if (!existsSync$1(pkgPath)) {
+    if (!existsSync(pkgPath)) {
         return;
     }
     try {
@@ -11281,11 +9641,11 @@ async function ensureVitePortConfig(projectPath) {
     const viteConfigJs = join$1(projectPath, 'vite.config.js');
     const viteConfigMts = join$1(projectPath, 'vite.config.mts');
     let configPath = null;
-    if (existsSync$1(viteConfigTs))
+    if (existsSync(viteConfigTs))
         configPath = viteConfigTs;
-    else if (existsSync$1(viteConfigMts))
+    else if (existsSync(viteConfigMts))
         configPath = viteConfigMts;
-    else if (existsSync$1(viteConfigJs))
+    else if (existsSync(viteConfigJs))
         configPath = viteConfigJs;
     if (!configPath)
         return;
@@ -11423,7 +9783,7 @@ async function orchestrateBuild(context) {
     }
     // Verify directory state for logging
     try {
-        if (existsSync$1(workingDirectory)) {
+        if (existsSync(workingDirectory)) {
             const files = await readdir(workingDirectory);
             if (process.env.DEBUG_BUILD === '1')
                 console.log(`[orchestrator] Directory status: ${files.length} files found`);
@@ -11662,7 +10022,8 @@ var TAG_DEFINITIONS = [
         description: "Anthropic Claude - Balanced performance and speed",
         logo: "/claude.png",
         provider: "claude-code",
-        model: "claude-sonnet-4-5"
+        model: "claude-sonnet-4-5",
+        sdk: "agent"
       },
       {
         value: "claude-opus-4-5",
@@ -11670,7 +10031,8 @@ var TAG_DEFINITIONS = [
         description: "Anthropic Claude - Most capable for complex tasks",
         logo: "/claude.png",
         provider: "claude-code",
-        model: "claude-opus-4-5"
+        model: "claude-opus-4-5",
+        sdk: "agent"
       },
       {
         value: "claude-haiku-4-5",
@@ -11678,7 +10040,8 @@ var TAG_DEFINITIONS = [
         description: "Anthropic Claude - Fastest, good for iterations",
         logo: "/claude.png",
         provider: "claude-code",
-        model: "claude-haiku-4-5"
+        model: "claude-haiku-4-5",
+        sdk: "agent"
       },
       {
         value: "gpt-5.2-codex",
@@ -11686,7 +10049,35 @@ var TAG_DEFINITIONS = [
         description: "OpenAI Codex - Advanced code generation",
         logo: "/openai.png",
         provider: "openai-codex",
-        model: "openai/gpt-5.2-codex"
+        model: "openai/gpt-5.2-codex",
+        sdk: "agent"
+      },
+      {
+        value: "factory-droid-opus",
+        label: "Factory Droid (Opus)",
+        description: "Factory Droid SDK with Claude Opus 4.5",
+        logo: "/factory.svg",
+        provider: "factory-droid",
+        model: "claude-opus-4-5-20251101",
+        sdk: "droid"
+      },
+      {
+        value: "factory-droid-codex",
+        label: "Factory Droid (Codex)",
+        description: "Factory Droid SDK with GPT-5.2 Codex",
+        logo: "/factory.svg",
+        provider: "factory-droid",
+        model: "gpt-5.2-codex",
+        sdk: "droid"
+      },
+      {
+        value: "factory-droid-glm",
+        label: "Factory Droid (GLM)",
+        description: "Factory Droid SDK with GLM 4.7",
+        logo: "/factory.svg",
+        provider: "factory-droid",
+        model: "glm-4.7",
+        sdk: "droid"
       }
     ]
   },
@@ -11910,7 +10301,7 @@ function getCleanEnv() {
  * Ensure a directory exists
  */
 function ensureDir(dir) {
-    if (!existsSync(dir)) {
+    if (!existsSync$1(dir)) {
         mkdirSync$1(dir, { recursive: true });
     }
 }
@@ -11954,7 +10345,7 @@ CRITICAL: Your response must START with { and END with }. Output only the JSON o
     }
     catch (error) {
         console.error('[project-analyzer] SDK query failed:', error);
-        captureException(error);
+        Sentry.captureException(error);
         throw error;
     }
     if (!responseText) {
@@ -12344,10 +10735,10 @@ async function waitForPort(port, maxRetries = 10, delayMs = 500) {
 }
 
 var portChecker = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isPortReady: isPortReady,
-  setSilentMode: setSilentMode,
-  waitForPort: waitForPort
+    __proto__: null,
+    isPortReady: isPortReady,
+    setSilentMode: setSilentMode,
+    waitForPort: waitForPort
 });
 
 /**
@@ -12492,7 +10883,7 @@ const hmrProxyManager = new HmrProxyManager();
 
 // Sentry is initialized via --import flag (see package.json scripts)
 // This ensures instrumentation loads before any other modules
-globalThis.AI_SDK_LOG_WARNINGS = false;
+// AI SDK log warnings disabled (legacy - no longer using AI SDK)
 /**
  * Truncate strings for logging to prevent excessive output
  */
@@ -12524,7 +10915,7 @@ const DEBUG_BUILD = process.env.DEBUG_BUILD === "1" || false;
 const log = (...args) => {
     const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
     try {
-        const logger = getLogger$1();
+        const logger = getLogger();
         logger.info('system', message);
     }
     catch {
@@ -12538,7 +10929,7 @@ const log = (...args) => {
 const buildLog = (...args) => {
     const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
     try {
-        const logger = getLogger$1();
+        const logger = getLogger();
         logger.info('build', message);
     }
     catch {
@@ -12554,7 +10945,7 @@ const debugLog = (...args) => {
         return;
     const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
     try {
-        const logger = getLogger$1();
+        const logger = getLogger();
         logger.debug('system', message);
     }
     catch {
@@ -12563,146 +10954,6 @@ const debugLog = (...args) => {
 };
 const DEFAULT_AGENT = "claude-code";
 const CODEX_MODEL = "gpt-5-codex";
-// Stderr debug logging - suppressed in TUI mode (SILENT_MODE=1)
-const stderrDebug = (message) => {
-    if (process.env.SILENT_MODE !== '1' && DEBUG_BUILD) {
-        process.stderr.write(message);
-    }
-};
-/**
- * Create Claude query function using AI SDK
- *
- * NOTE: This function prepends CLAUDE_SYSTEM_PROMPT to the systemPrompt from orchestrator.
- * The orchestrator provides context-specific sections only (no base prompt).
- */
-function createClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID) {
-    return async function* (prompt, workingDirectory, systemPrompt, agent, codexThreadId, messageParts) {
-        // Note: query is auto-instrumented by Sentry's claudeCodeAgentSdkIntegration via OpenTelemetry
-        stderrDebug("[runner] [createClaudeQuery] 🎯 Query function called\n");
-        stderrDebug(`[runner] [createClaudeQuery] Model: ${modelId}\n`);
-        stderrDebug(`[runner] [createClaudeQuery] Working dir: ${workingDirectory}\n`);
-        stderrDebug(`[runner] [createClaudeQuery] Prompt length: ${prompt.length}\n`);
-        // Check if we have image parts
-        const hasImages = messageParts?.some(p => p.type === 'image');
-        if (hasImages) {
-            const imageCount = messageParts?.filter(p => p.type === 'image').length || 0;
-            stderrDebug(`[runner] [createClaudeQuery] 🖼️  Multi-modal message with ${imageCount} image(s)\n`);
-        }
-        // Build combined system prompt
-        const systemPromptSegments = [CLAUDE_SYSTEM_PROMPT.trim()];
-        if (systemPrompt && systemPrompt.trim().length > 0) {
-            systemPromptSegments.push(systemPrompt.trim());
-        }
-        const appendedSystemPrompt = systemPromptSegments.join("\n\n");
-        // Use the full model ID as-is (claude-haiku-4-5, claude-sonnet-4-5, claude-opus-4-5)
-        const aiSdkModelId = modelId || "claude-haiku-4-5";
-        // Ensure working directory exists before passing to Claude Code
-        if (!existsSync$1(workingDirectory)) {
-            console.log(`[createClaudeQuery] Creating working directory: ${workingDirectory}`);
-            mkdirSync(workingDirectory, { recursive: true });
-        }
-        // NOTE: The community provider (ai-sdk-provider-claude-code) bundles an older
-        // version of the SDK types. We cast to `any` to avoid type conflicts.
-        // This legacy path is deprecated in favor of the native SDK implementation.
-        const model = claudeCode(aiSdkModelId, {
-            queryFunction: query, // Cast to avoid SDK version type conflict
-            systemPrompt: {
-                type: "preset",
-                preset: "claude_code",
-                append: appendedSystemPrompt,
-            },
-            cwd: workingDirectory,
-            permissionMode: "bypassPermissions",
-            maxTurns: 100,
-            additionalDirectories: [workingDirectory],
-            env: {
-                // Claude Code CLI default output cap is 32k; bumping to 64k per
-                // https://docs.claude.com/en/docs/claude-code/settings#environment-variables
-                CLAUDE_CODE_MAX_OUTPUT_TOKENS: process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS ?? "64000",
-            },
-            // Explicitly allow all tools to prevent "No tools are available" errors
-            canUseTool: createProjectScopedPermissionHandler(workingDirectory), // Cast for type compat
-            streamingInput: "always", // REQUIRED when using canUseTool - enables tool callbacks
-            includePartialMessages: true,
-            settingSources: ["user", "project"], // Load skills from user and project directories
-        });
-        // Build user message - either simple text or multi-part with images
-        let userMessage;
-        if (messageParts && messageParts.length > 0) {
-            // Multi-part message with images
-            const contentParts = [];
-            // Add image parts first (Claude best practice)
-            for (const part of messageParts) {
-                if (part.type === 'image' && part.image) {
-                    // AI SDK expects images as data URLs, which we already have
-                    contentParts.push({
-                        type: 'image',
-                        image: part.image, // Already a base64 data URL
-                    });
-                    // Extract media type for logging
-                    const match = part.image.match(/^data:(.+);base64,/);
-                    if (match) {
-                        stderrDebug(`[runner] [createClaudeQuery] ✅ Added image part (${match[1]})\n`);
-                    }
-                }
-                else if (part.type === 'text' && part.text) {
-                    contentParts.push({
-                        type: 'text',
-                        text: part.text
-                    });
-                }
-            }
-            // Add prompt text if not already in parts
-            if (!contentParts.some(p => p.type === 'text')) {
-                contentParts.push({
-                    type: 'text',
-                    text: prompt
-                });
-            }
-            userMessage = contentParts;
-            stderrDebug(`[runner] [createClaudeQuery] 📦 Built multi-part message with ${contentParts.length} part(s)\n`);
-        }
-        else {
-            // Simple text message (existing behavior)
-            userMessage = prompt;
-        }
-        // Stream with telemetry enabled for Sentry
-        // Use 'messages' param for multi-part content, 'prompt' for simple text
-        // IMPORTANT: experimental_telemetry is REQUIRED for the Vercel AI SDK integration to work
-        const streamOptions = {
-            model,
-            tools: CLAUDE_CLI_TOOL_REGISTRY,
-            experimental_telemetry: {
-                isEnabled: true,
-                functionId: 'createClaudeQuery',
-                recordInputs: true,
-                recordOutputs: true,
-            },
-        };
-        const result = Array.isArray(userMessage)
-            ? streamText({
-                ...streamOptions,
-                messages: [{ role: 'user', content: userMessage }],
-            })
-            : streamText({
-                ...streamOptions,
-                prompt: userMessage,
-            });
-        // Transform AI SDK stream format to our message format
-        if (process.env.DEBUG_BUILD === "1") {
-            console.log("[createClaudeQuery] Starting stream consumption...");
-        }
-        for await (const message of transformAISDKStream(result.fullStream)) {
-            if (process.env.DEBUG_BUILD === "1") {
-                console.log("[createClaudeQuery] Yielding message:", message.type);
-            }
-            yield message;
-        }
-        if (process.env.DEBUG_BUILD === "1") {
-            console.log("[createClaudeQuery] Stream consumption complete");
-        }
-    };
-}
 /**
  * Create Codex query function using ORIGINAL Codex SDK (NOT AI SDK)
  *
@@ -12797,7 +11048,7 @@ function createCodexQuery() {
             log(`🚀 [codex-query] Turn ${turnCount}: ${turnCount === 1 ? 'Initial request' : 'Continuing work'}...`);
             // Log full prompt being sent to Codex
             if (turnCount === 1) {
-                info(fmt `Full Codex prompt (Turn 1) ${{
+                Sentry.logger.info(Sentry.logger.fmt `Full Codex prompt (Turn 1) ${{
                     prompt: turnPrompt,
                     promptLength: turnPrompt.length,
                     promptPreview: turnPrompt.substring(0, 200),
@@ -12850,9 +11101,18 @@ function createCodexQuery() {
         fileLog.info(`Total turns: ${turnCount}`);
     };
 }
+/**
+ * SDK Feature Flags (environment variables)
+ *
+ * - ENABLE_OPENCODE_SDK: Imported from opencode-sdk.ts, enables OpenCode multi-provider routing
+ * - ENABLE_FACTORY_SDK: Enables Factory Droid SDK for builds
+ *
+ * By default (no flags set), only Agent SDK (Claude + Codex) is available.
+ */
+const ENABLE_FACTORY_SDK = process.env.ENABLE_FACTORY_SDK === 'true';
 function createBuildQuery(agent, modelId, abortController) {
     // When OpenCode SDK is enabled, route ALL requests through it (including Codex)
-    if (USE_OPENCODE_SDK) {
+    if (ENABLE_OPENCODE_SDK) {
         // Map openai-codex agent to the correct OpenCode model
         const normalizedModel = agent === "openai-codex"
             ? "openai/gpt-5.2-codex"
@@ -12865,13 +11125,18 @@ function createBuildQuery(agent, modelId, abortController) {
         console.log('[runner] 🔄 Using direct Codex SDK (fallback mode)');
         return createCodexQuery();
     }
-    // Use legacy AI SDK path when explicitly requested
-    if (!USE_NATIVE_SDK) {
-        console.log('[runner] 🔄 Using AI SDK with claude-code provider (legacy mode)');
-        return createClaudeQuery(modelId ?? DEFAULT_CLAUDE_MODEL_ID);
+    // Factory Droid SDK - uses the droid CLI for builds (only if enabled)
+    if (agent === "factory-droid") {
+        if (!ENABLE_FACTORY_SDK) {
+            console.warn('[runner] ⚠️ Factory Droid requested but ENABLE_FACTORY_SDK is not set');
+            console.warn('[runner] ⚠️ Falling back to native Claude Agent SDK');
+            return createNativeClaudeQuery(DEFAULT_CLAUDE_MODEL_ID, abortController);
+        }
+        console.log('[runner] 🔄 Using Factory Droid SDK');
+        return createDroidQuery(modelId);
     }
     // Default: Use native Claude Agent SDK (direct integration)
-    console.log('[runner] 🔄 Using NATIVE Claude Agent SDK v0.1.76');
+    console.log('[runner] 🔄 Using NATIVE Claude Agent SDK');
     return createNativeClaudeQuery(modelId ?? DEFAULT_CLAUDE_MODEL_ID, abortController);
 }
 /**
@@ -13047,7 +11312,7 @@ async function startRunner(options = {}) {
     const RUNNER_ID = options.runnerId ||
         process.env.RUNNER_ID ||
         process.env.RAILWAY_REPLICA_ID ||
-        `runner-${os__default.hostname()}`;
+        `runner-${os$1.hostname()}`;
     // WebSocket URL for direct connection to Next.js server
     // Supports both new RUNNER_WS_URL and legacy RUNNER_BROKER_URL for backward compatibility
     const WS_URL = options.wsUrl ||
@@ -13078,7 +11343,7 @@ async function startRunner(options = {}) {
     }
     const runnerSharedSecret = SHARED_SECRET; // Guaranteed to be string after validation check
     // Ensure workspace directory exists
-    if (!existsSync$1(WORKSPACE_ROOT)) {
+    if (!existsSync(WORKSPACE_ROOT)) {
         console.log(`📁 Creating workspace directory: ${WORKSPACE_ROOT}`);
         mkdirSync(WORKSPACE_ROOT, { recursive: true });
     }
@@ -13109,14 +11374,14 @@ async function startRunner(options = {}) {
                     id: RUNNER_ID,
                     connected: socket?.readyState === WebSocket$1.OPEN,
                     workspace: WORKSPACE_ROOT,
-                    workspaceExists: existsSync$1(WORKSPACE_ROOT),
+                    workspaceExists: existsSync(WORKSPACE_ROOT),
                 },
                 uptime: process.uptime(),
                 timestamp: new Date().toISOString(),
             });
         });
         healthApp.get('/ready', (req, res) => {
-            const isReady = socket?.readyState === WebSocket$1.OPEN && existsSync$1(WORKSPACE_ROOT);
+            const isReady = socket?.readyState === WebSocket$1.OPEN && existsSync(WORKSPACE_ROOT);
             res.status(isReady ? 200 : 503).json({
                 ready: isReady,
                 runnerId: RUNNER_ID,
@@ -13182,7 +11447,7 @@ async function startRunner(options = {}) {
         throw lastError || new Error('Persistence failed after retries');
     }
     async function persistBuildEventDirect(context, event) {
-        return startSpan({
+        return Sentry.startSpan({
             name: `persist.build-event.${event.type}`,
             op: 'http.client',
             attributes: {
@@ -13193,7 +11458,7 @@ async function startRunner(options = {}) {
             },
         }, async () => {
             // Get trace context for propagation
-            const traceData = getTraceData();
+            const traceData = Sentry.getTraceData();
             const headers = {
                 'Authorization': `Bearer ${runnerSharedSecret}`,
                 'Content-Type': 'application/json',
@@ -13301,7 +11566,7 @@ async function startRunner(options = {}) {
      */
     async function persistRunnerEvent(event) {
         // Wrap in Sentry span to create proper trace hierarchy
-        return startSpan({
+        return Sentry.startSpan({
             name: `persist.runner-event.${event.type}`,
             op: 'http.client',
             attributes: {
@@ -13355,9 +11620,9 @@ async function startRunner(options = {}) {
             try {
                 // Attach trace context to ALL events for distributed tracing
                 // This allows events to be linked back to the originating frontend request
-                const span = getActiveSpan();
+                const span = Sentry.getActiveSpan();
                 if (span) {
-                    const traceData = getTraceData();
+                    const traceData = Sentry.getTraceData();
                     event._sentry = {
                         trace: traceData['sentry-trace'],
                         baggage: traceData.baggage,
@@ -13382,6 +11647,9 @@ async function startRunner(options = {}) {
                 }
                 else if (event.type === "build-failed") {
                     log(`❌ Build failed: ${event.error}`);
+                    // Debug: log stack trace to see where this was triggered from
+                    process.stderr.write(`[runner] BUILD-FAILED triggered. Error: ${event.error}\n`);
+                    process.stderr.write(`[runner] Stack trace at send time:\n${new Error().stack}\n`);
                 }
                 // Suppress: build-stream, runner-status, ack, etc.
                 if (socket && socket.readyState === WebSocket$1.OPEN) {
@@ -13862,7 +12130,7 @@ async function startRunner(options = {}) {
                     logger.tunnel({ port, url: tunnelUrl, status: 'created' });
                     // Instrument tunnel startup timing
                     const tunnelDuration = Date.now() - tunnelStartTime;
-                    distribution('tunnel_startup_duration', tunnelDuration, {
+                    Sentry.metrics.distribution('tunnel_startup_duration', tunnelDuration, {
                         unit: 'millisecond',
                         attributes: {
                             port: port.toString(),
@@ -13880,7 +12148,7 @@ async function startRunner(options = {}) {
                     console.error("Failed to create tunnel:", error);
                     // Instrument failed tunnel startup timing
                     const tunnelDuration = Date.now() - tunnelStartTime;
-                    distribution('tunnel_startup_duration', tunnelDuration, {
+                    Sentry.metrics.distribution('tunnel_startup_duration', tunnelDuration, {
                         unit: 'millisecond',
                         attributes: {
                             port: command.payload.port.toString(),
@@ -14160,7 +12428,7 @@ async function startRunner(options = {}) {
                     log("project name:", projectName);
                     // Determine agent to use for this build
                     const agent = command.payload.agent ?? DEFAULT_AGENT;
-                    const agentLabel = agent === "openai-codex" ? "Codex" : "Claude";
+                    const agentLabel = agent === "openai-codex" ? "Codex" : (agent === "factory-droid" ? "Droid" : "Claude");
                     log("selected agent:", agent);
                     const claudeModel = agent === "claude-code" &&
                         (command.payload.claudeModel === "claude-haiku-4-5" ||
@@ -14168,6 +12436,8 @@ async function startRunner(options = {}) {
                             command.payload.claudeModel === "claude-opus-4-5")
                         ? command.payload.claudeModel
                         : DEFAULT_CLAUDE_MODEL_ID;
+                    // For factory-droid, use the droidModel from payload
+                    const droidModel = agent === "factory-droid" ? command.payload.droidModel : undefined;
                     // Create AbortController for cancellation support
                     const buildAbortController = new AbortController();
                     // Register build context for HTTP persistence
@@ -14189,7 +12459,12 @@ async function startRunner(options = {}) {
                     if (agent === "claude-code") {
                         log("claude model:", claudeModel);
                     }
-                    const agentQuery = createBuildQuery(agent, claudeModel, buildAbortController);
+                    else if (agent === "factory-droid") {
+                        log("droid model:", droidModel || "default");
+                    }
+                    // Select the appropriate model for the agent
+                    const modelId = agent === "factory-droid" ? droidModel : claudeModel;
+                    const agentQuery = createBuildQuery(agent, modelId, buildAbortController);
                     // Reset transformer state for new build
                     resetTransformerState();
                     setExpectedCwd(projectDirectory);
@@ -14441,18 +12716,48 @@ async function startRunner(options = {}) {
                                 }
                                 // Track completed todos for summary context
                                 if (toolEvent.toolName === 'TodoWrite' && toolEvent.input) {
-                                    const input = toolEvent.input;
-                                    if (input.todos) {
-                                        // Update the logger's todo list for the build panel
-                                        const todoItems = input.todos.map(t => ({
+                                    const rawInput = toolEvent.input;
+                                    // Handle both formats:
+                                    // 1. Droid CLI format: string with numbered list like "1. [completed] Task"
+                                    // 2. Claude format: array of objects with content, status, etc.
+                                    let todoItems = [];
+                                    if (typeof rawInput.todos === 'string') {
+                                        // Parse droid CLI string format: "1. [completed] First task\n2. [in_progress] Second task"
+                                        const lines = rawInput.todos.split('\n').filter(l => l.trim());
+                                        todoItems = lines.map((line, idx) => {
+                                            // Match patterns like "1. [completed] Task content" or "1. [in_progress] Task"
+                                            const match = line.match(/^\d+\.\s*\[(\w+)\]\s*(.+)$/);
+                                            if (match) {
+                                                const [, statusStr, content] = match;
+                                                const status = statusStr;
+                                                return {
+                                                    id: `todo-${Date.now()}-${idx}`,
+                                                    content: content.trim(),
+                                                    status,
+                                                };
+                                            }
+                                            // Fallback: treat line as pending task
+                                            return {
+                                                id: `todo-${Date.now()}-${idx}`,
+                                                content: line.replace(/^\d+\.\s*/, '').trim(),
+                                                status: 'pending',
+                                            };
+                                        });
+                                    }
+                                    else if (Array.isArray(rawInput.todos)) {
+                                        // Claude format: array of objects
+                                        todoItems = rawInput.todos.map(t => ({
                                             id: t.id || `todo-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
                                             content: t.content,
                                             status: t.status,
                                             priority: t.priority,
                                         }));
+                                    }
+                                    if (todoItems.length > 0) {
+                                        // Update the logger's todo list for the build panel
                                         logger.updateTodos(todoItems);
                                         // Get completed todos (excluding any "summarize" todos from old prompts)
-                                        const completed = input.todos
+                                        const completed = todoItems
                                             .filter(t => t.status === 'completed' && !t.content.toLowerCase().includes('summarize'))
                                             .map(t => t.content);
                                         // Update our list with the latest completed todos
@@ -14553,7 +12858,7 @@ async function startRunner(options = {}) {
                     // Detect framework from generated files
                     let detectedFramework = null;
                     try {
-                        const { detectFrameworkFromFilesystem } = await import('./chunks/port-allocator-Ct3ioni4.js');
+                        const { detectFrameworkFromFilesystem } = await import('./chunks/port-allocator-DuAZe2_S.js');
                         const framework = await detectFrameworkFromFilesystem(projectDirectory);
                         detectedFramework = framework;
                         if (framework) {
@@ -14592,11 +12897,25 @@ ${filesArray.length > 0 ? `Files modified:\n${filesArray.map(f => `- ${f}`).join
 ${completedTodoSnapshot.length > 0 ? `Tasks completed:\n${completedTodoSnapshot.map(t => `- ${t}`).join('\n')}` : ''}
 
 Write a brief, professional summary (1-3 sentences) describing what was accomplished. Focus on the outcome, not the process. Do not use phrases like "I did" or "The assistant". Just describe what was built or changed.`;
-                                const summaryResult = await generateText({
-                                    model: claudeCode("claude-haiku-4-5"),
+                                // Use native Claude Agent SDK for summary generation
+                                let summaryText = '';
+                                for await (const msg of query({
                                     prompt: summaryPrompt,
-                                });
-                                const summaryText = summaryResult.text?.trim();
+                                    options: {
+                                        model: 'claude-haiku-4-5',
+                                        maxTurns: 1,
+                                        permissionMode: 'default',
+                                    },
+                                })) {
+                                    if (msg.type === 'assistant' && msg.message?.content) {
+                                        for (const block of msg.message.content) {
+                                            if (block.type === 'text') {
+                                                summaryText += block.text;
+                                            }
+                                        }
+                                    }
+                                }
+                                summaryText = summaryText.trim();
                                 if (summaryText) {
                                     buildLog(` ✅ AI summary generated (${summaryText.length} chars)`);
                                     sendEvent({
@@ -14641,7 +12960,7 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : "Failed to run build";
                     logger.buildFailed(errorMessage);
-                    getActiveSpan()?.setStatus({
+                    Sentry.getActiveSpan()?.setStatus({
                         code: 2, // SPAN_STATUS_ERROR
                         message: "Build failed",
                     });
@@ -14858,15 +13177,15 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
     }
     function publishStatus(projectId, commandId) {
         const uptimeSeconds = Math.round(process.uptime());
-        const load = os__default.loadavg?.()[0];
+        const load = os$1.loadavg?.()[0];
         sendEvent({
             type: "runner-status",
             ...buildEventBase(projectId, commandId),
             payload: {
                 status: "online",
                 version: "prototype",
-                hostname: os__default.hostname(),
-                platform: os__default.platform(),
+                hostname: os$1.hostname(),
+                platform: os$1.platform(),
                 uptimeSeconds,
                 load,
             },
@@ -14994,12 +13313,12 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                 // This creates a span within the continued trace for the runner's work
                 if (command._sentry?.trace) {
                     console.log("[runner] Continuing trace from frontend:", command._sentry.trace.substring(0, 50));
-                    await continueTrace({
+                    await Sentry.continueTrace({
                         sentryTrace: command._sentry.trace,
                         baggage: command._sentry.baggage,
                     }, async () => {
                         // Create a span for this command execution within the continued trace
-                        await startSpan({
+                        await Sentry.startSpan({
                             name: `runner.${command.type}`,
                             op: command.type === 'start-build' ? 'build.runner' : `runner.${command.type}`,
                             attributes: {
@@ -15010,9 +13329,9 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                             },
                         }, async (span) => {
                             try {
-                                setTag("command_type", command.type);
-                                setTag("project_id", projectIdForTelemetry);
-                                setTag("command_id", command.id);
+                                Sentry.setTag("command_type", command.type);
+                                Sentry.setTag("project_id", projectIdForTelemetry);
+                                Sentry.setTag("command_id", command.id);
                                 // Capture build metrics for start-build commands
                                 if (command.type === 'start-build' && command.payload) {
                                     const agent = command.payload.agent ?? 'claude-code';
@@ -15022,7 +13341,7 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                                             command.payload.claudeModel === 'claude-opus-4-5')
                                         ? command.payload.claudeModel
                                         : 'claude-sonnet-4-5';
-                                    count('runner.build.started', 1, {
+                                    Sentry.metrics.count('runner.build.started', 1, {
                                         attributes: {
                                             project_id: command.projectId,
                                             model: agent === 'claude-code' ? claudeModel : agent,
@@ -15043,7 +13362,7 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                 else {
                     console.log("[runner] No trace context - starting isolated span");
                     // Create an isolated span when no trace context is provided
-                    await startSpan({
+                    await Sentry.startSpan({
                         name: `runner.${command.type}`,
                         op: command.type === 'start-build' ? 'build.runner' : `runner.${command.type}`,
                         attributes: {
@@ -15054,9 +13373,9 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                         },
                     }, async (span) => {
                         try {
-                            setTag("command_type", command.type);
-                            setTag("project_id", projectIdForTelemetry);
-                            setTag("command_id", command.id);
+                            Sentry.setTag("command_type", command.type);
+                            Sentry.setTag("project_id", projectIdForTelemetry);
+                            Sentry.setTag("command_id", command.id);
                             // Capture build metrics for start-build commands
                             if (command.type === 'start-build' && command.payload) {
                                 const agent = command.payload.agent ?? 'claude-code';
@@ -15066,7 +13385,7 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                                         command.payload.claudeModel === 'claude-opus-4-5')
                                     ? command.payload.claudeModel
                                     : 'claude-sonnet-4-5';
-                                count('runner.build.started', 1, {
+                                Sentry.metrics.count('runner.build.started', 1, {
                                     attributes: {
                                         project_id: command.projectId,
                                         model: agent === 'claude-code' ? claudeModel : agent,
@@ -15086,7 +13405,7 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
             }
             catch (error) {
                 console.error("Failed to parse command", error);
-                captureException(error);
+                Sentry.captureException(error);
                 sendEvent({
                     type: "error",
                     ...buildEventBase(undefined, randomUUID$1()),
@@ -15178,7 +13497,7 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
         // Final cleanup of any remaining tunnels
         await tunnelManager.closeAll();
         // Flush Sentry events before exiting
-        await flush(2000);
+        await Sentry.flush(2000);
         log("shutdown complete");
     };
     process.on("SIGINT", async () => {