@calltelemetry/openclaw-linear 0.3.1 → 0.4.0

package/index.ts

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { registerLinearProvider } from "./src/auth.js";
 import { registerCli } from "./src/cli.js";
@@ -22,7 +23,7 @@ export default function register(api: OpenClawPluginApi) {
   registerLinearProvider(api);
 
   // Register CLI commands: openclaw openclaw-linear auth|status
-  api.registerCli(({ program }) => registerCli(program, api), {
+  api.registerCli(({ program }) => registerCli(program as any, api), {
     commands: ["openclaw-linear"],
   });
 
@@ -55,8 +56,55 @@ export default function register(api: OpenClawPluginApi) {
     },
   });
 
+  // Narration Guard: catch short "Let me explore..." responses that narrate intent
+  // without actually calling tools, and append a warning for the user.
+  const NARRATION_PATTERNS = [
+    /let me (explore|look|investigate|check|dig|analyze|search|find|review|examine)/i,
+    /i('ll| will) (explore|look into|investigate|check|dig into|analyze|search|find|review)/i,
+    /let me (take a look|dive into|pull up|go through)/i,
+  ];
+  const MAX_SHORT_RESPONSE = 250;
+
+  api.on("message_sending", (event: { content?: string }) => {
+    const text = event?.content ?? "";
+    if (!text || text.length > MAX_SHORT_RESPONSE) return {};
+    const isNarration = NARRATION_PATTERNS.some((p) => p.test(text));
+    if (!isNarration) return {};
+    api.logger.warn(`Narration guard triggered: "${text.slice(0, 80)}..."`);
+    return {
+      content:
+        text +
+        "\n\n⚠️ _Agent acknowledged but may not have completed the task. Try asking again or rephrase your request._",
+    };
+  });
+
+  // Check CLI availability (Codex, Claude, Gemini)
+  const cliChecks: Record<string, string> = {};
+  const cliBins: [string, string, string][] = [
+    ["codex", "/home/claw/.npm-global/bin/codex", "npm install -g @openai/codex"],
+    ["claude", "/home/claw/.npm-global/bin/claude", "npm install -g @anthropic-ai/claude-code"],
+    ["gemini", "/home/claw/.npm-global/bin/gemini", "npm install -g @anthropic-ai/gemini-cli"],
+  ];
+  for (const [name, bin, installCmd] of cliBins) {
+    try {
+      const raw = execFileSync(bin, ["--version"], {
+        encoding: "utf8",
+        timeout: 5_000,
+        env: { ...process.env, CLAUDECODE: undefined } as any,
+      }).trim();
+      cliChecks[name] = raw || "unknown";
+    } catch {
+      cliChecks[name] = "not found";
+      api.logger.warn(
+        `${name} CLI not found at ${bin}. The ${name}_run tool will fail. Install with: ${installCmd}`,
+      );
+    }
+  }
+
   const agentId = (pluginConfig?.defaultAgentId as string) ?? "default";
+  const orchestration = pluginConfig?.enableOrchestration !== false ? "enabled" : "disabled";
+  const cliSummary = Object.entries(cliChecks).map(([k, v]) => `${k}: ${v}`).join(", ");
   api.logger.info(
-    `Linear agent extension registered (agent: ${agentId}, token: ${tokenInfo.source !== "none" ? `${tokenInfo.source}` : "missing"})`,
+    `Linear agent extension registered (agent: ${agentId}, token: ${tokenInfo.source !== "none" ? `${tokenInfo.source}` : "missing"}, ${cliSummary}, orchestration: ${orchestration})`,
   );
 }

package/openclaw.plugin.json

@@ -5,13 +5,19 @@
   "version": "0.2.0",
   "configSchema": {
     "type": "object",
+    "additionalProperties": false,
     "properties": {
+      "enabled": { "type": "boolean" },
       "clientId": { "type": "string", "description": "Linear OAuth Client ID" },
       "clientSecret": { "type": "string", "description": "Linear OAuth Client Secret", "sensitive": true },
       "redirectUri": { "type": "string", "description": "Linear OAuth Redirect URI (optional, defaults to gateway URL)" },
       "accessToken": { "type": "string", "description": "Linear API access token for agent activities", "sensitive": true },
       "defaultAgentId": { "type": "string", "description": "OpenClaw agent ID to use for pipeline stages" },
-      "enableAudit": { "type": "boolean", "description": "Run auditor stage after implementation", "default": true }
+      "enableAudit": { "type": "boolean", "description": "Run auditor stage after implementation", "default": true },
+      "codexBaseRepo": { "type": "string", "description": "Path to git repo for Codex worktrees", "default": "/home/claw/ai-workspace" },
+      "codexModel": { "type": "string", "description": "Default Codex model (optional — uses Codex default if omitted)" },
+      "codexTimeoutMs": { "type": "number", "description": "Default Codex timeout in milliseconds", "default": 600000 },
+      "enableOrchestration": { "type": "boolean", "description": "Allow agents to spawn sub-agents via spawn_agent/ask_agent tools", "default": true }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,8 @@
     "access": "public"
   },
   "devDependencies": {
-    "openclaw": "^2026.2.13"
+    "openclaw": "^2026.2.13",
+    "typescript": "^5.9.3"
   },
   "openclaw": {
     "extensions": [

package/src/active-session.ts

@@ -0,0 +1,66 @@
+/**
+ * active-session.ts — Idempotent registry of active Linear agent sessions.
+ *
+ * When the pipeline starts work on an issue, it registers the session here.
+ * Any tool (code_run, etc.) can look up the active session for the current
+ * issue to stream activities without relying on the LLM agent to pass params.
+ *
+ * This runs in the gateway process. Tool execution also happens in the gateway,
+ * so tools can read from this registry directly.
+ */
+
+export interface ActiveSession {
+  agentSessionId: string;
+  issueIdentifier: string;
+  issueId: string;
+  agentId?: string;
+  startedAt: number;
+}
+
+// Keyed by issue ID — one active session per issue at a time.
+const sessions = new Map<string, ActiveSession>();
+
+/**
+ * Register the active session for an issue. Idempotent — calling again
+ * for the same issue just updates the session.
+ */
+export function setActiveSession(session: ActiveSession): void {
+  sessions.set(session.issueId, session);
+}
+
+/**
+ * Clear the active session for an issue.
+ */
+export function clearActiveSession(issueId: string): void {
+  sessions.delete(issueId);
+}
+
+/**
+ * Look up the active session for an issue by issue ID.
+ */
+export function getActiveSession(issueId: string): ActiveSession | null {
+  return sessions.get(issueId) ?? null;
+}
+
+/**
+ * Look up the active session by issue identifier (e.g. "API-472").
+ * Slower than by ID — scans all sessions.
+ */
+export function getActiveSessionByIdentifier(identifier: string): ActiveSession | null {
+  for (const session of sessions.values()) {
+    if (session.issueIdentifier === identifier) return session;
+  }
+  return null;
+}
+
+/**
+ * Get the current active session. If there's exactly one, return it.
+ * If there are multiple (concurrent pipelines), returns null — caller
+ * must specify which issue.
+ */
+export function getCurrentSession(): ActiveSession | null {
+  if (sessions.size === 1) {
+    return sessions.values().next().value ?? null;
+  }
+  return null;
+}

package/src/agent.ts

@@ -1,21 +1,193 @@
+import { randomUUID } from "node:crypto";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { LinearAgentApi, ActivityContent } from "./linear-api.js";
+
+// Import extensionAPI for embedded agent runner (internal, not in public SDK)
+let _extensionAPI: typeof import("/home/claw/.npm-global/lib/node_modules/openclaw/dist/extensionAPI.js") | null = null;
+async function getExtensionAPI() {
+  if (!_extensionAPI) {
+    // Dynamic import to avoid blocking module load if unavailable
+    _extensionAPI = await import(
+      "/home/claw/.npm-global/lib/node_modules/openclaw/dist/extensionAPI.js"
+    );
+  }
+  return _extensionAPI;
+}
 
 export interface AgentRunResult {
   success: boolean;
   output: string;
 }
 
+export interface AgentStreamCallbacks {
+  linearApi: LinearAgentApi;
+  agentSessionId: string;
+}
+
+/**
+ * Run an agent using the embedded runner with streaming callbacks.
+ * Falls back to subprocess if the embedded runner is unavailable.
+ */
 export async function runAgent(params: {
   api: OpenClawPluginApi;
   agentId: string;
   sessionId: string;
   message: string;
   timeoutMs?: number;
+  streaming?: AgentStreamCallbacks;
 }): Promise<AgentRunResult> {
-  const { api, agentId, sessionId, message, timeoutMs = 5 * 60_000 } = params;
+  const { api, agentId, sessionId, message, timeoutMs = 5 * 60_000, streaming } = params;
 
   api.logger.info(`Dispatching agent ${agentId} for session ${sessionId}`);
 
+  // Try embedded runner first (has streaming callbacks)
+  if (streaming) {
+    try {
+      return await runEmbedded(api, agentId, sessionId, message, timeoutMs, streaming);
+    } catch (err) {
+      api.logger.warn(`Embedded runner failed, falling back to subprocess: ${err}`);
+    }
+  }
+
+  // Fallback: subprocess (no streaming)
+  return runSubprocess(api, agentId, sessionId, message, timeoutMs);
+}
+
+/**
+ * Embedded agent runner with real-time streaming to Linear.
+ */
+async function runEmbedded(
+  api: OpenClawPluginApi,
+  agentId: string,
+  sessionId: string,
+  message: string,
+  timeoutMs: number,
+  streaming: AgentStreamCallbacks,
+): Promise<AgentRunResult> {
+  const ext = await getExtensionAPI();
+
+  const workspaceDir = ext.resolveAgentWorkspaceDir({ agentId });
+  const sessionFile = ext.resolveSessionFilePath(sessionId);
+  const agentDir = ext.resolveAgentDir({ agentId });
+  const runId = randomUUID();
+
+  // Load config so embedded runner can resolve providers, API keys, etc.
+  const config = await api.runtime.config.loadConfig();
+
+  // Resolve model/provider from config — default is anthropic which requires
+  // a separate API key. Our agents use openrouter.
+  const configAny = config as Record<string, any>;
+  const agentList = configAny?.agents?.list as Array<Record<string, any>> | undefined;
+  const agentEntry = agentList?.find((a) => a.id === agentId);
+  const modelRef: string =
+    agentEntry?.model?.primary ??
+    configAny?.agents?.defaults?.model?.primary ??
+    `${ext.DEFAULT_PROVIDER}/${ext.DEFAULT_MODEL}`;
+
+  // Parse "provider/model-id" format (e.g. "openrouter/moonshotai/kimi-k2.5")
+  const slashIdx = modelRef.indexOf("/");
+  const provider = slashIdx > 0 ? modelRef.slice(0, slashIdx) : ext.DEFAULT_PROVIDER;
+  const model = slashIdx > 0 ? modelRef.slice(slashIdx + 1) : modelRef;
+
+  api.logger.info(`Embedded agent run: agent=${agentId} session=${sessionId} runId=${runId} provider=${provider} model=${model}`);
+
+  const emit = (content: ActivityContent) => {
+    streaming.linearApi.emitActivity(streaming.agentSessionId, content).catch((err) => {
+      api.logger.warn(`Activity emit failed: ${err}`);
+    });
+  };
+
+  // Track last emitted tool to avoid duplicates
+  let lastToolAction = "";
+
+  const result = await ext.runEmbeddedPiAgent({
+    sessionId,
+    sessionFile,
+    workspaceDir,
+    agentDir,
+    prompt: message,
+    agentId,
+    runId,
+    timeoutMs,
+    config,
+    provider,
+    model,
+    shouldEmitToolResult: () => true,
+    shouldEmitToolOutput: () => true,
+
+    // Stream reasoning/thinking to Linear
+    onReasoningStream: (payload) => {
+      const text = payload.text?.trim();
+      if (text && text.length > 10) {
+        emit({ type: "thought", body: text.slice(0, 500) });
+      }
+    },
+
+    // Stream tool results to Linear
+    onToolResult: (payload) => {
+      const text = payload.text?.trim();
+      if (text) {
+        // Truncate tool results for activity display
+        const truncated = text.length > 300 ? text.slice(0, 300) + "..." : text;
+        emit({ type: "action", action: lastToolAction || "Tool result", parameter: truncated });
+      }
+    },
+
+    // Raw agent events — capture tool starts/ends
+    onAgentEvent: (evt) => {
+      const { stream, data } = evt;
+
+      if (stream !== "tool") return;
+
+      const phase = String(data.phase ?? "");
+      const toolName = String(data.name ?? "tool");
+      const meta = typeof data.meta === "string" ? data.meta : "";
+
+      // Tool execution start — emit action with tool name + meta
+      if (phase === "start") {
+        lastToolAction = toolName;
+        emit({ type: "action", action: `Running ${toolName}`, parameter: meta.slice(0, 200) || toolName });
+      }
+
+      // Tool execution result with error
+      if (phase === "result" && data.isError) {
+        emit({ type: "action", action: `${toolName} failed`, parameter: meta.slice(0, 200) || "error" });
+      }
+    },
+
+    // Partial assistant text (for long responses)
+    onPartialReply: (payload) => {
+      // We don't emit every partial chunk to avoid flooding Linear
+      // The final response will be posted as a comment
+    },
+  });
+
+  // Extract output text from payloads
+  const payloads = result.payloads ?? [];
+  const outputText = payloads
+    .map((p) => p.text)
+    .filter(Boolean)
+    .join("\n\n");
+
+  if (result.meta?.error) {
+    api.logger.error(`Embedded agent error: ${result.meta.error.kind}: ${result.meta.error.message}`);
+    return { success: false, output: outputText || result.meta.error.message };
+  }
+
+  api.logger.info(`Embedded agent completed: agent=${agentId} session=${sessionId} duration=${result.meta.durationMs}ms`);
+  return { success: true, output: outputText || "(no output)" };
+}
+
+/**
+ * Subprocess fallback (no streaming, used when no Linear session context).
+ */
+async function runSubprocess(
+  api: OpenClawPluginApi,
+  agentId: string,
+  sessionId: string,
+  message: string,
+  timeoutMs: number,
+): Promise<AgentRunResult> {
   const command = [
     "openclaw",
     "agent",

package/src/auth.ts

@@ -46,7 +46,7 @@ export function registerLinearProvider(api: OpenClawPluginApi) {
       {
         id: "oauth",
         label: "OAuth",
-        kind: "oauth",
+        kind: "oauth" as const,
         run: async (ctx: ProviderAuthContext): Promise<ProviderAuthResult> => {
           // This is a placeholder for the actual OAuth flow.
           // In a real implementation, we would use ctx.oauth.createVpsAwareHandlers
@@ -112,8 +112,12 @@ export function registerLinearProvider(api: OpenClawPluginApi) {
               {
                 profileId: "linear:default",
                 credential: {
-                  type: "oauth",
+                  type: "oauth" as const,
                   provider: "linear",
+                  access: tokens.access_token,
+                  refresh: tokens.refresh_token,
+                  expires: Date.now() + (tokens.expires_in * 1000),
+                  // Keep aliases for backward compat with linear-api.ts resolveLinearToken
                   accessToken: tokens.access_token,
                   refreshToken: tokens.refresh_token,
                   expiresAt: Date.now() + (tokens.expires_in * 1000),

package/src/claude-tool.ts

@@ -0,0 +1,280 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { ActivityContent } from "./linear-api.js";
+import {
+  buildLinearApi,
+  resolveSession,
+  extractPrompt,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_BASE_REPO,
+  type CliToolParams,
+  type CliResult,
+} from "./cli-shared.js";
+
+const CLAUDE_BIN = "/home/claw/.npm-global/bin/claude";
+
+/**
+ * Map a Claude Code stream-json JSONL event to a Linear activity.
+ *
+ * Claude event types:
+ *   system(init) → assistant (text|tool_use) → user (tool_result) → result
+ */
+function mapClaudeEventToActivity(event: any): ActivityContent | null {
+  const type = event?.type;
+
+  // Assistant message — text response or tool use
+  if (type === "assistant") {
+    const content = event.message?.content;
+    if (!Array.isArray(content)) return null;
+
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        return { type: "thought", body: block.text.slice(0, 1000) };
+      }
+      if (block.type === "tool_use") {
+        const toolName = block.name ?? "tool";
+        const input = block.input ?? {};
+        // Summarize the input for display
+        let paramSummary: string;
+        if (input.command) {
+          paramSummary = String(input.command).slice(0, 200);
+        } else if (input.file_path) {
+          paramSummary = String(input.file_path);
+        } else if (input.pattern) {
+          paramSummary = String(input.pattern);
+        } else if (input.query) {
+          paramSummary = String(input.query).slice(0, 200);
+        } else {
+          paramSummary = JSON.stringify(input).slice(0, 200);
+        }
+        return { type: "action", action: `Running ${toolName}`, parameter: paramSummary };
+      }
+    }
+    return null;
+  }
+
+  // Tool result
+  if (type === "user") {
+    const content = event.message?.content;
+    if (!Array.isArray(content)) return null;
+
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        const output = typeof block.content === "string" ? block.content : "";
+        const truncated = output.length > 300 ? output.slice(0, 300) + "..." : output;
+        const isError = block.is_error === true;
+        return {
+          type: "action",
+          action: isError ? "Tool error" : "Tool result",
+          parameter: truncated || "(no output)",
+        };
+      }
+    }
+    return null;
+  }
+
+  // Final result
+  if (type === "result") {
+    const cost = event.total_cost_usd;
+    const turns = event.num_turns ?? 0;
+    const usage = event.usage;
+    const parts: string[] = [`Claude completed (${turns} turns)`];
+    if (cost != null) parts.push(`$${cost.toFixed(4)}`);
+    if (usage) {
+      const input = usage.input_tokens ?? 0;
+      const output = usage.output_tokens ?? 0;
+      parts.push(`${input} in / ${output} out tokens`);
+    }
+    return { type: "thought", body: parts.join(" — ") };
+  }
+
+  return null;
+}
+
+/**
+ * Run Claude Code CLI with JSONL streaming, mapping events to Linear activities.
+ */
+export async function runClaude(
+  api: OpenClawPluginApi,
+  params: CliToolParams,
+  pluginConfig?: Record<string, unknown>,
+): Promise<CliResult> {
+  api.logger.info(`claude_run params: ${JSON.stringify(params).slice(0, 500)}`);
+
+  const prompt = extractPrompt(params);
+  if (!prompt) {
+    return {
+      success: false,
+      output: `claude_run error: no prompt provided. Received keys: ${Object.keys(params).join(", ")}`,
+      error: "missing prompt",
+    };
+  }
+
+  const { model, timeoutMs } = params;
+  const { agentSessionId, issueIdentifier } = resolveSession(params);
+
+  api.logger.info(`claude_run: session=${agentSessionId ?? "none"}, issue=${issueIdentifier ?? "none"}`);
+
+  const timeout = timeoutMs ?? (pluginConfig?.claudeTimeoutMs as number) ?? DEFAULT_TIMEOUT_MS;
+  const workingDir = params.workingDir ?? (pluginConfig?.claudeBaseRepo as string) ?? DEFAULT_BASE_REPO;
+
+  const linearApi = buildLinearApi(api, agentSessionId);
+
+  if (linearApi && agentSessionId) {
+    await linearApi.emitActivity(agentSessionId, {
+      type: "thought",
+      body: `Starting Claude Code: "${prompt.slice(0, 100)}${prompt.length > 100 ? "..." : ""}"`,
+    }).catch(() => {});
+  }
+
+  // Build claude command
+  const args = [
+    "--print",
+    "--output-format", "stream-json",
+    "--verbose",
+    "--dangerously-skip-permissions",
+  ];
+  if (model ?? pluginConfig?.claudeModel) {
+    args.push("--model", (model ?? pluginConfig?.claudeModel) as string);
+  }
+  args.push("-C", workingDir);
+  args.push("-p", prompt);
+
+  api.logger.info(`Claude exec: ${CLAUDE_BIN} ${args.join(" ").slice(0, 200)}...`);
+
+  return new Promise<CliResult>((resolve) => {
+    // Must unset CLAUDECODE to avoid "nested session" error
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+
+    const child = spawn(CLAUDE_BIN, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      timeout: 0,
+    });
+
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+      setTimeout(() => { if (!child.killed) child.kill("SIGKILL"); }, 5_000);
+    }, timeout);
+
+    const collectedMessages: string[] = [];
+    const collectedCommands: string[] = [];
+    let stderrOutput = "";
+    let lastToolName = "";
+
+    const rl = createInterface({ input: child.stdout! });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+
+      let event: any;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        collectedMessages.push(line);
+        return;
+      }
+
+      // Collect assistant text for final output
+      if (event.type === "assistant") {
+        const content = event.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "text" && block.text) {
+              collectedMessages.push(block.text);
+            }
+            if (block.type === "tool_use") {
+              lastToolName = block.name ?? "tool";
+            }
+          }
+        }
+      }
+
+      // Collect tool results for final output
+      if (event.type === "user") {
+        const content = event.message?.content;
+        const toolResult = event.tool_use_result;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result") {
+              const output = toolResult?.stdout ?? (typeof block.content === "string" ? block.content : "");
+              const isError = block.is_error === true;
+              const truncOutput = output.length > 500 ? output.slice(0, 500) + "..." : output;
+              if (truncOutput) {
+                collectedCommands.push(
+                  `\`${lastToolName}\` → ${isError ? "error" : "ok"}${truncOutput ? "\n```\n" + truncOutput + "\n```" : ""}`
+                );
+              }
+            }
+          }
+        }
+      }
+
+      // Collect final result text
+      if (event.type === "result" && event.result) {
+        // result.result contains the final answer — only add if we haven't already captured it
+        // (it duplicates the last assistant text message)
+      }
+
+      // Stream activity to Linear
+      const activity = mapClaudeEventToActivity(event);
+      if (activity && linearApi && agentSessionId) {
+        linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+          api.logger.warn(`Failed to emit Claude activity: ${err}`);
+        });
+      }
+    });
+
+    child.stderr?.on("data", (chunk) => {
+      stderrOutput += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      rl.close();
+
+      const parts: string[] = [];
+      if (collectedMessages.length > 0) parts.push(collectedMessages.join("\n\n"));
+      if (collectedCommands.length > 0) parts.push(collectedCommands.join("\n\n"));
+      const output = parts.join("\n\n") || stderrOutput || "(no output)";
+
+      if (killed) {
+        api.logger.warn(`Claude timed out after ${timeout}ms`);
+        resolve({
+          success: false,
+          output: `Claude timed out after ${Math.round(timeout / 1000)}s. Partial output:\n${output}`,
+          error: "timeout",
+        });
+        return;
+      }
+
+      if (code !== 0) {
+        api.logger.warn(`Claude exited with code ${code}`);
+        resolve({
+          success: false,
+          output: `Claude failed (exit ${code}):\n${output}`,
+          error: `exit ${code}`,
+        });
+        return;
+      }
+
+      api.logger.info(`Claude completed successfully`);
+      resolve({ success: true, output });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      rl.close();
+      api.logger.error(`Claude spawn error: ${err}`);
+      resolve({
+        success: false,
+        output: `Failed to start Claude: ${err.message}`,
+        error: err.message,
+      });
+    });
+  });
+}
+