@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/features/web/server/spend-calculator.js

@@ -0,0 +1,228 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import Database from "better-sqlite3";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import {
+  calculateCost,
+  effectiveSpendMultiplier,
+  formatCost
+} from "../../../core/models/provider-pricing.js";
+import { getGcpSpend, getGcpSpendEnvFallback } from "./gcp-billing.js";
+const DEFAULT_CONDUCTOR_MODEL = "anthropic/claude-sonnet-4-20250514";
+const DEFAULT_RETRIEVAL_MODEL = "anthropic/claude-haiku-4-5-20251001";
+function resolvePricingKey(model, fallback = DEFAULT_CONDUCTOR_MODEL) {
+  if (!model) return fallback;
+  const normalized = model.toLowerCase().trim();
+  if (normalized.includes("claude-opus-4")) return "anthropic/claude-opus-4-7";
+  if (normalized.includes("claude-sonnet-4-5"))
+    return "anthropic/claude-sonnet-4-5-20250929";
+  if (normalized.includes("claude-sonnet-4"))
+    return "anthropic/claude-sonnet-4-20250514";
+  if (normalized.includes("claude-haiku"))
+    return "anthropic/claude-haiku-4-5-20251001";
+  if (normalized.includes("claude-3-5-haiku"))
+    return "anthropic/claude-haiku-4-5-20251001";
+  if (normalized.includes("gpt-4o")) return "openai/gpt-4o";
+  if (normalized.includes("meta-llama/llama-4-scout"))
+    return "openrouter/meta-llama/llama-4-scout";
+  if (normalized.includes("llama-4-scout-17b"))
+    return "cerebras/llama-4-scout-17b-16e-instruct";
+  if (normalized.includes("glm-4")) return "deepinfra/THUDM/glm-4-9b-chat";
+  return fallback;
+}
+function extractModelFromEventJson(eventJson) {
+  if (!eventJson) return void 0;
+  try {
+    const event = JSON.parse(eventJson);
+    const model = event.model ?? event.message?.model ?? event.body?.model ?? event.params?.model;
+    return typeof model === "string" ? model : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getConductorTracesDbPath() {
+  return join(homedir(), ".stackmemory", "conductor", "traces.db");
+}
+function getProjectContextDbPath() {
+  return join(process.cwd(), ".stackmemory", "context.db");
+}
+function readConductorUsage() {
+  const dbPath = getConductorTracesDbPath();
+  if (!existsSync(dbPath)) return [];
+  let db;
+  try {
+    db = new Database(dbPath, { readonly: true });
+    const rows = db.prepare(
+      `
+        SELECT
+          input_tokens as inputTokens,
+          output_tokens as outputTokens,
+          timestamp,
+          event_json as eventJson
+        FROM conductor_traces
+        WHERE input_tokens > 0 OR output_tokens > 0
+        ORDER BY timestamp DESC
+        `
+    ).all();
+    return rows.map((r) => ({
+      source: "conductor",
+      modelKey: resolvePricingKey(
+        extractModelFromEventJson(r.eventJson),
+        DEFAULT_CONDUCTOR_MODEL
+      ),
+      inputTokens: r.inputTokens || 0,
+      outputTokens: r.outputTokens || 0,
+      timestamp: r.timestamp
+    }));
+  } catch (error) {
+    console.warn("Failed to read conductor traces for spend estimate:", error);
+    return [];
+  } finally {
+    db?.close();
+  }
+}
+function readRetrievalUsage() {
+  const dbPath = getProjectContextDbPath();
+  if (!existsSync(dbPath)) return [];
+  let db;
+  try {
+    db = new Database(dbPath, { readonly: true });
+    const rows = db.prepare(
+      `
+        SELECT
+          tokens_used as tokensUsed,
+          timestamp
+        FROM retrieval_audit
+        WHERE tokens_used > 0
+        ORDER BY timestamp DESC
+        `
+    ).all();
+    return rows.map((r) => ({
+      source: "retrieval",
+      modelKey: DEFAULT_RETRIEVAL_MODEL,
+      // Estimate: 80% output, 20% input for the analysis call
+      inputTokens: Math.round((r.tokensUsed || 0) * 0.2),
+      outputTokens: Math.round((r.tokensUsed || 0) * 0.8),
+      timestamp: r.timestamp
+    }));
+  } catch (error) {
+    console.warn("Failed to read retrieval audit for spend estimate:", error);
+    return [];
+  } finally {
+    db?.close();
+  }
+}
+function dateKey(timestamp) {
+  const d = new Date(timestamp);
+  return d.toISOString().slice(0, 10);
+}
+function calculateSpendSummary(rows) {
+  const now = /* @__PURE__ */ new Date();
+  const multiplier = effectiveSpendMultiplier(now);
+  const bySource = {};
+  const byModel = {};
+  const byDayMap = {};
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalListCost = 0;
+  let totalEffectiveCost = 0;
+  for (const row of rows) {
+    const cost = calculateCost(
+      row.modelKey.split("/")[0],
+      row.modelKey.split("/").slice(1).join("/"),
+      row.inputTokens,
+      row.outputTokens
+    );
+    const listCost = cost?.totalCost ?? 0;
+    const effective = listCost * multiplier;
+    totalInputTokens += row.inputTokens;
+    totalOutputTokens += row.outputTokens;
+    totalListCost += listCost;
+    totalEffectiveCost += effective;
+    const src = bySource[row.source] ?? {
+      source: row.source,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      listCostUsd: 0,
+      effectiveCostUsd: 0
+    };
+    src.inputTokens += row.inputTokens;
+    src.outputTokens += row.outputTokens;
+    src.totalTokens += row.inputTokens + row.outputTokens;
+    src.listCostUsd += listCost;
+    src.effectiveCostUsd += effective;
+    bySource[row.source] = src;
+    const model = byModel[row.modelKey] ?? {
+      modelKey: row.modelKey,
+      displayName: row.modelKey.split("/").slice(1).join("/"),
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      listCostUsd: 0,
+      effectiveCostUsd: 0
+    };
+    model.inputTokens += row.inputTokens;
+    model.outputTokens += row.outputTokens;
+    model.totalTokens += row.inputTokens + row.outputTokens;
+    model.listCostUsd += listCost;
+    model.effectiveCostUsd += effective;
+    byModel[row.modelKey] = model;
+    const day = dateKey(row.timestamp);
+    const dayEntry = byDayMap[day] ?? {
+      date: day,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      listCostUsd: 0,
+      effectiveCostUsd: 0
+    };
+    dayEntry.inputTokens += row.inputTokens;
+    dayEntry.outputTokens += row.outputTokens;
+    dayEntry.totalTokens += row.inputTokens + row.outputTokens;
+    dayEntry.listCostUsd += listCost;
+    dayEntry.effectiveCostUsd += effective;
+    byDayMap[day] = dayEntry;
+  }
+  return {
+    totalInputTokens,
+    totalOutputTokens,
+    totalTokens: totalInputTokens + totalOutputTokens,
+    listCostUsd: totalListCost,
+    effectiveCostUsd: totalEffectiveCost,
+    discountMultiplier: multiplier,
+    formattedListCost: formatCost(totalListCost),
+    formattedEffectiveCost: formatCost(totalEffectiveCost),
+    bySource,
+    byModel,
+    byDay: Object.values(byDayMap).sort((a, b) => a.date.localeCompare(b.date))
+  };
+}
+async function getSpendSummary() {
+  const rows = [...readConductorUsage(), ...readRetrievalUsage()];
+  const summary = calculateSpendSummary(rows);
+  const gcp = await getGcpSpend();
+  if (gcp) {
+    summary.gcpSpendUsd = gcp.totalCostUsd;
+    summary.gcpSpendFormatted = formatCost(gcp.totalCostUsd);
+    summary.gcpSource = "bigquery";
+    summary.gcpTable = gcp.table;
+    summary.gcpDaily = gcp.daily;
+  } else {
+    const envSpend = getGcpSpendEnvFallback();
+    if (envSpend !== void 0) {
+      summary.gcpSpendUsd = envSpend;
+      summary.gcpSpendFormatted = formatCost(envSpend);
+      summary.gcpSource = "env";
+    }
+  }
+  return summary;
+}
+export {
+  calculateSpendSummary,
+  getSpendSummary
+};

package/dist/src/hooks/schemas.js

@@ -15,10 +15,13 @@ const ModelProviderSchema = z.enum([
   "anthropic",
   "qwen",
   "openai",
+  "xai",
+  "deepseek",
   "ollama",
   "cerebras",
   "deepinfra",
   "openrouter",
+  "moonshot",
   "anthropic-batch",
   "custom"
 ]);
@@ -40,7 +43,8 @@ const ModelRouterConfigSchema = z.object({
     review: ModelProviderSchema.optional(),
     linting: ModelProviderSchema.optional(),
     context: ModelProviderSchema.optional(),
-    testing: ModelProviderSchema.optional()
+    testing: ModelProviderSchema.optional(),
+    design: ModelProviderSchema.optional()
   }).optional().default({}),
   fallback: z.object({
     enabled: z.boolean(),
@@ -59,6 +63,7 @@ const ModelRouterConfigSchema = z.object({
     cerebras: ModelConfigSchema.optional(),
     deepinfra: ModelConfigSchema.optional(),
     openrouter: ModelConfigSchema.optional(),
+    moonshot: ModelConfigSchema.optional(),
     "anthropic-batch": ModelConfigSchema.optional(),
     custom: ModelConfigSchema.optional()
   }).optional().default({}),

package/dist/src/integrations/anthropic/client.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
+import { estimateTokens } from "../../core/cache/token-estimator.js";
 import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
 class AnthropicClient {
   apiKey;
@@ -220,8 +221,8 @@ describe('validateInput', () => {
       stopReason: "stop_sequence",
       model: request.model,
       usage: {
-        inputTokens: Math.ceil(request.prompt.length / 4),
-        outputTokens: Math.ceil(content.length / 4)
+        inputTokens: estimateTokens(request.prompt),
+        outputTokens: estimateTokens(content)
       }
     };
   }

package/dist/src/integrations/claude-code/agent-bridge.js

@@ -4,9 +4,6 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { v4 as uuidv4 } from "uuid";
 import { logger } from "../../core/monitoring/logger.js";
-import {
-  OracleWorkerCoordinator
-} from "../ralph/patterns/oracle-worker-pattern.js";
 import { ClaudeCodeTaskCoordinator } from "./task-coordinator.js";
 const CLAUDE_CODE_AGENTS = {
   // Oracle-level agents (strategic, high-level)

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

@@ -3,8 +3,9 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
+import { estimateTokens } from "../../core/cache/token-estimator.js";
 import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -17,6 +18,17 @@ import {
   createProvider
 } from "../../core/extensions/provider-adapter.js";
 import { AnthropicBatchClient } from "../anthropic/batch-client.js";
+const QUOTA_ERROR_PATTERNS = [
+  /rate.?limit/i,
+  /quota.?exceeded/i,
+  /too many requests/i,
+  /429/,
+  /capacity/i,
+  /billing/i,
+  /usage.?limit/i,
+  /plan.?limit/i,
+  /max.*requests/i
+];
 class ClaudeCodeSubagentClient {
   tempDir;
   mockMode;
@@ -33,8 +45,12 @@ class ClaudeCodeSubagentClient {
   }
   /**
    * Execute a subagent task.
-   * When multiProvider is enabled, routes cheap tasks to external providers.
-   * Falls back to Claude Code CLI path when disabled or for complex tasks.
+   *
+   * Routing priority (subscription-first to minimize API costs):
+   *   1. Codex CLI — subagents included in ChatGPT Plus/Pro subscription
+   *   2. Grok Build CLI — included in Grok Build subscription ($300/mo)
+   *   3. External API providers — when multiProvider enabled (DeepSeek, xAI, etc.)
+   *   4. Claude Code CLI — falls back here (uses API tokens, not subscription)
    */
   async executeSubagent(request) {
     const startTime = Date.now();
@@ -47,6 +63,43 @@ class ClaudeCodeSubagentClient {
     if (this.mockMode) {
       return this.getMockResponse(request, startTime, subagentId);
     }
+    if (request.type === "design" || request.forceProvider === "claude") {
+      return this.executeSubagentViaCLI(request, startTime, subagentId);
+    }
+    if (request.forceProvider === "codex" && this.isCodexAvailable()) {
+      return this.executeSubagentViaCodex(request, startTime, subagentId);
+    }
+    if (request.forceProvider === "grok" && this.isGrokBuildAvailable()) {
+      return this.executeSubagentViaGrokBuild(request, startTime, subagentId);
+    }
+    if (this.isCodexAvailable()) {
+      try {
+        return await this.executeSubagentViaCodex(
+          request,
+          startTime,
+          subagentId
+        );
+      } catch (error) {
+        logger.warn("Codex subagent failed, trying next provider", {
+          subagentId,
+          error: error.message
+        });
+      }
+    }
+    if (this.isGrokBuildAvailable()) {
+      try {
+        return await this.executeSubagentViaGrokBuild(
+          request,
+          startTime,
+          subagentId
+        );
+      } catch (error) {
+        logger.warn("Grok Build subagent failed, trying next provider", {
+          subagentId,
+          error: error.message
+        });
+      }
+    }
     if (isFeatureEnabled("multiProvider")) {
       const taskType = request.type;
       const complexity = scoreComplexity(request.task, request.context);
@@ -108,6 +161,12 @@ class ClaudeCodeSubagentClient {
         tokens: result.usage.inputTokens + result.usage.outputTokens
       };
     } catch (error) {
+      if (optimal.provider === "anthropic" && this.isQuotaError(error.message)) {
+        logger.warn("Anthropic API quota hit, overflowing to Kimi", {
+          error: error.message
+        });
+        return this.executeKimiOverflow(request, startTime, subagentId);
+      }
       logger.warn(`Direct API failed for ${optimal.provider}, falling back`, {
         error: error.message
       });
@@ -173,9 +232,16 @@ Context (JSON): ${JSON.stringify(request.context)}`;
         output: result.text,
         duration: Date.now() - startTime,
         subagentType: request.type,
-        tokens: this.estimateTokens(fullPrompt + result.text)
+        tokens: estimateTokens(fullPrompt + result.text)
       };
     } catch (error) {
+      if (this.isQuotaError(error.message)) {
+        logger.warn("Claude quota/rate limit hit, overflowing to Kimi", {
+          subagentId,
+          error: error.message
+        });
+        return this.executeKimiOverflow(request, startTime, subagentId);
+      }
       logger.error(`Subagent CLI execution failed: ${request.type}`, {
         error,
         subagentId
@@ -210,6 +276,195 @@ Context (JSON): ${JSON.stringify(request.context)}`;
       }
     });
   }
+  /**
+   * Check if Codex CLI is available (installed + authenticated via ChatGPT subscription)
+   */
+  isCodexAvailable() {
+    try {
+      const result = execSync("which codex 2>/dev/null", {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim();
+      return !!result;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if Grok Build CLI is available
+   */
+  isGrokBuildAvailable() {
+    try {
+      const result = execSync("which grok 2>/dev/null", {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim();
+      return !!result;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Execute subagent via Codex CLI.
+   * Subagents run against ChatGPT subscription — no API cost.
+   */
+  async executeSubagentViaCodex(request, startTime, subagentId) {
+    const prompt = this.buildSubagentPrompt(request);
+    logger.info("Routing subagent to Codex CLI (subscription-free)", {
+      subagentId,
+      type: request.type
+    });
+    return new Promise((resolve, reject) => {
+      const args = ["-q", "--json", "-a", "full-auto", prompt];
+      const proc = spawn("codex", args, {
+        cwd: process.cwd(),
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: request.timeout ?? 3e5
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (d) => {
+        stdout += d.toString();
+      });
+      proc.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`Codex exited ${code}: ${stderr.slice(0, 500)}`));
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(stdout);
+        } catch {
+          parsed = { rawOutput: stdout };
+        }
+        resolve({
+          success: true,
+          result: parsed,
+          output: stdout,
+          duration: Date.now() - startTime,
+          subagentType: `codex:${request.type}`
+        });
+      });
+      proc.on("error", reject);
+    });
+  }
+  /**
+   * Execute subagent via Grok Build CLI.
+   * Runs against Grok Build subscription — no per-token API cost.
+   */
+  async executeSubagentViaGrokBuild(request, startTime, subagentId) {
+    const prompt = this.buildSubagentPrompt(request);
+    logger.info("Routing subagent to Grok Build CLI (subscription-free)", {
+      subagentId,
+      type: request.type
+    });
+    return new Promise((resolve, reject) => {
+      const args = ["run", "--quiet", "--json", prompt];
+      const proc = spawn("grok", args, {
+        cwd: process.cwd(),
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: request.timeout ?? 3e5
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (d) => {
+        stdout += d.toString();
+      });
+      proc.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(
+            new Error(`Grok Build exited ${code}: ${stderr.slice(0, 500)}`)
+          );
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(stdout);
+        } catch {
+          parsed = { rawOutput: stdout };
+        }
+        resolve({
+          success: true,
+          result: parsed,
+          output: stdout,
+          duration: Date.now() - startTime,
+          subagentType: `grok-build:${request.type}`
+        });
+      });
+      proc.on("error", reject);
+    });
+  }
+  /**
+   * Check if an error message indicates quota/rate limit exhaustion
+   */
+  isQuotaError(message) {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+  }
+  /**
+   * Execute via Kimi/Moonshot API as overflow when Claude quota is exhausted.
+   * Uses OpenAI-compatible API at api.moonshot.ai/v1.
+   */
+  async executeKimiOverflow(request, startTime, subagentId) {
+    const apiKey = process.env["MOONSHOT_API_KEY"] || "";
+    if (!apiKey) {
+      logger.warn("No MOONSHOT_API_KEY set, cannot overflow to Kimi");
+      return {
+        success: false,
+        result: null,
+        error: "Claude quota exceeded and no MOONSHOT_API_KEY configured",
+        duration: Date.now() - startTime,
+        subagentType: request.type
+      };
+    }
+    try {
+      const adapter = createProvider("moonshot", {
+        apiKey,
+        baseUrl: "https://api.moonshot.ai/v1"
+      });
+      const prompt = this.buildSubagentPrompt(request);
+      const result = await adapter.complete(
+        [{ role: "user", content: prompt }],
+        { model: "kimi-k2.6", maxTokens: 8192 }
+      );
+      const text = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = { rawOutput: text };
+      }
+      logger.info("Kimi overflow completed", {
+        subagentId,
+        tokens: result.usage.inputTokens + result.usage.outputTokens
+      });
+      return {
+        success: true,
+        result: parsed,
+        output: text,
+        duration: Date.now() - startTime,
+        subagentType: request.type,
+        tokens: result.usage.inputTokens + result.usage.outputTokens
+      };
+    } catch (kimiError) {
+      logger.error("Kimi overflow also failed", {
+        subagentId,
+        error: kimiError.message
+      });
+      return {
+        success: false,
+        result: null,
+        error: `Claude quota exceeded, Kimi fallback failed: ${kimiError.message}`,
+        duration: Date.now() - startTime,
+        subagentType: request.type
+      };
+    }
+  }
   /**
    * Build subagent prompt based on type
    */
@@ -319,6 +574,23 @@ Context (JSON): ${JSON.stringify(request.context)}`;
         Search parameters are in the context file.
         
         Output relevant context snippets.`,
+      design: `You are a Frontend Design Subagent. You make creative, opinionated UI/UX decisions while implementing exactly what's scoped.
+
+        Task: ${request.task}
+
+        Instructions:
+        1. Make strong design decisions \u2014 pick colors, spacing, layout, typography, interactions
+        2. Write production-ready code (React/TSX + Tailwind preferred, adapt to project stack)
+        3. Favor distinctive, polished UI over generic/boilerplate aesthetics
+        4. Ensure responsive design and accessibility basics (contrast, focus, semantic HTML)
+        5. Include hover states, transitions, and micro-interactions where appropriate
+        6. Match existing design system if one exists in the project, otherwise create cohesive choices
+
+        The prompt is well-scoped but you own the UI/UX decisions. Don't ask \u2014 decide.
+
+        Context and requirements are in the provided file.
+
+        Output the implementation code with brief notes on design choices made.`,
       publish: `You are a Publishing Subagent handling releases and deployments.
         
         Task: ${request.task}
@@ -504,6 +776,15 @@ function greetUser(name: string): string {
         changelog: "Initial release",
         published: false,
         reason: "Mock mode - no actual publishing"
+      },
+      design: {
+        implementation: '<div className="flex flex-col gap-4 p-6">...</div>',
+        files_modified: ["src/components/Example.tsx"],
+        design_choices: [
+          "Dark mode default",
+          "Space Grotesk typography",
+          "8px grid"
+        ]
       }
     };
     const result = mockResponses[request.type] || {};
@@ -513,15 +794,9 @@ function greetUser(name: string): string {
       output: `Mock ${request.type} subagent completed successfully`,
       duration: Date.now() - startTime,
       subagentType: request.type,
-      tokens: this.estimateTokens(JSON.stringify(result))
+      tokens: estimateTokens(JSON.stringify(result))
     };
   }
-  /**
-   * Estimate token usage
-   */
-  estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-  }
   /**
    * Cleanup temporary files
    */
@@ -541,6 +816,27 @@ function greetUser(name: string): string {
       }
     }
   }
+  /**
+   * Delegate a design/frontend task to Claude.
+   * Always routes to Claude CLI regardless of subscription-first ordering,
+   * because Claude is the design specialist.
+   *
+   * Usage from any wrapper (codex-sm, opencode-sm, etc.):
+   *   const client = new ClaudeCodeSubagentClient();
+   *   const result = await client.delegateDesign(
+   *     'Build a settings page with dark/light toggle, user avatar, and notification preferences',
+   *     { stack: 'react+tailwind', designSystem: 'nothing' }
+   *   );
+   */
+  async delegateDesign(task, context = {}, options) {
+    return this.executeSubagent({
+      type: "design",
+      task,
+      context,
+      forceProvider: "claude",
+      ...options
+    });
+  }
   /**
    * Get active subagent statistics
    */

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

@@ -5,6 +5,7 @@ const __dirname = __pathDirname(__filename);
 import { v4 as uuidv4 } from "uuid";
 import { spawn } from "child_process";
 import { logger } from "../../core/monitoring/logger.js";
+import { estimateTokens } from "../../core/cache/token-estimator.js";
 class ClaudeCodeTaskCoordinator {
   activeTasks = /* @__PURE__ */ new Map();
   completedTasks = [];
@@ -347,7 +348,7 @@ class ClaudeCodeTaskCoordinator {
    * Estimate token usage
    */
   estimateTokenUsage(prompt, response) {
-    return Math.ceil((prompt.length + response.length) / 4);
+    return estimateTokens(prompt + response);
   }
   /**
    * Calculate actual task cost