wispy-cli 2.7.8 → 2.7.9

package/core/browser.mjs

@@ -0,0 +1,327 @@
+/**
+ * core/browser.mjs — Native browser integration via local-browser-bridge
+ *
+ * Connects to the local-browser-bridge HTTP API for browser control.
+ * Supports: health check, capabilities, diagnostics, tabs, attach,
+ * navigate, activate, screenshot, sessions.
+ *
+ * All HTTP calls use native fetch() (Node 18+).
+ */
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(execFile);
+const NOT_RUNNING_MSG =
+  "Bridge not running. Start with: npx local-browser-bridge serve";
+
+/**
+ * BrowserBridge — HTTP client for local-browser-bridge API.
+ *
+ * Usage:
+ *   const bridge = new BrowserBridge();
+ *   await bridge.ensureRunning();
+ *   const session = await bridge.autoAttach();
+ *   await bridge.navigate("https://example.com");
+ */
+export class BrowserBridge {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? "http://127.0.0.1:3000";
+    this.defaultBrowser = options.browser ?? "safari";
+    this._session = null; // current active session
+    this._engine = options.engine ?? null; // optional WispyEngine ref for audit/trust
+  }
+
+  // ── Private helpers ──────────────────────────────────────────────────────────
+
+  async _get(path, params = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined && v !== null) url.searchParams.set(k, v);
+    }
+    try {
+      const res = await fetch(url.toString(), {
+        signal: AbortSignal.timeout(10_000),
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${body.slice(0, 200)}` };
+      }
+      return res.json();
+    } catch (err) {
+      if (err.name === "AbortError" || err.name === "TimeoutError") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      if (err.code === "ECONNREFUSED" || err.cause?.code === "ECONNREFUSED") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      return { error: err.message ?? NOT_RUNNING_MSG };
+    }
+  }
+
+  async _post(path, body = {}) {
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        return { error: `HTTP ${res.status}: ${text.slice(0, 200)}` };
+      }
+      return res.json();
+    } catch (err) {
+      if (err.name === "AbortError" || err.name === "TimeoutError") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      if (err.code === "ECONNREFUSED" || err.cause?.code === "ECONNREFUSED") {
+        return { error: NOT_RUNNING_MSG };
+      }
+      return { error: err.message ?? NOT_RUNNING_MSG };
+    }
+  }
+
+  _audit(action, details = {}) {
+    if (!this._engine?.audit) return;
+    this._engine.audit.log({
+      type: "BROWSER_ACTION",
+      action,
+      ...details,
+    }).catch(() => {});
+  }
+
+  _trustLevel() {
+    if (!this._engine) return "careful";
+    return this._engine.config?.trustLevel ?? this._engine.permissions?.level ?? "careful";
+  }
+
+  _mayLog(action, detail) {
+    const level = this._trustLevel();
+    if (level !== "yolo") {
+      if (process.env.WISPY_DEBUG) {
+        process.stderr.write(`[browser] ${action}: ${detail}\n`);
+      }
+    }
+    this._audit(action, { detail });
+  }
+
+  // ── Health & discovery ───────────────────────────────────────────────────────
+
+  /** GET /health → { ok: true } */
+  async health() {
+    return this._get("/health");
+  }
+
+  /** GET /v1/capabilities?browser=X */
+  async capabilities(browser) {
+    return this._get("/v1/capabilities", { browser });
+  }
+
+  /** GET /v1/diagnostics?browser=X */
+  async diagnostics(browser) {
+    return this._get("/v1/diagnostics", { browser });
+  }
+
+  // ── Tab inspection ───────────────────────────────────────────────────────────
+
+  /** GET /v1/front-tab?browser=X */
+  async frontTab(browser) {
+    return this._get("/v1/front-tab", { browser: browser ?? this.defaultBrowser });
+  }
+
+  /**
+   * GET /v1/tab?browser=X&...
+   * query: { browser?, signature?, windowIndex?, tabIndex?, url?, title? }
+   */
+  async getTab(query = {}) {
+    const params = { browser: query.browser ?? this.defaultBrowser, ...query };
+    return this._get("/v1/tab", params);
+  }
+
+  /** GET /v1/tabs?browser=X */
+  async listTabs(browser) {
+    return this._get("/v1/tabs", { browser: browser ?? this.defaultBrowser });
+  }
+
+  // ── Session management ───────────────────────────────────────────────────────
+
+  /**
+   * POST /v1/attach { browser, mode?, tabTarget? }
+   * Stores the resulting session as this._session.
+   */
+  async attach(browser, opts = {}) {
+    const body = {
+      browser: browser ?? this.defaultBrowser,
+      ...opts,
+    };
+    const result = await this._post("/v1/attach", body);
+    if (!result.error) {
+      this._session = result;
+    }
+    return result;
+  }
+
+  /** GET /v1/sessions */
+  async listSessions() {
+    return this._get("/v1/sessions");
+  }
+
+  /** GET /v1/sessions/:id */
+  async getSession(id) {
+    return this._get(`/v1/sessions/${encodeURIComponent(id)}`);
+  }
+
+  /** POST /v1/sessions/:id/resume */
+  async resumeSession(id) {
+    const result = await this._post(`/v1/sessions/${encodeURIComponent(id)}/resume`);
+    if (!result.error) {
+      this._session = result;
+    }
+    return result;
+  }
+
+  // ── Actions (require active session) ─────────────────────────────────────────
+
+  /**
+   * Navigate to a URL.
+   * Uses session-scoped endpoint if sessionId/this._session is available.
+   */
+  async navigate(url, sessionId) {
+    this._mayLog("navigate", url);
+
+    const sid = sessionId ?? this._session?.id ?? this._session?.sessionId;
+    if (sid) {
+      return this._post(`/v1/sessions/${encodeURIComponent(sid)}/navigate`, { url });
+    }
+    return this._post("/v1/navigate", { url });
+  }
+
+  /**
+   * Bring browser tab to front / focus.
+   */
+  async activate(sessionId) {
+    this._mayLog("activate", sessionId ?? this._session?.id ?? "default");
+
+    const sid = sessionId ?? this._session?.id ?? this._session?.sessionId;
+    if (sid) {
+      return this._post(`/v1/sessions/${encodeURIComponent(sid)}/activate`);
+    }
+    return this._post("/v1/activate");
+  }
+
+  /**
+   * Take a screenshot.
+   * Returns { screenshot: "<base64>" } or { error }
+   */
+  async screenshot(sessionId) {
+    const sid = sessionId ?? this._session?.id ?? this._session?.sessionId;
+    if (sid) {
+      // Some implementations support GET, some POST
+      return this._get(`/v1/sessions/${encodeURIComponent(sid)}/screenshot`);
+    }
+    return this._post("/v1/screenshot");
+  }
+
+  // ── Lifecycle ────────────────────────────────────────────────────────────────
+
+  /**
+   * Check health, attempt to start bridge if not running.
+   * Returns { ok: boolean, started: boolean }
+   */
+  async ensureRunning() {
+    // 1. Try health
+    const h = await this.health();
+    if (h?.ok || (!h?.error && h !== null)) {
+      return { ok: true, started: false };
+    }
+
+    // 2. Try to start the bridge
+    let started = false;
+    try {
+      execFile("/bin/sh", ["-c", "npx local-browser-bridge serve --port 3000 &"], {
+        detached: true,
+        stdio: "ignore",
+      });
+      started = true;
+    } catch {
+      // ignore — may not have npx or may already be running
+    }
+
+    // 3. Wait up to 5 seconds for health to respond
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 500));
+      const h2 = await this.health();
+      if (h2?.ok || (!h2?.error && h2 !== null)) {
+        return { ok: true, started };
+      }
+    }
+
+    return { ok: false, started };
+  }
+
+  /**
+   * Auto-discover and attach to the best available browser.
+   * Order: safari-actionable > safari-readonly > chrome-actionable > chrome-readonly
+   */
+  async autoAttach() {
+    // 1. Get capabilities
+    const caps = await this.capabilities();
+    if (caps?.error) return { error: caps.error };
+
+    const browsers = Array.isArray(caps?.browsers)
+      ? caps.browsers
+      : Object.keys(caps ?? {}).filter((k) => k !== "error");
+
+    if (browsers.length === 0) {
+      return { error: "No browsers available via local-browser-bridge" };
+    }
+
+    // 2. Get diagnostics for each browser
+    const diagResults = [];
+    for (const browser of browsers) {
+      const d = await this.diagnostics(browser);
+      diagResults.push({ browser, diag: d });
+    }
+
+    // 3. Pick the best actionable browser
+    const priority = [
+      (d) => d.browser === "safari" && d.diag?.actionable === true,
+      (d) => d.browser === "chrome" && d.diag?.actionable === true,
+      (d) => d.diag?.actionable === true,
+      (d) => d.browser === "safari",
+      (d) => true,
+    ];
+
+    let chosen = null;
+    for (const pred of priority) {
+      chosen = diagResults.find(pred);
+      if (chosen) break;
+    }
+
+    if (!chosen) return { error: "No suitable browser found" };
+
+    // 4. Attach
+    const session = await this.attach(chosen.browser);
+    return session;
+  }
+
+  /** Summary status for display */
+  status() {
+    return {
+      baseUrl: this.baseUrl,
+      defaultBrowser: this.defaultBrowser,
+      session: this._session
+        ? {
+            id: this._session.id ?? this._session.sessionId,
+            browser: this._session.browser,
+            mode: this._session.mode,
+          }
+        : null,
+    };
+  }
+}
+
+export default BrowserBridge;

package/core/engine.mjs

@@ -27,6 +27,9 @@ import { Harness } from "./harness.mjs";
 import { SyncManager, getSyncManager } from "./sync.mjs";
 import { SkillManager } from "./skills.mjs";
 import { UserModel } from "./user-model.mjs";
+import { routeTask, classifyTask, filterAvailableModels } from "./task-router.mjs";
+import { decomposeTask, executeDecomposedPlan } from "./task-decomposer.mjs";
+import { BrowserBridge } from "./browser.mjs";
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -46,6 +49,7 @@ export class WispyEngine {
     this.sync = null; // SyncManager, initialized lazily
     this.skills = new SkillManager(WISPY_DIR, this);
     this.userModel = new UserModel(WISPY_DIR, this);
+    this.browser = new BrowserBridge({ engine: this });
     this._initialized = false;
     this._workMdContent = null;
     this._workMdLoaded = false;
@@ -87,9 +91,15 @@ export class WispyEngine {
     // Register skill tools
     this._registerSkillTools();
 
+    // Register routing + decomposition tools (v2.8)
+    this._registerRoutingTools();
+
     // Re-wire harness after tools are registered
     this.harness = new Harness(this.tools, this.permissions, this.audit, this.config);
 
+    // Start browser bridge (non-blocking, don't fail if unavailable)
+    this.browser.ensureRunning().catch(() => {});
+
     // Initialize MCP
     if (!opts.skipMcp) {
       await ensureDefaultMcpConfig(this.mcpManager.configPath);
@@ -347,6 +357,11 @@ export class WispyEngine {
       "node_list", "node_status", "node_execute",
       "update_work_context",
       "run_skill", "list_skills", "delete_skill",
+      "smart_route", "decompose_and_execute",
+      // Browser tools (v2.9)
+      "browser_status", "browser_tabs", "browser_navigate",
+      "browser_screenshot", "browser_front_tab", "browser_activate",
+      "browser_attach",
     ]);
 
     const harnessResult = await this.harness.execute(name, args, {
@@ -422,6 +437,26 @@ export class WispyEngine {
         return this._toolListSkills(args);
       case "delete_skill":
         return this._toolDeleteSkill(args);
+      // Smart routing + decomposition (v2.8)
+      case "smart_route":
+        return this._toolSmartRoute(args);
+      case "decompose_and_execute":
+        return this._toolDecomposeAndExecute(args, opts);
+      // Browser tools (v2.9)
+      case "browser_status":
+        return this._toolBrowserStatus();
+      case "browser_tabs":
+        return this._toolBrowserTabs(args);
+      case "browser_navigate":
+        return this._toolBrowserNavigate(args);
+      case "browser_screenshot":
+        return this._toolBrowserScreenshot(args);
+      case "browser_front_tab":
+        return this._toolBrowserFrontTab(args);
+      case "browser_activate":
+        return this._toolBrowserActivate(args);
+      case "browser_attach":
+        return this._toolBrowserAttach(args);
       default:
         return this.tools.execute(name, args);
     }
@@ -1191,6 +1226,210 @@ export class WispyEngine {
     return this.skills.delete(args.name);
   }
 
+  // ── Smart routing + decomposition tools (v2.8) ───────────────────────────────
+
+  _registerRoutingTools() {
+    const routingTools = [
+      {
+        name: "smart_route",
+        description: "Analyze a task and recommend the best model to handle it based on task type, complexity, and available providers.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string", description: "The task to analyze and route" },
+            cost_preference: {
+              type: "string",
+              enum: ["minimize", "balanced", "maximize-quality"],
+              description: "Tradeoff preference (default: balanced)",
+            },
+          },
+          required: ["task"],
+        },
+      },
+      {
+        name: "decompose_and_execute",
+        description: "Split a complex task into subtasks, route each to the best model, execute in parallel, and synthesize results into a coherent response.",
+        parameters: {
+          type: "object",
+          properties: {
+            task: { type: "string", description: "The complex task to decompose and execute" },
+            max_subtasks: { type: "number", description: "Maximum number of subtasks (default: 5)" },
+            cost_preference: {
+              type: "string",
+              enum: ["minimize", "balanced", "maximize-quality"],
+              description: "Cost/quality tradeoff preference (default: balanced)",
+            },
+          },
+          required: ["task"],
+        },
+      },
+    ];
+
+    for (const tool of routingTools) {
+      this.tools._definitions.set(tool.name, tool);
+    }
+  }
+
+  async _toolSmartRoute(args) {
+    try {
+      const classification = classifyTask(args.task ?? "");
+      const routing = routeTask(args.task ?? "", null, {
+        costPreference: args.cost_preference ?? "balanced",
+        defaultModel: this.model,
+      });
+
+      return {
+        success: true,
+        recommendation: routing,
+        classification,
+        availableModels: filterAvailableModels(
+          ["gpt-5.4", "gpt-4o", "gpt-4o-mini", "claude-opus-4-20250514", "claude-sonnet-4-20250514",
+           "claude-3-5-haiku-20241022", "gemini-2.5-pro", "gemini-2.5-flash",
+           "llama-3.3-70b-versatile", "deepseek-chat", "deepseek-reasoner"]
+        ),
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolDecomposeAndExecute(args, parentOpts = {}) {
+    try {
+      const task = args.task ?? "";
+      const maxSubtasks = args.max_subtasks ?? 5;
+      const costPreference = args.cost_preference ?? "balanced";
+
+      // Step 1: Decompose
+      const plan = await decomposeTask(task, {
+        maxSubtasks,
+        costPreference,
+        engine: this,
+      });
+
+      if (plan.subtasks.length === 0) {
+        return { success: false, error: "Failed to decompose task into subtasks" };
+      }
+
+      // Step 2: Execute
+      const executionResult = await executeDecomposedPlan(plan, this, {
+        costPreference,
+        onSubtaskStart: (st) => {
+          if (process.env.WISPY_DEBUG) {
+            console.error(`[decompose] Starting subtask ${st.id}: ${st.task.slice(0, 60)}`);
+          }
+        },
+        onSubtaskComplete: (st, result) => {
+          if (process.env.WISPY_DEBUG) {
+            console.error(`[decompose] Completed subtask ${st.id}`);
+          }
+        },
+      });
+
+      return {
+        success: true,
+        plan: {
+          subtaskCount: plan.subtasks.length,
+          parallelGroups: plan.parallelGroups.length,
+          estimatedCost: plan.estimatedCost,
+          estimatedTime: plan.estimatedTime,
+        },
+        subtasks: executionResult.results.map(r => ({
+          id: r.id,
+          type: r.type,
+          task: r.task.slice(0, 100),
+          resultPreview: r.result?.slice(0, 200) ?? null,
+        })),
+        errors: executionResult.errors,
+        synthesized: executionResult.synthesized,
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  // ── Browser tools (v2.9) ─────────────────────────────────────────────────────
+
+  async _toolBrowserStatus() {
+    try {
+      const health = await this.browser.health();
+      const status = this.browser.status();
+      return {
+        success: true,
+        health: health?.ok ?? false,
+        bridgeUrl: this.browser.baseUrl,
+        session: status.session,
+        hint: health?.error ? `Start bridge: npx local-browser-bridge serve` : undefined,
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserTabs(args) {
+    try {
+      const result = await this.browser.listTabs(args?.browser);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, tabs: result?.tabs ?? result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserNavigate(args) {
+    try {
+      const result = await this.browser.navigate(args.url);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, url: args.url, result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserScreenshot(args) {
+    try {
+      const result = await this.browser.screenshot(args?.sessionId);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, screenshot: result?.screenshot ?? result?.data, format: "base64" };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserFrontTab(args) {
+    try {
+      const result = await this.browser.frontTab(args?.browser);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, tab: result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserActivate(args) {
+    try {
+      const result = await this.browser.activate(args?.sessionId);
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolBrowserAttach(args) {
+    try {
+      let result;
+      if (!args?.browser) {
+        result = await this.browser.autoAttach();
+      } else {
+        result = await this.browser.attach(args.browser, { mode: args.mode });
+      }
+      if (result?.error) return { success: false, error: result.error };
+      return { success: true, session: result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
   // ── Cleanup ──────────────────────────────────────────────────────────────────
 
   destroy() {

package/core/subagents.mjs

@@ -34,6 +34,7 @@ import os from "node:os";
 import path from "node:path";
 import { readFile, writeFile, readdir, mkdir } from "node:fs/promises";
 import { WISPY_DIR } from "./config.mjs";
+import { routeTask, filterAvailableModels, MODEL_CAPABILITIES, getAvailableProviders } from "./task-router.mjs";
 
 const SUBAGENTS_DIR = path.join(WISPY_DIR, "subagents");
 
@@ -150,11 +151,33 @@ export class SubAgentManager extends EventEmitter {
    * @returns {Promise<SubAgent>}
    */
   async spawn(opts) {
+    // ── routingPreference: resolve model before spawning ──────────────────────
+    let resolvedModel = opts.model ?? null;
+    const routingPref = opts.routingPreference ?? "inherit";
+
+    if (routingPref === "auto") {
+      try {
+        const routing = routeTask(opts.task ?? "", null, { costPreference: "balanced" });
+        resolvedModel = routing.model;
+      } catch { /* ignore routing errors, use null */ }
+    } else if (routingPref === "fast") {
+      try {
+        const routing = routeTask(opts.task ?? "", null, { costPreference: "minimize" });
+        resolvedModel = routing.model;
+      } catch {}
+    } else if (routingPref === "quality") {
+      try {
+        const routing = routeTask(opts.task ?? "", null, { costPreference: "maximize-quality" });
+        resolvedModel = routing.model;
+      } catch {}
+    }
+    // "inherit" → use opts.model as-is (or null = parent's model)
+
     const agent = new SubAgent({
       id: makeId(),
       task: opts.task,
       label: opts.label,
-      model: opts.model,
+      model: resolvedModel,
       timeout: opts.timeout ? opts.timeout * 1000 : 300_000,
       workstream: opts.workstream ?? this._engine._activeWorkstream,
     });

package/core/task-decomposer.mjs

@@ -0,0 +1,375 @@
+/**
+ * core/task-decomposer.mjs — Task Decomposition Engine for Wispy
+ *
+ * Splits complex tasks into parallel subtasks, routes each to the best model,
+ * executes concurrently, and synthesizes results.
+ */
+
+import { routeTask, getCheapDecomposerModel, classifyTask } from "./task-router.mjs";
+
+// ── Subtask counter ───────────────────────────────────────────────────────────
+
+let _subtaskCounter = 0;
+function makeSubtaskId() {
+  return `st-${(++_subtaskCounter).toString().padStart(2, "0")}`;
+}
+
+// ── Decompose task using LLM ─────────────────────────────────────────────────
+
+/**
+ * Decompose a complex task into parallel subtasks using a cheap LLM.
+ *
+ * @param {string} task - The task description
+ * @param {object} [options]
+ * @param {number} [options.maxSubtasks=5] - Max number of subtasks
+ * @param {string} [options.costPreference="balanced"] - "minimize" | "balanced" | "maximize-quality"
+ * @param {object} [options.engine] - WispyEngine instance (for LLM calls)
+ * @returns {Promise<{
+ *   subtasks: Array<{id,task,type,dependencies,priority}>,
+ *   parallelGroups: string[][],
+ *   estimatedCost: string,
+ *   estimatedTime: string
+ * }>}
+ */
+export async function decomposeTask(task, options = {}) {
+  const maxSubtasks = options.maxSubtasks ?? 5;
+  const costPreference = options.costPreference ?? "balanced";
+  const engine = options.engine ?? null;
+
+  _subtaskCounter = 0; // reset for this decomposition
+
+  // Quick path: if the task seems simple, don't bother decomposing
+  const classification = classifyTask(task);
+  if (classification.complexity !== "complex" || !classification.parallelizable) {
+    const subtaskId = makeSubtaskId();
+    return {
+      subtasks: [
+        {
+          id: subtaskId,
+          task,
+          type: classification.type,
+          dependencies: [],
+          priority: 1,
+        },
+      ],
+      parallelGroups: [[subtaskId]],
+      estimatedCost: costPreference === "minimize" ? "very-low" : "low",
+      estimatedTime: classification.complexity === "simple" ? "<1min" : "1-2min",
+    };
+  }
+
+  // Use LLM decomposition if engine is available
+  if (engine) {
+    try {
+      return await _llmDecompose(task, maxSubtasks, costPreference, engine);
+    } catch (err) {
+      if (process.env.WISPY_DEBUG) {
+        console.error(`[task-decomposer] LLM decompose failed: ${err.message}, falling back to heuristic`);
+      }
+    }
+  }
+
+  // Heuristic decomposition (no LLM)
+  return _heuristicDecompose(task, maxSubtasks, costPreference, classification);
+}
+
+/**
+ * Decompose using an LLM call (cheap model).
+ */
+async function _llmDecompose(task, maxSubtasks, costPreference, engine) {
+  const { model } = getCheapDecomposerModel();
+
+  const systemPrompt = `You are a task decomposition expert. Split complex tasks into independent subtasks that can be parallelized.
+Reply with ONLY valid JSON. No markdown, no explanation.`;
+
+  const userPrompt = `Decompose this task into at most ${maxSubtasks} subtasks. 
+Task: "${task}"
+
+Requirements:
+- Identify subtasks that can run in parallel (no dependencies)
+- Identify subtasks that need results from others (add dependency IDs)  
+- Classify each subtask type: coding, research, analysis, design, review, summarize, format, or general
+- Set priority: 1 = first group (parallel), 2 = waits for priority 1, etc.
+
+Respond with ONLY this JSON (no markdown):
+{
+  "subtasks": [
+    {"id": "st-01", "task": "...", "type": "coding", "dependencies": [], "priority": 1},
+    {"id": "st-02", "task": "...", "type": "research", "dependencies": [], "priority": 1},
+    {"id": "st-03", "task": "...", "type": "review", "dependencies": ["st-01","st-02"], "priority": 2}
+  ],
+  "estimatedTime": "2-5min",
+  "estimatedCost": "low"
+}`;
+
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt },
+  ];
+
+  const result = await engine.providers.chat(messages, [], { model });
+  const text = result.type === "text" ? result.text : JSON.stringify(result);
+
+  // Extract JSON from response
+  const jsonMatch = text.match(/\{[\s\S]*"subtasks"[\s\S]*\}/);
+  if (!jsonMatch) throw new Error("LLM did not return valid decomposition JSON");
+
+  const parsed = JSON.parse(jsonMatch[0]);
+  const subtasks = (parsed.subtasks ?? []).slice(0, maxSubtasks);
+
+  // Ensure IDs are consistent
+  const idMap = {};
+  subtasks.forEach((st, i) => {
+    const newId = makeSubtaskId();
+    idMap[st.id] = newId;
+    st.id = newId;
+  });
+
+  // Remap dependency IDs
+  for (const st of subtasks) {
+    st.dependencies = (st.dependencies ?? []).map(d => idMap[d] ?? d).filter(d => subtasks.some(s => s.id === d));
+  }
+
+  // Build parallel groups from priority
+  const groups = {};
+  for (const st of subtasks) {
+    const p = st.priority ?? 1;
+    if (!groups[p]) groups[p] = [];
+    groups[p].push(st.id);
+  }
+  const parallelGroups = Object.keys(groups).sort((a, b) => Number(a) - Number(b)).map(k => groups[k]);
+
+  return {
+    subtasks,
+    parallelGroups,
+    estimatedCost: parsed.estimatedCost ?? _estimateCost(costPreference, subtasks.length),
+    estimatedTime: parsed.estimatedTime ?? _estimateTime(subtasks.length),
+  };
+}
+
+/**
+ * Heuristic decomposition (no LLM required).
+ */
+function _heuristicDecompose(task, maxSubtasks, costPreference, classification) {
+  // Split by "and" / newlines / semicolons as a heuristic
+  const sentences = task
+    .split(/\n|;|\band\b(?=[^,]*,|\s+\w+\s+the\s)/)
+    .map(s => s.trim())
+    .filter(s => s.length > 10);
+
+  const subtasks = sentences.slice(0, maxSubtasks).map((s, i) => ({
+    id: makeSubtaskId(),
+    task: s,
+    type: classifyTask(s).type,
+    dependencies: [],
+    priority: 1,
+  }));
+
+  // If no useful split found, use the whole task as one subtask
+  if (subtasks.length === 0) {
+    const id = makeSubtaskId();
+    return {
+      subtasks: [{ id, task, type: classification.type, dependencies: [], priority: 1 }],
+      parallelGroups: [[id]],
+      estimatedCost: _estimateCost(costPreference, 1),
+      estimatedTime: "1-3min",
+    };
+  }
+
+  return {
+    subtasks,
+    parallelGroups: [subtasks.map(s => s.id)],
+    estimatedCost: _estimateCost(costPreference, subtasks.length),
+    estimatedTime: _estimateTime(subtasks.length),
+  };
+}
+
+function _estimateCost(costPreference, numSubtasks) {
+  if (costPreference === "minimize") return "very-low";
+  if (costPreference === "maximize-quality") return numSubtasks > 3 ? "high" : "medium";
+  return numSubtasks > 3 ? "medium" : "low";
+}
+
+function _estimateTime(numSubtasks) {
+  if (numSubtasks <= 1) return "<1min";
+  if (numSubtasks <= 3) return "1-3min";
+  return "2-5min";
+}
+
+// ── Execute decomposed plan ──────────────────────────────────────────────────
+
+/**
+ * Execute an execution plan, running parallel groups concurrently.
+ *
+ * @param {object} plan - Result from decomposeTask()
+ * @param {object} engine - WispyEngine instance
+ * @param {object} [opts]
+ * @param {string} [opts.costPreference="balanced"]
+ * @param {Function} [opts.onSubtaskStart] - (subtask) => void
+ * @param {Function} [opts.onSubtaskComplete] - (subtask, result) => void
+ * @param {Function} [opts.onSubtaskFail] - (subtask, error) => void
+ * @returns {Promise<{ results: object[], synthesized: string, errors: object[] }>}
+ */
+export async function executeDecomposedPlan(plan, engine, opts = {}) {
+  const costPreference = opts.costPreference ?? "balanced";
+  const completedResults = {}; // id → result
+  const errors = [];
+  const MAX_RETRIES = 1;
+
+  for (const group of plan.parallelGroups) {
+    // Filter to subtasks in this group (skip if all deps not satisfied)
+    const groupSubtasks = group
+      .map(id => plan.subtasks.find(s => s.id === id))
+      .filter(Boolean);
+
+    // Run group in parallel
+    const groupPromises = groupSubtasks.map(async (subtask) => {
+      // Route to best model
+      const routing = routeTask(
+        { type: subtask.type, complexity: "medium", estimatedTokens: Math.ceil(subtask.task.length / 4) + 800, parallelizable: false },
+        null,
+        { costPreference }
+      );
+
+      opts.onSubtaskStart?.(subtask);
+
+      let attempt = 0;
+      while (attempt <= MAX_RETRIES) {
+        try {
+          // Build context from dependencies
+          const depContext = subtask.dependencies
+            .map(depId => completedResults[depId])
+            .filter(Boolean)
+            .map((r, i) => `### Dependency ${i + 1} result:\n${r}`)
+            .join("\n\n");
+
+          const fullTask = depContext
+            ? `${subtask.task}\n\n---\nContext from previous steps:\n${depContext}`
+            : subtask.task;
+
+          // Use sub-agent manager if available, else direct provider call
+          let result;
+          if (engine.subagents) {
+            const agent = await engine.subagents.spawn({
+              task: fullTask,
+              label: `decomposed-${subtask.id}`,
+              model: routing.model,
+              timeout: 120, // seconds
+              workstream: engine._activeWorkstream,
+            });
+
+            // Wait for completion
+            result = await engine.subagents.waitFor(agent.id, 120_000);
+            result = result.result ?? result.error ?? "(no result)";
+          } else {
+            // Direct provider call
+            const messages = [
+              { role: "system", content: `You are a focused worker agent. Complete only this specific subtask. Be concise.` },
+              { role: "user", content: fullTask },
+            ];
+            const response = await engine.providers.chat(messages, [], { model: routing.model });
+            result = response.type === "text" ? response.text : JSON.stringify(response);
+          }
+
+          completedResults[subtask.id] = result;
+          opts.onSubtaskComplete?.(subtask, result);
+          return { id: subtask.id, result, routing, success: true };
+        } catch (err) {
+          attempt++;
+          if (attempt > MAX_RETRIES) {
+            const error = { id: subtask.id, error: err.message, subtask };
+            errors.push(error);
+            opts.onSubtaskFail?.(subtask, err);
+            // Non-critical: continue with empty result
+            completedResults[subtask.id] = `[subtask ${subtask.id} failed: ${err.message}]`;
+            return { id: subtask.id, result: null, error: err.message, success: false };
+          }
+          // Retry
+          await new Promise(r => setTimeout(r, 1000 * attempt));
+        }
+      }
+    });
+
+    // Wait for all in group before proceeding to next group
+    await Promise.all(groupPromises);
+  }
+
+  // Collect results in subtask order
+  const orderedResults = plan.subtasks.map(st => ({
+    id: st.id,
+    task: st.task,
+    type: st.type,
+    result: completedResults[st.id] ?? null,
+  }));
+
+  // Synthesize
+  let synthesized;
+  try {
+    synthesized = await synthesizeResults(orderedResults, engine);
+  } catch (err) {
+    // Fallback: concatenate results
+    synthesized = orderedResults
+      .filter(r => r.result)
+      .map(r => `**${r.type.toUpperCase()}**: ${r.result}`)
+      .join("\n\n---\n\n");
+  }
+
+  return {
+    results: orderedResults,
+    synthesized,
+    errors,
+  };
+}
+
+// ── Synthesize results ────────────────────────────────────────────────────────
+
+/**
+ * Synthesize multiple subtask results into a coherent response.
+ *
+ * @param {Array<{id, task, type, result}>} subtaskResults
+ * @param {object} [engine] - WispyEngine instance (for LLM synthesis)
+ * @returns {Promise<string>}
+ */
+export async function synthesizeResults(subtaskResults, engine) {
+  const validResults = subtaskResults.filter(r => r.result && !r.result.startsWith("[subtask"));
+
+  if (validResults.length === 0) {
+    return "All subtasks failed to produce results.";
+  }
+
+  if (validResults.length === 1) {
+    return validResults[0].result;
+  }
+
+  // Build synthesis prompt
+  const parts = validResults.map((r, i) =>
+    `### Subtask ${i + 1} (${r.type}): ${r.task.slice(0, 100)}\n${r.result.slice(0, 2000)}`
+  ).join("\n\n---\n\n");
+
+  // If no engine, concatenate
+  if (!engine) {
+    return `## Combined Results\n\n${parts}`;
+  }
+
+  const { model } = getCheapDecomposerModel();
+
+  const messages = [
+    {
+      role: "system",
+      content: `You are a synthesis agent. Merge multiple subtask outputs into a single, coherent, well-structured response.
+Remove redundancy. Resolve conflicts by noting them. Maintain all important information.`,
+    },
+    {
+      role: "user",
+      content: `Synthesize these ${validResults.length} subtask results into one coherent response:\n\n${parts}`,
+    },
+  ];
+
+  try {
+    const result = await engine.providers.chat(messages, [], { model });
+    return result.type === "text" ? result.text : JSON.stringify(result);
+  } catch (err) {
+    // Fallback
+    return `## Synthesized Results\n\n${parts}`;
+  }
+}

