@openbuilder/cli 0.50.46 → 0.50.49

package/dist/index.js

@@ -18,11 +18,11 @@ 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 os$1 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 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';
@@ -202,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",
@@ -210,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",
@@ -218,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",
@@ -226,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"
           }
         ]
       },
@@ -1269,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.
 
@@ -2099,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) {
@@ -4551,7 +4676,7 @@ var AgentCore = /*#__PURE__*/Object.freeze({
  * 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.
@@ -4563,9 +4688,9 @@ var AgentCore = /*#__PURE__*/Object.freeze({
  * - Direct streaming without adaptation layer
  */
 // Debug logging helper - suppressed in TUI mode (SILENT_MODE=1)
-const debugLog$3 = (message) => {
+const debugLog$4 = (message) => {
     if (process.env.SILENT_MODE !== '1' && process.env.DEBUG_BUILD === '1') {
-        debugLog$3();
+        debugLog$4();
     }
 };
 /**
@@ -4684,10 +4809,10 @@ function buildPromptWithImages(prompt, messageParts) {
  */
 function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortController) {
     return async function* nativeClaudeQuery(prompt, workingDirectory, systemPrompt, _agent, _codexThreadId, messageParts) {
-        debugLog$3();
-        debugLog$3();
-        debugLog$3();
-        debugLog$3(`[runner] [native-sdk] Prompt length: ${prompt.length}\n`);
+        debugLog$4();
+        debugLog$4();
+        debugLog$4();
+        debugLog$4(`[runner] [native-sdk] Prompt length: ${prompt.length}\n`);
         // Build combined system prompt
         const systemPromptSegments = [CLAUDE_SYSTEM_PROMPT.trim()];
         if (systemPrompt && systemPrompt.trim().length > 0) {
@@ -4703,7 +4828,7 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         const hasImages = messageParts?.some(p => p.type === 'image');
         if (hasImages) {
             messageParts?.filter(p => p.type === 'image').length || 0;
-            debugLog$3();
+            debugLog$4();
         }
         // Build the final prompt
         const finalPrompt = buildPromptWithImages(prompt);
@@ -4737,7 +4862,7 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
             // See: https://github.com/anthropics/claude-agent-sdk-typescript/issues/46
             abortController,
         };
-        debugLog$3();
+        debugLog$4();
         let messageCount = 0;
         let toolCallCount = 0;
         let textBlockCount = 0;
@@ -4754,7 +4879,7 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                         for (const block of transformed.message.content) {
                             if (block.type === 'tool_use') {
                                 toolCallCount++;
-                                debugLog$3(`[runner] [native-sdk] 🔧 Tool call: ${block.name}\n`);
+                                debugLog$4(`[runner] [native-sdk] 🔧 Tool call: ${block.name}\n`);
                             }
                             else if (block.type === 'text') {
                                 textBlockCount++;
@@ -4766,17 +4891,17 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                 // Log result messages
                 if (sdkMessage.type === 'result') {
                     if (sdkMessage.subtype === 'success') {
-                        debugLog$3(`[runner] [native-sdk] ✅ Query complete - ${sdkMessage.num_turns} turns, $${sdkMessage.total_cost_usd?.toFixed(4)} USD\n`);
+                        debugLog$4(`[runner] [native-sdk] ✅ Query complete - ${sdkMessage.num_turns} turns, $${sdkMessage.total_cost_usd?.toFixed(4)} USD\n`);
                     }
                     else {
-                        debugLog$3(`[runner] [native-sdk] ⚠️  Query ended with: ${sdkMessage.subtype}\n`);
+                        debugLog$4(`[runner] [native-sdk] ⚠️  Query ended with: ${sdkMessage.subtype}\n`);
                     }
                 }
             }
-            debugLog$3(`[runner] [native-sdk] 📊 Stream complete - ${messageCount} messages, ${toolCallCount} tool calls, ${textBlockCount} text blocks\n`);
+            debugLog$4(`[runner] [native-sdk] 📊 Stream complete - ${messageCount} messages, ${toolCallCount} tool calls, ${textBlockCount} text blocks\n`);
         }
         catch (error) {
-            debugLog$3(`[runner] [native-sdk] ❌ Error: ${error instanceof Error ? error.message : String(error)}\n`);
+            debugLog$4(`[runner] [native-sdk] ❌ Error: ${error instanceof Error ? error.message : String(error)}\n`);
             Sentry.captureException(error);
             throw error;
         }
@@ -4796,7 +4921,7 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
  * - Runner receives events and transforms them to SSE format for the frontend
  */
 // Debug logging helper
-const debugLog$2 = (message) => {
+const debugLog$3 = (message) => {
     if (process.env.SILENT_MODE !== '1' && process.env.DEBUG_BUILD === '1') {
         console.error(message);
     }
@@ -4961,10 +5086,10 @@ function parseSSEEvent(data) {
  */
 function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
     return async function* openCodeQuery(prompt, workingDirectory, systemPrompt, _agent, _codexThreadId, messageParts) {
-        debugLog$2('[runner] [opencode-sdk] Starting OpenCode query');
-        debugLog$2(`[runner] [opencode-sdk] Model: ${modelId}`);
-        debugLog$2(`[runner] [opencode-sdk] Working dir: ${workingDirectory}`);
-        debugLog$2(`[runner] [opencode-sdk] Prompt length: ${prompt.length}`);
+        debugLog$3('[runner] [opencode-sdk] Starting OpenCode query');
+        debugLog$3(`[runner] [opencode-sdk] Model: ${modelId}`);
+        debugLog$3(`[runner] [opencode-sdk] Working dir: ${workingDirectory}`);
+        debugLog$3(`[runner] [opencode-sdk] Prompt length: ${prompt.length}`);
         // Ensure working directory exists
         if (!existsSync(workingDirectory)) {
             console.log(`[opencode-sdk] Creating working directory: ${workingDirectory}`);
@@ -5004,7 +5129,7 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
         });
         try {
             // Step 1: Create a session
-            debugLog$2('[runner] [opencode-sdk] Creating session...');
+            debugLog$3('[runner] [opencode-sdk] Creating session...');
             const sessionResponse = await fetch(`${baseUrl}/session`, {
                 method: 'POST',
                 headers,
@@ -5018,13 +5143,13 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
             }
             const session = await sessionResponse.json();
             sessionId = session.id;
-            debugLog$2(`[runner] [opencode-sdk] Session created: ${sessionId}`);
+            debugLog$3(`[runner] [opencode-sdk] Session created: ${sessionId}`);
             // Update span with session info
             if (sessionId) {
                 aiSpan?.setAttribute('opencode.session_id', sessionId);
             }
             // Step 2: Subscribe to events
-            debugLog$2('[runner] [opencode-sdk] Subscribing to events...');
+            debugLog$3('[runner] [opencode-sdk] Subscribing to events...');
             const eventResponse = await fetch(`${baseUrl}/event`, {
                 headers: {
                     ...headers,
@@ -5045,7 +5170,7 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
                             image: part.image,
                             mimeType: part.mimeType || 'image/png',
                         });
-                        debugLog$2('[runner] [opencode-sdk] Added image part');
+                        debugLog$3('[runner] [opencode-sdk] Added image part');
                     }
                 }
             }
@@ -5055,7 +5180,7 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
                 text: prompt,
             });
             // Step 4: Send the prompt (don't await - we'll stream the response)
-            debugLog$2('[runner] [opencode-sdk] Sending prompt...');
+            debugLog$3('[runner] [opencode-sdk] Sending prompt...');
             const promptPromise = fetch(`${baseUrl}/session/${sessionId}/message`, {
                 method: 'POST',
                 headers,
@@ -5079,7 +5204,7 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
                 while (!completed) {
                     const { done, value } = await reader.read();
                     if (done) {
-                        debugLog$2('[runner] [opencode-sdk] Event stream ended');
+                        debugLog$3('[runner] [opencode-sdk] Event stream ended');
                         break;
                     }
                     buffer += decoder.decode(value, { stream: true });
@@ -5147,14 +5272,14 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
                     subtype: 'success',
                 };
             }
-            debugLog$2('[runner] [opencode-sdk] Query complete');
+            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$2(`[runner] [opencode-sdk] Error: ${error instanceof Error ? error.message : String(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) });
@@ -5177,10 +5302,518 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
  * Feature flag to control which implementation to use
  *
  * Default: Claude Agent SDK (native)
- * Set USE_OPENCODE_SDK=1 to enable OpenCode multi-provider support
+ * Set ENABLE_OPENCODE_SDK=true 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;
+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`);
+            }
+        });
+        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`);
+                }
+            }
+            process.stderr.write(`[runner] [droid-sdk] Stream finished - ${messageCount} events, ${toolCallCount} tool calls, last event: ${lastEventType}\n`);
+        }
+        catch (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 {
+            // Cleanup session
+            await session.close();
+        }
+    };
+}
 
 // src/lib/logging/build-logger.ts
 var BuildLogger = class {
@@ -5622,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",
@@ -5630,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",
@@ -5638,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",
@@ -5646,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"
           }
         ]
       },
@@ -6689,6 +7353,94 @@ var init_codex_strategy = __esm({
   }
 });
 
+// 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 droidStrategy, droid_strategy_default;
+var init_droid_strategy = __esm({
+  "src/lib/agents/droid-strategy.ts"() {
+    init_resolver();
+    droidStrategy = {
+      buildSystemPromptSections: buildDroidSections,
+      buildFullPrompt: buildFullPrompt3,
+      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 = droidStrategy;
+  }
+});
+
 // src/lib/agents/strategy.ts
 var strategyRegistry = /* @__PURE__ */ new Map();
 function registerAgentStrategy(agentId, strategy) {
@@ -6708,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) {
@@ -9264,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",
@@ -9272,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",
@@ -9280,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",
@@ -9288,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"
       }
     ]
   },
@@ -10312,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"
@@ -10327,6 +11125,16 @@ function createBuildQuery(agent, modelId, abortController) {
         console.log('[runner] 🔄 Using direct Codex SDK (fallback mode)');
         return createCodexQuery();
     }
+    // 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');
     return createNativeClaudeQuery(modelId ?? DEFAULT_CLAUDE_MODEL_ID, abortController);
@@ -10839,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) {
@@ -11617,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" ||
@@ -11625,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
@@ -11646,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);
@@ -11898,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