@stackmemoryai/stackmemory 1.5.3 → 1.5.5

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

@@ -8,10 +8,13 @@ import {
   mkdirSync,
   rmSync,
   writeFileSync,
+  readdirSync,
   createWriteStream
 } from "fs";
 import { join, dirname } from "path";
 import { tmpdir, homedir } from "os";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
 import { fileURLToPath } from "url";
 import { Transform } from "stream";
 import { logger } from "../../core/monitoring/logger.js";
@@ -65,6 +68,35 @@ class TeeTransform extends Transform {
     callback();
   }
 }
+function inferPhaseFromStreamJson(event) {
+  if (event.type !== "assistant") return null;
+  const message = event.message;
+  const content = message?.content || [];
+  for (const block of content) {
+    if (block.type !== "tool_use") continue;
+    const toolLower = (block.name || "").toLowerCase();
+    if (toolLower.includes("read") || toolLower.includes("glob") || toolLower.includes("grep") || toolLower.includes("search")) {
+      return "reading";
+    }
+    if (toolLower.includes("todowrite") || toolLower.includes("todo")) {
+      return "planning";
+    }
+    if (toolLower.includes("edit") || toolLower.includes("write") || toolLower.includes("bash")) {
+      if (toolLower === "bash") {
+        const input = block.input;
+        const command = (input?.command ?? "").toLowerCase();
+        if (command.includes("git commit") || command.includes("git add")) {
+          return "committing";
+        }
+      }
+      return "implementing";
+    }
+    if (toolLower.includes("test")) {
+      return "testing";
+    }
+  }
+  return null;
+}
 function inferPhase(msg) {
   const method = msg.method;
   const params = msg.params;
@@ -85,7 +117,8 @@ function inferPhase(msg) {
     }
   }
   if (method === "item/commandExecution/started") {
-    const command = params?.command || "";
+    const args = params?.arguments;
+    const command = (args?.command ?? params?.command) || "";
     if (command.includes("git commit") || command.includes("git add")) {
       return "committing";
     }
@@ -98,7 +131,7 @@ const DEFAULT_CONFIG = {
   inProgressState: "In Progress",
   inReviewState: "In Review",
   pollIntervalMs: 3e4,
-  maxConcurrent: 3,
+  maxConcurrent: 5,
   workspaceRoot: join(tmpdir(), "conductor_workspaces"),
   repoRoot: process.cwd(),
   baseBranch: "main",
@@ -110,7 +143,8 @@ const DEFAULT_CONFIG = {
   ),
   turnTimeoutMs: 36e5,
   maxRetries: 1,
-  hookTimeoutMs: 6e4
+  hookTimeoutMs: 6e4,
+  agentMode: "cli"
 };
 class Conductor {
   config;
@@ -127,6 +161,23 @@ class Conductor {
   stateCache = /* @__PURE__ */ new Map();
   activeStatesLower;
   terminalStatesLower;
+  /** Global rate limit backoff state */
+  rateLimit = {
+    inBackoff: false,
+    backoffUntil: 0,
+    totalHits: 0,
+    consecutiveHits: 0,
+    lastHitAt: 0
+  };
+  /** Aggregated usage stats */
+  usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    estimatedMessages: 0,
+    perAgent: /* @__PURE__ */ new Map()
+  };
   constructor(config = {}) {
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.activeStatesLower = this.config.activeStates.map(
@@ -263,7 +314,9 @@ class Conductor {
       failed: this.failCount,
       totalAttempts: this.totalAttempts,
       uptime: Date.now() - this.startedAt,
-      issues
+      issues,
+      rateLimit: { ...this.rateLimit },
+      usage: { ...this.usage, perAgent: new Map(this.usage.perAgent) }
     };
   }
   // ── Status File ──
@@ -293,7 +346,31 @@ class Conductor {
       failed: this.failCount,
       totalAttempts: this.totalAttempts,
       maxConcurrent: this.config.maxConcurrent,
-      stopping: this.stopping
+      stopping: this.stopping,
+      rateLimit: {
+        inBackoff: this.rateLimit.inBackoff,
+        backoffUntil: this.rateLimit.backoffUntil,
+        backoffRemainingSec: this.rateLimit.inBackoff ? Math.max(
+          0,
+          Math.ceil((this.rateLimit.backoffUntil - Date.now()) / 1e3)
+        ) : 0,
+        totalHits: this.rateLimit.totalHits
+      },
+      usage: (() => {
+        const summary = this.getUsageSummary();
+        return {
+          inputTokens: summary.inputTokens,
+          outputTokens: summary.outputTokens,
+          totalTokens: summary.totalTokens,
+          estimatedMessages: summary.estimatedMessages,
+          tokensPerMin: summary.tokensPerMin,
+          budgetPct5x: summary.budgetPct5x,
+          budgetPct20x: summary.budgetPct20x,
+          minutesRemaining5x: summary.minutesRemaining5x,
+          minutesRemaining20x: summary.minutesRemaining20x,
+          cacheHitRate: summary.cacheHitRate
+        };
+      })()
     };
     try {
       writeFileSync(
@@ -359,6 +436,21 @@ class Conductor {
   }
   async poll() {
     if (!this.client || this.stopping) return;
+    if (this.rateLimit.inBackoff) {
+      const remaining = this.rateLimit.backoffUntil - Date.now();
+      if (remaining > 0) {
+        logger.info("Rate limit backoff active, skipping poll", {
+          remainingMs: remaining,
+          remainingSec: Math.ceil(remaining / 1e3),
+          totalHits: this.rateLimit.totalHits
+        });
+        return;
+      }
+      this.rateLimit.inBackoff = false;
+      this.rateLimit.backoffUntil = 0;
+      logger.info("Rate limit backoff expired, resuming dispatch");
+      console.log("[rate-limit] Backoff expired, resuming dispatch");
+    }
     await this.reconcile();
     const available = this.config.maxConcurrent - this.running.size;
     if (available <= 0) {
@@ -376,6 +468,29 @@ class Conductor {
     if (eligible.length === 0) return;
     const sorted = eligible.sort((a, b) => (a.priority || 4) - (b.priority || 4)).slice(0, available);
     const toDispatch = this.preflightFilter(sorted);
+    if (this.usage.inputTokens > 0) {
+      const summary = this.getUsageSummary();
+      logger.info("Usage summary", {
+        totalTokens: summary.totalTokens,
+        estimatedMessages: summary.estimatedMessages,
+        tokensPerMin: summary.tokensPerMin,
+        budgetPct5x: `${summary.budgetPct5x}%`,
+        budgetPct20x: `${summary.budgetPct20x}%`,
+        minutesRemaining5x: summary.minutesRemaining5x,
+        minutesRemaining20x: summary.minutesRemaining20x,
+        rateLimitHits: this.rateLimit.totalHits
+      });
+      if (summary.budgetPct5x >= 75 && summary.budgetPct5x < 100) {
+        console.log(
+          `[usage] \u26A0 ${summary.budgetPct5x}% of Max 5x budget used \u2014 ~${summary.minutesRemaining5x}min remaining at ${summary.tokensPerMin} tok/min`
+        );
+      }
+      if (summary.budgetPct5x >= 100) {
+        console.log(
+          `[usage] \u{1F6D1} Max 5x budget likely exhausted (${summary.estimatedMessages} est. messages / 225 limit). Expect 429s.`
+        );
+      }
+    }
     logger.info("Dispatching issues", {
       count: toDispatch.length,
       identifiers: toDispatch.map((i) => i.identifier),
@@ -538,6 +653,9 @@ class Conductor {
           error: run.error,
           attempt: run.attempt
         });
+        if (this.handleRateLimitError(run.error, issue.identifier)) {
+          throw err;
+        }
         if (run.workspacePath) {
           await this.runHook(
             "after-run",
@@ -564,6 +682,179 @@ class Conductor {
       }
     }
   }
+  // ── Rate Limit Detection ──
+  /**
+   * Check if an error indicates a rate limit (429) or usage cap.
+   * Triggers global backoff so no new agents are dispatched.
+   *
+   * Claude Max limits (approximate, shared between claude.ai + Claude Code):
+   * - Max 5x: ~225 messages per 5h window
+   * - Max 20x: ~900 messages per 5h window
+   * Messages are token-weighted: heavy agent usage ≈ 5-10x a casual message.
+   */
+  handleRateLimitError(error, identifier) {
+    const rateLimitPatterns = [
+      "usage limits",
+      "rate_limit",
+      "rate limit",
+      "overloaded",
+      "429",
+      "too many requests",
+      "quota exceeded",
+      "capacity"
+    ];
+    const isRateLimit = rateLimitPatterns.some(
+      (p) => error.toLowerCase().includes(p)
+    );
+    if (!isRateLimit) return false;
+    this.rateLimit.totalHits++;
+    this.rateLimit.lastHitAt = Date.now();
+    const timeSinceLast = Date.now() - this.rateLimit.lastHitAt;
+    if (timeSinceLast < 6e5) {
+      this.rateLimit.consecutiveHits++;
+    } else {
+      this.rateLimit.consecutiveHits = 1;
+    }
+    const backoffSec = Math.min(
+      60 * Math.pow(2, this.rateLimit.consecutiveHits - 1),
+      900
+    );
+    this.rateLimit.inBackoff = true;
+    this.rateLimit.backoffUntil = Date.now() + backoffSec * 1e3;
+    logger.warn("Rate limit hit \u2014 global backoff", {
+      identifier,
+      backoffSec,
+      consecutiveHits: this.rateLimit.consecutiveHits,
+      totalHits: this.rateLimit.totalHits,
+      error: error.slice(0, 200)
+    });
+    console.log(
+      `[rate-limit] Hit rate limit on ${identifier} \u2014 backing off ${backoffSec}s (hit #${this.rateLimit.totalHits})`
+    );
+    return true;
+  }
+  // ── Usage Tracking ──
+  /**
+   * Track token usage from a stream-json event (CLI mode) or JSON-RPC message (adapter mode).
+   * Updates both global and per-agent counters.
+   */
+  trackUsage(identifier, usage) {
+    const input = usage.input_tokens || 0;
+    const output = usage.output_tokens || 0;
+    const cacheCreate = usage.cache_creation_input_tokens || 0;
+    const cacheRead = usage.cache_read_input_tokens || 0;
+    this.usage.inputTokens += input;
+    this.usage.outputTokens += output;
+    this.usage.cacheCreationTokens += cacheCreate;
+    this.usage.cacheReadTokens += cacheRead;
+    this.usage.estimatedMessages = Math.ceil(
+      (this.usage.inputTokens + this.usage.outputTokens) / 1e4
+    );
+    const agent = this.usage.perAgent.get(identifier) || {
+      inputTokens: 0,
+      outputTokens: 0
+    };
+    agent.inputTokens += input;
+    agent.outputTokens += output;
+    this.usage.perAgent.set(identifier, agent);
+  }
+  /**
+   * Scan Claude Code JSONL logs for token usage from conductor-spawned sessions.
+   * Reads logs from ~/.claude/projects/ matching conductor workspace paths.
+   */
+  async scanUsageLogs() {
+    const logDirs = [
+      join(homedir(), ".claude", "projects"),
+      join(homedir(), ".config", "claude", "projects")
+    ];
+    for (const logDir of logDirs) {
+      if (!existsSync(logDir)) continue;
+      try {
+        const entries = readdirSync(logDir);
+        const conductorDirs = entries.filter(
+          (e) => e.includes("conductor_workspaces") || e.includes("conductor-")
+        );
+        for (const dir of conductorDirs) {
+          const projectDir = join(logDir, dir);
+          if (!existsSync(projectDir)) continue;
+          const jsonlFiles = readdirSync(projectDir).filter(
+            (f) => f.endsWith(".jsonl")
+          );
+          for (const file of jsonlFiles) {
+            await this.parseUsageFromJsonl(join(projectDir, file));
+          }
+        }
+      } catch (err) {
+        logger.debug("Usage log scan failed", {
+          error: err.message
+        });
+      }
+    }
+    return this.usage;
+  }
+  async parseUsageFromJsonl(filePath) {
+    try {
+      const rl = createInterface({
+        input: createReadStream(filePath),
+        crlfDelay: Infinity
+      });
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type === "assistant" && entry.message?.usage) {
+            const usage = entry.message.usage;
+            const identifier = entry.sessionId?.slice(0, 8) || "unknown";
+            this.trackUsage(identifier, usage);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get current usage summary with time-to-exhaustion estimate.
+   *
+   * Claude Max limits (approximate, shared between claude.ai + Claude Code):
+   * - Max 5x:  ~225 messages per 5h window (~10k tokens per "message")
+   * - Max 20x: ~900 messages per 5h window
+   *
+   * Heavy agent usage burns 5-10x faster than casual chat.
+   */
+  getUsageSummary() {
+    const totalCache = this.usage.cacheCreationTokens + this.usage.cacheReadTokens;
+    const cacheHitRate = totalCache > 0 ? this.usage.cacheReadTokens / totalCache : 0;
+    const uptimeMin = Math.max(1, (Date.now() - this.startedAt) / 6e4);
+    const totalTokens = this.usage.inputTokens + this.usage.outputTokens;
+    const tokensPerMin = Math.round(totalTokens / uptimeMin);
+    const estMessages = this.usage.estimatedMessages;
+    const MAX_5X_MESSAGES = 225;
+    const MAX_20X_MESSAGES = 900;
+    const budgetPct5x = Math.round(estMessages / MAX_5X_MESSAGES * 100);
+    const budgetPct20x = Math.round(estMessages / MAX_20X_MESSAGES * 100);
+    const msgsPerMin = tokensPerMin > 0 ? tokensPerMin / 1e4 : 0;
+    const minutesRemaining5x = msgsPerMin > 0 ? Math.round((MAX_5X_MESSAGES - estMessages) / msgsPerMin) : -1;
+    const minutesRemaining20x = msgsPerMin > 0 ? Math.round((MAX_20X_MESSAGES - estMessages) / msgsPerMin) : -1;
+    return {
+      totalTokens,
+      inputTokens: this.usage.inputTokens,
+      outputTokens: this.usage.outputTokens,
+      estimatedMessages: estMessages,
+      cacheHitRate: Math.round(cacheHitRate * 100),
+      tokensPerMin,
+      budgetPct5x,
+      budgetPct20x,
+      minutesRemaining5x: minutesRemaining5x < 0 ? -1 : minutesRemaining5x,
+      minutesRemaining20x: minutesRemaining20x < 0 ? -1 : minutesRemaining20x,
+      perAgent: Array.from(this.usage.perAgent.entries()).map(
+        ([id, stats]) => ({
+          id,
+          ...stats
+        })
+      )
+    };
+  }
   // ── Workspace Management ──
   async createWorkspace(issue) {
     const wsKey = this.sanitizeIdentifier(issue.identifier);
@@ -641,14 +932,194 @@ class Conductor {
   sanitizeIdentifier(identifier) {
     return identifier.replace(/[^A-Za-z0-9._-]/g, "_");
   }
+  /**
+   * Find the real claude binary, skipping shell wrappers (cmux, claude-smd).
+   * Wrappers inject --settings with hooks that block headless -p mode.
+   */
+  findClaudeBinary() {
+    const candidates = [
+      join(homedir(), ".local", "bin", "claude"),
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude"
+    ];
+    for (const c of candidates) {
+      if (existsSync(c)) return c;
+    }
+    return "claude";
+  }
   // ── Agent Execution ──
-  runAgent(issue, run) {
+  async runAgent(issue, run) {
+    if (this.config.agentMode === "cli") {
+      try {
+        return await this.runAgentCLI(issue, run);
+      } catch (err) {
+        const msg = err.message || "";
+        if (this.handleRateLimitError(msg, issue.identifier)) {
+          throw err;
+        }
+        if (msg.includes("usage limits") || msg.includes("overloaded")) {
+          logger.warn("CLI mode hit limits, falling back to adapter", {
+            identifier: issue.identifier,
+            error: msg.slice(0, 200)
+          });
+          run.toolCalls = 0;
+          run.filesModified = 0;
+          run.tokensUsed = 0;
+          run.phase = "reading";
+          return this.runAgentAdapter(issue, run);
+        }
+        throw err;
+      }
+    }
+    return this.runAgentAdapter(issue, run);
+  }
+  /**
+   * CLI mode: spawn `claude -p --output-format stream-json` directly.
+   * Uses whatever auth the environment provides (session quota, API key, etc).
+   */
+  runAgentCLI(issue, run) {
     return new Promise((resolve, reject) => {
       const prompt = this.buildPrompt(issue, run.attempt);
+      const claudeBin = this.findClaudeBinary();
+      const proc = spawn(
+        claudeBin,
+        [
+          "-p",
+          "--output-format",
+          "stream-json",
+          "--dangerously-skip-permissions",
+          "--settings",
+          '{"hooks":{}}',
+          prompt
+        ],
+        {
+          cwd: run.workspacePath,
+          env: (() => {
+            const env = { ...process.env };
+            delete env.CLAUDECODE;
+            delete env.ANTHROPIC_API_KEY;
+            return {
+              ...env,
+              SYMPHONY_WORKSPACE_DIR: run.workspacePath,
+              SYMPHONY_ISSUE_ID: issue.id,
+              SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
+              SYMPHONY_ATTEMPT: String(run.attempt)
+            };
+          })(),
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      run.process = proc;
+      proc.stdin.end();
+      const logStream = this.openAgentLogStream(issue.identifier);
+      run.logStream = logStream;
+      const tee = new TeeTransform(logStream);
+      proc.stdout.pipe(tee);
+      this.writeAgentStatus(issue.identifier, run);
+      let stderr = "";
+      let lastResultText = "";
+      const timer = setTimeout(() => {
+        logger.warn("Agent turn timeout (cli)", {
+          identifier: issue.identifier,
+          timeoutMs: this.config.turnTimeoutMs
+        });
+        proc.kill("SIGTERM");
+        reject(new Error(`Agent timeout after ${this.config.turnTimeoutMs}ms`));
+      }, this.config.turnTimeoutMs);
+      let lineBuffer = "";
+      tee.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);
+            const phase = inferPhaseFromStreamJson(event);
+            if (phase) {
+              run.phase = phase;
+            }
+            if (event.type === "assistant") {
+              const message = event.message;
+              const msgUsage = message?.usage;
+              if (msgUsage) {
+                this.trackUsage(issue.identifier, msgUsage);
+              }
+              const content = message?.content || [];
+              for (const block of content) {
+                if (block.type === "tool_use") {
+                  run.toolCalls++;
+                  const toolLower = (block.name || "").toLowerCase();
+                  if (toolLower.includes("edit") || toolLower.includes("write")) {
+                    run.filesModified++;
+                  }
+                }
+                if (block.type === "text" && block.text) {
+                  run.tokensUsed += Math.ceil(
+                    block.text.length / 4
+                  );
+                }
+              }
+            }
+            if (event.type === "result" && event.result) {
+              lastResultText = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+            }
+            if (run.toolCalls % 5 === 0 || phase) {
+              this.writeAgentStatus(issue.identifier, run);
+            }
+          } catch {
+          }
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+        const lines = data.toString().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          logger.debug(`[${issue.identifier}] ${line}`);
+        }
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        run.process = null;
+        if (run.logStream && !run.logStream.destroyed) {
+          run.logStream.end();
+        }
+        this.writeAgentStatus(issue.identifier, run);
+        if (code === 0) {
+          logger.info("Agent completed (cli)", {
+            identifier: issue.identifier,
+            toolCalls: run.toolCalls,
+            resultLength: lastResultText.length
+          });
+          resolve();
+        } else {
+          reject(
+            new Error(
+              `Claude exited with code ${code}: ${stderr.slice(0, 500)}`
+            )
+          );
+        }
+      });
+    });
+  }
+  /**
+   * Adapter mode: spawn claude-app-server.cjs via JSON-RPC protocol.
+   * Uses ANTHROPIC_API_KEY for auth.
+   */
+  runAgentAdapter(issue, run) {
+    return new Promise((resolve, reject) => {
+      const prompt = this.buildPrompt(issue, run.attempt);
+      const env = { ...process.env };
+      delete env.CLAUDECODE;
+      delete env.ANTHROPIC_API_KEY;
       const proc = spawn("node", [this.config.appServerPath], {
         cwd: run.workspacePath,
         env: {
-          ...process.env,
+          ...env,
           SYMPHONY_WORKSPACE_DIR: run.workspacePath,
           SYMPHONY_ISSUE_ID: issue.id,
           SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, conductor orchestrator, loop/watch monitoring, snapshot capture, pre-flight overlap checks, Claude/Codex/OpenCode wrappers, Linear sync, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",
@@ -100,6 +100,7 @@
     "postinstall": "node scripts/install-claude-hooks-auto.js || true",
     "init": "node dist/scripts/initialize.js",
     "build": "rm -rf dist && node esbuild.config.js",
+    "typecheck": "NODE_OPTIONS='--max-old-space-size=8192' tsc --noEmit",
     "lint": "eslint 'src/**/*.ts' 'scripts/**/*.ts'",
     "lint:fix": "eslint 'src/**/*.ts' 'scripts/**/*.ts' --fix --max-warnings=-1",
     "lint:fast": "oxlint src scripts",