speexor 0.2.0 → 0.2.1

package/dist/cli/index.js

@@ -1,20 +1,29 @@
 #!/usr/bin/env node
-import { createDashboardServer } from '../chunk-AOFWQZWY.js';
-import { generateDefaultConfig, loadConfig, SpeexorLifecycle } from '../chunk-2DX54KIM.js';
-import { loadAllPlugins } from '../chunk-7VZHDGRQ.js';
+import { createDashboardServer } from '../chunk-GOGI3JQD.js';
+import { generateDefaultConfig, loadConfig, SpeexorLifecycle, validateConfig } from '../chunk-VEZQT5SX.js';
+import { loadAllPlugins } from '../chunk-5OD5UWB5.js';
 import { Command } from 'commander';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname, join } from 'path';
-import { stringify } from 'yaml';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, rmSync, appendFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { execSync } from 'child_process';
+import { stringify, parse } from 'yaml';
 import Debug from 'debug';
 import ora from 'ora';
 import chalk4 from 'chalk';
+import { execa } from 'execa';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
 import { fileURLToPath } from 'url';
 
 var debug = Debug("speexor:start");
 async function startCommand(repo, options = {}) {
   const cwd = process.cwd();
-  const port = parseInt(options.port ?? "3000", 10);
+  const port = parseInt(options.port ?? "7777", 10);
+  const ensureDir = (dir) => {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  };
   if (repo) {
     const spinner = ora("Initializing Speexor project...").start();
     const config = generateDefaultConfig(repo, options.name);
@@ -26,15 +35,27 @@ async function startCommand(repo, options = {}) {
       writeFileSync(configPath, yaml, "utf-8");
       spinner.succeed(`Created speexor.config.yaml at ${configPath}`);
     }
-    const worktreesDir = join(cwd, ".speexor", "worktrees");
-    if (!existsSync(worktreesDir)) {
-      mkdirSync(worktreesDir, { recursive: true });
+    ensureDir(join(cwd, ".speexor", "worktrees"));
+    ensureDir(join(cwd, ".speexor", "logs"));
+    spinner.succeed("Project initialized");
+  } else {
+    let repoUrl;
+    try {
+      repoUrl = execSync("git remote get-url origin", { encoding: "utf-8", cwd }).trim();
+    } catch {
     }
-    const logsDir = join(cwd, ".speexor", "logs");
-    if (!existsSync(logsDir)) {
-      mkdirSync(logsDir, { recursive: true });
+    if (repoUrl) {
+      const configPath = join(cwd, "speexor.config.yaml");
+      if (!existsSync(configPath)) {
+        const spinner = ora("Detected git repo \u2014 auto-generating config...").start();
+        const config = generateDefaultConfig(repoUrl, options.name);
+        const yaml = stringify(config, { indent: 2 });
+        writeFileSync(configPath, yaml, "utf-8");
+        ensureDir(join(cwd, ".speexor", "worktrees"));
+        ensureDir(join(cwd, ".speexor", "logs"));
+        spinner.succeed(`Created speexor.config.yaml at ${configPath}`);
+      }
     }
-    spinner.succeed("Project initialized");
   }
   try {
     const config = loadConfig(cwd);
@@ -70,7 +91,7 @@ async function startCommand(repo, options = {}) {
   \u2716 Error: ${error.message}
 `);
       if (!repo) {
-        console.log("  Tip: Run `speexor start <repo-url>` first to initialize a project.\n");
+        console.log("  Tip: Run `speexor start <repo-url>` to initialize a project, or run from a git repository.\n");
       }
     }
     process.exit(1);
@@ -239,7 +260,7 @@ projects:
         auto: false
         action: notify
         retries: 0
-        escalateAfter: 0
+        escalateAfter: 1
 `)}
 
 ${chalk4.bold("Commands:")}
@@ -257,6 +278,2009 @@ ${chalk4.bold("Commands:")}
 function configHelpCommand() {
   console.log(CONFIG_HELP);
 }
+var debug2 = Debug("speexor:task-graph:store");
+var TaskGraphStore = class _TaskGraphStore {
+  db;
+  dbPath;
+  constructor(db, dbPath) {
+    this.db = db;
+    this.dbPath = dbPath;
+  }
+  static async create(dbPath) {
+    const { default: initSqlJs } = await import('sql.js');
+    const SQL = await initSqlJs();
+    const dir = dbPath ?? join(process.cwd(), ".speexor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const fullPath = join(dir, "task-graph.sqlite");
+    let db;
+    if (existsSync(fullPath)) {
+      const buffer = readFileSync(fullPath);
+      db = new SQL.Database(buffer);
+    } else {
+      db = new SQL.Database();
+    }
+    const store = new _TaskGraphStore(db, fullPath);
+    store.initialize();
+    return store;
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS task_graphs (
+        id TEXT PRIMARY KEY,
+        root_task_id TEXT NOT NULL,
+        project_name TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'decomposing',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS task_nodes (
+        id TEXT PRIMARY KEY,
+        graph_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        parent_id TEXT,
+        depth INTEGER NOT NULL DEFAULT 0,
+        depends_on TEXT DEFAULT '[]',
+        created_by TEXT NOT NULL DEFAULT 'user',
+        created_by_agent_id TEXT,
+        assigned_agent_id TEXT,
+        worktree_path TEXT,
+        skills_used TEXT DEFAULT '[]',
+        commands_executed TEXT DEFAULT '[]',
+        result_json TEXT,
+        proposed_by TEXT,
+        proposed_reason TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY (graph_id) REFERENCES task_graphs(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_nodes_graph ON task_nodes(graph_id);
+      CREATE INDEX IF NOT EXISTS idx_nodes_status ON task_nodes(status);
+      CREATE INDEX IF NOT EXISTS idx_nodes_parent ON task_nodes(parent_id);
+    `);
+    debug2("Task Graph SQLite store initialized");
+  }
+  save() {
+    const data = this.db.export();
+    writeFileSync(this.dbPath, Buffer.from(data));
+  }
+  queryOne(sql, params) {
+    const stmt = this.db.prepare(sql);
+    if (params) stmt.bind(params);
+    try {
+      if (stmt.step()) {
+        return stmt.getAsObject();
+      }
+      return void 0;
+    } finally {
+      stmt.free();
+    }
+  }
+  queryAll(sql, params) {
+    const stmt = this.db.prepare(sql);
+    if (params) stmt.bind(params);
+    const rows = [];
+    try {
+      while (stmt.step()) {
+        rows.push(stmt.getAsObject());
+      }
+      return rows;
+    } finally {
+      stmt.free();
+    }
+  }
+  createGraph(projectName, rootTask) {
+    const graph = {
+      id: `tg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      rootTaskId: rootTask.id,
+      projectName,
+      nodes: /* @__PURE__ */ new Map([[rootTask.id, rootTask]]),
+      status: "decomposing",
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.db.run("BEGIN");
+    try {
+      this.db.run(`INSERT INTO task_graphs (id, root_task_id, project_name, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`, [
+        graph.id,
+        graph.rootTaskId,
+        graph.projectName,
+        graph.status,
+        graph.createdAt.toISOString(),
+        graph.updatedAt.toISOString()
+      ]);
+      this.insertNode(graph.id, rootTask);
+      this.db.run("COMMIT");
+      this.save();
+    } catch (e) {
+      this.db.run("ROLLBACK");
+      throw e;
+    }
+    return graph;
+  }
+  insertNode(graphId, node) {
+    this.db.run(
+      `INSERT OR REPLACE INTO task_nodes (id, graph_id, title, description, status, parent_id, depth, depends_on, created_by, created_by_agent_id, assigned_agent_id, worktree_path, skills_used, commands_executed, result_json, proposed_by, proposed_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        node.id,
+        graphId,
+        node.title,
+        node.description,
+        node.status,
+        node.parentId,
+        node.depth,
+        JSON.stringify(node.dependsOn),
+        node.createdBy,
+        node.createdByAgentId ?? null,
+        node.assignedAgentId ?? null,
+        node.worktreePath ?? null,
+        JSON.stringify(node.skillsUsed),
+        JSON.stringify(node.commandsExecuted),
+        node.result ? JSON.stringify(node.result) : null,
+        node.proposedBy ?? null,
+        node.proposedReason ?? null,
+        node.createdAt.toISOString(),
+        node.updatedAt.toISOString()
+      ]
+    );
+  }
+  getGraph(graphId) {
+    const graphRow = this.queryOne("SELECT * FROM task_graphs WHERE id = ?", [graphId]);
+    if (!graphRow) return null;
+    const nodeRows = this.queryAll("SELECT * FROM task_nodes WHERE graph_id = ?", [graphId]);
+    const nodes = /* @__PURE__ */ new Map();
+    for (const row of nodeRows) {
+      nodes.set(row.id, this.rowToNode(row));
+    }
+    return {
+      id: graphRow.id,
+      rootTaskId: graphRow.root_task_id,
+      projectName: graphRow.project_name,
+      nodes,
+      status: graphRow.status,
+      createdAt: new Date(graphRow.created_at),
+      updatedAt: new Date(graphRow.updated_at)
+    };
+  }
+  rowToNode(row) {
+    return {
+      id: row.id,
+      title: row.title,
+      description: row.description ?? "",
+      status: row.status,
+      parentId: row.parent_id ?? null,
+      depth: Number.parseInt(row.depth),
+      dependsOn: JSON.parse(row.depends_on ?? "[]"),
+      createdBy: row.created_by,
+      createdByAgentId: row.created_by_agent_id ?? void 0,
+      assignedAgentId: row.assigned_agent_id ?? null,
+      worktreePath: row.worktree_path ?? null,
+      skillsUsed: JSON.parse(row.skills_used ?? "[]"),
+      commandsExecuted: JSON.parse(row.commands_executed ?? "[]"),
+      result: row.result_json ? JSON.parse(row.result_json) : void 0,
+      proposedBy: row.proposed_by ?? void 0,
+      proposedReason: row.proposed_reason ?? void 0,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+  updateNodeStatus(nodeId, status) {
+    this.db.run("UPDATE task_nodes SET status = ?, updated_at = ? WHERE id = ?", [status, (/* @__PURE__ */ new Date()).toISOString(), nodeId]);
+    this.save();
+  }
+  updateNodeResult(nodeId, result) {
+    this.db.run("UPDATE task_nodes SET result_json = ?, updated_at = ? WHERE id = ?", [
+      JSON.stringify(result),
+      (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId
+    ]);
+    this.save();
+  }
+  addNode(graphId, node) {
+    this.insertNode(graphId, node);
+    this.save();
+  }
+  getReadyNodes(graphId) {
+    const rows = this.queryAll("SELECT * FROM task_nodes WHERE graph_id = ? AND status = ?", [graphId, "ready"]);
+    return rows.map((r) => this.rowToNode(r));
+  }
+  getNodesByStatus(graphId, status) {
+    const rows = this.queryAll("SELECT * FROM task_nodes WHERE graph_id = ? AND status = ?", [graphId, status]);
+    return rows.map((r) => this.rowToNode(r));
+  }
+  updateGraphStatus(graphId, status) {
+    this.db.run("UPDATE task_graphs SET status = ?, updated_at = ? WHERE id = ?", [status, (/* @__PURE__ */ new Date()).toISOString(), graphId]);
+    this.save();
+  }
+  assignAgent(nodeId, agentId) {
+    this.db.run("UPDATE task_nodes SET assigned_agent_id = ?, updated_at = ? WHERE id = ?", [agentId, (/* @__PURE__ */ new Date()).toISOString(), nodeId]);
+    this.save();
+  }
+  close() {
+    this.save();
+    this.db.close();
+  }
+};
+
+// src/task-graph/graph.ts
+var TaskGraphManager = class {
+  graph;
+  constructor(graph) {
+    this.graph = graph;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  getNode(nodeId) {
+    return this.graph.nodes.get(nodeId);
+  }
+  addNode(node) {
+    this.graph.nodes.set(node.id, node);
+    this.graph.updatedAt = /* @__PURE__ */ new Date();
+  }
+  updateNodeStatus(nodeId, status) {
+    const node = this.graph.nodes.get(nodeId);
+    if (node) {
+      node.status = status;
+      node.updatedAt = /* @__PURE__ */ new Date();
+      this.graph.updatedAt = /* @__PURE__ */ new Date();
+      if (status === "failed") {
+        this.blockDependents(nodeId);
+      }
+    }
+  }
+  blockDependents(nodeId) {
+    for (const [, node] of this.graph.nodes) {
+      if (node.dependsOn.includes(nodeId) && node.status === "pending") {
+        node.status = "blocked";
+        node.updatedAt = /* @__PURE__ */ new Date();
+      }
+    }
+  }
+  /** Get topologically sorted list of nodes */
+  topologicalSort() {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visit = (nodeId) => {
+      if (visited.has(nodeId)) return;
+      visited.add(nodeId);
+      const node = this.graph.nodes.get(nodeId);
+      if (!node) return;
+      for (const depId of node.dependsOn) {
+        visit(depId);
+      }
+      result.push(node);
+    };
+    visit(this.graph.rootTaskId);
+    for (const [id] of this.graph.nodes) {
+      if (!visited.has(id)) visit(id);
+    }
+    return result;
+  }
+  /** Get nodes that are ready to execute (all dependencies done) */
+  getReadyNodes() {
+    const ready = [];
+    for (const [, node] of this.graph.nodes) {
+      if (node.status !== "pending") continue;
+      const allDepsDone = node.dependsOn.every((depId) => {
+        const dep = this.graph.nodes.get(depId);
+        return dep?.status === "done";
+      });
+      if (allDepsDone) {
+        ready.push(node);
+      }
+    }
+    return ready;
+  }
+  /** Validate the DAG has no cycles */
+  validateDag() {
+    const visited = /* @__PURE__ */ new Set();
+    const recStack = /* @__PURE__ */ new Set();
+    const dfs = (nodeId, path) => {
+      visited.add(nodeId);
+      recStack.add(nodeId);
+      path.push(nodeId);
+      const node = this.graph.nodes.get(nodeId);
+      if (node) {
+        for (const depId of node.dependsOn) {
+          if (!visited.has(depId)) {
+            const result = dfs(depId, [...path]);
+            if (result) return result;
+          } else if (recStack.has(depId)) {
+            const cycleStart = path.indexOf(depId);
+            return path.slice(cycleStart);
+          }
+        }
+      }
+      recStack.delete(nodeId);
+      return null;
+    };
+    for (const [id] of this.graph.nodes) {
+      if (!visited.has(id)) {
+        const cycle = dfs(id, []);
+        if (cycle) return { valid: false, cycle };
+      }
+    }
+    return { valid: true };
+  }
+  /** Get all leaf nodes (no dependents) */
+  getLeafNodes() {
+    const hasDependents = /* @__PURE__ */ new Set();
+    for (const [, node] of this.graph.nodes) {
+      for (const depId of node.dependsOn) {
+        hasDependents.add(depId);
+      }
+    }
+    return Array.from(this.graph.nodes.values()).filter((n) => !hasDependents.has(n.id));
+  }
+  /** Get depth of a node from root */
+  getNodeDepth(nodeId) {
+    let depth = 0;
+    let current = this.graph.nodes.get(nodeId);
+    while (current?.parentId) {
+      depth++;
+      current = this.graph.nodes.get(current.parentId);
+    }
+    return depth;
+  }
+  /** Check if the graph is complete */
+  isComplete() {
+    for (const [, node] of this.graph.nodes) {
+      if (node.status !== "done" && node.status !== "failed") return false;
+    }
+    return true;
+  }
+  /** Check if all nodes are terminal (done or failed) */
+  allTerminal() {
+    for (const [, node] of this.graph.nodes) {
+      if (node.status !== "done" && node.status !== "failed") return false;
+    }
+    return true;
+  }
+};
+
+// src/planner/decomposer.ts
+var TaskDecomposer = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  createDecompositionPrompt(task) {
+    return `You are a task decomposition engine. Break down the following software engineering task into smaller, executable subtasks.
+
+ROOT TASK: ${task.title}
+DESCRIPTION: ${task.description}
+
+RULES:
+- Each subtask must be scoped to a single concern (e.g., "Create database schema", not "Build the feature")
+- Maximum depth: ${this.config.maxTaskGraphDepth}
+- Maximum nodes per graph: ${this.config.maxNodesPerGraph}
+- Identify dependencies between subtasks (e.g., "schema" must be done before "API endpoints")
+- Each subtask should be completable independently
+
+OUTPUT FORMAT (JSON only):
+{
+  "subtasks": [
+    {
+      "title": "Short task title",
+      "description": "What to do, acceptance criteria, files likely involved",
+      "dependsOn": ["title of task this depends on"]
+    }
+  ]
+}
+
+Output ONLY valid JSON, no explanation.`;
+  }
+  parseDecompositionResponse(llmResponse) {
+    try {
+      let jsonStr = llmResponse.trim();
+      if (jsonStr.startsWith("```")) {
+        jsonStr = jsonStr.replace(/```(?:json)?\n?/g, "").trim();
+      }
+      const parsed = JSON.parse(jsonStr);
+      const subtasks = parsed.subtasks;
+      if (!Array.isArray(subtasks) || subtasks.length === 0) {
+        return {
+          subtasks: [],
+          isValid: false,
+          warnings: ["No subtasks found in response"]
+        };
+      }
+      if (subtasks.length > this.config.maxNodesPerGraph) {
+        return {
+          subtasks: subtasks.slice(0, this.config.maxNodesPerGraph),
+          isValid: false,
+          warnings: [
+            `Truncated to ${this.config.maxNodesPerGraph} subtasks (max)`
+          ]
+        };
+      }
+      const warnings = [];
+      const titles = new Set(subtasks.map((s) => s.title));
+      for (const sub of subtasks) {
+        for (const dep of sub.dependsOn) {
+          if (!titles.has(dep)) {
+            warnings.push(
+              `Subtask "${sub.title}" depends on "${dep}" which doesn't exist`
+            );
+          }
+        }
+      }
+      const graph = /* @__PURE__ */ new Map();
+      for (const sub of subtasks) {
+        graph.set(sub.title, sub.dependsOn);
+      }
+      const visited = /* @__PURE__ */ new Set();
+      const recStack = /* @__PURE__ */ new Set();
+      const hasCycle = (title) => {
+        if (recStack.has(title)) return true;
+        if (visited.has(title)) return false;
+        visited.add(title);
+        recStack.add(title);
+        const deps = graph.get(title) ?? [];
+        for (const dep of deps) {
+          if (hasCycle(dep)) return true;
+        }
+        recStack.delete(title);
+        return false;
+      };
+      for (const title of titles) {
+        if (hasCycle(title)) {
+          warnings.push("Circular dependency detected in decomposition");
+          break;
+        }
+      }
+      return { subtasks, isValid: warnings.length === 0, warnings };
+    } catch (error) {
+      return {
+        subtasks: [],
+        isValid: false,
+        warnings: [
+          `Failed to parse LLM response: ${error instanceof Error ? error.message : String(error)}`
+        ]
+      };
+    }
+  }
+  needsFurtherDecomposition(subtask, currentDepth) {
+    if (currentDepth >= this.config.maxTaskGraphDepth) return false;
+    const scopeIndicators = [
+      "implement",
+      "build",
+      "create",
+      "develop",
+      "setup"
+    ];
+    const hasMultipleConcepts = subtask.description.includes(" and ") || subtask.description.includes(",");
+    const hasBroadVerbs = scopeIndicators.some(
+      (v) => subtask.description.toLowerCase().startsWith(v)
+    );
+    const isLong = subtask.description.length > 500;
+    return hasMultipleConcepts || hasBroadVerbs && isLong;
+  }
+  heuristicDecomposition(task) {
+    const text = `${task.title} ${task.description}`.toLowerCase();
+    const subtasks = [];
+    const warnings = [];
+    const patterns = [
+      {
+        keyword: "research|analyze|investigate|understand",
+        label: "Research & Analysis",
+        phase: 0
+      },
+      {
+        keyword: "design|architect|plan|outline|schema",
+        label: "Design & Architecture",
+        phase: 1
+      },
+      {
+        keyword: "implement|build|create|develop|write|code|add",
+        label: "Implementation",
+        phase: 2
+      },
+      {
+        keyword: "test|verify|validate|check|qa",
+        label: "Testing & Verification",
+        phase: 3
+      },
+      {
+        keyword: "document|documentation|readme|comment",
+        label: "Documentation",
+        phase: 4
+      },
+      {
+        keyword: "deploy|release|ship|publish|ci|cd",
+        label: "Deployment & Release",
+        phase: 5
+      },
+      {
+        keyword: "refactor|clean|optimize|improve|migrate",
+        label: "Refactoring & Optimization",
+        phase: 2
+      }
+    ];
+    const mentionedPhases = patterns.filter(
+      (p) => new RegExp(p.keyword, "i").test(text)
+    );
+    if (mentionedPhases.length > 0) {
+      const unique = /* @__PURE__ */ new Map();
+      for (const p of mentionedPhases) unique.set(p.phase, p);
+      const sorted = [...unique.values()].sort((a, b) => a.phase - b.phase);
+      for (let i = 0; i < sorted.length; i++) {
+        const current = sorted[i];
+        const prev = i > 0 ? sorted[i - 1] : void 0;
+        const deps = prev ? [prev.label] : [];
+        subtasks.push({
+          title: current.label,
+          description: `Perform ${current.label.toLowerCase()} for: ${task.description}`,
+          dependsOn: deps
+        });
+      }
+    } else {
+      const parts = task.description.split(/\band\b|[,;]\s+/).map((s) => s.trim()).filter((s) => s.length > 10);
+      if (parts.length >= 2) {
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          const title = part.length > 60 ? `${part.slice(0, 57)}...` : part;
+          const prev = i > 0 ? subtasks[i - 1] : void 0;
+          subtasks.push({
+            title,
+            description: part,
+            dependsOn: prev ? [prev.title] : []
+          });
+        }
+      } else {
+        subtasks.push(
+          {
+            title: "Research & Approach",
+            description: `Research and determine approach for: ${task.description}`,
+            dependsOn: []
+          },
+          {
+            title: "Implementation",
+            description: `Implement the solution for: ${task.description}`,
+            dependsOn: ["Research & Approach"]
+          },
+          {
+            title: "Testing",
+            description: `Write and run tests for: ${task.description}`,
+            dependsOn: ["Implementation"]
+          }
+        );
+      }
+    }
+    if (subtasks.length > this.config.maxNodesPerGraph) {
+      warnings.push(
+        `Truncated to ${this.config.maxNodesPerGraph} subtasks (max)`
+      );
+    }
+    return {
+      subtasks: subtasks.slice(0, this.config.maxNodesPerGraph),
+      isValid: warnings.length === 0,
+      warnings
+    };
+  }
+  subtasksToNodes(subtasks, parentId, parentTask, depth) {
+    const titleToId = /* @__PURE__ */ new Map();
+    const nodes = [];
+    for (const sub of subtasks) {
+      const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      titleToId.set(sub.title, id);
+    }
+    for (const sub of subtasks) {
+      const nodeId = titleToId.get(sub.title);
+      nodes.push({
+        id: nodeId,
+        title: sub.title,
+        description: sub.description,
+        status: "pending",
+        parentId,
+        depth,
+        dependsOn: sub.dependsOn.map((d) => titleToId.get(d) ?? d).filter(Boolean),
+        createdBy: parentTask.createdBy === "user" ? "agent" : "subagent",
+        createdByAgentId: parentTask.createdByAgentId,
+        assignedAgentId: null,
+        worktreePath: null,
+        skillsUsed: [],
+        commandsExecuted: [],
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    return nodes;
+  }
+};
+var debug3 = Debug("speexor:planner:engine");
+var PlannerEngine = class {
+  decomposer;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.decomposer = new TaskDecomposer(config);
+  }
+  async planTask(task, graph, store) {
+    const manager = new TaskGraphManager(graph);
+    const newNodes = [];
+    if (task.depth >= this.config.maxTaskGraphDepth) {
+      debug3(`Max depth reached for ${task.id}, marking as ready`);
+      manager.updateNodeStatus(task.id, "ready");
+      store.updateNodeStatus(task.id, "ready");
+      return { graph, newNodes: [] };
+    }
+    const prompt = this.decomposer.createDecompositionPrompt(task);
+    let result = null;
+    const provider = this.config.plannerProvider || "opencode";
+    result = await this.callLLM(prompt, provider);
+    if (!result || !result.isValid) {
+      debug3(`LLM decomposition failed, falling back to heuristic`);
+      result = this.heuristicDecomposition(task);
+    }
+    if (!result || !result.subtasks.length) {
+      debug3(`Heuristic returned no subtasks, marking as atomic task`);
+      manager.updateNodeStatus(task.id, "ready");
+      store.updateNodeStatus(task.id, "ready");
+      return { graph, newNodes: [] };
+    }
+    const childNodes = this.decomposer.subtasksToNodes(
+      result.subtasks,
+      task.id,
+      task,
+      task.depth + 1
+    );
+    for (const node of childNodes) {
+      manager.addNode(node);
+      store.addNode(graph.id, node);
+      newNodes.push(node);
+    }
+    if (newNodes.length === 0) {
+      manager.updateNodeStatus(task.id, "ready");
+      store.updateNodeStatus(task.id, "ready");
+    }
+    return { graph, newNodes };
+  }
+  async callLLM(prompt, provider) {
+    const fallbackChain = [provider, "opencode", "claude-code"];
+    for (const p of fallbackChain) {
+      try {
+        const response = await this.callProvider(prompt, p);
+        if (!response) continue;
+        const result = this.decomposer.parseDecompositionResponse(response);
+        if (result.isValid && result.subtasks.length > 0) {
+          return result;
+        }
+        debug3(
+          `Provider "${p}" returned invalid result: ${result.warnings.join(", ")}`
+        );
+      } catch (error) {
+        debug3(
+          `Provider "${p}" threw: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return null;
+  }
+  async callProvider(prompt, provider) {
+    switch (provider) {
+      case "opencode":
+        return this.callOpenCode(prompt);
+      case "claude-code":
+        return this.callClaudeCode(prompt);
+      default:
+        debug3(`Unknown provider "${provider}", trying opencode CLI`);
+        return this.callOpenCode(prompt);
+    }
+  }
+  async callOpenCode(prompt) {
+    try {
+      const { stdout } = await execa(
+        "opencode",
+        ["prompt", prompt, "--quiet"],
+        {
+          timeout: 3e4,
+          reject: false
+        }
+      );
+      return stdout || null;
+    } catch (error) {
+      debug3(
+        `opencode CLI failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+  async callClaudeCode(prompt) {
+    try {
+      const { stdout } = await execa("claude", ["-p", prompt, "--print"], {
+        timeout: 3e4,
+        reject: false
+      });
+      return stdout || null;
+    } catch (error) {
+      debug3(
+        `claude CLI failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+  heuristicDecomposition(task) {
+    return this.decomposer.heuristicDecomposition(task);
+  }
+  generateDefaultPlan(task) {
+    return [
+      {
+        title: `Analyze: ${task.title}`,
+        description: `Research and analyze requirements for: ${task.description}`,
+        dependsOn: []
+      },
+      {
+        title: `Implement: ${task.title}`,
+        description: `Implement the changes needed for: ${task.description}`,
+        dependsOn: [`Analyze: ${task.title}`]
+      },
+      {
+        title: `Test: ${task.title}`,
+        description: `Write and run tests for: ${task.description}`,
+        dependsOn: [`Implement: ${task.title}`]
+      }
+    ];
+  }
+  async decomposeGraph(graph, store) {
+    const manager = new TaskGraphManager(graph);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      const pendingNodes = Array.from(graph.nodes.values()).filter(
+        (n) => n.status === "pending"
+      );
+      for (const node of pendingNodes) {
+        if (node.depth >= this.config.maxTaskGraphDepth) {
+          manager.updateNodeStatus(node.id, "ready");
+          store.updateNodeStatus(node.id, "ready");
+          continue;
+        }
+        const { graph: updatedGraph } = await this.planTask(node, graph, store);
+        graph = updatedGraph;
+        changed = true;
+      }
+    }
+    store.updateGraphStatus(graph.id, "executing");
+    return graph;
+  }
+};
+async function taskSubmitCommand(description) {
+  try {
+    const config = loadConfig();
+    const depConfig = config.decomposition ?? {
+      maxTaskGraphDepth: 5,
+      maxAgentSpawnDepth: 3,
+      maxNodesPerGraph: 50,
+      plannerProvider: "opencode"
+    };
+    const projectName = config.projects[0]?.name ?? "default";
+    const store = await TaskGraphStore.create();
+    const rootNode = {
+      id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      title: description.length > 80 ? `${description.slice(0, 77)}...` : description,
+      description,
+      status: "pending",
+      parentId: null,
+      depth: 0,
+      dependsOn: [],
+      createdBy: "user",
+      assignedAgentId: null,
+      worktreePath: null,
+      skillsUsed: [],
+      commandsExecuted: [],
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const graph = store.createGraph(projectName, rootNode);
+    const planner = new PlannerEngine(depConfig);
+    const finalGraph = await planner.decomposeGraph(graph, store);
+    const manager = new TaskGraphManager(finalGraph);
+    const sorted = manager.topologicalSort();
+    console.log(`
+  ${chalk4.bold("\u{1F4CB} Task Graph Generated")}`);
+    console.log(`  ${chalk4.dim(`Graph ID: ${graph.id}`)}`);
+    console.log(`  ${chalk4.dim(`Project: ${projectName}`)}`);
+    console.log(`  ${chalk4.dim(`Nodes: ${sorted.length}`)}
+`);
+    const depthColors = [chalk4.cyan, chalk4.green, chalk4.yellow, chalk4.magenta, chalk4.blue];
+    for (const node of sorted) {
+      const color = depthColors[node.depth] ?? chalk4.white;
+      const indent = "  ".repeat(node.depth);
+      const statusIcon = node.status === "done" ? "\u2713" : node.status === "failed" ? "\u2716" : node.status === "blocked" ? "\u2298" : node.status === "ready" ? "\u2192" : node.status === "in_progress" ? "\u25CC" : "\u25CB";
+      const statusColor = node.status === "done" ? chalk4.green : node.status === "failed" ? chalk4.red : node.status === "blocked" ? chalk4.red : node.status === "ready" ? chalk4.cyan : chalk4.dim;
+      const deps = node.dependsOn.length > 0 ? chalk4.dim(
+        ` (after: ${sorted.filter((n) => node.dependsOn.includes(n.id)).map((n) => n.title.substring(0, 30)).join(", ")})`
+      ) : "";
+      console.log(`  ${indent}${statusColor(statusIcon)} ${color(node.title)}${deps}`);
+    }
+    console.log(`
+  ${chalk4.green("\u2713")} Task graph persisted to ${chalk4.bold(".speexor/task-graph.sqlite")}
+`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+    process.exit(1);
+  }
+}
+var debug4 = Debug("speexor:marketplace");
+var MarketplaceClient = class {
+  sources;
+  constructor(sources) {
+    this.sources = sources;
+  }
+  async search(query) {
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    for (const source of this.sources) {
+      try {
+        const packages = await this.fetchSourceIndex(source);
+        const filtered = packages.filter(
+          (pkg) => pkg.name.toLowerCase().includes(lowerQuery) || pkg.description.toLowerCase().includes(lowerQuery) || pkg.author.toLowerCase().includes(lowerQuery)
+        );
+        results.push(...filtered);
+      } catch (err) {
+        debug4(
+          `Failed to search source ${source.url}: ${err.message}`
+        );
+      }
+    }
+    return results;
+  }
+  async getDetails(packageName) {
+    for (const source of this.sources) {
+      try {
+        const packages = await this.fetchSourceIndex(source);
+        const found = packages.find((p) => p.name === packageName);
+        if (found) return found;
+      } catch (err) {
+        debug4(
+          `Failed to fetch details from ${source.url}: ${err.message}`
+        );
+      }
+    }
+    throw new Error(
+      `Package "${packageName}" not found in any marketplace source`
+    );
+  }
+  resolveDownloadUrl(packageName) {
+    for (const source of this.sources) {
+      if (source.type === "github-index") {
+        const base = source.url.replace(/\/index\.json$/, "").replace(/\/$/, "");
+        return `${base}/${packageName}/speexor.extension.json`;
+      }
+      if (source.type === "npm") {
+        return `npm:${packageName}`;
+      }
+    }
+    throw new Error(`No download URL could be resolved for "${packageName}"`);
+  }
+  async fetchSourceIndex(source) {
+    if (source.type === "github-index") {
+      const response = await fetch(source.url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.packages ?? [];
+    }
+    if (source.type === "npm") {
+      const encodedName = source.url.startsWith("@") ? `@${encodeURIComponent(source.url.slice(1).split("/")[0])}/${encodeURIComponent(source.url.split("/")[1])}` : encodeURIComponent(source.url);
+      const response = await fetch(`https://registry.npmjs.org/${encodedName}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return [
+        {
+          name: data.name,
+          manifestUrl: `https://www.npmjs.com/package/${source.url}`,
+          checksum: "",
+          author: data.author?.name ?? data._npmUser?.name ?? "unknown",
+          description: data.description ?? "",
+          version: data["dist-tags"]?.latest ?? "0.0.0"
+        }
+      ];
+    }
+    return [];
+  }
+};
+var ExtensionManifestLoader = class {
+  loadFromFile(path) {
+    if (!existsSync(path)) {
+      throw new Error(`Manifest file not found: ${path}`);
+    }
+    let raw;
+    try {
+      raw = readFileSync(path, "utf-8");
+    } catch (err) {
+      throw new Error(
+        `Failed to read manifest file: ${err.message}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON in manifest file: ${err.message}`
+      );
+    }
+    const manifest = parsed;
+    const validation = this.validate(manifest);
+    if (!validation.valid) {
+      throw new Error(
+        `Manifest validation failed:
+  ${validation.errors.join("\n  ")}`
+      );
+    }
+    return manifest;
+  }
+  validate(manifest) {
+    const errors = [];
+    if (!manifest.name || typeof manifest.name !== "string") {
+      errors.push('Missing or invalid "name" (must be a non-empty string)');
+    }
+    if (!manifest.version || typeof manifest.version !== "string") {
+      errors.push('Missing or invalid "version" (must be a string)');
+    } else if (!/^\d+\.\d+\.\d+/.test(manifest.version)) {
+      errors.push('Invalid "version" format (must be semver like x.y.z)');
+    }
+    const validTypes = [
+      "agent-backend",
+      "skill",
+      "plugin",
+      "action-adapter",
+      "library",
+      "mcp-server"
+    ];
+    if (!manifest.type || !validTypes.includes(manifest.type)) {
+      errors.push(
+        `Missing or invalid "type" (must be one of: ${validTypes.join(", ")})`
+      );
+    }
+    if (!manifest.speexorApiVersion || typeof manifest.speexorApiVersion !== "string") {
+      errors.push('Missing or invalid "speexorApiVersion" (must be a string)');
+    }
+    if (!manifest.entry || typeof manifest.entry !== "string") {
+      errors.push('Missing or invalid "entry" (must be a string)');
+    }
+    if (!manifest.description || typeof manifest.description !== "string") {
+      errors.push(
+        'Missing or invalid "description" (must be a non-empty string)'
+      );
+    }
+    if (!manifest.author || typeof manifest.author !== "string") {
+      errors.push('Missing or invalid "author" (must be a non-empty string)');
+    }
+    if (manifest.permissions) {
+      const permErrors = this.validatePermissions(manifest.permissions);
+      errors.push(...permErrors);
+    } else {
+      errors.push('Missing "permissions" object');
+    }
+    if (manifest.signature !== void 0 && typeof manifest.signature !== "string") {
+      errors.push('Invalid "signature" (must be a string if present)');
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  checkApiCompatibility(manifest, currentApiVersion) {
+    const reqParts = manifest.speexorApiVersion.split(".").map(Number);
+    const curParts = currentApiVersion.split(".").map(Number);
+    if (reqParts.length < 2 || curParts.length < 2) return false;
+    return reqParts[0] === curParts[0] && reqParts[1] === curParts[1];
+  }
+  validatePermissions(permissions) {
+    const errors = [];
+    const validLevels = [
+      "none",
+      "read-only",
+      "read-write",
+      "scoped",
+      "full"
+    ];
+    const axes = [
+      "fileSystem",
+      "network",
+      "shell"
+    ];
+    for (const axis of axes) {
+      if (!validLevels.includes(permissions[axis])) {
+        errors.push(
+          `Invalid permission level for "${axis}" (must be one of: ${validLevels.join(", ")})`
+        );
+      }
+    }
+    if (!Array.isArray(permissions.secrets)) {
+      errors.push('"permissions.secrets" must be an array of strings');
+    } else {
+      for (const s of permissions.secrets) {
+        if (typeof s !== "string") {
+          errors.push('Each entry in "permissions.secrets" must be a string');
+          break;
+        }
+      }
+    }
+    return errors;
+  }
+};
+
+// src/extension-manager/permission-view.ts
+var axisLabels = {
+  fileSystem: "File system access",
+  network: "Network access",
+  shell: "Shell/command execution",
+  secrets: "Secret/key access"
+};
+var levelDescriptions = {
+  none: "No access",
+  "read-only": "Read-only access",
+  "read-write": "Read and write access",
+  scoped: "Scoped access (limited to specific paths/origins)",
+  full: "Full unrestricted access"
+};
+function formatPermissions(permissions) {
+  const lines = ["Permissions:"];
+  const axes = [
+    "fileSystem",
+    "network",
+    "shell"
+  ];
+  for (const axis of axes) {
+    lines.push(
+      `  ${axisLabels[axis]}: ${levelDescriptions[permissions[axis]]}`
+    );
+  }
+  if (permissions.secrets.length > 0) {
+    lines.push(`  Secret scopes: ${permissions.secrets.join(", ")}`);
+  } else {
+    lines.push("  Secret scopes: none");
+  }
+  return lines.join("\n");
+}
+function getPermissionRiskLevel(permissions) {
+  let riskScore = 0;
+  if (permissions.fileSystem === "full" || permissions.fileSystem === "read-write")
+    riskScore += 2;
+  else if (permissions.fileSystem === "scoped") riskScore += 1;
+  if (permissions.network === "full" || permissions.network === "read-write")
+    riskScore += 2;
+  else if (permissions.network === "scoped") riskScore += 1;
+  if (permissions.shell === "full" || permissions.shell === "read-write")
+    riskScore += 3;
+  else if (permissions.shell === "scoped") riskScore += 1;
+  if (permissions.secrets.length > 0)
+    riskScore += Math.min(permissions.secrets.length, 3);
+  if (riskScore >= 6) return "high";
+  if (riskScore >= 3) return "medium";
+  return "low";
+}
+
+// src/extension-manager/registry.ts
+var debug5 = Debug("speexor:extension-registry");
+var ExtensionRegistry = class {
+  baseDir;
+  registryPath;
+  extensionsDir;
+  data;
+  manifestLoader;
+  constructor(baseDir) {
+    const defaultDir = join(homedir(), ".speexor", "extensions");
+    this.baseDir = baseDir ?? defaultDir;
+    this.registryPath = join(this.baseDir, "registry.json");
+    this.extensionsDir = this.baseDir;
+    this.manifestLoader = new ExtensionManifestLoader();
+    this.data = this.loadRegistry();
+  }
+  async install(manifestPath) {
+    const manifest = this.manifestLoader.loadFromFile(manifestPath);
+    if (this.get(manifest.name)) {
+      throw new Error(`Extension "${manifest.name}" is already installed`);
+    }
+    const extDir = join(this.extensionsDir, manifest.name);
+    if (!existsSync(extDir)) {
+      mkdirSync(extDir, { recursive: true });
+    }
+    const destManifest = join(extDir, "speexor.extension.json");
+    copyFileSync(manifestPath, destManifest);
+    const sourceDir = dirname(manifestPath);
+    const entryPath = join(sourceDir, manifest.entry);
+    if (existsSync(entryPath)) {
+      const destEntry = join(extDir, manifest.entry);
+      const destEntryDir = dirname(destEntry);
+      if (!existsSync(destEntryDir)) {
+        mkdirSync(destEntryDir, { recursive: true });
+      }
+      copyFileSync(entryPath, destEntry);
+    }
+    const checksum = createHash("sha256").update(JSON.stringify(manifest)).digest("hex");
+    const installed = {
+      name: manifest.name,
+      manifest,
+      enabled: true,
+      installPath: extDir,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      checksum
+    };
+    this.data.extensions.push(installed);
+    this.saveRegistry();
+    debug5(`Installed extension "${manifest.name}" v${manifest.version}`);
+    return installed;
+  }
+  remove(name) {
+    const idx = this.data.extensions.findIndex((e) => e.name === name);
+    if (idx === -1) {
+      throw new Error(`Extension "${name}" is not installed`);
+    }
+    const ext = this.data.extensions[idx];
+    const extDir = ext.installPath;
+    if (existsSync(extDir)) {
+      rmSync(extDir, { recursive: true, force: true });
+    }
+    this.data.extensions.splice(idx, 1);
+    for (const projectName of Object.keys(this.data.projectOverrides)) {
+      const overrides = this.data.projectOverrides[projectName];
+      if (overrides) {
+        delete overrides[name];
+        if (Object.keys(overrides).length === 0) {
+          delete this.data.projectOverrides[projectName];
+        }
+      }
+    }
+    this.saveRegistry();
+    debug5(`Removed extension "${name}"`);
+  }
+  enable(name, projectName) {
+    const ext = this.get(name);
+    if (!ext) {
+      throw new Error(`Extension "${name}" is not installed`);
+    }
+    if (projectName) {
+      if (!this.data.projectOverrides[projectName]) {
+        this.data.projectOverrides[projectName] = {};
+      }
+      this.data.projectOverrides[projectName][name] = true;
+    } else {
+      ext.enabled = true;
+    }
+    this.saveRegistry();
+    debug5(`Enabled extension "${name}"${projectName ? ` for project "${projectName}"` : ""}`);
+  }
+  disable(name, projectName) {
+    const ext = this.get(name);
+    if (!ext) {
+      throw new Error(`Extension "${name}" is not installed`);
+    }
+    if (projectName) {
+      if (!this.data.projectOverrides[projectName]) {
+        this.data.projectOverrides[projectName] = {};
+      }
+      this.data.projectOverrides[projectName][name] = false;
+    } else {
+      ext.enabled = false;
+    }
+    this.saveRegistry();
+    debug5(`Disabled extension "${name}"${projectName ? ` for project "${projectName}"` : ""}`);
+  }
+  list() {
+    return [...this.data.extensions];
+  }
+  get(name) {
+    return this.data.extensions.find((e) => e.name === name);
+  }
+  isEnabled(name, projectName) {
+    const ext = this.get(name);
+    if (!ext) return false;
+    if (projectName) {
+      const overrides = this.data.projectOverrides[projectName];
+      if (overrides && name in overrides) {
+        return overrides[name] === true;
+      }
+    }
+    return ext.enabled;
+  }
+  verifyInstall(name) {
+    const ext = this.get(name);
+    if (!ext) {
+      throw new Error(`Extension "${name}" is not installed`);
+    }
+    const actual = createHash("sha256").update(JSON.stringify(ext.manifest)).digest("hex");
+    return {
+      valid: ext.checksum === actual,
+      expectedChecksum: ext.checksum ?? "",
+      actualChecksum: actual
+    };
+  }
+  displayPermissions(name) {
+    const ext = this.get(name);
+    if (!ext) {
+      throw new Error(`Extension "${name}" is not installed`);
+    }
+    const formatted = formatPermissions(ext.manifest.permissions);
+    const risk = getPermissionRiskLevel(ext.manifest.permissions);
+    return `${formatted}
+Risk level: ${risk}`;
+  }
+  loadRegistry() {
+    try {
+      if (existsSync(this.registryPath)) {
+        const raw = readFileSync(this.registryPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+          version: parsed.version ?? 1,
+          extensions: parsed.extensions ?? [],
+          projectOverrides: parsed.projectOverrides ?? {}
+        };
+      }
+    } catch (error) {
+      debug5(`Failed to load registry: ${error}`);
+    }
+    return { version: 1, extensions: [], projectOverrides: {} };
+  }
+  saveRegistry() {
+    try {
+      if (!existsSync(this.baseDir)) {
+        mkdirSync(this.baseDir, { recursive: true });
+      }
+      writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2), "utf-8");
+    } catch (error) {
+      debug5(`Failed to save registry: ${error}`);
+    }
+  }
+};
+async function extSearchCommand(query) {
+  try {
+    const config = loadConfig();
+    const sources = [
+      { type: "github-index", url: config.extensions?.marketplaceIndex ?? "https://marketplace.speexor.dev/index.json" }
+    ];
+    const client = new MarketplaceClient(sources);
+    const results = await client.search(query);
+    if (results.length === 0) {
+      console.log(`
+  ${chalk4.dim("No extensions found matching")} "${query}"
+`);
+      return;
+    }
+    console.log(`
+  ${chalk4.bold(`\u{1F50D} Search results for "${query}"`)} (${results.length})
+`);
+    for (const pkg of results) {
+      console.log(`  ${chalk4.cyan(pkg.name)} ${chalk4.dim(`v${pkg.version}`)}`);
+      console.log(`    ${pkg.description}`);
+      console.log(`    ${chalk4.dim(`by ${pkg.author}`)}`);
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+  }
+}
+async function extInstallCommand(name) {
+  try {
+    const config = loadConfig();
+    const sources = [
+      { type: "github-index", url: config.extensions?.marketplaceIndex ?? "https://marketplace.speexor.dev/index.json" }
+    ];
+    const client = new MarketplaceClient(sources);
+    await client.getDetails(name);
+    const downloadUrl = client.resolveDownloadUrl(name);
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to download extension manifest: HTTP ${response.status}`);
+    }
+    const manifestJson = await response.text();
+    const extDir = join(process.cwd(), ".speexor", "extensions", name);
+    if (!existsSync(extDir)) {
+      mkdirSync(extDir, { recursive: true });
+    }
+    const manifestPath = join(extDir, "speexor.extension.json");
+    writeFileSync(manifestPath, manifestJson, "utf-8");
+    const registry = new ExtensionRegistry();
+    const installed = await registry.install(manifestPath);
+    console.log(`
+  ${chalk4.green("\u2713")} Installed ${chalk4.bold(installed.name)} v${installed.manifest.version}
+`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+  }
+}
+async function extListCommand() {
+  try {
+    const registry = new ExtensionRegistry();
+    const extensions = registry.list();
+    if (extensions.length === 0) {
+      console.log(`
+  ${chalk4.dim("No extensions installed.")}
+`);
+      return;
+    }
+    console.log(`
+  ${chalk4.bold("\u{1F4E6} Installed Extensions")} (${extensions.length})
+`);
+    for (const ext of extensions) {
+      const status = ext.enabled ? chalk4.green("enabled") : chalk4.red("disabled");
+      console.log(`  ${chalk4.cyan(ext.name)} ${chalk4.dim(`v${ext.manifest.version}`)} [${status}]`);
+      console.log(`    ${ext.manifest.description}`);
+      console.log(`    ${chalk4.dim(`type: ${ext.manifest.type}  path: ${ext.installPath}`)}`);
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+  }
+}
+async function extUpdateCommand(name) {
+  try {
+    const registry = new ExtensionRegistry();
+    const config = loadConfig();
+    const sources = [
+      { type: "github-index", url: config.extensions?.marketplaceIndex ?? "https://marketplace.speexor.dev/index.json" }
+    ];
+    const client = new MarketplaceClient(sources);
+    const toUpdate = name ? registry.list().filter((e) => e.name === name) : registry.list();
+    if (toUpdate.length === 0) {
+      console.log(`
+  ${chalk4.dim("No extensions to update.")}
+`);
+      return;
+    }
+    let updated = 0;
+    for (const ext of toUpdate) {
+      try {
+        const pkg = await client.getDetails(ext.name);
+        if (pkg.version !== ext.manifest.version) {
+          registry.remove(ext.name);
+          const downloadUrl = client.resolveDownloadUrl(ext.name);
+          const response = await fetch(downloadUrl);
+          if (response.ok) {
+            const manifestJson = await response.text();
+            const extDir = join(process.cwd(), ".speexor", "extensions", ext.name);
+            if (!existsSync(extDir)) mkdirSync(extDir, { recursive: true });
+            const manifestPath = join(extDir, "speexor.extension.json");
+            writeFileSync(manifestPath, manifestJson, "utf-8");
+            const installed = await registry.install(manifestPath);
+            console.log(
+              `  ${chalk4.green("\u2713")} Updated ${chalk4.bold(installed.name)} ${chalk4.dim(`${ext.manifest.version} \u2192 ${installed.manifest.version}`)}`
+            );
+            updated++;
+          }
+        } else {
+          console.log(`  ${chalk4.dim(`${ext.name} is already at latest version (${pkg.version})`)}`);
+        }
+      } catch (err) {
+        console.error(`  ${chalk4.red("\u2716")} Failed to update ${ext.name}: ${err.message}`);
+      }
+    }
+    if (updated > 0) {
+      console.log(`
+  ${chalk4.green("\u2713")} ${updated} extension(s) updated
+`);
+    } else {
+      console.log(`
+  ${chalk4.dim("All extensions up to date.")}
+`);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+  }
+}
+async function extRemoveCommand(name) {
+  try {
+    const registry = new ExtensionRegistry();
+    registry.remove(name);
+    console.log(`
+  ${chalk4.green("\u2713")} Removed extension ${chalk4.bold(name)}
+`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+  }
+}
+var debug6 = Debug("speexor:config-migration:registry");
+var MigrationRegistry = class {
+  migrations = [];
+  register(migration) {
+    const existing = this.migrations.find(
+      (m) => m.fromVersion === migration.fromVersion && m.toVersion === migration.toVersion
+    );
+    if (existing) {
+      debug6(
+        `Overwriting migration ${migration.fromVersion} \u2192 ${migration.toVersion}`
+      );
+      const idx = this.migrations.indexOf(existing);
+      this.migrations[idx] = migration;
+      return;
+    }
+    this.migrations.push(migration);
+    debug6(
+      `Registered migration ${migration.fromVersion} \u2192 ${migration.toVersion}`
+    );
+  }
+  getMigration(from, to) {
+    return this.migrations.find(
+      (m) => m.fromVersion === from && m.toVersion === to
+    );
+  }
+  getAvailableMigrations() {
+    return this.migrations.map((m) => ({
+      from: m.fromVersion,
+      to: m.toVersion
+    }));
+  }
+  resolveChain(from, to) {
+    const chain = [];
+    let current = from;
+    while (current !== to) {
+      const next = this.findNextStep(current);
+      if (!next) {
+        throw new Error(
+          `No migration path from ${from} to ${to}. Available: ${JSON.stringify(this.getAvailableMigrations())}`
+        );
+      }
+      chain.push(next);
+      current = next.toVersion;
+    }
+    return chain;
+  }
+  clear() {
+    this.migrations = [];
+    debug6("Migration registry cleared");
+  }
+  findNextStep(from) {
+    return this.migrations.find((m) => m.fromVersion === from);
+  }
+};
+var debug7 = Debug("speexor:config-migration:migrations");
+function migration1to2(config, configPath) {
+  const migrated = { ...config };
+  migrated.version = "2";
+  if (!migrated.decomposition) {
+    migrated.decomposition = {
+      maxTaskGraphDepth: 5,
+      maxAgentSpawnDepth: 3,
+      maxNodesPerGraph: 50
+    };
+  }
+  if (!migrated.scheduler) {
+    migrated.scheduler = {
+      maxConcurrentAgents: "auto",
+      retryOnFailure: 3,
+      providerFallbackChain: []
+    };
+  }
+  if (!migrated.governance) {
+    migrated.governance = {
+      autoApproveProposedTasks: false,
+      autoApproveCategories: [],
+      duplicateSimilarityThreshold: 0.8
+    };
+  }
+  debug7(
+    "Migrated v1 \u2192 v2: added decomposition, scheduler, governance defaults"
+  );
+  return migrated;
+}
+function migration2to3(config, configPath) {
+  const migrated = { ...config };
+  migrated.version = "3";
+  if (!migrated.riskPolicy) {
+    migrated.riskPolicy = {
+      autoApprove: [],
+      requireApproval: [],
+      approvalTimeout: "30m",
+      approvalDefaultAction: "escalate",
+      defaultRiskTierForUnknownActions: "medium"
+    };
+  }
+  if (!migrated.scheduler) {
+    migrated.scheduler = {
+      maxConcurrentAgents: "auto",
+      retryOnFailure: 3,
+      providerFallbackChain: []
+    };
+  }
+  debug7("Migrated v2 \u2192 v3: added riskPolicy, session config");
+  return migrated;
+}
+function migration3to4(config, configPath) {
+  const migrated = { ...config };
+  migrated.version = "4";
+  if (!migrated.extensions) {
+    migrated.extensions = {
+      enabled: [],
+      permissionsMode: "strict"
+    };
+  }
+  if (!migrated.security) {
+    migrated.security = {
+      secretsBackend: "file",
+      encryptAtRest: false,
+      sandboxModel: "process"
+    };
+  }
+  if (!migrated.performance) {
+    migrated.performance = {
+      maxConcurrentAgents: "auto",
+      workerThreadPoolSize: 4
+    };
+  }
+  debug7("Migrated v3 \u2192 v4: added extensions, security, performance config");
+  return migrated;
+}
+function migration4to5(config, configPath) {
+  const migrated = { ...config };
+  migrated.version = "5";
+  if (!migrated.worktreeHierarchy) {
+    migrated.worktreeHierarchy = {
+      pinToCommitHash: true,
+      serializeMerges: true,
+      conflictEscalatesToApproval: true
+    };
+  }
+  if (!migrated.costGuard) {
+    migrated.costGuard = {
+      trackByProvider: true,
+      trackByProject: true,
+      trackByTaskNode: false
+    };
+  }
+  if (!migrated.logging) {
+    migrated.logging = {
+      level: "info"
+    };
+  }
+  if (migrated.extensions && typeof migrated.extensions === "object") {
+    const ext = migrated.extensions;
+    if (ext.marketplaceIndex === void 0) {
+      ext.marketplaceIndex = "https://marketplace.speexor.dev";
+    }
+  }
+  debug7("Migrated v4 \u2192 v5: added worktreeHierarchy, costGuard, logging");
+  return migrated;
+}
+
+// src/config-migration/engine.ts
+var debug8 = Debug("speexor:config-migration:engine");
+var MigrationEngine = class {
+  registry;
+  constructor(registry) {
+    this.registry = registry ?? this.buildDefaultRegistry();
+  }
+  detectVersion(configPath) {
+    const absPath = resolve(configPath);
+    if (!existsSync(absPath)) {
+      throw new Error(`Config file not found: ${absPath}`);
+    }
+    const raw = readFileSync(absPath, "utf-8");
+    const parsed = parse(raw);
+    const version = parsed?.version;
+    if (!version || typeof version !== "string") {
+      throw new Error(
+        `Config file ${absPath} is missing a valid 'version' field`
+      );
+    }
+    debug8(`Detected version ${version} in ${absPath}`);
+    return version;
+  }
+  needsMigration(configPath) {
+    const from = this.detectVersion(configPath);
+    if (from === "5") {
+      return { needs: false, from, to: "5" };
+    }
+    return { needs: true, from, to: "5" };
+  }
+  previewMigration(configPath) {
+    const absPath = resolve(configPath);
+    const from = this.detectVersion(absPath);
+    if (from === "5") {
+      return `Config at ${absPath} is already at latest version (5). No migration needed.`;
+    }
+    const chain = this.registry.resolveChain(from, "5");
+    const raw = readFileSync(absPath, "utf-8");
+    const parsed = parse(raw);
+    const lines = [];
+    lines.push(`Migration preview for ${absPath}`);
+    lines.push(`  From: v${from}`);
+    lines.push(`  To:   v5`);
+    lines.push(
+      `  Steps: ${chain.map((m) => `${m.fromVersion}\u2192${m.toVersion}`).join(" \u2192 ")}`
+    );
+    lines.push("");
+    let current = { ...parsed };
+    for (const step of chain) {
+      const beforeKeys = Object.keys(current).sort();
+      const after = step.migrate({ ...current });
+      const afterKeys = Object.keys(after).sort();
+      const added = afterKeys.filter((k) => !beforeKeys.includes(k));
+      const removed = beforeKeys.filter((k) => !afterKeys.includes(k));
+      if (removed.length > 0) {
+        lines.push(`  v${step.fromVersion} \u2192 v${step.toVersion}:`);
+        lines.push(`    Removed keys: ${removed.join(", ")}`);
+      }
+      if (added.length > 0) {
+        lines.push(`  v${step.fromVersion} \u2192 v${step.toVersion}:`);
+        for (const key of added) {
+          lines.push(`    + ${key}: ${JSON.stringify(after[key])}`);
+        }
+      }
+      if (added.length === 0 && removed.length === 0) {
+        lines.push(
+          `  v${step.fromVersion} \u2192 v${step.toVersion}: (internal changes only)`
+        );
+      }
+      current = after;
+    }
+    lines.push("");
+    lines.push("Run applyMigration to execute this migration.");
+    return lines.join("\n");
+  }
+  applyMigration(configPath) {
+    const absPath = resolve(configPath);
+    const from = this.detectVersion(absPath);
+    if (from === "5") {
+      return { success: true, backupPath: "" };
+    }
+    const chain = this.registry.resolveChain(from, "5");
+    const raw = readFileSync(absPath, "utf-8");
+    const parsed = parse(raw);
+    let current = { ...parsed };
+    let lastBackupPath = "";
+    for (const step of chain) {
+      const stepBackupPath = `${absPath}.v${step.fromVersion}-to-v${step.toVersion}.${Date.now()}.bak`;
+      copyFileSync(absPath, stepBackupPath);
+      lastBackupPath = stepBackupPath;
+      const migrated = step.migrate(current);
+      current = migrated;
+      debug8(
+        `Applied migration ${step.fromVersion} \u2192 ${step.toVersion}, backup at ${stepBackupPath}`
+      );
+    }
+    const output = stringify(current, { indent: 2 });
+    writeFileSync(absPath, output, "utf-8");
+    debug8(`Written migrated config to ${absPath}`);
+    return { success: true, backupPath: lastBackupPath };
+  }
+  rollbackMigration(backupPath) {
+    const absBakPath = resolve(backupPath);
+    if (!existsSync(absBakPath)) {
+      throw new Error(`Backup file not found: ${absBakPath}`);
+    }
+    const configPath = absBakPath.replace(/\.v\d+-to-v\d+\.\d+\.bak$/, "").replace(/\.\d+\.bak$/, "");
+    if (!existsSync(configPath)) {
+      throw new Error(
+        `Cannot determine config path from backup: ${absBakPath}`
+      );
+    }
+    copyFileSync(absBakPath, configPath);
+    debug8(`Restored ${configPath} from backup ${absBakPath}`);
+  }
+  buildDefaultRegistry() {
+    const registry = new MigrationRegistry();
+    registry.register({
+      fromVersion: "1",
+      toVersion: "2",
+      migrate: (config) => migration1to2(config)
+    });
+    registry.register({
+      fromVersion: "2",
+      toVersion: "3",
+      migrate: (config) => migration2to3(config)
+    });
+    registry.register({
+      fromVersion: "3",
+      toVersion: "4",
+      migrate: (config) => migration3to4(config)
+    });
+    registry.register({
+      fromVersion: "4",
+      toVersion: "5",
+      migrate: (config) => migration4to5(config)
+    });
+    return registry;
+  }
+};
+async function configValidateCommand() {
+  try {
+    const cwd = process.cwd();
+    const candidates = ["speexor.config.yaml", "speexor.config.yml", ".speexor.yaml", ".speexor.yml", "speexor.yaml"];
+    let configPath;
+    for (const c of candidates) {
+      const full = join(cwd, c);
+      if (existsSync(full)) {
+        configPath = full;
+        break;
+      }
+    }
+    if (!configPath) {
+      console.error(`
+  ${chalk4.red("\u2716")} No speexor config found in ${cwd}
+`);
+      return;
+    }
+    console.log(`
+  ${chalk4.bold("\u{1F50D} Config Validation")}`);
+    console.log(`  ${chalk4.dim(`Path: ${resolve(configPath)}`)}
+`);
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = parse(raw);
+    const currentVersion = parsed?.version ?? "unknown";
+    console.log(`  Schema version: ${chalk4.cyan(currentVersion)}`);
+    console.log(`  Latest version: ${chalk4.green("5")}`);
+    const engine = new MigrationEngine();
+    const detected = engine.detectVersion(configPath);
+    const migrationStatus = engine.needsMigration(configPath);
+    if (migrationStatus.needs) {
+      console.log(`
+  ${chalk4.yellow("\u26A0")} Version mismatch: v${detected} \u2192 v5`);
+      console.log(`  ${chalk4.dim("Run migration to update config to latest schema.")}`);
+      console.log();
+      console.log(`  ${chalk4.cyan("Preview:")}`);
+      console.log(`  ${engine.previewMigration(configPath).replace(/\n/g, "\n  ")}`);
+      console.log();
+      console.log(`  Run ${chalk4.bold("speexor config migrate")} to apply.
+`);
+    } else {
+      console.log(`  ${chalk4.green("\u2713")} Config is at latest version
+`);
+    }
+    try {
+      validateConfig(parsed);
+      console.log(`  ${chalk4.green("\u2713")} Schema validation passed
+`);
+    } catch (schemaError) {
+      console.log(`  ${chalk4.red("\u2716")} Schema validation failed:
+`);
+      const msg = schemaError.message;
+      for (const line of msg.split("\n")) {
+        console.log(`  ${chalk4.red(line)}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+  }
+}
+var debug9 = Debug("speexor:eval:decision-log");
+var DecisionLog = class {
+  entries = [];
+  logPath;
+  constructor(baseDir) {
+    const dir = baseDir ?? join(process.cwd(), ".speexor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    this.logPath = join(dir, "decision-log.jsonl");
+    this.load();
+  }
+  load() {
+    try {
+      if (existsSync(this.logPath)) {
+        const lines = readFileSync(this.logPath, "utf-8").split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            entry.createdAt = new Date(entry.createdAt);
+            this.entries.push(entry);
+          } catch {
+            debug9("Skipping malformed log line");
+          }
+        }
+      }
+    } catch {
+      debug9("Failed to load decision log, starting fresh");
+    }
+  }
+  record(entry) {
+    this.entries.push(entry);
+    appendFileSync(this.logPath, JSON.stringify(entry) + "\n");
+    debug9(`Decision recorded: ${entry.id} (confidence: ${entry.confidence})`);
+  }
+  getEntries(filter) {
+    let result = this.entries;
+    if (filter) {
+      if (filter.taskId)
+        result = result.filter((e) => e.taskId === filter.taskId);
+      if (filter.agentId)
+        result = result.filter((e) => e.agentId === filter.agentId);
+      if (filter.confidenceMin !== void 0)
+        result = result.filter((e) => e.confidence >= filter.confidenceMin);
+      if (filter.confidenceMax !== void 0)
+        result = result.filter((e) => e.confidence <= filter.confidenceMax);
+    }
+    return [...result];
+  }
+  getUnlabeledEntries() {
+    return this.entries.filter((e) => !e.outcome || e.outcome === "unknown");
+  }
+  getEntriesByTimeRange(from, to) {
+    return this.entries.filter((e) => e.createdAt >= from && e.createdAt <= to);
+  }
+};
+var debug10 = Debug("speexor:eval:calibration");
+var CalibrationAnalyzer = class {
+  analyze(entries) {
+    const buckets = [];
+    const boundaries = [0, 0.2, 0.4, 0.6, 0.8, 1];
+    for (let i = 0; i < boundaries.length - 1; i++) {
+      const lo = boundaries[i];
+      const hi = boundaries[i + 1];
+      const inRange = entries.filter(
+        (e) => e.confidence >= lo && (i === boundaries.length - 2 ? e.confidence <= hi : e.confidence < hi)
+      );
+      const labeled = inRange.filter(
+        (e) => e.outcome && e.outcome !== "unknown"
+      );
+      const correct = labeled.filter((e) => e.outcome === "correct");
+      const range = `${lo.toFixed(1)}-${hi.toFixed(1)}`;
+      buckets.push({
+        range,
+        count: inRange.length,
+        correctRate: labeled.length > 0 ? correct.length / labeled.length : 0
+      });
+    }
+    const labeledEntries = entries.filter(
+      (e) => e.outcome && e.outcome !== "unknown"
+    );
+    const correctEntries = labeledEntries.filter(
+      (e) => e.outcome === "correct"
+    );
+    const report = {
+      buckets,
+      overallAccuracy: labeledEntries.length > 0 ? correctEntries.length / labeledEntries.length : 0,
+      totalDecisions: entries.length,
+      labeledDecisions: labeledEntries.length
+    };
+    debug10(
+      `Calibration report: ${report.labeledDecisions}/${report.totalDecisions} labeled, accuracy ${(report.overallAccuracy * 100).toFixed(1)}%`
+    );
+    return report;
+  }
+  getUnderConfidenceAreas(report) {
+    const areas = [];
+    for (const bucket of report.buckets) {
+      const [lo, hi] = bucket.range.split("-").map(Number);
+      if (hi === 0) continue;
+      const midConfidence = (lo + hi) / 2;
+      if (bucket.count > 0 && bucket.correctRate > midConfidence + 0.1) {
+        areas.push(
+          `Bucket ${bucket.range}: correctRate=${(bucket.correctRate * 100).toFixed(1)}% > midConfidence=${(midConfidence * 100).toFixed(1)}% (underconfident)`
+        );
+      }
+    }
+    return areas;
+  }
+  getOverConfidenceAreas(report) {
+    const areas = [];
+    for (const bucket of report.buckets) {
+      const [lo, hi] = bucket.range.split("-").map(Number);
+      if (hi === 0) continue;
+      const midConfidence = (lo + hi) / 2;
+      if (bucket.count > 0 && bucket.correctRate < midConfidence - 0.1) {
+        areas.push(
+          `Bucket ${bucket.range}: correctRate=${(bucket.correctRate * 100).toFixed(1)}% < midConfidence=${(midConfidence * 100).toFixed(1)}% (overconfident)`
+        );
+      }
+    }
+    return areas;
+  }
+};
+var debug11 = Debug("speexor:eval:evaluator");
+var DecisionEvaluator = class {
+  log;
+  analyzer;
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(baseDir) {
+    this.log = new DecisionLog(baseDir);
+    this.analyzer = new CalibrationAnalyzer();
+  }
+  getDecisionLog() {
+    return this.log;
+  }
+  async runEvaluation() {
+    const unlabeled = this.log.getUnlabeledEntries();
+    debug11(`Running evaluation on ${unlabeled.length} unlabeled entries`);
+    return this.getReport();
+  }
+  labelDecision(entryId, outcome) {
+    const all = this.log.getEntries();
+    const entry = all.find((e) => e.id === entryId);
+    if (entry) {
+      entry.outcome = outcome;
+      entry.outcomeLabeledBy = "user";
+      debug11(`Decision ${entryId} labeled as ${outcome} by user`);
+      this.notify();
+    }
+  }
+  async autoLabelWithLLM(entry) {
+    debug11(`Auto-labeling decision ${entry.id} via LLM judge`);
+    return null;
+  }
+  getReport() {
+    const entries = this.log.getEntries();
+    return this.analyzer.analyze(entries);
+  }
+  subscribe(handler) {
+    this.subscribers.add(handler);
+    return () => {
+      this.subscribers.delete(handler);
+    };
+  }
+  notify() {
+    const report = this.getReport();
+    for (const handler of this.subscribers) {
+      try {
+        handler(report);
+      } catch {
+        debug11("Subscriber handler threw");
+      }
+    }
+  }
+};
+async function evalDecisionsCommand() {
+  try {
+    const evaluator = new DecisionEvaluator();
+    const report = await evaluator.runEvaluation();
+    console.log(`
+  ${chalk4.bold("\u{1F4CA} Decision Quality Evaluation")}
+`);
+    console.log(`  ${chalk4.dim(`Total decisions: ${report.totalDecisions}`)}`);
+    console.log(`  ${chalk4.dim(`Labeled decisions: ${report.labeledDecisions}`)}`);
+    console.log(`  Overall accuracy: ${chalk4.cyan(`${(report.overallAccuracy * 100).toFixed(1)}%`)}
+`);
+    if (report.buckets.length > 0) {
+      console.log(`  ${chalk4.bold("Calibration Report:")}
+`);
+      console.log(`  ${chalk4.dim("Confidence Range  |  Count  |  Correct Rate")}`);
+      console.log(`  ${chalk4.dim("\u2500".repeat(45))}`);
+      for (const bucket of report.buckets) {
+        const bar = "\u2588".repeat(Math.round(bucket.correctRate * 20));
+        const mid = bucket.range.split("-").map(Number);
+        const midConf = ((mid[0] ?? 0) + (mid[1] ?? 1)) / 2;
+        let color = chalk4.green;
+        if (bucket.count > 0) {
+          if (bucket.correctRate < midConf - 0.1) color = chalk4.red;
+          else if (bucket.correctRate > midConf + 0.1) color = chalk4.yellow;
+        }
+        const rateStr = bucket.count > 0 ? `${(bucket.correctRate * 100).toFixed(0).padStart(3)}%` : " N/A";
+        console.log(`  ${`${bucket.range.padEnd(17)}`}\u2502 ${String(bucket.count).padStart(4)}  \u2502 ${color(rateStr)} ${bar}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`
+  ${chalk4.red("\u2716")} ${error.message}
+`);
+    }
+  }
+}
 var __dirname$1 = dirname(fileURLToPath(import.meta.url));
 function getVersion() {
   try {
@@ -271,10 +2295,10 @@ function getVersion() {
 }
 var program = new Command();
 program.name("speexor").description("Agent Orchestrator for multi-AI coding agent orchestration (Speexor)").version(getVersion());
-program.command("start [repo]").description("Initialize a project and start the dashboard").option("-p, --port <port>", "Dashboard port", "3000").option("-n, --name <name>", "Project name").option("--no-dashboard", "Skip starting dashboard").action(startCommand);
+program.command("start [repo]").description("Initialize a project and start the dashboard").option("-p, --port <port>", "Dashboard port", "7777").option("-n, --name <name>", "Project name").option("--no-dashboard", "Skip starting dashboard").action(startCommand);
 program.command("agent").description("Manage agents").addCommand(
   new Command("spawn").description("Spawn a new agent for a task").requiredOption("-t, --task <id>", "Task ID").option("-a, --agent <type>", "Agent type (opencode, claude-code, aider, codex)", "opencode").action(async (opts) => {
-    const { agentSpawnCommand } = await import('../agent-D4BRWEOZ.js');
+    const { agentSpawnCommand } = await import('../agent-C64T66XT.js');
     await agentSpawnCommand(opts);
   })
 );
@@ -282,6 +2306,22 @@ program.command("list").description("List all projects and active agent statuses
 program.command("stop <session-id>").description("Stop an agent session safely").action(stopCommand);
 program.command("logs <session-id>").description("Tail logs for an agent session").option("-f, --follow", "Follow log output").option("-n, --lines <count>", "Number of lines", "50").action(logsCommand);
 program.command("config-help").description("Show full config schema reference").action(configHelpCommand);
+program.command("task").description("Submit and manage tasks").addCommand(
+  new Command("submit").description("Submit a task description for decomposition into a task graph").argument("<description>", "Task description").action(taskSubmitCommand)
+);
+program.command("ext").description("Manage extensions").addCommand(
+  new Command("search").description("Search the extension marketplace").argument("<query>", "Search query").action(extSearchCommand)
+).addCommand(
+  new Command("install").description("Install an extension from the marketplace").argument("<name>", "Extension name").action(extInstallCommand)
+).addCommand(new Command("list").description("List installed extensions").action(extListCommand)).addCommand(
+  new Command("update").description("Update installed extension(s)").argument("[name]", "Extension name (omit to update all)").action(extUpdateCommand)
+).addCommand(
+  new Command("remove").description("Remove an installed extension").argument("<name>", "Extension name").action(extRemoveCommand)
+);
+program.command("config").description("Manage configuration").addCommand(new Command("validate").description("Validate current config against schema and check version").action(configValidateCommand));
+program.command("eval").description("Run evaluations and reports").addCommand(
+  new Command("decisions").description("Run Decision Quality evaluation and show calibration report").action(evalDecisionsCommand)
+);
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map