@stackmemoryai/stackmemory 1.3.0 → 1.3.2

package/dist/src/cli/commands/symphony.js

@@ -5,9 +5,10 @@ const __dirname = __pathDirname(__filename);
 import { Command } from "commander";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
+import { homedir, tmpdir } from "os";
 import Database from "better-sqlite3";
 import { logger } from "../../core/monitoring/logger.js";
+import { SymphonyOrchestrator } from "./symphony-orchestrator.js";
 function getGlobalStorePath() {
   const dir = join(homedir(), ".stackmemory", "symphony");
   if (!existsSync(dir)) {
@@ -260,6 +261,34 @@ function createSymphonyCommands() {
     }
     globalDb.close();
   });
+  cmd.command("start").description("Start the Symphony orchestrator daemon").option("--team <id>", "Linear team ID").option(
+    "--states <states>",
+    "Comma-separated issue states to pick up",
+    "Todo"
+  ).option(
+    "--in-progress <state>",
+    "State name for in-progress",
+    "In Progress"
+  ).option(
+    "--in-review <state>",
+    "State name for completed review",
+    "In Review"
+  ).option("--poll <ms>", "Polling interval in milliseconds", "30000").option("--concurrency <n>", "Max concurrent agents", "3").option("--workspace-root <path>", "Workspace root directory").option("--repo <path>", "Git repo root for worktrees", process.cwd()).option("--branch <name>", "Base branch for worktrees", "main").option("--retries <n>", "Max retries per issue", "1").option("--turn-timeout <ms>", "Agent turn timeout in ms", "3600000").action(async (options) => {
+    const orchestrator = new SymphonyOrchestrator({
+      teamId: options.team,
+      activeStates: options.states.split(",").map((s) => s.trim()),
+      inProgressState: options.inProgress,
+      inReviewState: options.inReview,
+      pollIntervalMs: parseInt(options.poll, 10),
+      maxConcurrent: parseInt(options.concurrency, 10),
+      workspaceRoot: options.workspaceRoot || join(tmpdir(), "symphony_workspaces"),
+      repoRoot: options.repo,
+      baseBranch: options.branch,
+      maxRetries: parseInt(options.retries, 10),
+      turnTimeoutMs: parseInt(options.turnTimeout, 10)
+    });
+    await orchestrator.start();
+  });
   return cmd;
 }
 export {

package/dist/src/core/database/sqlite-adapter.js

@@ -292,11 +292,16 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     logger.info("FTS5 index rebuilt");
   }
   /**
-   * Incremental garbage collection: delete expired frames and cascade to related tables.
-   * Respects retention_policy per frame:
+   * Incremental garbage collection with generational compression.
+   *
+   * Phase 1 — Compress: Apply generational strategies to mature/old frames.
+   *   - 'digest_only': Strip inputs/outputs/events, keep digest + anchors
+   *   - 'anchors_only': Strip inputs/outputs/events/digest_json, keep digest_text + anchors
+   *   - 'keep_all': No compression
+   *
+   * Phase 2 — Delete: Remove frames past retention cutoffs.
    *   - 'keep_forever': never deleted
-   *   - 'default': deleted after retentionDays (default 90)
-   *   - 'archive': same as default
+   *   - 'default'/'archive': deleted after retentionDays (default 90)
    *   - 'ttl_30d': deleted after 30 days
    *   - 'ttl_7d': deleted after 7 days
    */
@@ -314,6 +319,62 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     const defaultCutoff = nowSec - retentionDays * 86400;
     const ttl30dCutoff = nowSec - 30 * 86400;
     const ttl7dCutoff = nowSec - 7 * 86400;
