@serkanalgur/opencode-nexus 1.0.5 → 1.2.0

package/dist/index.js

@@ -1,3 +1,6 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // node_modules/@opencode/plugin/dist/promise/plugin.js
 function define(plugin) {
   return plugin;
@@ -3457,7 +3460,7 @@ function hasCheck(checks, id) {
 }
 var number2 = /* @__PURE__ */ new Number4;
 
-class Boolean extends Base2 {
+class Boolean2 extends Base2 {
   _tag = "Boolean";
   getParser() {
     return fromRefinement(this, isBoolean);
@@ -3466,7 +3469,7 @@ class Boolean extends Base2 {
     return "boolean";
   }
 }
-var boolean = /* @__PURE__ */ new Boolean;
+var boolean = /* @__PURE__ */ new Boolean2;
 class Arrays extends Base2 {
   _tag = "Arrays";
   isMutable;
@@ -5372,7 +5375,7 @@ var Null2 = /* @__PURE__ */ make9(null_);
 var Undefined2 = /* @__PURE__ */ make9(undefined_2);
 var String5 = /* @__PURE__ */ make9(string2);
 var Number5 = /* @__PURE__ */ make9(number2);
-var Boolean2 = /* @__PURE__ */ make9(boolean);
+var Boolean3 = /* @__PURE__ */ make9(boolean);
 function makeStruct(ast, fields) {
   return make9(ast, {
     fields,
@@ -6406,14 +6409,14 @@ var Option = Struct({
 var When = Struct({
   key: String5,
   op: Literals(["eq", "neq"]),
-  value: Union2([String5, Number5, Boolean2])
+  value: Union2([String5, Number5, Boolean3])
 }).annotate({ identifier: "Form.When" });
 var FieldBase = {
   key: String5,
   title: String5.pipe(optional3),
   description: String5.pipe(optional3),
-  required: Boolean2.pipe(optional3),
-  hidden: Boolean2.pipe(optional3).annotate({
+  required: Boolean3.pipe(optional3),
+  hidden: Boolean3.pipe(optional3).annotate({
     description: "Skip the interactive authentication prompt and use the default unless an answer is supplied"
   }),
   when: ArraySchema(When).pipe(optional3)
@@ -6428,7 +6431,7 @@ var StringField = Struct({
   placeholder: String5.pipe(optional3),
   default: String5.pipe(optional3),
   options: ArraySchema(Option).pipe(optional3),
-  custom: Boolean2.pipe(optional3)
+  custom: Boolean3.pipe(optional3)
 }).annotate({ identifier: "Form.StringField" });
 var NumberField = Struct({
   ...FieldBase,
@@ -6447,7 +6450,7 @@ var IntegerField = Struct({
 var BooleanField = Struct({
   ...FieldBase,
   type: Literal2("boolean"),
-  default: Boolean2.pipe(optional3)
+  default: Boolean3.pipe(optional3)
 }).annotate({ identifier: "Form.BooleanField" });
 var MultiselectField = Struct({
   ...FieldBase,
@@ -6455,7 +6458,7 @@ var MultiselectField = Struct({
   options: ArraySchema(Option),
   minItems: NonNegativeInt.pipe(optional3),
   maxItems: NonNegativeInt.pipe(optional3),
-  custom: Boolean2.pipe(optional3),
+  custom: Boolean3.pipe(optional3),
   default: ArraySchema(String5).pipe(optional3)
 }).annotate({ identifier: "Form.MultiselectField" });
 var ExternalField = Struct({
@@ -6484,7 +6487,7 @@ var Info2 = Struct({
   ...InfoBase,
   fields: Fields
 }).annotate({ identifier: "Form.Info" });
-var Value = Union2([String5, Number5, Boolean2, ArraySchema(String5)]).annotate({
+var Value = Union2([String5, Number5, Boolean3, ArraySchema(String5)]).annotate({
   identifier: "Form.Value"
 });
 var Answer = Record(String5, Value).annotate({ identifier: "Form.Answer" });
@@ -6720,14 +6723,14 @@ var Overlays2 = {
 };
 var Compatibility = Struct({
   reasoningField: ReasoningField.pipe(optional3),
-  requireReasoning: Boolean2.pipe(optional3),
+  requireReasoning: Boolean3.pipe(optional3),
   maxTokensField: MaxTokensField.pipe(optional3),
-  requireFinishReason: Boolean2.pipe(optional3),
-  requireAssistantAfterTool: Boolean2.pipe(optional3),
-  supportsPromptCacheKey: Boolean2.pipe(optional3)
+  requireFinishReason: Boolean3.pipe(optional3),
+  requireAssistantAfterTool: Boolean3.pipe(optional3),
+  supportsPromptCacheKey: Boolean3.pipe(optional3)
 }).annotate({ identifier: "Model.Compatibility" });
 var Capabilities = Struct({
-  tools: Boolean2,
+  tools: Boolean3,
   input: ArraySchema(String5),
   output: ArraySchema(String5)
 }).annotate({ identifier: "Model.Capabilities" }).pipe(statics(() => ({
@@ -6766,7 +6769,7 @@ var Info6 = Struct({
   }),
   cost: ArraySchema(Cost),
   status: Literals(["alpha", "beta", "deprecated", "active"]),
-  enabled: Boolean2,
+  enabled: Boolean3,
   limit: Struct({
     context: Int,
     input: Int.pipe(optional3),
@@ -6850,7 +6853,7 @@ var Info7 = Struct({
   system: String5.pipe(optional3),
   description: String5.pipe(optional3),
   mode: Literals(["subagent", "primary", "all"]),
-  hidden: Boolean2,
+  hidden: Boolean3,
   color: Color.pipe(optional3),
   steps: PositiveInt.pipe(optional3),
   permissions: Ruleset
@@ -6909,8 +6912,8 @@ class LocalConfig extends Class3("Mcp.LocalConfig")({
     description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory."
   }),
   environment: Record(String5, String5).pipe(optional3),
-  disabled: Boolean2.pipe(optional3),
-  codemode: Boolean2.pipe(optional3).annotate({
+  disabled: Boolean3.pipe(optional3),
+  codemode: Boolean3.pipe(optional3).annotate({
     description: "Expose this server's tools through Code Mode. Defaults to true."
   }),
   timeout: TimeoutConfig.pipe(optional3),
@@ -6935,8 +6938,8 @@ class RemoteConfig extends Class3("Mcp.RemoteConfig")({
   url: String5,
   headers: Record(String5, String5).pipe(optional3),
   oauth: Union2([OAuthConfig, Literal2(false)]).pipe(optional3),
-  disabled: Boolean2.pipe(optional3),
-  codemode: Boolean2.pipe(optional3).annotate({
+  disabled: Boolean3.pipe(optional3),
+  codemode: Boolean3.pipe(optional3).annotate({
     description: "Expose this server's tools through Code Mode. Defaults to true."
   }),
   timeout: TimeoutConfig.pipe(optional3),
@@ -7118,7 +7121,7 @@ var Info11 = Struct({
   id: ID11,
   name: Name2,
   description: String5.pipe(optional3),
-  autoinvoke: Boolean2.pipe(optional3),
+  autoinvoke: Boolean3.pipe(optional3),
   path: AbsolutePath,
   content: String5
 }).annotate({ identifier: "Skill.Info" });
@@ -7261,7 +7264,7 @@ var Output = Struct({
   output: String5,
   cursor: NonNegativeInt,
   size: NonNegativeInt,
-  truncated: Boolean2
+  truncated: Boolean3
 });
 // node_modules/@opencode/schema/dist/session-error.js
 var Error5 = Struct({
@@ -7386,7 +7389,7 @@ var AssistantTool = Struct({
   type: tag("tool"),
   id: String5,
   name: String5,
-  executed: Boolean2.pipe(optional3),
+  executed: Boolean3.pipe(optional3),
   providerState: ProviderState.pipe(optional3),
   providerResultState: ProviderState.pipe(optional3),
   state: ToolState,
@@ -7583,7 +7586,7 @@ var Info17 = Struct({
 }).annotate({ identifier: "InstructionEntry.Info" });
 var Snapshot = ArraySchema(Struct({
   ...Info17.fields,
-  removed: Boolean2
+  removed: Boolean3
 })).annotate({ identifier: "InstructionEntry.Snapshot" });
 var MaxValueBytes = 256 * 1024;
 
@@ -8028,7 +8031,7 @@ var Tool;
     schema: {
       ...ToolBase,
       input: Record(String5, Unknown2),
-      executed: Boolean2,
+      executed: Boolean3,
       state: ProviderState.pipe(optional3)
     }
   });
@@ -8049,7 +8052,7 @@ var Tool;
       ...ToolBase,
       content: NonEmptyArray(Content),
       metadata: Record(String5, Json2).pipe(optional3),
-      executed: Boolean2,
+      executed: Boolean3,
       resultState: ProviderState.pipe(optional3)
     }
   });
@@ -8064,7 +8067,7 @@ var Tool;
       error: Error5,
       content: NonEmptyArray(Content).pipe(optional3),
       metadata: Record(String5, Json2).pipe(optional3),
-      executed: Boolean2,
+      executed: Boolean3,
       resultState: ProviderState.pipe(optional3)
     }
   });
@@ -8241,21 +8244,21 @@ var LocalSource = Struct({
   type: Literal2("local"),
   path: AbsolutePath,
   description: String5.pipe(optional3),
-  hidden: Boolean2.pipe(optional3)
+  hidden: Boolean3.pipe(optional3)
 }).annotate({ identifier: "Reference.LocalSource" });
 var GitSource = Struct({
   type: Literal2("git"),
   repository: String5,
   branch: String5.pipe(optional3),
   description: String5.pipe(optional3),
-  hidden: Boolean2.pipe(optional3)
+  hidden: Boolean3.pipe(optional3)
 }).annotate({ identifier: "Reference.GitSource" });
 var Source4 = Union2([LocalSource, GitSource]).pipe(toTaggedUnion("type")).annotate({ identifier: "Reference.Source" });
 var Info21 = Struct({
   name: String5,
   path: AbsolutePath,
   description: String5.pipe(optional3),
-  hidden: Boolean2.pipe(optional3),
+  hidden: Boolean3.pipe(optional3),
   source: Source4
 }).annotate({ identifier: "Reference.Info" });
 // node_modules/@opencode/schema/dist/vcs.js
@@ -8301,7 +8304,7 @@ var Result2 = Struct({
   })
 }).annotate({ identifier: "WebSearch.Result" });
 
-class Response extends Class3("WebSearch.Response")({
+class Response2 extends Class3("WebSearch.Response")({
   providerID: ID16,
   results: ArraySchema(Result2)
 }) {
@@ -8325,7 +8328,7 @@ var CreateInput4 = Struct({
 var RemoveInput = Struct({
   projectID: ID10,
   directory: AbsolutePath,
-  force: Boolean2
+  force: Boolean3
 }).annotate({ identifier: "Worktree.RemoveInput" });
 var Info23 = Struct({
   directory: AbsolutePath
@@ -8341,7 +8344,7 @@ var ListEntry = Struct({
 
 class OperationError extends TaggedError3()("Worktree.OperationError", {
   message: String5,
-  forceRequired: optional3(Boolean2)
+  forceRequired: optional3(Boolean3)
 }) {
 }
 var List = ArraySchema(Directory).annotate({ identifier: "Worktree.List" });
@@ -8361,6 +8364,64 @@ var Resolved = durable({
 });
 var Event16 = { Updated: Updated12, Resolved, Definitions: inventory(Updated12, Resolved) };
 // src/config.ts
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+function stripJsonComments(jsonc) {
+  const result = [];
+  let i = 0;
+  const len = jsonc.length;
+  while (i < len) {
+    const ch = jsonc[i];
+    if (ch === '"') {
+      result.push(ch);
+      i++;
+      while (i < len && jsonc[i] !== '"') {
+        if (jsonc[i] === "\\") {
+          result.push(jsonc[i], jsonc[i + 1] ?? "");
+          i += 2;
+        } else {
+          result.push(jsonc[i]);
+          i++;
+        }
+      }
+      if (i < len) {
+        result.push(jsonc[i]);
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && jsonc[i + 1] === "/") {
+      while (i < len && jsonc[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === "/" && jsonc[i + 1] === "*") {
+      i += 2;
+      while (i < len && !(jsonc[i] === "*" && jsonc[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    result.push(ch);
+    i++;
+  }
+  return result.join("");
+}
+function readJsoncFile(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const stripped = stripJsonComments(raw);
+    const parsed = JSON.parse(stripped);
+    return parsed;
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.warn(`[nexus] Failed to load config from ${filePath}: ${err.message}`);
+    }
+    return null;
+  }
+}
 var DEFAULT_CONFIG = {
   models: {
     architect: "anthropic/claude-sonnet-4-6",
@@ -8388,12 +8449,18 @@ class NexusConfigManager {
   globalConfig = null;
   storageConfig = null;
   constructor() {
-    this.loadConfigs();
-  }
-  loadConfigs() {
     this.projectConfig = null;
     this.globalConfig = null;
   }
+  loadConfigs(basePath) {
+    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    this.projectConfig = readJsoncFile(projectPath);
+    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    this.globalConfig = readJsoncFile(globalPath);
+  }
+  loadFromPath(basePath) {
+    this.loadConfigs(basePath);
+  }
   getConfig() {
     return {
       models: {
@@ -8451,24 +8518,108 @@ class NexusConfigManager {
   }
   getRoleDisplayName(role) {
     const names = {
-      architect: "\uD83C\uDFD7️ Architect",
-      coder: "\uD83D\uDCBB Coder",
-      reviewer: "\uD83D\uDD0D Reviewer",
-      tester: "\uD83E\uDDEA Tester",
-      explorer: "\uD83D\uDD2C Explorer",
-      documenter: "\uD83D\uDCDD Documenter"
+      architect: "Architect",
+      coder: "Coder",
+      reviewer: "Reviewer",
+      tester: "Tester",
+      explorer: "Explorer",
+      documenter: "Documenter"
     };
     return names[role] || role;
   }
+  getRoleEmoji(role) {
+    const emojis = {
+      architect: "\uD83C\uDFD7️",
+      coder: "\uD83D\uDCBB",
+      reviewer: "\uD83D\uDD0D",
+      tester: "\uD83E\uDDEA",
+      explorer: "\uD83D\uDD2C",
+      documenter: "\uD83D\uDCDD"
+    };
+    return emojis[role] || "\uD83E\uDD16";
+  }
   exportConfig() {
     return this.getConfig();
   }
   importConfig(config) {
     this.storageConfig = { ...config };
   }
+  writeJsoncFile(filePath, config) {
+    const dir = dirname(filePath);
+    mkdirSync(dir, { recursive: true });
+    const jsonc = [
+      "// Nexus Configuration — https://github.com/serkanalgur/opencode-nexus",
+      "// Precedence: this file > global config > TUI settings > defaults",
+      "",
+      JSON.stringify(config, null, 2)
+    ].join(`
+`);
+    writeFileSync(filePath, jsonc + `
+`, "utf-8");
+  }
+  saveProjectConfig(basePath) {
+    const projectPath = join(basePath, ".opencode", "nexus.jsonc");
+    const config = this.getNonDefaultConfig();
+    this.writeJsoncFile(projectPath, config);
+  }
+  saveGlobalConfig() {
+    const globalPath = join(homedir(), ".config", "opencode", "nexus.jsonc");
+    const config = this.getNonDefaultConfig();
+    this.writeJsoncFile(globalPath, config);
+  }
+  saveConfig(level, basePath) {
+    if (level === "project") {
+      this.saveProjectConfig(basePath || process.cwd());
+    } else {
+      this.saveGlobalConfig();
+    }
+  }
+  getNonDefaultConfig() {
+    const current = this.getConfig();
+    const result = {};
+    const models = {};
+    for (const role of this.getRoles()) {
+      if (current.models[role] !== DEFAULT_CONFIG.models[role]) {
+        models[role] = current.models[role];
+      }
+    }
+    if (Object.keys(models).length > 0) {
+      result.models = models;
+    }
+    const budget = {};
+    const budgetKeys = ["maxTotalCost", "maxCostPerTask", "maxCostPerAgent", "alertThreshold"];
+    for (const key of budgetKeys) {
+      if (current.budget[key] !== DEFAULT_CONFIG.budget[key]) {
+        budget[key] = current.budget[key];
+      }
+    }
+    if (Object.keys(budget).length > 0) {
+      result.budget = budget;
+    }
+    const selfHealing = {};
+    const shKeys = ["enabled", "maxRetries", "contextTransfer"];
+    for (const key of shKeys) {
+      if (current.selfHealing[key] !== DEFAULT_CONFIG.selfHealing[key]) {
+        selfHealing[key] = current.selfHealing[key];
+      }
+    }
+    if (Object.keys(selfHealing).length > 0) {
+      result.selfHealing = selfHealing;
+    }
+    return result;
+  }
   resetToDefaults() {
     this.storageConfig = null;
   }
+  applyPreset(name) {
+    const preset = PRESETS[name];
+    if (!preset)
+      throw new Error(`Unknown preset: ${name}. Available: ${Object.keys(PRESETS).join(", ")}`);
+    this.storageConfig = { ...this.storageConfig, ...preset.config };
+  }
+  listPresets() {
+    return Object.keys(PRESETS);
+  }
   getSummary() {
     const config = this.getConfig();
     const lines = [
@@ -8496,212 +8647,1423 @@ class NexusConfigManager {
 `);
   }
 }
-
-// src/orchestrator.ts
-class NexusOrchestrator {
-  agents = new Map;
-  tasks = new Map;
-  dag = null;
-  config;
-  budget;
-  running = false;
-  paused = false;
-  totalSpent = 0;
-  costByAgent = new Map;
-  costByModel = new Map;
-  messageQueue = [];
-  subscribers = new Map;
-  memory = new Map;
-  eventHandlers = new Map;
-  configManager;
-  constructor(config) {
-    this.config = this.mergeConfig(config);
-    this.budget = this.config.budget;
-    this.configManager = new NexusConfigManager;
-  }
-  mergeConfig(partial) {
-    const defaults = {
-      maxConcurrency: 5,
-      schedulerInterval: 1000,
-      defaultTimeout: 300000,
+var PRESETS = {
+  minimal: {
+    name: "Minimal",
+    description: "Low-cost setup with free/cheap models, minimal budget",
+    config: {
+      models: {
+        architect: "google/gemini-2.5-flash",
+        coder: "google/gemini-2.5-flash",
+        reviewer: "google/gemini-2.5-flash",
+        tester: "google/gemini-2.5-flash",
+        explorer: "google/gemini-2.5-flash",
+        documenter: "google/gemini-2.5-flash"
+      },
+      budget: {
+        maxTotalCost: 1,
+        maxCostPerTask: 0.1,
+        maxCostPerAgent: 0.5,
+        alertThreshold: 0.5
+      },
+      selfHealing: {
+        enabled: false,
+        maxRetries: 1,
+        contextTransfer: false
+      }
+    }
+  },
+  balanced: {
+    name: "Balanced",
+    description: "Good quality models with moderate budget",
+    config: {
+      models: {
+        architect: "anthropic/claude-sonnet-4-6",
+        coder: "anthropic/claude-sonnet-4-6",
+        reviewer: "openai/gpt-5-mini",
+        tester: "anthropic/claude-haiku-4-5",
+        explorer: "google/gemini-2.5-flash",
+        documenter: "anthropic/claude-haiku-4-5"
+      },
       budget: {
         maxTotalCost: 10,
         maxCostPerTask: 1,
         maxCostPerAgent: 2,
-        alertThreshold: 0.2,
-        hardLimit: false
-      },
-      agents: {
-        defaultRole: "coder",
-        spawnDelay: 100,
-        healthCheckInterval: 30000
+        alertThreshold: 0.2
       },
       selfHealing: {
         enabled: true,
         maxRetries: 3,
-        retryDelay: 1000,
-        backoffMultiplier: 2,
         contextTransfer: true
+      }
+    }
+  },
+  enterprise: {
+    name: "Enterprise",
+    description: "High-quality models with generous budget and full self-healing",
+    config: {
+      models: {
+        architect: "anthropic/claude-sonnet-4-6",
+        coder: "anthropic/claude-sonnet-4-6",
+        reviewer: "openai/gpt-5",
+        tester: "anthropic/claude-sonnet-4-6",
+        explorer: "anthropic/claude-sonnet-4-6",
+        documenter: "anthropic/claude-haiku-4-5"
       },
-      communication: {
-        mode: "pubsub",
-        maxQueueSize: 100,
-        messageTTL: 60000,
-        persistence: false
+      budget: {
+        maxTotalCost: 50,
+        maxCostPerTask: 5,
+        maxCostPerAgent: 10,
+        alertThreshold: 0.1
       },
-      memory: {
+      selfHealing: {
         enabled: true,
-        storage: "memory",
-        maxEntriesPerScope: 1000,
-        syncInterval: 5000
-      },
-      dashboard: {
-        enabled: false,
-        port: 4747,
-        host: "127.0.0.1"
+        maxRetries: 5,
+        contextTransfer: true
+      }
+    }
+  },
+  "cost-optimized": {
+    name: "Cost-Optimized",
+    description: "Minimize costs while maintaining reasonable quality",
+    config: {
+      models: {
+        architect: "anthropic/claude-haiku-4-5",
+        coder: "google/gemini-2.5-flash",
+        reviewer: "openai/gpt-5-mini",
+        tester: "google/gemini-2.5-flash",
+        explorer: "google/gemini-2.5-flash",
+        documenter: "google/gemini-2.5-flash"
       },
-      security: {
-        sastEnabled: true,
-        secretsScanning: true,
-        scopeEnforcement: true
+      budget: {
+        maxTotalCost: 3,
+        maxCostPerTask: 0.3,
+        maxCostPerAgent: 1,
+        alertThreshold: 0.3
       },
-      learning: {
+      selfHealing: {
         enabled: true,
-        patternStorage: "memory",
-        minConfidence: 0.7
+        maxRetries: 2,
+        contextTransfer: false
       }
-    };
-    return {
-      ...defaults,
-      ...partial,
-      budget: { ...defaults.budget, ...partial?.budget },
-      agents: { ...defaults.agents, ...partial?.agents },
-      selfHealing: { ...defaults.selfHealing, ...partial?.selfHealing },
-      communication: { ...defaults.communication, ...partial?.communication },
-      memory: { ...defaults.memory, ...partial?.memory },
-      dashboard: { ...defaults.dashboard, ...partial?.dashboard },
-      security: { ...defaults.security, ...partial?.security },
-      learning: { ...defaults.learning, ...partial?.learning }
-    };
-  }
-  async execute(request) {
-    if (this.running) {
-      throw new Error("Orchestrator is already running");
     }
-    this.running = true;
-    const startTime = Date.now();
-    try {
-      this.dag = this.buildDAG(request.tasks);
-      if (request.budget) {
-        this.budget = request.budget;
-      }
-      await this.executeDAG();
-      const results = this.collectResults();
-      const totalDuration = Date.now() - startTime;
-      return {
-        success: true,
-        tasks: results,
-        totalCost: this.totalSpent,
-        totalDuration,
-        agentsUsed: this.agents.size
-      };
-    } catch (error) {
-      return {
-        success: false,
-        tasks: [],
-        totalCost: this.totalSpent,
-        totalDuration: Date.now() - startTime,
-        agentsUsed: this.agents.size
-      };
-    } finally {
-      this.running = false;
+  }
+};
+
+// src/broadcast.ts
+class StateBroadcaster {
+  clients = new Set;
+  orchestrator;
+  broadcastTimer = null;
+  throttleMs;
+  unsubscribers = [];
+  constructor(orchestrator, opts) {
+    this.orchestrator = orchestrator;
+    this.throttleMs = opts?.throttleMs ?? 1000;
+    this.setupEventListeners();
+  }
+  addClient(ws) {
+    this.clients.add(ws);
+    this.sendTo(ws, {
+      type: "orchestrator:state",
+      data: this.orchestrator.getState(),
+      timestamp: new Date().toISOString()
+    });
+  }
+  removeClient(ws) {
+    this.clients.delete(ws);
+  }
+  setupEventListeners() {
+    const orch = this.orchestrator;
+    const eventNames = [
+      "agent:spawned",
+      "agent:terminated",
+      "budget:alert",
+      "budget:exceeded"
+    ];
+    for (const eventName of eventNames) {
+      const unsub = orch.on?.(eventName, (data) => {
+        this.broadcast(eventName, data);
+      });
+      if (unsub)
+        this.unsubscribers.push(unsub);
     }
   }
-  buildDAG(tasks) {
-    const dag = {
-      nodes: new Map,
-      addNode: (node) => {
-        dag.nodes.set(node.id, node);
-      },
-      addDependency: (nodeId, dependsOn) => {
-        const node = dag.nodes.get(nodeId);
-        if (node) {
-          node.dependencies.push(dependsOn);
-        }
-      },
-      removeNode: (nodeId) => {
-        dag.nodes.delete(nodeId);
-      },
-      getReadyNodes: () => {
-        const ready = [];
-        dag.nodes.forEach((node) => {
-          if (node.status === "pending") {
-            const depsComplete = node.dependencies.every((dep) => {
-              const depNode = dag.nodes.get(dep);
-              return depNode?.status === "completed";
-            });
-            if (depsComplete) {
-              ready.push(node);
-            }
-          }
-        });
-        return ready;
-      },
-      markComplete: (nodeId, result) => {
-        const node = dag.nodes.get(nodeId);
-        if (node) {
-          node.status = "completed";
-          node.result = result;
-        }
-      },
-      markFailed: (nodeId, error) => {
-        const node = dag.nodes.get(nodeId);
-        if (node) {
-          node.status = "failed";
-        }
-      },
-      getParallelGroups: () => {
-        const groups = [];
-        const ready = dag.getReadyNodes();
-        if (ready.length > 0) {
-          groups.push(ready);
-        }
-        return groups;
-      },
-      isComplete: () => {
-        let complete = true;
-        dag.nodes.forEach((node) => {
-          if (node.status !== "completed" && node.status !== "failed") {
-            complete = false;
-          }
-        });
-        return complete;
+  broadcastState() {
+    if (this.broadcastTimer)
+      return;
+    this.broadcastTimer = setTimeout(() => {
+      this.broadcastTimer = null;
+      this.broadcast("orchestrator:state", this.orchestrator.getState());
+    }, this.throttleMs);
+  }
+  broadcast(event, data) {
+    const message = JSON.stringify({
+      type: event,
+      data,
+      timestamp: new Date().toISOString()
+    });
+    for (const client of this.clients) {
+      try {
+        client.send(message);
+      } catch {
+        this.clients.delete(client);
       }
-    };
-    for (const task of tasks) {
-      const node = {
-        id: task.id,
-        task,
-        dependencies: task.dependencies,
-        status: "pending"
-      };
-      dag.addNode(node);
     }
-    return dag;
   }
-  async executeDAG() {
-    while (!this.dag.isComplete() && !this.paused) {
-      const readyNodes = this.dag.getReadyNodes();
-      for (const node of readyNodes) {
-        if (this.agents.size < this.config.maxConcurrency) {
-          await this.spawnAndExecute(node);
-        }
-      }
-      await this.sleep(this.config.schedulerInterval);
+  sendTo(ws, data) {
+    try {
+      ws.send(JSON.stringify(data));
+    } catch {
+      this.clients.delete(ws);
     }
   }
-  async spawnAndExecute(node) {
-    const complexity = this.analyzeComplexity(node.task);
+  getClientCount() {
+    return this.clients.size;
+  }
+  destroy() {
+    if (this.broadcastTimer) {
+      clearTimeout(this.broadcastTimer);
+      this.broadcastTimer = null;
+    }
+    for (const unsub of this.unsubscribers) {
+      unsub();
+    }
+    this.unsubscribers = [];
+    this.clients.clear();
+  }
+}
+
+// src/dashboard.ts
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      ...CORS_HEADERS
+    }
+  });
+}
+
+class DashboardModule {
+  server = null;
+  clients = new Set;
+  orchestrator;
+  constructor(orchestrator) {
+    this.orchestrator = orchestrator;
+  }
+  start(port, host) {
+    const self = this;
+    try {
+      this.server = Bun.serve({
+        port,
+        hostname: host,
+        fetch(req, server) {
+          const url = new URL(req.url);
+          if (req.method === "OPTIONS") {
+            return new Response(null, { headers: CORS_HEADERS });
+          }
+          if (url.pathname === "/ws/events") {
+            if (server.upgrade(req, { data: {} }))
+              return new Response(null);
+            return new Response("WebSocket upgrade failed", { status: 500 });
+          }
+          if (url.pathname === "/api/state") {
+            return jsonResponse(self.orchestrator.getState());
+          }
+          if (url.pathname === "/api/config") {
+            return jsonResponse(self.orchestrator.configManager.exportConfig());
+          }
+          if (url.pathname === "/api/agents") {
+            const state = self.orchestrator.getState();
+            return jsonResponse(state.agents);
+          }
+          if (url.pathname === "/api/costs") {
+            return jsonResponse(self.orchestrator.getCostReport());
+          }
+          if (url.pathname === "/api/health") {
+            return jsonResponse({ ok: true, uptime: process.uptime() });
+          }
+          return new Response("Nexus Dashboard API", {
+            headers: {
+              "Content-Type": "text/plain",
+              ...CORS_HEADERS
+            }
+          });
+        },
+        websocket: {
+          open(ws) {
+            self.clients.add(ws);
+            ws.send(JSON.stringify({
+              type: "orchestrator:state",
+              data: self.orchestrator.getState(),
+              timestamp: new Date().toISOString()
+            }));
+          },
+          message(ws, message) {
+            try {
+              const msg = JSON.parse(typeof message === "string" ? message : message.toString());
+              if (msg.type === "ping") {
+                ws.send(JSON.stringify({
+                  type: "pong",
+                  timestamp: new Date().toISOString()
+                }));
+              }
+            } catch {}
+          },
+          close(ws) {
+            self.clients.delete(ws);
+          }
+        }
+      });
+      console.log(`[nexus] Dashboard server running at http://${host}:${port}`);
+    } catch (err) {
+      this.server = null;
+      console.error(`[nexus] Failed to start dashboard on ${host}:${port}: ${err.message}`);
+      throw new Error(`Dashboard failed to start on port ${port}: ${err.message}`);
+    }
+  }
+  broadcast(event, data) {
+    const message = JSON.stringify({
+      type: event,
+      data,
+      timestamp: new Date().toISOString()
+    });
+    for (const client of this.clients) {
+      try {
+        client.send(message);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+  stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+    this.clients.clear();
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  isRunning() {
+    return this.server !== null;
+  }
+}
+
+// src/dag.ts
+function detectCycles(nodes) {
+  const cycles = [];
+  const visited = new Set;
+  const inStack = new Set;
+  const path = [];
+  function dfs(nodeId) {
+    if (inStack.has(nodeId)) {
+      const cycleStart = path.indexOf(nodeId);
+      cycles.push([...path.slice(cycleStart), nodeId]);
+      return;
+    }
+    if (visited.has(nodeId))
+      return;
+    visited.add(nodeId);
+    inStack.add(nodeId);
+    path.push(nodeId);
+    const node = nodes.find((n) => n.id === nodeId);
+    if (node) {
+      for (const depId of node.dependencies) {
+        dfs(depId);
+      }
+    }
+    path.pop();
+    inStack.delete(nodeId);
+  }
+  for (const node of nodes) {
+    dfs(node.id);
+  }
+  return cycles;
+}
+
+// src/message-store.ts
+import { appendFileSync, readFileSync as readFileSync2, existsSync, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join2, dirname as dirname2 } from "node:path";
+var DEFAULT_CONFIG2 = {
+  storagePath: join2(process.env.HOME || "~", ".local", "share", "opencode-nexus", "messages.jsonl"),
+  maxMessages: 1e4,
+  rotationSize: 1000
+};
+
+class MessageStore {
+  messages = [];
+  config;
+  writeCount = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.loadFromDisk();
+  }
+  loadFromDisk() {
+    try {
+      if (existsSync(this.config.storagePath)) {
+        const raw = readFileSync2(this.config.storagePath, "utf-8");
+        const lines = raw.split(`
+`).filter((l) => l.trim());
+        this.messages = lines.map((l) => JSON.parse(l)).slice(-this.config.maxMessages);
+      }
+    } catch {
+      this.messages = [];
+    }
+  }
+  ensureDir() {
+    try {
+      mkdirSync2(dirname2(this.config.storagePath), { recursive: true });
+    } catch {}
+  }
+  add(message) {
+    this.messages.push(message);
+    if (this.messages.length > this.config.maxMessages) {
+      this.messages = this.messages.slice(-this.config.maxMessages);
+    }
+    try {
+      this.ensureDir();
+      appendFileSync(this.config.storagePath, JSON.stringify(message) + `
+`);
+      this.writeCount++;
+      if (this.writeCount % this.config.rotationSize === 0) {
+        this.rotate();
+      }
+    } catch {}
+  }
+  rotate() {
+    try {
+      const content = this.messages.map((m) => JSON.stringify(m)).join(`
+`) + `
+`;
+      const { writeFileSync } = __require("node:fs");
+      writeFileSync(this.config.storagePath, content);
+    } catch {}
+  }
+  getAll() {
+    return [...this.messages];
+  }
+  getByTopic(topic) {
+    return this.messages.filter((m) => m.topic === topic);
+  }
+  getByAgent(agentId) {
+    return this.messages.filter((m) => m.from === agentId || m.to === agentId);
+  }
+  getRecent(count) {
+    return this.messages.slice(-count);
+  }
+  clear() {
+    this.messages = [];
+    this.writeCount = 0;
+  }
+  getStats() {
+    let fileSize = 0;
+    try {
+      if (existsSync(this.config.storagePath)) {
+        const { statSync } = __require("node:fs");
+        fileSize = statSync(this.config.storagePath).size;
+      }
+    } catch {}
+    return {
+      total: this.messages.length,
+      writeCount: this.writeCount,
+      fileSize
+    };
+  }
+}
+
+// src/memory-store.ts
+import { Database } from "bun:sqlite";
+import { join as join3, dirname as dirname3 } from "node:path";
+import { mkdirSync as mkdirSync3 } from "node:fs";
+var DEFAULT_CONFIG3 = {
+  dbPath: join3(process.env.HOME || "~", ".local", "share", "opencode-nexus", "memory.db"),
+  defaultTTL: 0,
+  maxEntries: 1e4
+};
+
+class PersistentMemoryStore {
+  db;
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    try {
+      mkdirSync3(dirname3(this.config.dbPath), { recursive: true });
+    } catch {}
+    this.db = new Database(this.config.dbPath);
+    this.init();
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memory (
+        id TEXT PRIMARY KEY,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        scope TEXT NOT NULL,
+        author TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        confidence REAL DEFAULT 1.0,
+        tags TEXT DEFAULT '[]',
+        ttl INTEGER DEFAULT 0,
+        expires_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_scope ON memory(scope);
+      CREATE INDEX IF NOT EXISTS idx_memory_key ON memory(key);
+      CREATE INDEX IF NOT EXISTS idx_memory_author ON memory(author);
+    `);
+  }
+  set(entry) {
+    const id = `mem-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const timestamp = Date.now();
+    const expiresAt = entry.ttl ? timestamp + entry.ttl : null;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO memory (id, key, value, scope, author, timestamp, confidence, tags, ttl, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, entry.key, JSON.stringify(entry.value), entry.scope, entry.author, timestamp, entry.confidence, JSON.stringify(entry.tags || []), entry.ttl || 0, expiresAt);
+    return { ...entry, id, timestamp: new Date(timestamp) };
+  }
+  get(key, scope) {
+    const entries = this.getByKey(key, scope);
+    return entries[entries.length - 1] || null;
+  }
+  getByKey(key, scope) {
+    let query = "SELECT * FROM memory WHERE key = ?";
+    const params = [key];
+    if (scope) {
+      query += " AND scope = ?";
+      params.push(scope);
+    }
+    query += " AND (expires_at IS NULL OR expires_at > ?)";
+    params.push(Date.now());
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map(this.rowToEntry);
+  }
+  getByScope(scope) {
+    const rows = this.db.prepare("SELECT * FROM memory WHERE scope = ? AND (expires_at IS NULL OR expires_at > ?) ORDER BY timestamp DESC").all(scope, Date.now());
+    return rows.map(this.rowToEntry);
+  }
+  search(query) {
+    const rows = this.db.prepare(`SELECT * FROM memory WHERE (key LIKE ? OR value LIKE ?) AND (expires_at IS NULL OR expires_at > ?) ORDER BY timestamp DESC`).all(`%${query}%`, `%${query}%`, Date.now());
+    return rows.map(this.rowToEntry);
+  }
+  getRecent(count) {
+    const rows = this.db.prepare("SELECT * FROM memory WHERE (expires_at IS NULL OR expires_at > ?) ORDER BY timestamp DESC LIMIT ?").all(Date.now(), count);
+    return rows.map(this.rowToEntry);
+  }
+  getByAuthor(author) {
+    const rows = this.db.prepare("SELECT * FROM memory WHERE author = ? AND (expires_at IS NULL OR expires_at > ?) ORDER BY timestamp DESC").all(author, Date.now());
+    return rows.map(this.rowToEntry);
+  }
+  delete(key, scope) {
+    let query = "DELETE FROM memory WHERE key = ?";
+    const params = [key];
+    if (scope) {
+      query += " AND scope = ?";
+      params.push(scope);
+    }
+    const result = this.db.prepare(query).run(...params);
+    return result.changes > 0;
+  }
+  clear(scope) {
+    let query = "DELETE FROM memory";
+    const params = [];
+    if (scope) {
+      query += " WHERE scope = ?";
+      params.push(scope);
+    }
+    const result = this.db.prepare(query).run(...params);
+    return result.changes;
+  }
+  getStats() {
+    const total = this.db.prepare("SELECT COUNT(*) as count FROM memory").get().count;
+    const byScope = {};
+    const scopes = this.db.prepare("SELECT DISTINCT scope FROM memory").all();
+    for (const { scope } of scopes) {
+      byScope[scope] = this.db.prepare("SELECT COUNT(*) as count FROM memory WHERE scope = ?").get(scope).count;
+    }
+    const expired = this.db.prepare("SELECT COUNT(*) as count FROM memory WHERE expires_at IS NOT NULL AND expires_at <= ?").get(Date.now()).count;
+    return { total, byScope, expired };
+  }
+  rowToEntry(row) {
+    let value;
+    try {
+      value = JSON.parse(row.value);
+    } catch {
+      value = row.value;
+    }
+    let tags = [];
+    try {
+      tags = JSON.parse(row.tags || "[]");
+    } catch {
+      tags = [];
+    }
+    return {
+      id: row.id,
+      key: row.key,
+      value,
+      scope: row.scope,
+      author: row.author,
+      timestamp: new Date(row.timestamp),
+      confidence: row.confidence,
+      tags,
+      ttl: row.ttl || undefined
+    };
+  }
+  close() {
+    this.db.close();
+  }
+}
+
+// src/health.ts
+var DEFAULT_HEALTH_CONFIG = {
+  checkInterval: 30000,
+  unhealthyThreshold: 0.5,
+  degradedThreshold: 1e4
+};
+
+class HealthMonitor {
+  checks = new Map;
+  interval = null;
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_HEALTH_CONFIG, ...config };
+  }
+  start(getAgents) {
+    this.stop();
+    this.interval = setInterval(() => {
+      const agents = getAgents();
+      for (const agent of agents) {
+        if (agent.status === "working" || agent.status === "idle") {
+          this.checkAgent(agent);
+        }
+      }
+    }, this.config.checkInterval);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  checkAgent(agent) {
+    const errorRate = agent.metrics.tasksFailed / Math.max(1, agent.metrics.tasksCompleted + agent.metrics.tasksFailed);
+    const avgResponseTime = agent.metrics.averageResponseTime || 0;
+    let status = "healthy";
+    if (errorRate > this.config.unhealthyThreshold)
+      status = "unhealthy";
+    else if (avgResponseTime > this.config.degradedThreshold)
+      status = "degraded";
+    const check = {
+      agentId: agent.id,
+      timestamp: new Date,
+      responseTime: avgResponseTime,
+      errorRate,
+      tokensPerSecond: 0,
+      memoryUsage: 0,
+      status
+    };
+    const history = this.checks.get(agent.id) || [];
+    history.push(check);
+    if (history.length > 100)
+      history.shift();
+    this.checks.set(agent.id, history);
+    return check;
+  }
+  getHealth(agentId) {
+    const history = this.checks.get(agentId);
+    return history?.[history.length - 1] || null;
+  }
+  getHistory(agentId) {
+    return this.checks.get(agentId) || [];
+  }
+  getUnhealthyAgents() {
+    const unhealthy = [];
+    for (const [agentId, history] of this.checks) {
+      const latest = history[history.length - 1];
+      if (latest?.status === "unhealthy")
+        unhealthy.push(agentId);
+    }
+    return unhealthy;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  isActive() {
+    return this.interval !== null;
+  }
+}
+
+// src/fanout.ts
+class MessageRouter {
+  routes = new Map;
+  wildcardSubscribers = new Set;
+  messageHandlers = new Map;
+  subscribe(subscriberId, topic, handler) {
+    this.messageHandlers.set(subscriberId, handler);
+    if (topic === "*") {
+      this.wildcardSubscribers.add(subscriberId);
+    } else {
+      const subs = this.routes.get(topic) || new Set;
+      subs.add(subscriberId);
+      this.routes.set(topic, subs);
+    }
+  }
+  unsubscribe(subscriberId) {
+    this.messageHandlers.delete(subscriberId);
+    this.wildcardSubscribers.delete(subscriberId);
+    for (const subs of this.routes.values()) {
+      subs.delete(subscriberId);
+    }
+  }
+  route(message) {
+    const deliveredTo = [];
+    const exactSubs = this.routes.get(message.topic);
+    if (exactSubs) {
+      for (const subId of exactSubs) {
+        const handler = this.messageHandlers.get(subId);
+        if (handler) {
+          handler(message);
+          deliveredTo.push(subId);
+        }
+      }
+    }
+    for (const subId of this.wildcardSubscribers) {
+      if (!deliveredTo.includes(subId)) {
+        const handler = this.messageHandlers.get(subId);
+        if (handler) {
+          handler(message);
+          deliveredTo.push(subId);
+        }
+      }
+    }
+    return deliveredTo;
+  }
+  broadcast(message) {
+    for (const handler of this.messageHandlers.values()) {
+      handler(message);
+    }
+  }
+  getSubscribers(topic) {
+    const subs = this.routes.get(topic);
+    return subs ? [...subs] : [];
+  }
+  getWildcardSubscribers() {
+    return [...this.wildcardSubscribers];
+  }
+  getStats() {
+    return {
+      topics: this.routes.size,
+      totalSubscribers: this.messageHandlers.size,
+      wildcardSubscribers: this.wildcardSubscribers.size
+    };
+  }
+}
+
+// src/notifications.ts
+import { spawn } from "node:child_process";
+
+class NotificationManager {
+  enabled;
+  platform;
+  constructor(enabled = true) {
+    this.enabled = enabled;
+    this.platform = process.platform;
+  }
+  async notify(options) {
+    if (!this.enabled)
+      return false;
+    try {
+      if (this.platform === "darwin") {
+        return await this.notifyMacOS(options);
+      } else if (this.platform === "linux") {
+        return await this.notifyLinux(options);
+      } else if (this.platform === "win32") {
+        return await this.notifyWindows(options);
+      }
+    } catch {}
+    return false;
+  }
+  async notifyMacOS(options) {
+    const soundFlag = options.silent ? "" : options.sound !== false ? 'sound name "Glass"' : "";
+    const script = `display notification "${options.body}" with title "${options.title}" ${soundFlag}`;
+    return new Promise((resolve) => {
+      const proc = spawn("osascript", ["-e", script]);
+      proc.on("close", (code) => resolve(code === 0));
+      proc.on("error", () => resolve(false));
+      setTimeout(() => {
+        proc.kill();
+        resolve(false);
+      }, 3000);
+    });
+  }
+  async notifyLinux(options) {
+    return new Promise((resolve) => {
+      const proc = spawn("notify-send", [options.title, options.body]);
+      proc.on("close", (code) => resolve(code === 0));
+      proc.on("error", () => resolve(false));
+      setTimeout(() => {
+        proc.kill();
+        resolve(false);
+      }, 3000);
+    });
+  }
+  async notifyWindows(options) {
+    return new Promise((resolve) => {
+      const proc = spawn("powershell", ["-Command", `New-BurntToastNotification -Text '${options.title}','${options.body}'`]);
+      proc.on("close", (code) => resolve(code === 0));
+      proc.on("error", () => resolve(false));
+      setTimeout(() => {
+        proc.kill();
+        resolve(false);
+      }, 3000);
+    });
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+}
+
+// src/learning.ts
+class LearningModule {
+  entries = new Map;
+  minConfidence;
+  constructor(minConfidence = 0.5) {
+    this.minConfidence = minConfidence;
+  }
+  recordFailure(pattern, solution, context, tags = []) {
+    const existing = this.findByPattern(pattern);
+    if (existing) {
+      existing.failCount++;
+      existing.lastSeen = new Date;
+      existing.confidence = Math.max(0, existing.confidence - 0.1);
+      return existing;
+    }
+    const entry = {
+      id: `learn-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      pattern,
+      solution,
+      context,
+      confidence: 0.3,
+      successCount: 0,
+      failCount: 1,
+      lastSeen: new Date,
+      tags
+    };
+    this.entries.set(entry.id, entry);
+    return entry;
+  }
+  recordSuccess(entryId) {
+    const entry = this.entries.get(entryId);
+    if (entry) {
+      entry.successCount++;
+      entry.confidence = Math.min(1, entry.confidence + 0.15);
+      entry.lastSeen = new Date;
+    }
+  }
+  findSolutions(errorPattern) {
+    const matches = [];
+    for (const entry of this.entries.values()) {
+      if (entry.confidence < this.minConfidence)
+        continue;
+      const similarity = this.calculateSimilarity(errorPattern, entry.pattern);
+      if (similarity > 0.3) {
+        matches.push({ entry, similarity });
+      }
+    }
+    return matches.sort((a, b) => b.similarity - a.similarity);
+  }
+  getReliable() {
+    return [...this.entries.values()].filter((e) => e.confidence >= this.minConfidence && e.successCount > 0).sort((a, b) => b.confidence - a.confidence);
+  }
+  getStats() {
+    const all = [...this.entries.values()];
+    const reliable = all.filter((e) => e.confidence >= this.minConfidence && e.successCount > 0);
+    const avgConfidence = all.length > 0 ? all.reduce((sum, e) => sum + e.confidence, 0) / all.length : 0;
+    return { total: all.length, reliable: reliable.length, avgConfidence };
+  }
+  getEntries() {
+    return [...this.entries.values()];
+  }
+  findByPattern(pattern) {
+    for (const entry of this.entries.values()) {
+      if (entry.pattern === pattern)
+        return entry;
+    }
+    return;
+  }
+  calculateSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/));
+    const intersection = new Set([...wordsA].filter((w) => wordsB.has(w)));
+    const union = new Set([...wordsA, ...wordsB]);
+    return union.size > 0 ? intersection.size / union.size : 0;
+  }
+  clear() {
+    this.entries.clear();
+  }
+}
+
+// src/modules.ts
+class ModuleRegistry {
+  modules = new Map;
+  contexts = new Map;
+  register(module) {
+    if (this.modules.has(module.name)) {
+      throw new Error(`Module '${module.name}' is already registered`);
+    }
+    this.modules.set(module.name, module);
+  }
+  async setupAll(ctx) {
+    for (const [name, module] of this.modules) {
+      try {
+        if (module.setup) {
+          await module.setup(ctx);
+          this.contexts.set(name, ctx);
+        }
+        if (module.hooks) {
+          for (const hook of module.hooks) {
+            ctx.on(hook.event, hook.handler);
+          }
+        }
+      } catch (err) {
+        console.error(`[nexus] Failed to setup module '${name}':`, err);
+      }
+    }
+  }
+  async teardownAll() {
+    for (const [name, module] of this.modules) {
+      try {
+        if (module.teardown) {
+          await module.teardown();
+        }
+      } catch (err) {
+        console.error(`[nexus] Failed to teardown module '${name}':`, err);
+      }
+    }
+    this.contexts.clear();
+  }
+  get(name) {
+    return this.modules.get(name);
+  }
+  list() {
+    return [...this.modules.values()];
+  }
+  getTools() {
+    const tools = [];
+    for (const module of this.modules.values()) {
+      if (module.tools) {
+        tools.push(...module.tools);
+      }
+    }
+    return tools;
+  }
+  isRegistered(name) {
+    return this.modules.has(name);
+  }
+  unregister(name) {
+    this.contexts.delete(name);
+    return this.modules.delete(name);
+  }
+}
+
+// src/security.ts
+var DEFAULT_SECURITY_CONFIG = {
+  enabled: true,
+  scanSecrets: true,
+  scanPatterns: true,
+  customPatterns: [],
+  excludeFiles: ["node_modules", ".git", "dist", "*.test.ts", "*.spec.ts"]
+};
+var SECRET_PATTERNS = [
+  { pattern: /(?:api[_-]?key|apikey)\s*[:=]\s*['"][^'"]+['"]/gi, category: "secrets", message: "Possible API key found" },
+  { pattern: /(?:secret|password|passwd|pwd)\s*[:=]\s*['"][^'"]+['"]/gi, category: "secrets", message: "Possible password/secret found" },
+  { pattern: /(?:token|access_token|auth_token)\s*[:=]\s*['"][^'"]+['"]/gi, category: "secrets", message: "Possible token found" },
+  { pattern: /(?:private[_-]?key)\s*[:=]\s*['"][^'"]+['"]/gi, category: "secrets", message: "Possible private key found" },
+  { pattern: /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/g, category: "secrets", message: "Private key block found" },
+  { pattern: /(?:AWS|aws)(?:_ACCESS_KEY_ID|_SECRET_ACCESS_KEY)\s*[:=]\s*['"][^'"]+['"]/gi, category: "secrets", message: "AWS credentials found" }
+];
+var DANGEROUS_PATTERNS = [
+  { pattern: /eval\s*\(/g, category: "injection", message: "eval() usage detected", suggestion: "Use safer alternatives like JSON.parse() or Function constructor" },
+  { pattern: /exec\s*\(/g, category: "injection", message: "exec() usage detected", suggestion: "Use execFile() or spawn() with argument arrays" },
+  { pattern: /child_process/g, category: "injection", message: "child_process usage detected", suggestion: "Ensure user input is sanitized before shell execution" },
+  { pattern: /innerHTML\s*=/g, category: "xss", message: "innerHTML assignment detected", suggestion: "Use textContent or sanitize input before setting innerHTML" },
+  { pattern: /document\.write\s*\(/g, category: "xss", message: "document.write() usage detected", suggestion: "Use DOM manipulation methods instead" },
+  { pattern: /new Function\s*\(/g, category: "injection", message: "Function constructor usage detected", suggestion: "Avoid dynamic code execution" },
+  { pattern: /__proto__\s*=/g, category: "prototype-pollution", message: "__proto__ assignment detected", suggestion: "Use Object.create() or Object.assign() instead" },
+  { pattern: /process\.env\[?[\"'][^\"']+[\"']\]?(?!\.replace)/g, category: "data-exposure", message: "Direct process.env access", suggestion: "Use a config module with validation" }
+];
+
+class SecurityScanner {
+  config;
+  issues = [];
+  constructor(config) {
+    this.config = { ...DEFAULT_SECURITY_CONFIG, ...config };
+  }
+  scanContent(content, filename) {
+    if (!this.config.enabled)
+      return [];
+    if (this.isExcluded(filename))
+      return [];
+    const issues = [];
+    if (this.config.scanSecrets) {
+      for (const { pattern, category, message } of SECRET_PATTERNS) {
+        const matches = content.matchAll(new RegExp(pattern.source, pattern.flags));
+        for (const match of matches) {
+          const line = this.getLineNumber(content, match.index || 0);
+          issues.push({
+            id: `sec-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`,
+            severity: "critical",
+            category,
+            message,
+            file: filename,
+            line,
+            suggestion: "Remove hardcoded secrets and use environment variables or a secrets manager"
+          });
+        }
+      }
+    }
+    if (this.config.scanPatterns) {
+      for (const { pattern, category, message, suggestion } of DANGEROUS_PATTERNS) {
+        const matches = content.matchAll(new RegExp(pattern.source, pattern.flags));
+        for (const match of matches) {
+          const line = this.getLineNumber(content, match.index || 0);
+          issues.push({
+            id: `sec-${Date.now()}-${Math.random().toString(36).substr(6, 6)}`,
+            severity: "medium",
+            category,
+            message,
+            file: filename,
+            line,
+            suggestion
+          });
+        }
+      }
+    }
+    for (const pattern of this.config.customPatterns) {
+      const matches = content.matchAll(new RegExp(pattern.source, pattern.flags));
+      for (const match of matches) {
+        const line = this.getLineNumber(content, match.index || 0);
+        issues.push({
+          id: `sec-${Date.now()}-${Math.random().toString(36).substr(12, 6)}`,
+          severity: "medium",
+          category: "custom",
+          message: `Custom pattern match in ${filename}`,
+          file: filename,
+          line
+        });
+      }
+    }
+    this.issues.push(...issues);
+    return issues;
+  }
+  getResult() {
+    const severityScores = { critical: 0, high: 10, medium: 25, low: 50 };
+    let deductions = 0;
+    for (const issue of this.issues) {
+      deductions += severityScores[issue.severity] || 25;
+    }
+    const score = Math.max(0, 100 - deductions);
+    return {
+      issues: [...this.issues],
+      score,
+      scannedAt: new Date,
+      filesScanned: new Set(this.issues.map((i) => i.file).filter(Boolean)).size || 0
+    };
+  }
+  getBySeverity(severity) {
+    return this.issues.filter((i) => i.severity === severity);
+  }
+  getByCategory(category) {
+    return this.issues.filter((i) => i.category === category);
+  }
+  isExcluded(filename) {
+    return this.config.excludeFiles.some((exclusion) => {
+      if (exclusion.startsWith("*")) {
+        return filename.endsWith(exclusion.slice(1));
+      }
+      return filename.includes(exclusion);
+    });
+  }
+  getLineNumber(content, index) {
+    return content.substring(0, index).split(`
+`).length;
+  }
+  clear() {
+    this.issues = [];
+  }
+  getStats() {
+    return {
+      total: this.issues.length,
+      critical: this.getBySeverity("critical").length,
+      high: this.getBySeverity("high").length,
+      medium: this.getBySeverity("medium").length,
+      low: this.getBySeverity("low").length
+    };
+  }
+}
+
+// src/orchestrator.ts
+var DEFAULT_ESCALATION = {
+  maxRetries: 3,
+  retryDelay: 1000,
+  enableRespawn: true,
+  fallbackModels: ["google/gemini-2.5-flash", "anthropic/claude-haiku-4-5"],
+  alertOnFailure: true
+};
+
+class NexusOrchestrator {
+  agents = new Map;
+  tasks = new Map;
+  dag = null;
+  config;
+  budget;
+  running = false;
+  paused = false;
+  budgetExceeded = false;
+  totalSpent = 0;
+  costByAgent = new Map;
+  costByModel = new Map;
+  messageQueue = [];
+  subscribers = new Map;
+  messageStore;
+  memoryStore;
+  messageRouter;
+  eventHandlers = new Map;
+  configManager;
+  ctx = null;
+  broadcaster = null;
+  dashboard = null;
+  _healthMonitor = null;
+  learning;
+  escalationPolicy;
+  nodeRetryCounts = new Map;
+  moduleRegistry;
+  securityScanner;
+  onStateChange = null;
+  stateChangeTimer = null;
+  costHistory = [];
+  cleanupInterval = null;
+  get healthMonitor() {
+    return this._healthMonitor;
+  }
+  notifications = null;
+  constructor(config, messageStoreConfig, memoryStoreConfig) {
+    this.config = this.mergeConfig(config);
+    this.budget = this.config.budget;
+    this.configManager = new NexusConfigManager;
+    this.moduleRegistry = new ModuleRegistry;
+    this.messageStore = new MessageStore(messageStoreConfig);
+    this.memoryStore = new PersistentMemoryStore(memoryStoreConfig);
+    this.messageRouter = new MessageRouter;
+    this.escalationPolicy = {
+      ...DEFAULT_ESCALATION,
+      maxRetries: this.config.selfHealing.maxRetries,
+      retryDelay: this.config.selfHealing.retryDelay,
+      enableRespawn: this.config.selfHealing.contextTransfer
+    };
+    this.learning = new LearningModule(this.config.learning.minConfidence);
+    this.securityScanner = new SecurityScanner;
+  }
+  async initialize(ctx, onStateChange) {
+    this.ctx = ctx;
+    this.onStateChange = onStateChange ?? null;
+    this.configManager.loadFromPath(process.cwd());
+    this.cleanupInterval = setInterval(() => this.cleanupStaleData(), 300000);
+    this._healthMonitor = new HealthMonitor({
+      checkInterval: this.config.agents.healthCheckInterval
+    });
+    this.notifications = new NotificationManager(true);
+    const moduleCtx = {
+      orchestrator: this,
+      config: this.config,
+      emit: (event, data) => this.emit(event, data),
+      on: (event, handler) => {
+        this.on(event, handler);
+      }
+    };
+    await this.moduleRegistry.setupAll(moduleCtx);
+  }
+  initBroadcaster(opts) {
+    this.broadcaster = new StateBroadcaster(this, opts);
+    const previousOnStateChange = this.onStateChange;
+    this.onStateChange = () => {
+      previousOnStateChange?.();
+      this.broadcaster?.broadcastState();
+    };
+  }
+  startDashboard(port, host) {
+    const dashPort = port || this.config.dashboard.port;
+    const dashHost = host || this.config.dashboard.host;
+    this.dashboard = new DashboardModule(this);
+    this.dashboard.start(dashPort, dashHost);
+    this.on("agent:spawned", (agent) => this.dashboard.broadcast("agent:spawned", agent));
+    this.on("agent:terminated", (agent) => this.dashboard.broadcast("agent:terminated", agent));
+    this.on("budget:alert", (data) => this.dashboard.broadcast("budget:alert", data));
+    this.on("budget:exceeded", (data) => this.dashboard.broadcast("budget:exceeded", data));
+  }
+  stopDashboard() {
+    if (this.dashboard) {
+      this.dashboard.stop();
+      this.dashboard = null;
+    }
+  }
+  getState() {
+    const agents = Array.from(this.agents.values()).map((a) => ({
+      id: a.id,
+      name: a.name,
+      role: a.role,
+      status: a.status,
+      model: `${a.model.provider}/${a.model.model}`,
+      sessionID: a.sessionID,
+      spawnedAt: a.spawnedAt.toISOString(),
+      tasksCompleted: a.metrics.tasksCompleted,
+      tasksFailed: a.metrics.tasksFailed,
+      totalCost: a.metrics.totalCost
+    }));
+    const tasks = Array.from(this.tasks.values()).map((t) => ({
+      id: t.id,
+      name: t.name,
+      role: t.requiredRole,
+      priority: t.priority || "normal",
+      status: t.status,
+      assignedAgent: t.assignedAgent,
+      result: t.result ? {
+        success: t.result.success,
+        output: t.result.output?.slice(0, 500),
+        error: t.result.error,
+        duration: t.result.duration
+      } : undefined
+    }));
+    return {
+      running: this.running,
+      paused: this.paused,
+      agents,
+      tasks,
+      totalSpent: this.totalSpent,
+      budgetRemaining: this.budget.maxTotalCost - this.totalSpent,
+      lastUpdated: new Date().toISOString()
+    };
+  }
+  mergeConfig(partial) {
+    const defaults = {
+      maxConcurrency: 5,
+      schedulerInterval: 1000,
+      defaultTimeout: 300000,
+      budget: {
+        maxTotalCost: 10,
+        maxCostPerTask: 1,
+        maxCostPerAgent: 2,
+        alertThreshold: 0.2,
+        hardLimit: false
+      },
+      agents: {
+        defaultRole: "coder",
+        spawnDelay: 100,
+        healthCheckInterval: 30000
+      },
+      selfHealing: {
+        enabled: true,
+        maxRetries: 3,
+        retryDelay: 1000,
+        backoffMultiplier: 2,
+        contextTransfer: true
+      },
+      communication: {
+        mode: "pubsub",
+        maxQueueSize: 100,
+        messageTTL: 60000,
+        persistence: false
+      },
+      memory: {
+        enabled: true,
+        storage: "memory",
+        maxEntriesPerScope: 1000,
+        syncInterval: 5000
+      },
+      dashboard: {
+        enabled: true,
+        port: 4747,
+        host: "127.0.0.1"
+      },
+      security: {
+        sastEnabled: true,
+        secretsScanning: true,
+        scopeEnforcement: true
+      },
+      learning: {
+        enabled: true,
+        patternStorage: "memory",
+        minConfidence: 0.7
+      }
+    };
+    return {
+      ...defaults,
+      ...partial,
+      budget: { ...defaults.budget, ...partial?.budget },
+      agents: { ...defaults.agents, ...partial?.agents },
+      selfHealing: { ...defaults.selfHealing, ...partial?.selfHealing },
+      communication: { ...defaults.communication, ...partial?.communication },
+      memory: { ...defaults.memory, ...partial?.memory },
+      dashboard: { ...defaults.dashboard, ...partial?.dashboard },
+      security: { ...defaults.security, ...partial?.security },
+      learning: { ...defaults.learning, ...partial?.learning }
+    };
+  }
+  notifyStateChange() {
+    if (this.stateChangeTimer)
+      return;
+    this.stateChangeTimer = setTimeout(() => {
+      this.stateChangeTimer = null;
+      this.onStateChange?.();
+    }, 100);
+  }
+  async execute(request) {
+    if (this.running) {
+      throw new Error("Orchestrator is already running");
+    }
+    if (!this.ctx) {
+      throw new Error("Orchestrator not initialized - call initialize(ctx) first");
+    }
+    this.running = true;
+    const startTime = Date.now();
+    this.notifyStateChange();
+    try {
+      this.dag = this.buildDAG(request.tasks);
+      const dagNodes = Array.from(this.dag.nodes.values());
+      const cycles = detectCycles(dagNodes);
+      if (cycles.length > 0) {
+        const cycleDescriptions = cycles.map((c) => c.join(" → ")).join(", ");
+        throw new Error(`Circular dependency detected: ${cycleDescriptions}`);
+      }
+      if (request.budget) {
+        this.budget = request.budget;
+      }
+      await this.executeDAG();
+      const results = this.collectResults();
+      const totalDuration = Date.now() - startTime;
+      return {
+        success: true,
+        tasks: results,
+        totalCost: this.totalSpent,
+        totalDuration,
+        agentsUsed: this.agents.size
+      };
+    } catch (error) {
+      return {
+        success: false,
+        tasks: [],
+        totalCost: this.totalSpent,
+        totalDuration: Date.now() - startTime,
+        agentsUsed: this.agents.size
+      };
+    } finally {
+      this.running = false;
+      this.notifyStateChange();
+    }
+  }
+  buildDAG(tasks) {
+    const dag = {
+      nodes: new Map,
+      addNode: (node) => {
+        dag.nodes.set(node.id, node);
+      },
+      addDependency: (nodeId, dependsOn) => {
+        const node = dag.nodes.get(nodeId);
+        if (node) {
+          node.dependencies.push(dependsOn);
+        }
+      },
+      removeNode: (nodeId) => {
+        dag.nodes.delete(nodeId);
+      },
+      getReadyNodes: () => {
+        const ready = [];
+        dag.nodes.forEach((node) => {
+          if (node.status === "pending") {
+            const depsComplete = node.dependencies.every((dep) => {
+              const depNode = dag.nodes.get(dep);
+              return depNode?.status === "completed";
+            });
+            if (depsComplete) {
+              ready.push(node);
+            }
+          }
+        });
+        const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
+        return ready.sort((a, b) => {
+          const pa = priorityOrder[a.task.priority] ?? 2;
+          const pb = priorityOrder[b.task.priority] ?? 2;
+          return pa - pb;
+        });
+      },
+      markComplete: (nodeId, result) => {
+        const node = dag.nodes.get(nodeId);
+        if (node) {
+          node.status = "completed";
+          node.result = result;
+        }
+      },
+      markFailed: (nodeId, error) => {
+        const node = dag.nodes.get(nodeId);
+        if (node) {
+          node.status = "failed";
+        }
+      },
+      getParallelGroups: () => {
+        const groups = [];
+        const ready = dag.getReadyNodes();
+        if (ready.length > 0) {
+          groups.push(ready);
+        }
+        return groups;
+      },
+      isComplete: () => {
+        let complete = true;
+        dag.nodes.forEach((node) => {
+          if (node.status !== "completed" && node.status !== "failed") {
+            complete = false;
+          }
+        });
+        return complete;
+      }
+    };
+    for (const task of tasks) {
+      const node = {
+        id: task.id,
+        task,
+        dependencies: task.dependencies,
+        status: "pending"
+      };
+      dag.addNode(node);
+    }
+    return dag;
+  }
+  async executeDAG() {
+    while (!this.dag.isComplete() && !this.paused) {
+      const readyNodes = this.dag.getReadyNodes();
+      const spawnPromises = [];
+      for (const node of readyNodes) {
+        if (this.agents.size < this.config.maxConcurrency) {
+          spawnPromises.push(this.spawnAndExecute(node));
+        }
+      }
+      await Promise.all(spawnPromises);
+      await this.sleep(this.config.schedulerInterval);
+    }
+  }
+  async spawnAndExecute(node, transferContext) {
+    const complexity = this.analyzeComplexity(node.task);
     const model = this.selectModel(node.task.requiredRole, complexity);
     const agent = await this.spawnAgent({
       role: node.task.requiredRole,
@@ -8710,86 +10072,232 @@ class NexusOrchestrator {
     });
     node.spawnedAgent = agent;
     node.status = "running";
-    this.monitorAgent(agent, node);
+    node.task.assignedAgent = agent.id;
+    this.notifyStateChange();
+    await this.executeTask(agent, node, transferContext);
   }
-  async monitorAgent(agent, node) {
-    const timeout = node.task.timeout || this.config.defaultTimeout;
-    setTimeout(() => {
-      if (node.status === "running") {
-        this.handleAgentTimeout(agent, node);
-      }
-    }, timeout);
-  }
-  handleAgentTimeout(agent, node) {
-    if (this.config.selfHealing.enabled) {
-      this.handleFailure(agent, node, new Error("Agent timed out"));
-    } else {
+  async executeTask(agent, node, transferContext) {
+    if (!this.ctx || !agent.sessionID) {
       node.status = "failed";
       node.result = {
         success: false,
-        error: "Agent timed out",
-        duration: node.task.timeout || this.config.defaultTimeout,
+        error: "No session available for agent",
+        duration: 0,
+        tokensUsed: 0,
+        cost: 0
+      };
+      this.notifyStateChange();
+      return;
+    }
+    const startTime = Date.now();
+    const timeout = node.task.timeout || this.config.defaultTimeout;
+    try {
+      const rolePrompt = this.buildRolePrompt(node.task.requiredRole);
+      let taskPrompt = `${rolePrompt}
+
+## Task
+${node.task.name}
+
+${node.task.description}
+
+## Scope
+Files: ${node.task.files.include.join(", ")}`;
+      if (transferContext) {
+        taskPrompt += `
+
+## Previous Agent Context (from failed agent ${transferContext.previousAgentId})`;
+        taskPrompt += `
+Partial results: ${transferContext.partialResults.join(", ") || "None"}`;
+        taskPrompt += `
+Decisions made: ${transferContext.decisions.join(", ") || "None"}`;
+        taskPrompt += `
+Progress: ${transferContext.taskProgress}%`;
+        taskPrompt += `
+Errors encountered: ${transferContext.errorLog.join(", ") || "None"}`;
+        taskPrompt += `
+
+Please continue from where the previous agent left off.`;
+      }
+      await this.ctx.session.prompt({
+        sessionID: agent.sessionID,
+        text: taskPrompt
+      });
+      const waitPromise = this.ctx.session.wait({ sessionID: agent.sessionID });
+      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Task timed out")), timeout));
+      await Promise.race([waitPromise, timeoutPromise]);
+      const messages = await this.ctx.session.context({ sessionID: agent.sessionID });
+      const lastAssistantMsg = messages.filter((m) => m.role === "assistant").pop();
+      const output = lastAssistantMsg?.content || "Task completed";
+      const duration = Date.now() - startTime;
+      const result = {
+        success: true,
+        output: typeof output === "string" ? output : JSON.stringify(output),
+        duration,
+        tokensUsed: 0,
+        cost: this.estimateModelCost(agent.model.model)
+      };
+      this.dag.markComplete(node.id, result);
+      agent.metrics.tasksCompleted++;
+      agent.metrics.totalCost += result.cost;
+      this.totalSpent += result.cost;
+      this.costByAgent.set(agent.id, (this.costByAgent.get(agent.id) || 0) + result.cost);
+      this.checkBudget();
+      if (this.notifications?.isEnabled()) {
+        this.notifications.notify({ title: "Nexus: Task Complete", body: `${node.task.name} completed successfully` });
+      }
+      const priorPattern = this.learning.findSolutions(`task ${node.id} failed`);
+      if (priorPattern.length > 0) {
+        this.learning.recordSuccess(priorPattern[0].entry.id);
+      }
+      if (typeof output === "string" && output.length > 0) {
+        const securityIssues = this.securityScanner.scanContent(output, node.task.name);
+        if (securityIssues.length > 0) {
+          this.emit("security:issues-found", {
+            taskId: node.id,
+            taskName: node.task.name,
+            issues: securityIssues,
+            totalIssues: securityIssues.length
+          });
+        }
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const result = {
+        success: false,
+        error: error.message || "Task failed",
+        duration,
         tokensUsed: 0,
         cost: 0
       };
+      this.dag.markFailed(node.id, new Error(result.error));
+      agent.metrics.tasksFailed++;
+      if (this.config.selfHealing.enabled) {
+        await this.handleFailure(agent, node, new Error(result.error));
+      }
+    } finally {
+      agent.status = "idle";
+      node.task.status = node.status === "completed" ? "completed" : "failed";
+      this.notifyStateChange();
+    }
+  }
+  buildRolePrompt(role) {
+    const rolePrompts = {
+      architect: "You are a software architect. Focus on system design, architecture patterns, and high-level technical decisions. Analyze requirements and propose structured solutions.",
+      coder: "You are a senior software engineer. Write clean, efficient, well-documented code. Follow best practices and coding standards.",
+      reviewer: "You are a code reviewer. Review code for correctness, security, performance, and maintainability. Provide constructive feedback.",
+      tester: "You are a QA engineer. Write comprehensive tests, identify edge cases, and ensure code quality.",
+      explorer: "You are a code explorer. Navigate and analyze codebases, understand architecture, and provide detailed reports.",
+      documenter: "You are a technical writer. Create clear, comprehensive documentation for code and APIs."
+    };
+    return rolePrompts[role] || `You are a ${role}. Complete the assigned task professionally.`;
+  }
+  collectContext(agent) {
+    const partialResults = [];
+    const decisions = [];
+    const errorLog = [];
+    if (agent.sessionID && this.ctx) {
+      if (agent.metrics.tasksCompleted > 0) {
+        partialResults.push(`${agent.metrics.tasksCompleted} task(s) completed before failure`);
+      }
+      if (agent.metrics.tasksFailed > 0) {
+        errorLog.push(`${agent.metrics.tasksFailed} task(s) failed`);
+      }
     }
+    const memoryEntries = [];
+    const byAgentId = this.memoryStore.getByAuthor(agent.id);
+    const byRole = this.memoryStore.getByAuthor(agent.role);
+    memoryEntries.push(...byAgentId, ...byRole);
+    const taskProgress = agent.metrics.tasksCompleted > 0 ? Math.min(50, agent.metrics.tasksCompleted * 25) : 0;
+    return {
+      previousAgentId: agent.id,
+      partialResults,
+      decisions,
+      memoryEntries,
+      taskProgress,
+      errorLog
+    };
   }
   async handleFailure(agent, node, error) {
-    const failureCount = agent.metrics.tasksFailed + 1;
-    agent.metrics.tasksFailed++;
-    if (failureCount < this.config.selfHealing.maxRetries) {
-      const delay = this.config.selfHealing.retryDelay * Math.pow(this.config.selfHealing.backoffMultiplier, failureCount - 1);
-      setTimeout(async () => {
-        await this.retryAgent(agent, node);
-      }, delay);
-    } else if (this.config.selfHealing.contextTransfer) {
-      await this.respawnAgent(agent, node);
-    } else {
-      node.status = "failed";
-      node.result = {
-        success: false,
-        error: error.message,
-        duration: 0,
-        tokensUsed: 0,
-        cost: 0
-      };
+    const policy = this.escalationPolicy;
+    const retryCount = this.nodeRetryCounts.get(node.id) || 0;
+    const pattern = error.message || "Unknown error";
+    const solution = `Retry (attempt ${retryCount + 1}/${policy.maxRetries})`;
+    const context = `during ${node.task.requiredRole} task "${node.task.name}"`;
+    this.learning.recordFailure(pattern, solution, context, [node.task.requiredRole]);
+    if (retryCount < policy.maxRetries) {
+      this.nodeRetryCounts.set(node.id, retryCount + 1);
+      const delay = policy.retryDelay * Math.pow(2, retryCount);
+      await this.sleep(delay);
+      node.status = "pending";
+      this.notifyStateChange();
+      await this.spawnAndExecute(node);
+      return;
     }
-  }
-  async retryAgent(agent, node) {
-    agent.status = "working";
-    node.status = "running";
-    this.emit("agent:retry", { agent, node });
-  }
-  async respawnAgent(oldAgent, node) {
-    const newAgent = await this.spawnAgent({
-      role: oldAgent.role,
-      task: node.task,
-      model: oldAgent.model.model
-    });
-    if (this.config.selfHealing.contextTransfer) {
-      await this.transferContext(oldAgent, newAgent);
+    if (policy.enableRespawn && this.config.selfHealing.contextTransfer) {
+      const context = this.collectContext(agent);
+      this.setMemory("session", `context:${agent.id}`, context, agent.id);
+      await this.terminateAgent(agent.id);
+      node.status = "pending";
+      this.notifyStateChange();
+      await this.spawnAndExecute(node, context);
+      return;
     }
-    await this.terminateAgent(oldAgent.id);
-    node.spawnedAgent = newAgent;
-    node.status = "running";
-    this.monitorAgent(newAgent, node);
-  }
-  async transferContext(oldAgent, newAgent) {
-    this.emit("context:transfer", { from: oldAgent, to: newAgent });
+    if (policy.fallbackModels.length > 0) {
+      const fallbackModel = policy.fallbackModels.shift();
+      if (fallbackModel) {
+        await this.terminateAgent(agent.id);
+        node.status = "pending";
+        this.notifyStateChange();
+        await this.spawnAgent({ role: node.task.requiredRole, model: fallbackModel });
+        return;
+      }
+    }
+    if (policy.alertOnFailure) {
+      this.emit("agent:escalation", { agentId: agent.id, taskId: node.id, error: error.message });
+      if (this.notifications?.isEnabled()) {
+        this.notifications.notify({ title: "Nexus: Task Failed", body: `${node.task.name} failed: ${error.message}`, sound: true });
+      }
+    }
+    node.status = "failed";
+    node.result = {
+      success: false,
+      error: error.message,
+      duration: 0,
+      tokensUsed: 0,
+      cost: 0
+    };
+    this.notifyStateChange();
   }
   async spawnAgent(config) {
+    if (!this.ctx) {
+      throw new Error("Orchestrator not initialized");
+    }
+    if (this.budgetExceeded) {
+      throw new Error("Budget exceeded — cannot spawn new agents");
+    }
     const agentId = `agent-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const modelConfig = config.model || this.configManager.getModelForRole(config.role);
+    const slashIndex = modelConfig.indexOf("/");
+    const provider = slashIndex > -1 ? modelConfig.slice(0, slashIndex) : modelConfig;
+    const modelName = slashIndex > -1 ? modelConfig.slice(slashIndex + 1) : modelConfig;
+    const roleEmoji = this.configManager.getRoleEmoji(config.role);
+    const title = `${roleEmoji} ${this.configManager.getRoleDisplayName(config.role)} — ${modelConfig}`;
+    const session = await this.ctx.session.create({
+      title,
+      agent: "build",
+      model: modelName ? { providerID: provider, id: modelName } : undefined
+    });
     const agent = {
       id: agentId,
-      name: `${config.role}-${agentId.slice(0, 8)}`,
+      name: title,
       role: config.role,
-      status: "spawning",
+      status: "idle",
       model: {
-        provider: "opencode",
-        model: config.model || "default",
+        provider,
+        model: modelName || "default",
         estimatedCost: 0,
         estimatedQuality: 0.5,
-        reasoning: "Default selection"
+        reasoning: `Configured for ${config.role}`
       },
       spawnedAt: new Date,
       lastActivity: new Date,
@@ -8800,12 +10308,17 @@ class NexusOrchestrator {
         totalCost: 0,
         averageResponseTime: 0,
         errorRate: 0
-      }
+      },
+      sessionID: session.id
     };
     this.agents.set(agentId, agent);
     this.emit("agent:spawned", agent);
-    await this.sleep(this.config.agents.spawnDelay);
-    agent.status = "idle";
+    this.notifyStateChange();
+    this.enforceAgentLimit();
+    const monitor = this.getOrCreateHealthMonitor();
+    if (!monitor.isActive()) {
+      monitor.start(() => Array.from(this.agents.values()));
+    }
     return agent;
   }
   async terminateAgent(agentId) {
@@ -8814,76 +10327,41 @@ class NexusOrchestrator {
       agent.status = "terminated";
       this.agents.delete(agentId);
       this.emit("agent:terminated", agent);
+      this.notifyStateChange();
+      if (this._healthMonitor && this.agents.size === 0) {
+        this._healthMonitor.stop();
+      }
     }
   }
   analyzeComplexity(task) {
     const fileCount = task.files.include.length;
-    const codeLines = this.estimateCodeLines(task);
+    const codeLines = task.files.include.length * 50;
     const dependencyDepth = task.dependencies.length;
-    const domainKnowledge = this.estimateDomainKnowledge(task);
-    const riskLevel = this.estimateRiskLevel(task);
-    const overall = Math.min(100, fileCount * 10 + codeLines / 10 + dependencyDepth * 15 + domainKnowledge * 20 + (riskLevel === "high" ? 30 : riskLevel === "medium" ? 15 : 0));
-    return {
-      overall,
-      factors: {
-        fileCount,
-        codeLines,
-        dependencyDepth,
-        domainKnowledge,
-        riskLevel
-      }
-    };
-  }
-  estimateCodeLines(task) {
-    return task.files.include.length * 50;
-  }
-  estimateDomainKnowledge(task) {
+    let domainKnowledge = 0;
     const keywords = ["security", "auth", "payment", "crypto", "database"];
-    let score = 0;
     for (const keyword of keywords) {
       if (task.description.toLowerCase().includes(keyword)) {
-        score += 20;
+        domainKnowledge += 20;
       }
     }
-    return Math.min(100, score);
-  }
-  estimateRiskLevel(task) {
+    domainKnowledge = Math.min(100, domainKnowledge);
+    let riskLevel = "low";
     const highRiskKeywords = ["migration", "production", "security", "payment"];
-    const mediumRiskKeywords = ["refactor", "update", "modify"];
     for (const keyword of highRiskKeywords) {
       if (task.description.toLowerCase().includes(keyword)) {
-        return "high";
-      }
-    }
-    for (const keyword of mediumRiskKeywords) {
-      if (task.description.toLowerCase().includes(keyword)) {
-        return "medium";
+        riskLevel = "high";
+        break;
       }
     }
-    return "low";
-  }
-  selectModel(role, complexity) {
-    const configModel = this.configManager.getModelForRole(role);
-    const [provider, ...modelParts] = configModel.split("/");
-    const model = modelParts.join("/");
-    const budgetRemaining = this.budget.maxTotalCost - this.totalSpent;
-    if (budgetRemaining < 1 && configModel !== "opencode/minimax-m2.5-free") {
-      return {
-        provider: "opencode",
-        model: "minimax-m2.5-free",
-        estimatedCost: 0,
-        estimatedQuality: 0.5,
-        reasoning: "Budget constrained, using free tier"
-      };
-    }
+    const overall = Math.min(100, fileCount * 10 + codeLines / 10 + dependencyDepth * 15 + domainKnowledge * 20 + (riskLevel === "high" ? 30 : riskLevel === "medium" ? 15 : 0));
     return {
-      provider,
-      model,
-      estimatedCost: this.estimateModelCost(model),
-      estimatedQuality: this.estimateModelQuality(model),
-      reasoning: `Configured model for ${role}`
+      overall,
+      factors: { fileCount, codeLines, dependencyDepth, domainKnowledge, riskLevel }
     };
   }
+  selectModel(role, complexity) {
+    return this.selectBestModel(role, complexity);
+  }
   estimateModelCost(model) {
     const costs = {
       "claude-sonnet-4-6": 0.15,
@@ -8908,21 +10386,86 @@ class NexusOrchestrator {
     };
     return quality[model] || 0.6;
   }
+  estimateModelSpeed(model) {
+    const speeds = {
+      "claude-opus-4-7": 0.4,
+      "claude-sonnet-4-6": 0.7,
+      "gpt-5": 0.6,
+      "claude-haiku-4-5": 0.9,
+      "gemini-2.5-flash": 0.95,
+      "gpt-5-mini": 0.85,
+      "minimax-m2.5-free": 0.8
+    };
+    return speeds[model] || 0.5;
+  }
+  scoreModel(modelId, role, complexity) {
+    const [provider, ...parts] = modelId.split("/");
+    const model = parts.join("/");
+    const cost = this.estimateModelCost(model);
+    const quality = this.estimateModelQuality(model);
+    const maxCost = 15;
+    const costScore = 1 - cost / maxCost;
+    const speedScore = this.estimateModelSpeed(model);
+    const qualityWeight = complexity.overall > 70 ? 0.6 : complexity.overall > 40 ? 0.4 : 0.2;
+    const costWeight = 1 - qualityWeight;
+    const overallScore = quality * qualityWeight + costScore * costWeight;
+    return {
+      model,
+      provider,
+      costScore,
+      qualityScore: quality,
+      speedScore,
+      overallScore,
+      reasoning: `Score: ${overallScore.toFixed(2)} (quality: ${quality.toFixed(2)}, cost: ${costScore.toFixed(2)}, speed: ${speedScore.toFixed(2)})`
+    };
+  }
+  selectBestModel(role, complexity) {
+    const configModel = this.configManager.getModelForRole(role);
+    const candidates = [
+      configModel,
+      "anthropic/claude-sonnet-4-6",
+      "anthropic/claude-haiku-4-5",
+      "openai/gpt-5-mini",
+      "google/gemini-2.5-flash",
+      "opencode/minimax-m2.5-free"
+    ];
+    const unique = [...new Set(candidates)];
+    const scored = unique.map((m) => this.scoreModel(m, role, complexity));
+    const budgetRemaining = this.budget.maxTotalCost - this.totalSpent;
+    const affordable = scored.filter((s) => {
+      const cost = this.estimateModelCost(s.model);
+      return cost <= budgetRemaining || cost === 0;
+    });
+    const best = (affordable.length > 0 ? affordable : scored).sort((a, b) => b.overallScore - a.overallScore)[0];
+    return {
+      provider: best.provider,
+      model: best.model,
+      estimatedCost: this.estimateModelCost(best.model),
+      estimatedQuality: best.qualityScore,
+      reasoning: best.reasoning
+    };
+  }
   trackCost(agentId, model, cost, tokens) {
     this.totalSpent += cost;
     const agentCost = this.costByAgent.get(agentId) || 0;
     this.costByAgent.set(agentId, agentCost + cost);
     const modelCost = this.costByModel.get(model) || 0;
     this.costByModel.set(model, modelCost + cost);
+    this.costHistory.push({ timestamp: Date.now(), cost, agentId });
     this.checkBudget();
+    this.notifyStateChange();
   }
   checkBudget() {
     const remaining = this.budget.maxTotalCost - this.totalSpent;
     const remainingPercent = remaining / this.budget.maxTotalCost;
     if (remainingPercent <= this.config.budget.alertThreshold) {
       this.emit("budget:alert", { remaining, remainingPercent });
+      if (this.notifications?.isEnabled()) {
+        this.notifications.notify({ title: "Nexus: Budget Alert", body: `Budget low: $${remaining.toFixed(2)} remaining (${(remainingPercent * 100).toFixed(1)}%)`, sound: true });
+      }
     }
-    if (this.budget.hardLimit && remaining <= 0) {
+    if (this.budget.hardLimit && remaining <= 0 && !this.budgetExceeded) {
+      this.budgetExceeded = true;
       this.emit("budget:exceeded", { totalSpent: this.totalSpent });
       this.pause();
     }
@@ -8930,12 +10473,15 @@ class NexusOrchestrator {
   publish(topic, message) {
     const fullMessage = {
       ...message,
+      topic: message.topic ?? topic,
       id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
       timestamp: new Date
     };
     this.messageQueue.push(fullMessage);
+    this.messageStore.add(fullMessage);
     const handlers = this.subscribers.get(topic) || [];
     handlers.forEach((handler) => handler(fullMessage));
+    this.messageRouter.route(fullMessage);
   }
   subscribe(topic, handler) {
     const handlers = this.subscribers.get(topic) || [];
@@ -8943,130 +10489,128 @@ class NexusOrchestrator {
     this.subscribers.set(topic, handlers);
     return () => {
       const idx = handlers.indexOf(handler);
-      if (idx > -1) {
+      if (idx > -1)
         handlers.splice(idx, 1);
-      }
-    };
-  }
-  send(agentId, message) {
-    const fullMessage = {
-      ...message,
-      id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      to: agentId,
-      timestamp: new Date
     };
-    this.messageQueue.push(fullMessage);
-    this.emit("message:sent", fullMessage);
   }
   setMemory(scope, key, value, author) {
-    const entry = {
-      id: `mem-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+    const entry = this.memoryStore.set({
       key,
       value,
       scope,
       author,
-      timestamp: new Date,
       confidence: 1,
       tags: []
-    };
-    this.memory.set(`${scope}:${key}`, entry);
+    });
     this.emit("memory:set", entry);
   }
   getMemory(scope, key) {
-    return this.memory.get(`${scope}:${key}`);
-  }
-  searchMemory(query, scope) {
-    const results = [];
-    this.memory.forEach((entry) => {
-      if (scope && entry.scope !== scope)
-        return;
-      if (entry.key.includes(query) || JSON.stringify(entry.value).includes(query)) {
-        results.push(entry);
-      }
-    });
-    return results;
+    return this.memoryStore.get(key, scope) ?? undefined;
   }
   getStatus(detailed) {
-    const status = {
-      running: this.running,
-      paused: this.paused,
-      agents: this.agents.size,
-      tasks: this.tasks.size,
-      totalCost: this.totalSpent,
-      budgetRemaining: this.budget.maxTotalCost - this.totalSpent
-    };
-    if (detailed) {
-      return JSON.stringify({
-        ...status,
-        agentsByStatus: this.getAgentsByStatus(),
-        costByAgent: Object.fromEntries(this.costByAgent),
-        costByModel: Object.fromEntries(this.costByModel)
-      }, null, 2);
-    }
-    return JSON.stringify(status, null, 2);
+    const state = this.getState();
+    if (detailed)
+      return JSON.stringify({ ...state, budgetExceeded: this.budgetExceeded }, null, 2);
+    return JSON.stringify({
+      running: state.running,
+      paused: state.paused,
+      budgetExceeded: this.budgetExceeded,
+      agents: state.agents.length,
+      tasks: state.tasks.length,
+      totalCost: state.totalSpent,
+      budgetRemaining: state.budgetRemaining
+    }, null, 2);
   }
   listAgents(filter) {
-    const agents = Array.from(this.agents.values());
-    const filtered = filter ? agents.filter((a) => a.status === filter) : agents;
+    const state = this.getState();
+    const filtered = filter ? state.agents.filter((a) => a.status === filter) : state.agents;
     return JSON.stringify(filtered, null, 2);
   }
   getCostReport() {
-    const report = {
-      totalSpent: this.totalSpent,
-      budgetRemaining: this.budget.maxTotalCost - this.totalSpent,
-      byAgent: new Map,
-      byModel: new Map,
-      timeline: []
-    };
-    this.agents.forEach((agent) => {
-      report.byAgent.set(agent.id, {
-        agentId: agent.id,
-        agentName: agent.name,
-        totalCost: agent.metrics.totalCost,
-        tokenCount: agent.metrics.totalTokens,
-        taskCount: agent.metrics.tasksCompleted
-      });
-    });
+    const state = this.getState();
     return JSON.stringify({
-      ...report,
-      byAgent: Object.fromEntries(report.byAgent),
-      byModel: Object.fromEntries(report.byModel)
+      totalSpent: state.totalSpent,
+      budgetRemaining: state.budgetRemaining,
+      byAgent: Object.fromEntries(this.costByAgent),
+      byModel: Object.fromEntries(this.costByModel)
     }, null, 2);
   }
   pause() {
     this.paused = true;
     this.emit("orchestrator:paused", {});
+    this.notifyStateChange();
   }
   resume() {
     this.paused = false;
     this.emit("orchestrator:resumed", {});
+    this.notifyStateChange();
   }
-  shutdown() {
+  isBudgetExceeded() {
+    return this.budgetExceeded;
+  }
+  resetBudgetExceeded() {
+    this.budgetExceeded = false;
+  }
+  async shutdown() {
+    await this.moduleRegistry.teardownAll();
+    this._healthMonitor?.stop();
+    this.stopDashboard();
+    this.memoryStore.close();
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    if (this.stateChangeTimer) {
+      clearTimeout(this.stateChangeTimer);
+      this.stateChangeTimer = null;
+    }
     this.agents.forEach((agent) => {
       agent.status = "terminated";
     });
     this.agents.clear();
     this.running = false;
     this.emit("orchestrator:shutdown", {});
+    this.onStateChange?.();
+  }
+  cleanupStaleData() {
+    const now = Date.now();
+    for (const [id, agent] of this.agents) {
+      if (agent.status === "terminated" && now - agent.lastActivity.getTime() > 3600000) {
+        this.agents.delete(id);
+      }
+    }
+    if (this.costHistory.length > 1000) {
+      this.costHistory = this.costHistory.slice(-500);
+    }
+  }
+  enforceAgentLimit() {
+    const MAX_AGENTS = this.config.maxConcurrency || 10;
+    if (this.agents.size > MAX_AGENTS) {
+      const terminated = [...this.agents.entries()].filter(([_, a]) => a.status === "terminated").sort((a, b) => a[1].lastActivity.getTime() - b[1].lastActivity.getTime());
+      const toRemove = terminated.slice(0, this.agents.size - MAX_AGENTS);
+      for (const [id] of toRemove) {
+        this.agents.delete(id);
+      }
+    }
+  }
+  getOrCreateHealthMonitor() {
+    if (!this._healthMonitor) {
+      this._healthMonitor = new HealthMonitor({
+        checkInterval: this.config.agents.healthCheckInterval
+      });
+    }
+    return this._healthMonitor;
   }
   collectResults() {
     const results = [];
     if (this.dag) {
       this.dag.nodes.forEach((node) => {
-        if (node.result) {
+        if (node.result)
           results.push(node.result);
-        }
       });
     }
     return results;
   }
-  getAgentsByStatus() {
-    const counts = {};
-    this.agents.forEach((agent) => {
-      counts[agent.status] = (counts[agent.status] || 0) + 1;
-    });
-    return counts;
-  }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -9076,9 +10620,8 @@ class NexusOrchestrator {
     this.eventHandlers.set(event, handlers);
     return () => {
       const idx = handlers.indexOf(handler);
-      if (idx > -1) {
+      if (idx > -1)
         handlers.splice(idx, 1);
-      }
     };
   }
   emit(event, data) {
@@ -9090,31 +10633,113 @@ class NexusOrchestrator {
     const command = parts[1];
     switch (command) {
       case "status":
-        console.log(this.getStatus(true));
-        break;
+        return this.getStatus(true);
       case "agents":
-        console.log(this.listAgents(parts[2]));
-        break;
+        return this.listAgents(parts[2]);
       case "costs":
-        console.log(this.getCostReport());
-        break;
+        return this.getCostReport();
       case "pause":
         this.pause();
-        break;
+        return "Orchestrator paused";
       case "resume":
         this.resume();
-        break;
+        return "Orchestrator resumed";
+      case "dashboard":
+        return JSON.stringify(this.getState(), null, 2);
       default:
-        console.log("Unknown command. Use /nexus help");
+        return "Unknown command. Available: status, agents, costs, pause, resume, dashboard";
     }
   }
 }
 
+// src/templates.ts
+var TEMPLATES = {
+  feature: {
+    name: "Feature Development",
+    description: "Full feature pipeline: architect → coder → reviewer → tester",
+    steps: [
+      { role: "architect", name: "Design", description: "Design the feature architecture and API", files: { include: ["**/*.ts"], exclude: ["node_modules"] } },
+      { role: "coder", name: "Implement", description: "Implement the feature according to design", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "reviewer", name: "Review", description: "Code review for quality, security, and correctness", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "tester", name: "Test", description: "Write and run tests for the feature", files: { include: ["test/**/*.ts"], exclude: ["node_modules"] } }
+    ]
+  },
+  bugfix: {
+    name: "Bug Fix",
+    description: "Bug investigation and fix: explorer → coder → reviewer",
+    steps: [
+      { role: "explorer", name: "Investigate", description: "Investigate the bug root cause", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "coder", name: "Fix", description: "Implement the bug fix", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "reviewer", name: "Review", description: "Review the fix for correctness", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } }
+    ]
+  },
+  refactor: {
+    name: "Refactoring",
+    description: "Code refactoring: architect → coder → reviewer → tester",
+    steps: [
+      { role: "architect", name: "Plan", description: "Plan the refactoring approach", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "coder", name: "Refactor", description: "Execute the refactoring", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "reviewer", name: "Review", description: "Review refactored code", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "tester", name: "Verify", description: "Run existing tests to ensure no regressions", files: { include: ["test/**/*.ts"], exclude: ["node_modules"] } }
+    ]
+  },
+  documentation: {
+    name: "Documentation",
+    description: "Documentation update: explorer → documenter → reviewer",
+    steps: [
+      { role: "explorer", name: "Analyze", description: "Analyze codebase to understand what needs documentation", files: { include: ["src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "documenter", name: "Write", description: "Write documentation", files: { include: ["**/*.md", "src/**/*.ts"], exclude: ["node_modules"] } },
+      { role: "reviewer", name: "Review", description: "Review documentation for accuracy", files: { include: ["**/*.md"], exclude: ["node_modules"] } }
+    ]
+  }
+};
+var DEFAULT_COMPLEXITY = {
+  overall: 50,
+  factors: {
+    fileCount: 1,
+    codeLines: 100,
+    dependencyDepth: 1,
+    domainKnowledge: 1,
+    riskLevel: "medium"
+  }
+};
+function instantiateTemplate(templateName, baseDir) {
+  const template = TEMPLATES[templateName];
+  if (!template)
+    throw new Error(`Unknown template: ${templateName}. Available: ${Object.keys(TEMPLATES).join(", ")}`);
+  return template.steps.map((step, index) => ({
+    id: `${templateName}-${index + 1}-${step.role}`,
+    name: `${template.name}: ${step.name}`,
+    description: step.description,
+    requiredRole: step.role,
+    complexity: { ...DEFAULT_COMPLEXITY },
+    files: {
+      include: step.files.include.map((f) => f.startsWith("/") ? f : `${baseDir}/${f}`),
+      exclude: step.files.exclude
+    },
+    dependencies: index > 0 ? [`${templateName}-${index}-${template.steps[index - 1].role}`] : [],
+    timeout: step.timeout,
+    status: "pending",
+    priority: "normal"
+  }));
+}
+function listTemplates() {
+  return Object.keys(TEMPLATES);
+}
+function getTemplate(name) {
+  return TEMPLATES[name];
+}
+
 // src/index.ts
 var src_default = define({
   id: "nexus",
   async setup(ctx) {
     const orchestrator = new NexusOrchestrator;
+    await orchestrator.initialize(ctx, () => {
+      const state = orchestrator.getState();
+      ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(state))).catch(() => {});
+    });
+    await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
     await ctx.tool.transform((editor) => {
       editor.namespace({
         name: "nexus",
@@ -9132,7 +10757,9 @@ var src_default = define({
         },
         execute: async (input) => {
           const { detailed } = input;
-          return { content: orchestrator.getStatus(detailed) };
+          const status = orchestrator.getStatus(detailed);
+          await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+          return { content: status };
         }
       });
       editor.add({
@@ -9162,10 +10789,231 @@ var src_default = define({
           return { content: orchestrator.getCostReport() };
         }
       });
+      editor.add({
+        name: "dashboard",
+        description: "Get full orchestrator state for dashboard display",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const state = orchestrator.getState();
+          await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(state)));
+          return { content: JSON.stringify(state, null, 2) };
+        }
+      });
+      editor.add({
+        name: "queue",
+        description: "Show current task queue with priorities",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const state = orchestrator.getState();
+          const tasks = state.tasks || [];
+          return { content: JSON.stringify(tasks, null, 2) };
+        }
+      });
+      editor.add({
+        name: "config.save",
+        description: "Save Nexus config to disk (project or global)",
+        input: {
+          type: "object",
+          properties: {
+            level: { type: "string", enum: ["project", "global"], description: "Config level to save" },
+            basePath: { type: "string", description: "Project root (for project-level, defaults to cwd)" }
+          },
+          required: ["level"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { level, basePath } = input;
+          orchestrator.configManager.saveConfig(level, basePath || process.cwd());
+          const location = level === "project" ? `${basePath || process.cwd()}/.opencode/nexus.jsonc` : "~/.config/opencode/nexus.jsonc";
+          return { content: `Config saved to ${level} level at ${location}` };
+        }
+      });
+      editor.add({
+        name: "config.init",
+        description: "Initialize default config files for project and/or global",
+        input: {
+          type: "object",
+          properties: {
+            level: { type: "string", enum: ["project", "global", "both"], description: "Which config to initialize" },
+            basePath: { type: "string", description: "Project root" }
+          },
+          required: ["level"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { level, basePath } = input;
+          const path = basePath || process.cwd();
+          const locations = [];
+          if (level === "project" || level === "both") {
+            orchestrator.configManager.saveProjectConfig(path);
+            locations.push(`${path}/.opencode/nexus.jsonc`);
+          }
+          if (level === "global" || level === "both") {
+            orchestrator.configManager.saveGlobalConfig();
+            locations.push("~/.config/opencode/nexus.jsonc");
+          }
+          return { content: `Config initialized at ${level} level(s): ${locations.join(", ")}` };
+        }
+      });
+      editor.add({
+        name: "preset",
+        description: "Apply a preset configuration",
+        input: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Preset name (minimal, balanced, enterprise, cost-optimized)" }
+          },
+          required: ["name"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { name } = input;
+          try {
+            orchestrator.configManager.applyPreset(name);
+            return { content: `Applied preset: ${PRESETS[name]?.name || name}` };
+          } catch (error) {
+            return { content: `Error: ${error.message}` };
+          }
+        }
+      });
+      editor.add({
+        name: "dashboard.start",
+        description: "Start the web dashboard server",
+        input: {
+          type: "object",
+          properties: {
+            port: { type: "number", description: "Port (default: 4747)" },
+            host: { type: "string", description: "Host (default: 127.0.0.1)" }
+          },
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { port, host } = input;
+          orchestrator.startDashboard(port, host);
+          return { content: `Dashboard started at http://${host || "127.0.0.1"}:${port || 4747}` };
+        }
+      });
+      editor.add({
+        name: "dashboard.stop",
+        description: "Stop the web dashboard server",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          orchestrator.stopDashboard();
+          return { content: "Dashboard stopped" };
+        }
+      });
+      editor.add({
+        name: "spawn",
+        description: "Spawn a sub-agent for a task",
+        input: {
+          type: "object",
+          properties: {
+            role: { type: "string", description: "Agent role (architect, coder, reviewer, tester, explorer, documenter)" },
+            task: { type: "string", description: "Task description" },
+            model: { type: "string", description: "Model override (optional)" }
+          },
+          required: ["role", "task"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { role, task, model } = input;
+          try {
+            const agent = await orchestrator.spawnAgent({ role, model });
+            await orchestrator.ctx.session.prompt({
+              sessionID: agent.sessionID,
+              text: task
+            });
+            const complexity = orchestrator.analyzeComplexity({
+              id: `spawn-${Date.now()}`,
+              name: task,
+              description: task,
+              files: { include: [] },
+              dependencies: [],
+              requiredRole: role,
+              complexity: { overall: 0, factors: { fileCount: 0, codeLines: 0, dependencyDepth: 0, domainKnowledge: 0, riskLevel: "low" } },
+              priority: "normal",
+              status: "running"
+            });
+            agent.complexity = complexity;
+            const modelSelection = orchestrator.selectModel(role, complexity);
+            await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+            const taskPreview = task.length > 80 ? task.substring(0, 77) + "..." : task;
+            const output = [
+              `${agent.name}`,
+              `\uD83D\uDCCB Task: ${taskPreview}`,
+              `\uD83D\uDCCA Complexity: ${complexity.overall}/100 (${complexity.factors.riskLevel} risk)`,
+              `\uD83E\uDD16 Model reasoning: ${modelSelection.reasoning}`,
+              `\uD83D\uDCCE Session: ${agent.sessionID}`
+            ].join(`
+`);
+            return { content: output };
+          } catch (error) {
+            return { content: `Failed to spawn agent: ${error.message}` };
+          }
+        }
+      });
+      editor.add({
+        name: "template",
+        description: "List or instantiate task templates",
+        input: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Template name to instantiate (or 'list' to show all)" },
+            baseDir: { type: "string", description: "Base directory for file paths" }
+          },
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { name, baseDir } = input;
+          if (!name || name === "list") {
+            const templates = listTemplates();
+            return { content: templates.map((t) => `${t}: ${TEMPLATES[t].description}`).join(`
+`) };
+          }
+          try {
+            const tasks = instantiateTemplate(name, baseDir || process.cwd());
+            return { content: JSON.stringify(tasks, null, 2) };
+          } catch (error) {
+            return { content: `Error: ${error.message}` };
+          }
+        }
+      });
+      editor.add({
+        name: "security.scan",
+        description: "Scan content for security issues",
+        input: {
+          type: "object",
+          properties: {
+            content: { type: "string", description: "Code content to scan" },
+            filename: { type: "string", description: "Filename for context" }
+          },
+          required: ["content"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { content, filename } = input;
+          const issues = orchestrator.securityScanner.scanContent(content, filename || "unknown");
+          const result = orchestrator.securityScanner.getResult();
+          return { content: JSON.stringify({ issues: issues.length, score: result.score, details: issues }, null, 2) };
+        }
+      });
     });
     await ctx.session.hook("prompt", (event) => {
-      if (event.prompt.text.includes("/nexus")) {
-        orchestrator.handleCommand(event.prompt.text);
+      if (event.prompt.text.startsWith("/nexus")) {
+        const result = orchestrator.handleCommand(event.prompt.text);
+        event.metadata = { ...event.metadata, nexusResult: result };
       }
     });
     return () => {
@@ -9175,7 +11023,21 @@ var src_default = define({
 });
 export {
   DEFAULT_CONFIG,
+  HealthMonitor,
+  LearningModule,
+  MessageRouter,
+  MessageStore,
+  ModuleRegistry,
   NexusConfigManager,
   NexusOrchestrator,
-  src_default as default
+  PRESETS,
+  PersistentMemoryStore,
+  SecurityScanner,
+  StateBroadcaster,
+  TEMPLATES,
+  src_default as default,
+  detectCycles,
+  getTemplate,
+  instantiateTemplate,
+  listTemplates
 };