package/core/task-router.mjs

@@ -42,7 +42,7 @@ export const MODEL_CAPABILITIES = {
 
   // Claude family
   "claude-opus-4-20250514": {
-    strengths: ["architecture", "reasoning", "writing", "analysis"],
+    strengths: ["architecture", "reasoning", "writing", "analysis", "design"],
     speed: "slow",
     cost: "very-high",
     contextWindow: 200000,
@@ -327,7 +327,7 @@ export function routeTask(task, availableModels, opts = {}) {
       score -= costScore(model) * 2;
       score -= speedScore(model);
     } else if (costPreference === "maximize-quality") {
-      score += (5 - costScore(model));  // prefer expensive (high quality)
+      score += costScore(model) * 2;    // prefer expensive (high quality)
       score -= speedScore(model) * 0.5;
     } else {
       // balanced: for complex tasks lean toward quality, simple tasks lean toward speed+cost

package/core/tools.mjs

@@ -275,6 +275,57 @@ export class ToolRegistry {
           required: ["id", "message"],
         },
       },
+      // ── Browser tools ────────────────────────────────────────────────────────
+      {
+        name: "browser_status",
+        description: "Check browser bridge health and current session status",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_tabs",
+        description: "List all open browser tabs",
+        parameters: {
+          type: "object",
+          properties: {
+            browser: { type: "string", enum: ["safari", "chrome"] },
+          },
+        },
+      },
+      {
+        name: "browser_navigate",
+        description: "Navigate the active browser tab to a URL",
+        parameters: {
+          type: "object",
+          properties: { url: { type: "string" } },
+          required: ["url"],
+        },
+      },
+      {
+        name: "browser_screenshot",
+        description: "Take a screenshot of the active browser tab",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_front_tab",
+        description: "Get info about the currently active browser tab (URL, title)",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_activate",
+        description: "Bring the browser tab to front / focus it",
+        parameters: { type: "object", properties: {} },
+      },
+      {
+        name: "browser_attach",
+        description: "Attach to a browser for control. Auto-selects the best available browser if no args given.",
+        parameters: {
+          type: "object",
+          properties: {
+            browser: { type: "string" },
+            mode: { type: "string" },
+          },
+        },
+      },
     ];
 
     for (const def of builtins) {
@@ -594,6 +645,14 @@ export class ToolRegistry {
         case "get_subagent_result":
         case "kill_subagent":
         case "steer_subagent":
+        // Browser tools — handled at engine level
+        case "browser_status":
+        case "browser_tabs":
+        case "browser_navigate":
+        case "browser_screenshot":
+        case "browser_front_tab":
+        case "browser_activate":
+        case "browser_attach":
           return { success: false, error: `Tool "${name}" requires engine context. Call via WispyEngine.processMessage().` };
 
         default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispy-cli",
-  "version": "2.7.8",
+  "version": "2.7.9",
   "description": "🌿 Wispy — AI workspace assistant with trustworthy execution (harness, receipts, approvals, diffs)",
   "license": "MIT",
   "author": "Minseo & Poropo",