+    let framesCompressed = 0;
+    const gc = options.generationalGc;
+    if (gc && !dryRun) {
+      const youngDays = gc.youngCutoffDays ?? 1;
+      const matureDays = gc.matureCutoffDays ?? 7;
+      const oldDays = gc.oldCutoffDays ?? 30;
+      const youngCutoff = nowSec - youngDays * 86400;
+      const matureCutoff = nowSec - matureDays * 86400;
+      const matureStrategy = gc.mature_strategy ?? "digest_only";
+      if (matureStrategy !== "keep_all") {
+        const matureFrames = this.db.prepare(
+          `SELECT frame_id FROM frames
+             WHERE created_at < ? AND created_at >= ?
+             AND state = 'closed'
+             AND retention_policy != 'keep_forever'
+             AND inputs != '{}'
+             AND run_id NOT IN (SELECT value FROM json_each(?))
+             LIMIT ?`
+        ).all(
+          youngCutoff,
+          matureCutoff,
+          JSON.stringify(protectedRunIds),
+          batchSize
+        );
+        if (matureFrames.length > 0) {
+          framesCompressed += this.compressFrames(
+            matureFrames.map((f) => f.frame_id),
+            matureStrategy
+          );
+        }
+      }
+      const oldStrategy = gc.old_strategy ?? "anchors_only";
+      if (oldStrategy !== "keep_all") {
+        const oldCutoff = nowSec - oldDays * 86400;
+        const oldFrames = this.db.prepare(
+          `SELECT frame_id FROM frames
+             WHERE created_at < ? AND created_at >= ?
+             AND state = 'closed'
+             AND retention_policy != 'keep_forever'
+             AND inputs != '{}'
+             AND run_id NOT IN (SELECT value FROM json_each(?))
+             LIMIT ?`
+        ).all(
+          matureCutoff,
+          oldCutoff,
+          JSON.stringify(protectedRunIds),
+          batchSize
+        );
+        if (oldFrames.length > 0) {
+          framesCompressed += this.compressFrames(
+            oldFrames.map((f) => f.frame_id),
+            oldStrategy
+          );
+        }
+      }
+    }
     const candidates = this.db.prepare(
       `SELECT frame_id FROM frames
          WHERE (
@@ -340,7 +401,8 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
         eventsDeleted: 0,
         anchorsDeleted: 0,
         embeddingsDeleted: 0,
-        ftsEntriesDeleted: 0
+        ftsEntriesDeleted: 0,
+        framesCompressed
       };
     }
     if (dryRun) {
@@ -362,8 +424,9 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
         eventsDeleted: eventsCount,
         anchorsDeleted: anchorsCount,
         embeddingsDeleted: embeddingsCount,
-        ftsEntriesDeleted: frameIds.length
+        ftsEntriesDeleted: frameIds.length,
         // FTS has one entry per frame
+        framesCompressed
       };
     }
     const placeholders = frameIds.map(() => "?").join(",");
@@ -392,14 +455,16 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
       framesDeleted: frameIds.length,
       eventsDeleted,
       anchorsDeleted,
-      embeddingsDeleted
+      embeddingsDeleted,
+      framesCompressed
     });
     return {
       framesDeleted: frameIds.length,
       eventsDeleted,
       anchorsDeleted,
       embeddingsDeleted,
-      ftsEntriesDeleted: frameIds.length
+      ftsEntriesDeleted: frameIds.length,
+      framesCompressed
     };
   }
   /**
@@ -432,6 +497,85 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     if (nowSec - frame.created_at < 86400) score += 0.1;
     return Math.round(Math.min(score, 1) * 100) / 100;
   }
+  /**
+   * Compress a frame by stripping data according to strategy.
+   *
+   * - 'digest_only': Remove inputs, outputs, events. Keep digest_text, digest_json, anchors.
+   * - 'anchors_only': Remove inputs, outputs, events, digest_json. Keep digest_text, anchors.
+   *
+   * Returns true if the frame was compressed, false if not found.
+   */
+  compressFrame(frameId, strategy) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const frame = this.db.prepare("SELECT frame_id FROM frames WHERE frame_id = ?").get(frameId);
+    if (!frame) return false;
+    this.db.prepare("BEGIN").run();
+    try {
+      if (strategy === "digest_only") {
+        this.db.prepare(
+          "UPDATE frames SET inputs = '{}', outputs = '{}' WHERE frame_id = ?"
+        ).run(frameId);
+      } else {
+        this.db.prepare(
+          "UPDATE frames SET inputs = '{}', outputs = '{}', digest_json = '{}' WHERE frame_id = ?"
+        ).run(frameId);
+      }
+      this.db.prepare("DELETE FROM events WHERE frame_id = ?").run(frameId);
+      if (this.vecEnabled) {
+        this.db.prepare("DELETE FROM frame_embeddings WHERE frame_id = ?").run(frameId);
+      }
+      this.db.prepare("COMMIT").run();
+      return true;
+    } catch (error) {
+      this.db.prepare("ROLLBACK").run();
+      throw error;
+    }
+  }
+  /**
+   * Compress multiple frames in a single transaction.
+   * Returns count of frames compressed.
+   */
+  compressFrames(frameIds, strategy) {
+    if (!this.db || frameIds.length === 0) return 0;
+    const placeholders = frameIds.map(() => "?").join(",");
+    this.db.prepare("BEGIN").run();
+    try {
+      if (strategy === "digest_only") {
+        this.db.prepare(
+          `UPDATE frames SET inputs = '{}', outputs = '{}' WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      } else {
+        this.db.prepare(
+          `UPDATE frames SET inputs = '{}', outputs = '{}', digest_json = '{}' WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      }
+      this.db.prepare(`DELETE FROM events WHERE frame_id IN (${placeholders})`).run(...frameIds);
+      if (this.vecEnabled) {
+        this.db.prepare(
+          `DELETE FROM frame_embeddings WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      }
+      this.db.prepare("COMMIT").run();
+      return frameIds.length;
+    } catch (error) {
+      this.db.prepare("ROLLBACK").run();
+      throw error;
+    }
+  }
+  /**
+   * Get database file size in bytes.
+   */
+  getDatabaseSize() {
+    if (!this.db) return 0;
+    const result = this.db.prepare(
+      "SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()"
+    ).get();
+    return result?.size ?? 0;
+  }
   /**
    * Recompute importance scores for frames still at default score (0.5).
    * Processes oldest frames first in batches.

package/dist/src/integrations/claude-code/subagent-client.js

@@ -4,8 +4,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
 import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
-import { exec } from "child_process";
-import { promisify } from "util";
+import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -18,12 +17,10 @@ import {
   createProvider
 } from "../../core/extensions/provider-adapter.js";
 import { AnthropicBatchClient } from "../anthropic/batch-client.js";
-const execAsync = promisify(exec);
 class ClaudeCodeSubagentClient {
   tempDir;
-  activeSubagents = /* @__PURE__ */ new Map();
   mockMode;
-  constructor(mockMode = true) {
+  constructor(mockMode = false) {
     this.mockMode = mockMode;
     this.tempDir = path.join(os.tmpdir(), "stackmemory-rlm");
     if (!fs.existsSync(this.tempDir)) {
@@ -148,7 +145,8 @@ class ClaudeCodeSubagentClient {
     }
   }
   /**
-   * Original CLI-based subagent execution (unchanged behavior)
+   * Execute subagent via Claude Code CLI (`claude -p --output-format stream-json`).
+   * Spawns a real Claude Code process with full tool use.
    */
   async executeSubagentViaCLI(request, startTime, subagentId) {
     try {
@@ -158,31 +156,24 @@ class ClaudeCodeSubagentClient {
         contextFile,
         JSON.stringify(request.context, null, 2)
       );
-      const resultFile = path.join(this.tempDir, `${subagentId}-result.json`);
-      const taskCommand = this.buildTaskCommand(
-        request,
-        prompt,
-        contextFile,
-        resultFile
-      );
-      const result = await this.executeTaskTool(taskCommand, request.timeout);
-      let subagentResult = {};
-      if (fs.existsSync(resultFile)) {
-        const resultContent = await fs.promises.readFile(resultFile, "utf-8");
-        try {
-          subagentResult = JSON.parse(resultContent);
-        } catch {
-          subagentResult = { rawOutput: resultContent };
-        }
-      }
+      const fullPrompt = `${prompt}
+
+Context (JSON): ${JSON.stringify(request.context)}`;
+      const result = await this.spawnClaude(fullPrompt, request.timeout);
       this.cleanup(subagentId);
+      let parsed;
+      try {
+        parsed = JSON.parse(result.text);
+      } catch {
+        parsed = { rawOutput: result.text };
+      }
       return {
         success: true,
-        result: subagentResult,
-        output: result.stdout,
+        result: parsed,
+        output: result.text,
         duration: Date.now() - startTime,
         subagentType: request.type,
-        tokens: this.estimateTokens(prompt + JSON.stringify(subagentResult))
+        tokens: this.estimateTokens(fullPrompt + result.text)
       };
     } catch (error) {
       logger.error(`Subagent CLI execution failed: ${request.type}`, {
@@ -347,66 +338,88 @@ class ClaudeCodeSubagentClient {
     return (request.systemPrompt || prompts[request.type] || prompts.planning) + STRUCTURED_RESPONSE_SUFFIX;
   }
   /**
-   * Build Task tool command
-   * This creates a command that Claude Code's Task tool can execute
-   */
-  buildTaskCommand(request, prompt, contextFile, resultFile) {
-    const scriptContent = `
-#!/bin/bash
-# Subagent execution script for ${request.type}
-
-# Read context
-CONTEXT=$(cat "${contextFile}")
-
-# Execute task based on type
-case "${request.type}" in
-  "testing")
-    # For testing subagent, actually run tests
-    echo "Generating and running tests..."
-    # The subagent will generate test files and run them
-    ;;
-  "linting")
-    # For linting subagent, run actual linters
-    echo "Running linters..."
-    npm run lint || true
-    ;;
-  "code")
-    # For code generation, create implementation files
-    echo "Generating implementation..."
-    ;;
-  *)
-    # Default behavior
-    echo "Executing ${request.type} task..."
-    ;;
-esac
-
-# Write result
-echo '{"status": "completed", "type": "${request.type}"}' > "${resultFile}"
-`;
-    const scriptFile = path.join(this.tempDir, `${request.type}-script.sh`);
-    fs.writeFileSync(scriptFile, scriptContent);
-    fs.chmodSync(scriptFile, "755");
-    return scriptFile;
-  }
-  /**
-   * Execute via Task tool (simulated for now)
-   * In production, this would use Claude Code's actual Task tool API
+   * Spawn `claude -p --output-format stream-json` and collect the result.
+   * Parses stream-json events to extract the final assistant text.
    */
-  async executeTaskTool(command, timeout) {
-    try {
-      const result = await execAsync(command, {
-        timeout: timeout || 3e5,
-        // 5 minutes default
-        maxBuffer: 10 * 1024 * 1024
-        // 10MB buffer
+  spawnClaude(prompt, timeout) {
+    return new Promise((resolve, reject) => {
+      const args = ["-p", "--output-format", "stream-json", prompt];
+      const claude = spawn("claude", args, {
+        cwd: process.cwd(),
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"]
       });
-      return result;
-    } catch (error) {
-      if (error.killed || error.signal === "SIGTERM") {
-        throw new Error(`Subagent timeout after ${timeout}ms`);
-      }
-      throw error;
-    }
+      const timeoutMs = timeout || 3e5;
+      const timer = setTimeout(() => {
+        claude.kill("SIGTERM");
+        reject(new Error(`Subagent timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      let lastAssistantText = "";
+      let toolUseCount = 0;
+      let lineBuffer = "";
+      let stderr = "";
+      claude.stdout.on("data", (chunk) => {
+        lineBuffer += chunk.toString();
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "assistant" && event.message) {
+              const textBlocks = (event.message.content || []).filter((b) => b.type === "text").map((b) => b.text);
+              if (textBlocks.length > 0) {
+                lastAssistantText = textBlocks.join("\n");
+              }
+              const toolBlocks = (event.message.content || []).filter(
+                (b) => b.type === "tool_use"
+              );
+              toolUseCount += toolBlocks.length;
+            }
+            if (event.type === "result" && event.result) {
+              lastAssistantText = event.result;
+            }
+          } catch {
+          }
+        }
+      });
+      claude.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      claude.on("close", (code) => {
+        clearTimeout(timer);
+        if (lineBuffer.trim()) {
+          try {
+            const event = JSON.parse(lineBuffer);
+            if (event.type === "result" && event.result) {
+              lastAssistantText = event.result;
+            }
+          } catch {
+          }
+        }
+        logger.info("Claude subagent completed", {
+          code,
+          toolUseCount,
+          outputLength: lastAssistantText.length
+        });
+        if (code === 0 && lastAssistantText) {
+          resolve({ text: lastAssistantText, toolUseCount });
+        } else if (code === 0) {
+          resolve({
+            text: "(Claude completed but produced no text output)",
+            toolUseCount
+          });
+        } else {
+          reject(
+            new Error(`Claude exited code ${code}: ${stderr.slice(0, 500)}`)
+          );
+        }
+      });
+      claude.on("error", (err) => {
+        clearTimeout(timer);
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+    });
   }
   /**
    * Get mock response for testing
@@ -528,84 +541,11 @@ function greetUser(name: string): string {
       }
     }
   }
-  /**
-   * Create a mock Task tool response for development
-   * This simulates what Claude Code's Task tool would return
-   */
-  async mockTaskToolExecution(request) {
-    const startTime = Date.now();
-    await new Promise(
-      (resolve) => setTimeout(resolve, 1e3 + Math.random() * 2e3)
-    );
-    const mockResponses = {
-      planning: {
-        tasks: [
-          { id: "1", type: "analyze", description: "Analyze requirements" },
-          { id: "2", type: "implement", description: "Implement solution" },
-          { id: "3", type: "test", description: "Test implementation" },
-          { id: "4", type: "review", description: "Review and improve" }
-        ],
-        dependencies: { "2": ["1"], "3": ["2"], "4": ["3"] }
-      },
-      code: {
-        implementation: `
-export class Solution {
-  constructor(private config: any) {}
-  
-  async execute(input: string): Promise<string> {
-    // Implementation generated by Code subagent
-    return this.process(input);
-  }
-  
-  private process(input: string): string {
-    return \`Processed: \${input}\`;
-  }
-}`,
-        files: ["src/solution.ts"]
-      },
-      testing: {
-        tests: `
-describe('Solution', () => {
-  it('should process input correctly', () => {
-    const solution = new Solution({});
-    const result = solution.execute('test');
-    expect(result).toBe('Processed: test');
-  });
-  
-  it('should handle edge cases', () => {
-    // Edge case tests
-  });
-});`,
-        coverage: { lines: 95, branches: 88, functions: 100 }
-      },
-      review: {
-        quality: 0.82,
-        issues: [
-          { severity: "high", message: "Missing error handling" },
-          { severity: "medium", message: "Could improve type safety" }
-        ],
-        suggestions: [
-          "Add try-catch blocks",
-          "Use stricter TypeScript types",
-          "Add input validation"
-        ]
-      }
-    };
-    return {
-      success: true,
-      result: mockResponses[request.type] || { status: "completed" },
-      output: `Mock ${request.type} subagent completed successfully`,
-      duration: Date.now() - startTime,
-      subagentType: request.type,
-      tokens: Math.floor(Math.random() * 5e3) + 1e3
-    };
-  }
   /**
    * Get active subagent statistics
    */
   getStats() {
     return {
-      activeSubagents: this.activeSubagents.size,
       tempDir: this.tempDir
     };
   }
@@ -613,10 +553,6 @@ describe('Solution', () => {
    * Cleanup all resources
    */
   async cleanupAll() {
-    for (const [id, controller] of this.activeSubagents) {
-      controller.abort();
-    }
-    this.activeSubagents.clear();
     if (fs.existsSync(this.tempDir)) {
       const files = await fs.promises.readdir(this.tempDir);
       for (const file of files) {

package/dist/src/integrations/claude-code/task-coordinator.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { v4 as uuidv4 } from "uuid";
+import { spawn } from "child_process";
 import { logger } from "../../core/monitoring/logger.js";
 class ClaudeCodeTaskCoordinator {
   activeTasks = /* @__PURE__ */ new Map();
@@ -165,11 +166,16 @@ class ClaudeCodeTaskCoordinator {
       completedTasks: this.completedTasks.length
     });
     if (this.activeTasks.size > 0) {
-      const timeoutPromise = new Promise(
-        (resolve) => setTimeout(resolve, 3e4)
-      );
+      let timer;
+      const timeoutPromise = new Promise((resolve) => {
+        timer = setTimeout(resolve, 3e4);
+      });
       const completionPromise = this.waitForTaskCompletion();
-      await Promise.race([completionPromise, timeoutPromise]);
+      try {
+        await Promise.race([completionPromise, timeoutPromise]);
+      } finally {
+        clearTimeout(timer);
+      }
       if (this.activeTasks.size > 0) {
         logger.warn("Force terminating active tasks", {
           remainingTasks: this.activeTasks.size
@@ -205,26 +211,68 @@ class ClaudeCodeTaskCoordinator {
       agentType: agentConfig.type,
       promptTokens: this.estimateTokenUsage(prompt, "")
     });
-    return this.simulateClaudeCodeExecution(agentName, prompt, agentConfig);
+    return this.spawnClaudeCode(agentName, prompt, agentConfig);
   }
   /**
-   * Simulate Claude Code execution (temporary until real integration)
+   * Spawn Claude Code CLI as a subprocess.
+   * Uses `claude --print` for non-interactive execution with stdout capture.
+   * Workspace cwd is inherited from the coordinator's process.
    */
-  simulateClaudeCodeExecution(agentName, prompt, agentConfig) {
-    return new Promise((resolve) => {
-      const executionTime = agentConfig.type === "oracle" ? 2e3 + Math.random() * 3e3 : 1e3 + Math.random() * 2e3;
-      setTimeout(() => {
-        const result = `Claude Code agent '${agentName}' completed task successfully.
-        
-Agent Capabilities Used: ${agentConfig.capabilities.slice(0, 3).join(", ")}
-Task Type: ${agentConfig.type}
-Specializations: ${agentConfig.specializations.join(", ")}
-
-Simulated output based on prompt context: ${prompt.substring(0, 100)}...
-
-This simulation will be replaced with actual Claude Code Task tool integration.`;
-        resolve(result);
-      }, executionTime);
+  spawnClaudeCode(agentName, prompt, agentConfig) {
+    return new Promise((resolve, reject) => {
+      const args = ["--print"];
+      if (agentConfig.type === "oracle") {
+        args.push("--model", "opus");
+      }
+      if (agentConfig.capabilities.includes("code_implementation")) {
+        args.push("--allowedTools", "Edit,Write,Bash,Read,Glob,Grep");
+      } else {
+        args.push("--allowedTools", "Read,Glob,Grep,Bash");
+      }
+      args.push(prompt);
+      logger.info("Spawning claude CLI", {
+        agentName,
+        agentType: agentConfig.type,
+        cwd: process.cwd(),
+        promptLength: prompt.length
+      });
+      const proc = spawn("claude", args, {
+        cwd: process.cwd(),
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("error", (err) => {
+        logger.error("Failed to spawn claude CLI", {
+          agentName,
+          error: err.message
+        });
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          logger.debug("Claude CLI completed", {
+            agentName,
+            outputLength: stdout.length
+          });
+          resolve(stdout.trim());
+        } else {
+          const errMsg = stderr.slice(0, 500) || `exit code ${code}`;
+          logger.warn("Claude CLI failed", {
+            agentName,
+            exitCode: code,
+            stderr: errMsg
+          });
+          reject(new Error(`Claude CLI exited with code ${code}: ${errMsg}`));
+        }
+      });
     });
   }
   /**