@serkanalgur/opencode-nexus 1.7.0 → 1.8.1

package/dist/index.js

@@ -9962,6 +9962,116 @@ class WorktreeManager {
   }
 }
 
+// src/todo.ts
+class TodoEnforcer {
+  items = new Map;
+  maxItems;
+  constructor(maxItems = 50) {
+    this.maxItems = maxItems;
+  }
+  add(description, assignedTo) {
+    if (this.items.size >= this.maxItems) {
+      const completedItems = [...this.items.values()].filter((i) => i.status === "completed").sort((a, b) => (a.completedAt?.getTime() || 0) - (b.completedAt?.getTime() || 0));
+      if (completedItems.length > 0) {
+        this.items.delete(completedItems[0].id);
+      } else {
+        const oldestPending = [...this.items.values()].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+        if (oldestPending.length > 0) {
+          this.items.delete(oldestPending[0].id);
+        }
+      }
+    }
+    const item = {
+      id: `todo-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`,
+      description,
+      status: "pending",
+      assignedTo,
+      createdAt: new Date
+    };
+    this.items.set(item.id, item);
+    return item;
+  }
+  start(id) {
+    const item = this.items.get(id);
+    if (item)
+      item.status = "in_progress";
+  }
+  complete(id) {
+    const item = this.items.get(id);
+    if (item) {
+      item.status = "completed";
+      item.completedAt = new Date;
+    }
+  }
+  block(id) {
+    const item = this.items.get(id);
+    if (item)
+      item.status = "blocked";
+  }
+  get(id) {
+    return this.items.get(id);
+  }
+  getPending() {
+    return [...this.items.values()].filter((i) => i.status === "pending");
+  }
+  getInProgress() {
+    return [...this.items.values()].filter((i) => i.status === "in_progress");
+  }
+  getCompleted() {
+    return [...this.items.values()].filter((i) => i.status === "completed");
+  }
+  getAll() {
+    return [...this.items.values()];
+  }
+  getStats() {
+    const all = [...this.items.values()];
+    return {
+      total: all.length,
+      pending: all.filter((i) => i.status === "pending").length,
+      inProgress: all.filter((i) => i.status === "in_progress").length,
+      completed: all.filter((i) => i.status === "completed").length,
+      blocked: all.filter((i) => i.status === "blocked").length
+    };
+  }
+  clear() {
+    this.items.clear();
+  }
+  trackTask(taskId, description, role) {
+    return this.add(`[Task: ${taskId}] ${description}`, role);
+  }
+  completeTask(taskId) {
+    for (const item of this.items.values()) {
+      if (item.description.startsWith(`[Task: ${taskId}]`)) {
+        this.complete(item.id);
+        break;
+      }
+    }
+  }
+  formatAll() {
+    const all = this.getAll();
+    if (all.length === 0)
+      return "\uD83D\uDCCB No todo items.";
+    const statusIcon = {
+      pending: "⏳",
+      in_progress: "\uD83D\uDD04",
+      completed: "✅",
+      blocked: "\uD83D\uDEAB"
+    };
+    const lines = all.map((item) => {
+      const icon = statusIcon[item.status] || "❓";
+      const assigned = item.assignedTo ? ` (${item.assignedTo})` : "";
+      const time = item.completedAt ? `completed ${item.completedAt.toISOString()}` : `created ${item.createdAt.toISOString()}`;
+      return `  ${icon} ${item.id}: ${item.description}${assigned} — ${time}`;
+    });
+    const stats = this.getStats();
+    const summary = `\uD83D\uDCCB Todo: ${stats.total} total | ⏳ ${stats.pending} pending | \uD83D\uDD04 ${stats.inProgress} in progress | ✅ ${stats.completed} completed | \uD83D\uDEAB ${stats.blocked} blocked`;
+    return `${summary}
+
+${lines.join(`
+`)}`;
+  }
+}
+
 // src/orchestrator.ts
 var DEFAULT_ESCALATION = {
   maxRetries: 3,
@@ -10004,6 +10114,7 @@ class NexusOrchestrator {
   customRoles;
   forecaster;
   worktreeManager = null;
+  todoEnforcer = new TodoEnforcer;
   onStateChange = null;
   stateChangeTimer = null;
   costHistory = [];
@@ -10451,6 +10562,7 @@ Please continue from where the previous agent left off.`;
         cost: this.estimateModelCost(agent.model.model)
       };
       this.dag.markComplete(node.id, result);
+      this.todoEnforcer.completeTask(agent.id);
       agent.metrics.tasksCompleted++;
       agent.metrics.totalCost += result.cost;
       this.totalSpent += result.cost;
@@ -10496,15 +10608,28 @@ Please continue from where the previous agent left off.`;
       }
     } catch (error) {
       const duration = Date.now() - startTime;
+      const errorMessage = error.message || "Task failed";
       const result = {
         success: false,
-        error: error.message || "Task failed",
+        error: errorMessage,
         duration,
         tokensUsed: 0,
         cost: 0
       };
-      this.dag.markFailed(node.id, new Error(result.error));
+      this.dag.markFailed(node.id, new Error(errorMessage));
+      this.todoEnforcer.completeTask(agent.id);
       agent.metrics.tasksFailed++;
+      agent.status = "failed";
+      this.emit("task:failed", {
+        taskId: node.id,
+        taskName: node.task.name,
+        agentId: agent.id,
+        role: node.task.requiredRole,
+        model: agent.model.model,
+        error: errorMessage,
+        duration,
+        sessionID: agent.sessionID
+      });
       this.performanceTracker.record({
         model: agent.model.model,
         role: node.task.requiredRole,
@@ -10524,13 +10649,18 @@ Please continue from where the previous agent left off.`;
         tokensUsed: result.tokensUsed,
         startedAt: new Date(startTime),
         completedAt: new Date,
-        error: result.error
+        error: errorMessage
       });
+      if (this.notifications?.isEnabled()) {
+        this.notifications.notify({ title: "Nexus: Task Failed", body: `${node.task.name} failed: ${errorMessage}`, sound: true });
+      }
       if (this.config.selfHealing.enabled) {
-        await this.handleFailure(agent, node, new Error(result.error));
+        await this.handleFailure(agent, node, new Error(errorMessage));
       }
     } finally {
-      agent.status = "idle";
+      if (agent.status !== "terminated" && agent.status !== "failed") {
+        agent.status = "idle";
+      }
       node.task.status = node.status === "completed" ? "completed" : "failed";
       this.notifyStateChange();
     }
@@ -10653,7 +10783,13 @@ Please continue from where the previous agent left off.`;
       title,
       agent: agentType,
       model: modelName ? { providerID: provider, id: modelName } : undefined,
-      parentID: this.parentSessionID || undefined
+      parentID: this.parentSessionID || undefined,
+      metadata: {
+        nexusRole: config.role,
+        nexusTask: config.task?.name || "direct-spawn",
+        nexusAgentId: agentId,
+        nexusModel: modelConfig
+      }
     });
     const agent = {
       id: agentId,
@@ -10680,6 +10816,8 @@ Please continue from where the previous agent left off.`;
       sessionID: session.id
     };
     this.agents.set(agentId, agent);
+    const taskDesc = config.task?.name || `Agent ${config.role} task`;
+    this.todoEnforcer.trackTask(agentId, taskDesc, config.role);
     this.emit("agent:spawned", agent);
     this.notifyStateChange();
     this.enforceAgentLimit();
@@ -11102,6 +11240,203 @@ function getTemplate(name) {
   return TEMPLATES[name];
 }
 
+// src/goal.ts
+var goalCounter = 0;
+
+class GoalManager {
+  goals = new Map;
+  activeGoalId = null;
+  set(description, autoContinue = true) {
+    if (this.activeGoalId) {
+      const prev = this.goals.get(this.activeGoalId);
+      if (prev && prev.status === "active") {
+        prev.status = "completed";
+        prev.completedAt = new Date;
+      }
+    }
+    const goal = {
+      id: `goal-${Date.now()}-${++goalCounter}`,
+      description,
+      status: "active",
+      tasks: [],
+      createdAt: new Date,
+      autoContinue
+    };
+    this.goals.set(goal.id, goal);
+    this.activeGoalId = goal.id;
+    return goal;
+  }
+  addTask(goalId, taskId) {
+    const goal = this.goals.get(goalId);
+    if (goal)
+      goal.tasks.push(taskId);
+  }
+  complete(goalId) {
+    const goal = this.goals.get(goalId);
+    if (goal) {
+      goal.status = "completed";
+      goal.completedAt = new Date;
+      if (this.activeGoalId === goalId) {
+        this.activeGoalId = null;
+      }
+    }
+  }
+  pause(goalId) {
+    const goal = this.goals.get(goalId);
+    if (goal)
+      goal.status = "paused";
+  }
+  resume(goalId) {
+    const goal = this.goals.get(goalId);
+    if (goal)
+      goal.status = "active";
+  }
+  getActive() {
+    if (!this.activeGoalId)
+      return null;
+    const goal = this.goals.get(this.activeGoalId);
+    if (!goal || goal.status !== "active")
+      return null;
+    return goal;
+  }
+  getAll() {
+    return [...this.goals.values()];
+  }
+  shouldContinue() {
+    const active = this.getActive();
+    return active?.autoContinue === true && active.status === "active";
+  }
+  get(goalId) {
+    return this.goals.get(goalId);
+  }
+}
+
+// src/team.ts
+class TeamManager {
+  teams = new Map;
+  teamCounter = 0;
+  memberCounter = 0;
+  create(name, leadRole) {
+    this.teamCounter++;
+    const team = {
+      id: `team-${Date.now()}-${this.teamCounter}`,
+      name,
+      lead: leadRole,
+      members: [],
+      status: "forming",
+      createdAt: new Date
+    };
+    this.teams.set(team.id, team);
+    return team;
+  }
+  addMember(teamId, role, model) {
+    const team = this.teams.get(teamId);
+    if (!team)
+      return null;
+    this.memberCounter++;
+    const member = {
+      id: `member-${Date.now()}-${this.memberCounter}`,
+      role,
+      status: "idle",
+      model
+    };
+    team.members.push(member);
+    return member;
+  }
+  activate(teamId) {
+    const team = this.teams.get(teamId);
+    if (team)
+      team.status = "active";
+  }
+  complete(teamId) {
+    const team = this.teams.get(teamId);
+    if (team)
+      team.status = "completed";
+  }
+  get(teamId) {
+    return this.teams.get(teamId);
+  }
+  getAll() {
+    return [...this.teams.values()];
+  }
+  getActive() {
+    return [...this.teams.values()].find((t) => t.status === "active") || null;
+  }
+}
+
+// src/astgrep.ts
+import { execSync as execSync2 } from "node:child_process";
+
+class AstGrep {
+  _available = null;
+  search(pattern, language, directory) {
+    if (!this.isAvailable()) {
+      return [];
+    }
+    try {
+      const cmd = `sg run --pattern "${pattern}" --lang ${language} --json ${directory}`;
+      const output = execSync2(cmd, { encoding: "utf-8", timeout: 30000 });
+      const results = JSON.parse(output);
+      if (!Array.isArray(results))
+        return [];
+      return results.map((r) => ({
+        file: r.file?.path || r.file || "",
+        line: r.range?.start?.line || 0,
+        column: r.range?.start?.column || 0,
+        match: r.text || r.source || ""
+      }));
+    } catch {
+      return [];
+    }
+  }
+  rewrite(pattern, rewrite, language, directory) {
+    if (!this.isAvailable()) {
+      return { count: 0, results: [] };
+    }
+    try {
+      const cmd = `sg run --pattern "${pattern}" --rewrite "${rewrite}" --lang ${language} --json ${directory}`;
+      const output = execSync2(cmd, { encoding: "utf-8", timeout: 30000 });
+      const results = JSON.parse(output);
+      if (!Array.isArray(results)) {
+        return { count: 0, results: [] };
+      }
+      const mapped = results.map((r) => ({
+        file: r.file?.path || r.file || "",
+        line: r.range?.start?.line || 0,
+        column: r.range?.start?.column || 0,
+        match: r.text || r.source || "",
+        replacement: r.replacement || undefined
+      }));
+      return { count: mapped.length, results: mapped };
+    } catch {
+      return { count: 0, results: [] };
+    }
+  }
+  isAvailable() {
+    if (this._available !== null)
+      return this._available;
+    try {
+      execSync2("sg --version", { encoding: "utf-8", timeout: 5000 });
+      this._available = true;
+    } catch {
+      this._available = false;
+    }
+    return this._available;
+  }
+  status() {
+    const available = this.isAvailable();
+    if (available) {
+      try {
+        const version = execSync2("sg --version", { encoding: "utf-8", timeout: 5000 }).trim();
+        return `✅ ast-grep is installed (${version})`;
+      } catch {
+        return "✅ ast-grep is installed";
+      }
+    }
+    return "❌ ast-grep is not installed. Install with: brew install ast-grep";
+  }
+}
+
 // src/index.ts
 import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3 } from "node:fs";
 import { join as join6 } from "node:path";
@@ -11113,18 +11448,28 @@ mode: primary
 
 # Nexus Orchestrator Agent
 
-You are the Nexus Orchestrator — an intelligent multi-agent coordinator. You manage parallel sub-agents with cost-aware model selection, self-healing on failures, and DAG-based task execution.
+You are the Nexus Orchestrator — an intelligent multi-agent coordinator with cost awareness, performance tracking, and security scanning. You manage parallel sub-agents through a disciplined 5-phase execution model, routing tasks to optimal models, reviewing every delivery, and integrating with conflict recovery.
+
+The currency of the whole orchestration is the **validated commit**: a delivery exists only as an immutable commit SHA that passed review and tests. Never treat a working tree as a delivery.
 
-## Core Capabilities
+Execute the five phases in order. Never skip the quality gate.
 
-- **Spawn specialized sub-agents** for each task (architect, coder, reviewer, tester, explorer, documenter)
-- **Wait for completion** — get results back from agents
-- **Background execution** — run agents in background while you continue
-- **Cost-aware routing** — automatically selects optimal models based on task complexity and budget
-- **Self-healing** — retries failed tasks, transfers context to new agents, escalates if needed
-- **Performance tracking** — learns which model/role combinations work best
+## Model configuration
 
-## How to Use Nexus Tools
+Read your model pools from the first file that exists: \`.opencode/nexus.jsonc\` in the project, then \`~/.config/opencode/nexus.jsonc\`. The configuration maps complexity levels to model pools:
+
+\`\`\`json
+{
+  "models": {
+    "complex": "provider/model-a, provider/model-b",
+    "normal": "provider/model-c"
+  }
+}
+### Delegating Tasks (Recommended — spawn + wait + result)
+\`\`\`
+nexus.delegate(role="coder", task="Implement JWT auth")
+nexus.delegate(role="reviewer", task="Review the implementation", timeout=180000)
+\`\`\`
 
 ### Spawning Agents (Wait for Result)
 \`\`\`
@@ -11132,57 +11477,306 @@ nexus.spawn(role="coder", task="Implement JWT auth", wait=true)
 nexus.spawn(role="reviewer", task="Review implementation", wait=true, timeout=60000)
 \`\`\`
 
-### Spawning Agents (Parallel, No Wait)
-\`\`\`
-nexus.spawn(role="coder", task="Task A")
-nexus.spawn(role="coder", task="Task B")
-# Both run in parallel
-nexus.sessions()  # Check progress
-nexus.background()  # Move to background
-\`\`\`
+- A model reference is \`provider/model\`, optionally suffixed with a variant: \`provider/model#max\`, \`provider/model#xhigh\`.
+- Each level maps to a pool of models (comma-separated).
+- \`complex\` and \`normal\` are task complexity levels for implementation, research, and verification tasks.
+- The \`reviewer\` and \`simplifier\` sub-agents always run with your own session model — no configuration needed.
 
-### Getting Results
-\`\`\`
-nexus.result(sessionID="ses_xxx")  # Get output from completed agent
-\`\`\`
+**Rotation rule:** when a pool contains several models, assign them round-robin across tasks. Comparison tasks are the exception: they use the whole pool at once.
 
+**Fallback rules:**
+- Missing \`complex\` → use \`normal\`.
+- Missing \`normal\`, or no config file → use the session default model everywhere (do not pass an explicit \`model\`).
 ### Other Tools
 \`\`\`
-nexus.status(detailed=true)    # Full state
-nexus.costs()                  # Cost report
-nexus.forecast(tasks='[...]')  # Predict costs
-nexus.performance.scores()     # Performance data
-nexus.history.list(count=10)   # Execution history
-nexus.security.scan(content="...", filename="app.ts")  # Security scan
+nexus.status(detailed=true)      # Full state
+nexus.costs()                    # Cost report
+nexus.forecast(tasks='[...]')    # Predict costs
+nexus.performance.scores()       # Performance data
+nexus.history.list(count=10)     # Execution history
+nexus.security.scan(content="..", filename="app.ts")  # Security scan
+nexus.dashboard.start(port=4747) # Start web dashboard
+nexus.dashboard.stop()           # Stop web dashboard
 \`\`\`
 
-## Task Decomposition Strategy
+**Cost-aware selection:** before dispatching, use \`nexus.forecast()\` to estimate task costs. If a complex model exceeds budget thresholds, downgrade to normal. Use \`nexus.performance.best(role)\` to prefer models with proven success rates.
 
+## Phase 1 — Decompose
 When given a development request:
 1. **Analyze** — Break into discrete tasks
 2. **Plan** — Determine parallel vs sequential
 3. **Estimate** — Use nexus.forecast for costs
-4. **Spawn** — Parallel tasks: spawn without wait
-5. **Spawn** — Sequential tasks: spawn with wait=true
+4. **Delegate** — Sequential tasks: use nexus.delegate (recommended)
+5. **Spawn** — Parallel tasks: spawn without wait
 6. **Monitor** — nexus.sessions() to track progress
-7. **Review** — nexus.spawn(role="reviewer", wait=true)
+7. **Review** — nexus.delegate(role="reviewer")
 8. **Report** — Summarize outcomes
 
+1. Analyze the request and the codebase; delegate exploration to an \`explorer\` sub-agent for large codebases, and the decomposition itself to an \`architect\` sub-agent when the plan is genuinely hard.
+2. Each task must define:
+   - \`id\`: short kebab-case slug
+   - \`kind\`: \`implementation\` | \`research\` | \`verification\`
+   - \`objective\`: what to build, find, or verify, with acceptance criteria
+   - \`scope\`: files or directories it may touch (empty for research and verification)
+   - \`complexity\`: \`complex\` or \`normal\`
+   - \`compare\`: optional, \`true\` to run the task on every model of the pool and keep the best delivery
+   - \`depends_on\`: ids of tasks that must be validated before this one starts
+3. **Isolation rule:** implementation tasks running in parallel must have disjoint scopes; overlapping scopes are serialized through \`depends_on\`. Research and verification tasks touch no code but still wait for their prerequisites.
+4. If the request is ambiguous, ask the user before decomposing. Then present the plan (tasks, kinds, models, parallel groups) and get the user's approval before launching any task sub-agent. Read-only preparatory sub-agents (\`explorer\`, \`architect\`) may run before approval — they build the plan, not code.
+## Web Dashboard
+
+Start the web dashboard to monitor agents, costs, and history in real-time:
+\`\`\`
+nexus.dashboard.start(port=4747, host="127.0.0.1")
+\`\`\`
+Then open http://127.0.0.1:4747 in your browser.
+
+Stop it when done:
+\`\`\`
+nexus.dashboard.stop()
+\`\`\`
+
+## Git Workflow & Environment Detection
+
+Before starting any work, detect the git environment and follow proper workflow:
+
+### Detection
+- Run \`git status\` to verify it's a git repo
+- Check \`.github/\` or \`.gitlab-ci.yml\` for CI/CD
+- Check \`git remote -v\` for GitHub/GitLab URLs
+
+### Rules
+1. **NEVER push directly to main** — always create a feature branch
+2. **Use conventional commits**: \`feat:\`, \`fix:\`, \`docs:\`, \`chore:\`
+3. **Create PR** for review before merging
+4. **Ask the user** about branching strategy if unclear
+
+### Memory
+Store git workflow preferences in memory for future reference.
+
 ## Quality Gates
 
-- Every code change → nexus.spawn(role="reviewer", wait=true)
+## Phase 2 — Worktrees and snapshots
+
+1. Enable worktree isolation: \`nexus.worktree.enable()\`. Verify the repository is clean; if not, stop and report. Record the base branch and its commit — the immovable anchor for the whole run.
+2. Every implementation task gets its own worktree and branch, following the environment's conventions; the main checkout stays untouched. Verification tasks also get their own worktree at the prepared snapshot. Comparison candidates use separate worktrees.
+3. A task's worktree is created only once all its prerequisites are validated, from this snapshot rule (transitive implementation ancestors count, even through research or verification prerequisites):
+   - No implementation ancestor → start from the base commit
+   - Exactly one implementation ancestor → fast-path: branch directly from that ancestor's validated commit
+   - Several implementation ancestors → start from the base commit and merge each ancestor's validated commit in \`depends_on\` order
+4. Research prerequisites contribute no commits: pass their findings explicitly in the dependent's prompt. Verification reports must identify the verified commit SHA, the checks performed, and their results — they produce findings, not implementation deliveries. A verification report only validates the snapshot it ran against: if an ancestor's validated revision later changes, re-run the verification on the new snapshot.
+5. Comparison candidates must all start from the same snapshot.
+6. A conflict while assembling a multi-ancestor snapshot is delegated to the involved ancestor's implementer; the assembled snapshot must pass build and tests before the dependent is dispatched.
+
+## Phase 3 — Dispatch
+
+1. Spawn one sub-agent per ready task (all prerequisites validated), in the background with \`nexus.spawn(role=..., task=..., wait=false)\`, with the \`model\` picked from the pool matching its complexity.
+2. Each prompt must include:
+   - the kind, objective, and acceptance criteria
+   - the task scope, with the instruction to never touch files outside it
+   - findings from research and verification prerequisites, when any
+   - for implementation tasks: work inside your worktree (move your session there so every read, edit, and command targets it) and run the project build and tests before reporting — the final delivery commit is produced during the quality gate
+   - for verification tasks: work inside your snapshot worktree (move your session there) and report the verified commit SHA, the checks performed, and their results
+3. **Comparison tasks:** spawn one sub-agent per model in the pool, in parallel, each in its own worktree.
+4. Monitor progress: use \`nexus.sessions()\` to track active agents. When a task completes, use \`nexus.result(sessionID=...)\` to retrieve its output.
+5. When a task is validated, prepare its dependents' worktrees (Phase 2) and dispatch them.
+
+## Phase 4 — Quality gate (every implementation delivery)
+
+Research and verification reports are assessed directly against their acceptance criteria.
+
+1. **Review:** spawn a \`reviewer\` sub-agent with \`nexus.spawn(role="reviewer", wait=true)\` to review the delivered code in the worktree — committed, staged, unstaged, and untracked alike.
+2. **Security scan:** run \`nexus.security.scan(content=..., filename=...)\` on changed files. Flag any security findings as blocking issues.
+3. **Rework loop:** blocking issues go back to the session that produced the delivery (resume it, full context kept), optionally under a different model — escalate when stuck, downgrade when slow or costly. Each round repeats review until no blocking issues remain.
+4. **Commit:** the implementer commits the complete delivery — exactly what was reviewed; any further change goes through the rework loop.
+5. **Validation:** build and tests pass at that commit and the worktree is clean → record the commit SHA as the task's \`validated_commit\`.
+6. **Comparison tasks:** once every candidate passed the gate (or after one review round), keep the best delivery against the acceptance criteria and discard the others. Use \`nexus.performance.scores()\` to inform which model delivered the best result.
+7. **Limits:** at most 2 rework rounds per task, then \`failed\`: remove its worktree, keep its branch for possible later recovery. When a task fails, transitively mark its pending dependents \`failed\` (recording the failing prerequisite) and continue independent tasks so the final barrier stays reachable.
+8. **Cost tracking:** after each quality gate round, call \`nexus.costs()\` to check budget status. If budget is exhausted, halt remaining tasks and report.
+
+## Phase 5 — Final integration and simplification
+
+1. Wait until every task is validated or marked failed. Never merge mid-flight.
+2. Merge each validated implementation task's \`validated_commit\` into the base branch, in \`depends_on\` topological order; research and verification tasks produce findings, not commits. Once a task is integrated, clean up after it immediately: remove its worktree, delete its merged branch, and delete temporary artifacts it created outside the repository (build outputs, logs, captures) once they are no longer needed.
+3. **Conflict recovery** — never force:
+   - Abort the conflicting merge in the base checkout first; never leave an unfinished merge behind.
+   - Delegate to the implementer: merge the current integration commit into its task branch in its worktree and resolve.
+   - The resolution changes the delivery: commit it, re-run the quality gate, record the replacement \`validated_commit\`, then retry.
+   - When a prerequisite's validated revision changes, revalidate its affected dependents — bounded to one cascade per integration; further churn marks the task \`failed\`.
+   - If a task ultimately fails here, exclude its unmerged descendants — even previously validated ones — and confirm the base checkout is clean before continuing.
+4. **Simplification pass:** once the final merge is done, spawn a \`simplifier\` sub-agent with \`nexus.spawn(role="documenter", task="Simplify the integrated changes between BASE and HEAD", wait=true)\`. Its edits get a focused \`reviewer\` review, then build and tests re-run, and you commit the result on the base branch.
+5. Remove every remaining worktree (research, verification, failed, excluded) via \`nexus.worktree.disable()\` and delete stray temporary artifacts.
+6. **Final report:** summarize per-task status, model(s) used, review round-trips, costs incurred (\`nexus.costs()\`), performance insights (\`nexus.performance.scores()\`), and the overall outcome with follow-ups.
+
+## Rules
+
+- Never modify code directly; all code changes go through sub-agents. The only commits you create are technical ones: snapshot assembly merges, final integration merges, and the post-simplification commit. Validated delivery commits always come from sub-agents.
+- Never force a merge, rewrite history, or discard uncommitted user work.
+- Rework always resumes the session that produced the delivery, possibly under a different model.
+- Never leave the base checkout in an unfinished merge state.
+- Always identify a validated task by its immutable \`validated_commit\`: use recorded SHAs, never branch names or working trees, when creating dependents and integrating deliveries.
+- Report progress after each phase. Keep reports concise.
+
+## Nexus-Specific Advantages
+
+These capabilities differentiate Nexus from a plain orchestrator:
+
+### Cost Intelligence
+- \`nexus.forecast(tasks=...)\` — estimate costs before dispatching, avoid budget surprises
+- \`nexus.costs()\` — real-time budget status, halt if exhausted
+- \`nexus.model.costs(model=...)\` — inspect per-model pricing to make informed routing decisions
+
+### Performance Learning
+- \`nexus.performance.scores()\` — see which model/role combos succeed most
+- \`nexus.performance.best(role=...)\` — pick the proven winner for a role
+- Scores improve routing over time: complex tasks go to high-performers, simple tasks use cheaper models
+
+### Security Scanning
+- \`nexus.security.scan(content=..., filename=...)\` — automated security review at the quality gate
+- Findings become blocking issues in the rework loop
+- No code ships without a security pass
+
+### Observability
+- \`nexus.dashboard.start()\` — live web dashboard for monitoring orchestrator state
+- \`nexus.status(detailed=true)\` — full metrics on demand
+- \`nexus.history.list(count=N)\` — execution history for post-mortem analysis
+- \`nexus.history.stats()\` — aggregate success rates and cost trends
+
+### Extensibility
+- \`nexus.roles.add(...)\` — define custom agent roles with specialized prompts
+- \`nexus.template(name=...)\` — reusable task templates for common workflows
+- \`nexus.worktree.enable()\` — git worktree isolation for parallel safety
+- Every code change → nexus.delegate(role="reviewer")
 - Security check → nexus.security.scan()
-- Testing → nexus.spawn(role="tester", wait=true)
+- Testing → nexus.delegate(role="tester")
 `;
 var src_default = define({
   id: "nexus",
   async setup(ctx) {
     try {
       const agentDir = join6(homedir2(), ".config", "opencode", "agents");
-      const agentFile = join6(agentDir, "nexus-orchestrator.md");
-      if (!existsSync3(agentFile)) {
-        mkdirSync4(agentDir, { recursive: true });
-        writeFileSync2(agentFile, NEXUS_AGENT_CONTENT, "utf-8");
+      mkdirSync4(agentDir, { recursive: true });
+      const orchestratorFile = join6(agentDir, "nexus-orchestrator.md");
+      if (!existsSync3(orchestratorFile)) {
+        writeFileSync2(orchestratorFile, NEXUS_AGENT_CONTENT, "utf-8");
+      }
+      const subagents = {
+        "nexus-architect.md": `---
+description: Nexus Architect agent — designs system architecture with cost-aware model selection
+mode: subagent
+permissions:
+  - action: edit
+    resource: "*"
+  - action: shell
+    resource: "*"
+---
+
+# Nexus Architect Agent
+
+You are a Nexus Architect sub-agent. Design system architecture.
+
+- System design and architecture patterns
+- High-level technical decisions
+- API design and interface definitions
+- Consider cost implications
+- Document decisions and trade-offs`,
+        "nexus-coder.md": `---
+description: Nexus Coder agent — implements code with cost-aware model selection
+mode: subagent
+permissions:
+  - action: edit
+    resource: "*"
+  - action: shell
+    resource: "*"
+---
+
+# Nexus Coder Agent
+
+You are a Nexus Coder sub-agent. Implement code tasks.
+
+- Write clean, efficient TypeScript/JavaScript code
+- Follow existing code patterns
+- Add tests for functionality
+- Use model from nexus config for your role
+- Commit with conventional commit messages`,
+        "nexus-explorer.md": `---
+description: Nexus Explorer agent — explores codebases and provides architecture analysis
+mode: subagent
+permissions:
+  - action: edit
+    resource: "*"
+    effect: deny
+---
+
+# Nexus Explorer Agent
+
+You are a Nexus Explorer sub-agent. Explore codebases.
+
+- Read-only exploration
+- Find files by patterns
+- Analyze dependencies
+- Report architecture findings`,
+        "nexus-tester.md": `---
+description: Nexus Tester agent — writes and runs tests for quality assurance
+mode: subagent
+permissions:
+  - action: edit
+    resource: "*"
+  - action: shell
+    resource: "*"
+---
+
+# Nexus Tester Agent
+
+You are a Nexus Tester sub-agent. Write and run tests.
+
+- Unit tests for new functions
+- Integration tests for features
+- Test edge cases and errors
+- Follow existing test patterns`,
+        "nexus-reviewer.md": `---
+description: Nexus Reviewer agent — reviews code for quality, security, and correctness
+mode: subagent
+permissions:
+  - action: edit
+    resource: "*"
+    effect: deny
+---
+
+# Nexus Reviewer Agent
+
+You are a Nexus Reviewer sub-agent. Review code changes.
+
+- Code correctness and logic
+- Security vulnerabilities
+- Performance implications
+- Test coverage
+- Provide APPROVED / CHANGES REQUESTED assessment`,
+        "nexus-documenter.md": `---
+description: Nexus Documenter agent — writes clear, comprehensive technical documentation
+mode: subagent
+permissions:
+  - action: edit
+    resource: "*"
+  - action: shell
+    resource: "*"
+---
+
+# Nexus Documenter Agent
+
+You are a Nexus Documenter sub-agent. Write documentation.
+
+- API documentation
+- README files
+- Architecture docs
+- Include code examples
+- Keep docs close to code`
+      };
+      for (const [filename, content] of Object.entries(subagents)) {
+        const filepath = join6(agentDir, filename);
+        if (!existsSync3(filepath)) {
+          writeFileSync2(filepath, content, "utf-8");
+        }
       }
     } catch {}
     try {
@@ -11197,12 +11791,49 @@ var src_default = define({
         }
       }
     } catch {}
+    try {
+      const nexusConfigPath = join6(process.cwd(), ".opencode", "nexus.jsonc");
+      if (existsSync3(nexusConfigPath)) {
+        const nexusContent = readFileSync3(nexusConfigPath, "utf-8");
+        const stripped = nexusContent.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+        const nexusConfig = JSON.parse(stripped);
+        if (nexusConfig.models) {
+          const configPath = join6(homedir2(), ".config", "opencode", "opencode.jsonc");
+          if (existsSync3(configPath)) {
+            let configContent = readFileSync3(configPath, "utf-8");
+            const configObj = JSON.parse(configContent);
+            if (!configObj.agents)
+              configObj.agents = {};
+            if (!configObj.agents["nexus-orchestrator"])
+              configObj.agents["nexus-orchestrator"] = {};
+            if (!configObj.agents["nexus-orchestrator"].model) {
+              configObj.agents["nexus-orchestrator"].model = nexusConfig.models.coder || "opencode-go/mimo-v2.5";
+              writeFileSync2(configPath, JSON.stringify(configObj, null, 2) + `
+`, "utf-8");
+            }
+          }
+        }
+      }
+    } catch {}
     const orchestrator = new NexusOrchestrator;
+    const goalManager = new GoalManager;
     await orchestrator.initialize(ctx, () => {
       const state = orchestrator.getState();
       ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(state))).catch(() => {});
+      const sidebarState = {
+        agents: state.agents,
+        totalCost: state.totalSpent,
+        budgetRemaining: state.budgetRemaining
+      };
+      ctx.storage.set("nexus-sidebar-state", JSON.parse(JSON.stringify(sidebarState))).catch(() => {});
     });
     await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+    const initialState = orchestrator.getState();
+    await ctx.storage.set("nexus-sidebar-state", JSON.parse(JSON.stringify({
+      agents: initialState.agents,
+      totalCost: initialState.totalSpent,
+      budgetRemaining: initialState.budgetRemaining
+    })));
     await ctx.tool.transform((editor) => {
       editor.namespace({
         name: "nexus",
@@ -11422,7 +12053,7 @@ var src_default = define({
           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)" },
+            model: { type: "string", description: "Model override (optional, e.g. 'anthropic/claude-sonnet-4-6')" },
             wait: { type: "boolean", description: "Wait for completion (default: false)" },
             timeout: { type: "number", description: "Timeout in ms when waiting (default: 120000)" }
           },
@@ -11432,17 +12063,62 @@ var src_default = define({
         execute: async (input) => {
           const { role, task, model, wait, timeout } = input;
           try {
-            orchestrator.parentSessionID = null;
+            if (!orchestrator.parentSessionID) {
+              try {
+                const currentSession = ctx.session?.current?.();
+                if (currentSession?.id) {
+                  orchestrator.parentSessionID = currentSession.id;
+                }
+              } catch {}
+            }
             const agent = await orchestrator.spawnAgent({ role, model });
             await orchestrator.ctx.session.prompt({
               sessionID: agent.sessionID,
               text: task
             });
+            agent.status = "working";
+            orchestrator.notifyStateChange();
             if (wait) {
               const waitTimeout = timeout || 120000;
+              const waitPromise = orchestrator.ctx.session.wait({ sessionID: agent.sessionID });
+              const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Timed out after ${waitTimeout}ms`)), waitTimeout));
               try {
-                await orchestrator.ctx.session.wait({ sessionID: agent.sessionID });
-              } catch {}
+                await Promise.race([waitPromise, timeoutPromise]);
+              } catch (waitError) {
+                agent.status = "working";
+                orchestrator.notifyStateChange();
+                try {
+                  const messages = await orchestrator.ctx.session.context({ sessionID: agent.sessionID });
+                  const lastMsg = messages.filter((m) => m.role === "assistant").pop();
+                  if (lastMsg) {
+                    agent.status = "completed";
+                    await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+                    const taskPreview = task.length > 80 ? task.substring(0, 77) + "..." : task;
+                    return {
+                      content: [
+                        `${agent.name}`,
+                        `\uD83D\uDCCB Task: ${taskPreview}`,
+                        `⏱️ Status: ${waitError.message || "timeout"}`,
+                        `\uD83D\uDCCE Session: ${agent.sessionID}`,
+                        `
+--- Partial Result ---`,
+                        typeof lastMsg.content === "string" ? lastMsg.content : JSON.stringify(lastMsg.content)
+                      ].join(`
+`)
+                    };
+                  }
+                } catch {}
+                return {
+                  content: [
+                    `${agent.name}`,
+                    `\uD83D\uDCCB Task: ${task.length > 80 ? task.substring(0, 77) + "..." : task}`,
+                    `⏱️ Status: ${waitError.message || "timeout"}`,
+                    `\uD83D\uDCCE Session: ${agent.sessionID}`,
+                    `\uD83D\uDCA1 Use nexus.result(sessionID="${agent.sessionID}") to check later`
+                  ].join(`
+`)
+                };
+              }
               try {
                 const messages = await orchestrator.ctx.session.context({ sessionID: agent.sessionID });
                 const lastMsg = messages.filter((m) => m.role === "assistant").pop();
@@ -11458,11 +12134,23 @@ var src_default = define({
                     `\uD83D\uDCCE Session: ${agent.sessionID}`,
                     `
 --- Result ---`,
-                    result
+                    typeof result === "string" ? result : JSON.stringify(result)
                   ].join(`
 `)
                 };
-              } catch {}
+              } catch {
+                agent.status = "completed";
+                await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+                return {
+                  content: [
+                    `${agent.name}`,
+                    `✅ Status: completed`,
+                    `\uD83D\uDCCE Session: ${agent.sessionID}`,
+                    `⚠️ Could not read result output`
+                  ].join(`
+`)
+                };
+              }
             }
             const complexity = orchestrator.analyzeComplexity({
               id: `spawn-${Date.now()}`,
@@ -11485,7 +12173,7 @@ var src_default = define({
               `\uD83D\uDCCA Complexity: ${complexity.overall}/100 (${complexity.factors.riskLevel} risk)`,
               `\uD83E\uDD16 Model reasoning: ${modelSelection.reasoning}`,
               `\uD83D\uDCCE Session: ${agent.sessionID}`,
-              `\uD83D\uDCA1 Use wait=true to wait for completion`
+              `\uD83D\uDCA1 Use wait=true to wait for completion, or nexus.result() to fetch later`
             ].join(`
 `);
             return { content: output };
@@ -11494,6 +12182,72 @@ var src_default = define({
           }
         }
       });
+      editor.add({
+        name: "delegate",
+        description: "Delegate a task to a sub-agent and wait for result (convenience wrapper around spawn+wait)",
+        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)" },
+            timeout: { type: "number", description: "Timeout in ms (default: 120000)" }
+          },
+          required: ["role", "task"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { role, task, model, timeout } = input;
+          try {
+            const agent = await orchestrator.spawnAgent({ role, model });
+            await orchestrator.ctx.session.prompt({
+              sessionID: agent.sessionID,
+              text: task
+            });
+            agent.status = "working";
+            orchestrator.notifyStateChange();
+            const waitTimeout = timeout || 120000;
+            const waitPromise = orchestrator.ctx.session.wait({ sessionID: agent.sessionID });
+            const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve("timeout"), waitTimeout));
+            const outcome = await Promise.race([waitPromise.then(() => "completed"), timeoutPromise]);
+            try {
+              const messages = await orchestrator.ctx.session.context({ sessionID: agent.sessionID });
+              const lastMsg = messages.filter((m) => m.role === "assistant").pop();
+              const resultContent = lastMsg?.content || (outcome === "timeout" ? "Timed out — agent may still be running" : "Completed with no output");
+              agent.status = outcome === "timeout" ? "working" : "completed";
+              orchestrator.notifyStateChange();
+              await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+              const statusIcon = outcome === "timeout" ? "⏱️" : "✅";
+              return {
+                content: [
+                  `${agent.name}`,
+                  `\uD83D\uDCCB Task: ${task.length > 80 ? task.substring(0, 77) + "..." : task}`,
+                  `${statusIcon} Status: ${outcome}`,
+                  `\uD83D\uDCCE Session: ${agent.sessionID}`,
+                  `
+--- Result ---`,
+                  typeof resultContent === "string" ? resultContent : JSON.stringify(resultContent)
+                ].join(`
+`)
+              };
+            } catch {
+              agent.status = outcome === "timeout" ? "working" : "completed";
+              orchestrator.notifyStateChange();
+              return {
+                content: [
+                  `${agent.name}`,
+                  `${outcome === "timeout" ? "⏱️" : "✅"} Status: ${outcome}`,
+                  `\uD83D\uDCCE Session: ${agent.sessionID}`,
+                  `⚠️ Could not read result output`
+                ].join(`
+`)
+              };
+            }
+          } catch (error) {
+            return { content: `Delegate failed: ${error.message}` };
+          }
+        }
+      });
       editor.add({
         name: "template",
         description: "List or instantiate task templates",
@@ -11764,6 +12518,381 @@ ${lastMsg.content}` };
           }
         }
       });
+      editor.add({
+        name: "clarify",
+        description: "Ask clarifying question before proceeding with ambiguous task",
+        input: {
+          type: "object",
+          properties: {
+            question: { type: "string", description: "The clarifying question to ask" },
+            options: { type: "string", description: "Comma-separated options to present" },
+            assumption: { type: "string", description: "Default assumption if no response" }
+          },
+          required: ["question"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { question, options, assumption } = input;
+          const optionList = options ? options.split(",").map((o) => o.trim()) : [];
+          let response = `❓ ${question}`;
+          if (optionList.length > 0) {
+            response += `
+Options: ${optionList.map((o, i) => `${i + 1}. ${o}`).join(", ")}`;
+          }
+          if (assumption) {
+            response += `
+\uD83D\uDCA1 Default: ${assumption}`;
+          }
+          return { content: response };
+        }
+      });
+      editor.add({
+        name: "todo.add",
+        description: "Add a todo item to track work",
+        input: {
+          type: "object",
+          properties: {
+            description: { type: "string", description: "Todo description" },
+            assignedTo: { type: "string", description: "Agent or role to assign (optional)" }
+          },
+          required: ["description"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { description, assignedTo } = input;
+          const item = orchestrator.todoEnforcer.add(description, assignedTo);
+          return { content: `\uD83D\uDCDD Todo added: ${item.id}: ${item.description} (${item.status})` };
+        }
+      });
+      editor.add({
+        name: "todo.list",
+        description: "List all todo items",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          return { content: orchestrator.todoEnforcer.formatAll() };
+        }
+      });
+      editor.add({
+        name: "todo.complete",
+        description: "Mark a todo item as completed",
+        input: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Todo item ID" }
+          },
+          required: ["id"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { id } = input;
+          const item = orchestrator.todoEnforcer.get(id);
+          if (!item)
+            return { content: `❌ Todo ${id} not found.` };
+          orchestrator.todoEnforcer.complete(id);
+          return { content: `✅ Todo completed: ${id}: ${item.description}` };
+        }
+      });
+      editor.add({
+        name: "todo.stats",
+        description: "Get todo statistics",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const stats = orchestrator.todoEnforcer.getStats();
+          return {
+            content: `\uD83D\uDCCA Todo Statistics:
+  Total: ${stats.total}
+  ⏳ Pending: ${stats.pending}
+  \uD83D\uDD04 In Progress: ${stats.inProgress}
+  ✅ Completed: ${stats.completed}
+  \uD83D\uDEAB Blocked: ${stats.blocked}`
+          };
+        }
+      });
+      editor.add({
+        name: "goal.set",
+        description: "Set a new persistent objective",
+        input: {
+          type: "object",
+          properties: {
+            description: { type: "string", description: "Goal description" },
+            autoContinue: { type: "boolean", description: "Auto-continue (default: true)" }
+          },
+          required: ["description"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { description, autoContinue } = input;
+          const goal = goalManager.set(description, autoContinue ?? true);
+          return { content: `\uD83C\uDFAF Goal set: ${goal.description}` };
+        }
+      });
+      editor.add({
+        name: "goal.status",
+        description: "Show current goal status",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          const goal = goalManager.getActive();
+          if (!goal)
+            return { content: "No active goal. Use nexus.goal.set() to create one." };
+          return { content: `\uD83C\uDFAF ${goal.description}
+Status: ${goal.status}
+Tasks: ${goal.tasks.length}` };
+        }
+      });
+      editor.add({
+        name: "goal.complete",
+        description: "Complete current goal",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          const goal = goalManager.getActive();
+          if (!goal)
+            return { content: "No active goal." };
+          goalManager.complete(goal.id);
+          return { content: `✅ Goal completed: ${goal.description}` };
+        }
+      });
+      editor.add({
+        name: "goal.list",
+        description: "List all goals",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          const goals = goalManager.getAll();
+          if (goals.length === 0)
+            return { content: "No goals yet." };
+          const lines = goals.map((g) => `${g.status === "active" ? "\uD83C\uDFAF" : "✅"} ${g.description}`);
+          return { content: lines.join(`
+`) };
+        }
+      });
+      editor.add({
+        name: "goal.status",
+        description: "Show current active goal status",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const active = goalManager.getActive();
+          if (!active)
+            return { content: "No active goal. Use nexus.goal.set() to set one." };
+          return {
+            content: [
+              `\uD83C\uDFAF Active Goal: ${active.description}`,
+              `\uD83D\uDCCB ID: ${active.id}`,
+              `\uD83D\uDD04 Auto-continue: ${active.autoContinue ? "enabled" : "disabled"}`,
+              `\uD83D\uDCCA Status: ${active.status}`,
+              `\uD83D\uDCCE Tasks: ${active.tasks.length > 0 ? active.tasks.join(", ") : "none yet"}`,
+              `\uD83D\uDCC5 Created: ${active.createdAt.toISOString()}`,
+              `⏱️ Should continue: ${goalManager.shouldContinue() ? "yes" : "no"}`
+            ].join(`
+`)
+          };
+        }
+      });
+      editor.add({
+        name: "goal.complete",
+        description: "Mark current active goal as completed",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const active = goalManager.getActive();
+          if (!active)
+            return { content: "No active goal to complete." };
+          goalManager.complete(active.id);
+          await ctx.storage.set("nexus-goal", JSON.parse(JSON.stringify(goalManager.getAll())));
+          return {
+            content: [
+              `✅ Goal completed: ${active.description}`,
+              `\uD83D\uDCCB ID: ${active.id}`,
+              `\uD83D\uDCCE Tasks tracked: ${active.tasks.length}`
+            ].join(`
+`)
+          };
+        }
+      });
+      editor.add({
+        name: "goal.list",
+        description: "List all goals",
+        input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        execute: async () => {
+          const goals = goalManager.getAll();
+          if (goals.length === 0)
+            return { content: "No goals set yet. Use nexus.goal.set() to create one." };
+          const lines = goals.map((g) => {
+            const icon = g.status === "active" ? "\uD83C\uDFAF" : g.status === "completed" ? "✅" : g.status === "paused" ? "⏸️" : "❌";
+            return `${icon} [${g.status}] ${g.description} (tasks: ${g.tasks.length})`;
+          });
+          return { content: `Goals (${goals.length}):
+${lines.join(`
+`)}` };
+        }
+      });
+      const teamManager = new TeamManager;
+      const astGrep = new AstGrep;
+      editor.add({
+        name: "team.create",
+        description: "Create a new team with a lead role",
+        input: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Team name" },
+            leadRole: { type: "string", description: "Role of the team lead" }
+          },
+          required: ["name", "leadRole"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { name, leadRole } = input;
+          const team = teamManager.create(name, leadRole);
+          return { content: `Team '${team.name}' created with ID: ${team.id}
+Lead: ${leadRole}
+Status: ${team.status}
+
+Add members with nexus.team.addMember(teamId="${team.id}", role="...", model="...")` };
+        }
+      });
+      editor.add({
+        name: "team.addMember",
+        description: "Add a member to a team",
+        input: {
+          type: "object",
+          properties: {
+            teamId: { type: "string", description: "Team ID" },
+            role: { type: "string", description: "Role for this member" },
+            model: { type: "string", description: "Model for this member" }
+          },
+          required: ["teamId", "role", "model"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { teamId, role, model } = input;
+          const member = teamManager.addMember(teamId, role, model);
+          if (!member) {
+            return { content: `Team ${teamId} not found.` };
+          }
+          const team = teamManager.get(teamId);
+          return { content: `Member added to team '${team?.name}':
+ID: ${member.id}
+Role: ${member.role}
+Model: ${member.model}
+Status: ${member.status}
+
+Total members: ${team?.members.length || 0}` };
+        }
+      });
+      editor.add({
+        name: "team.status",
+        description: "Show team status",
+        input: {
+          type: "object",
+          properties: {
+            teamId: { type: "string", description: "Team ID (optional, shows all if omitted)" }
+          },
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { teamId } = input;
+          if (teamId) {
+            const team = teamManager.get(teamId);
+            if (!team) {
+              return { content: `Team ${teamId} not found.` };
+            }
+            const memberLines = team.members.map((m) => `  - ${m.role} (${m.model}): ${m.status}`).join(`
+`);
+            return { content: `Team: ${team.name} (${team.id})
+Lead: ${team.lead}
+Status: ${team.status}
+Created: ${team.createdAt.toISOString()}
+Members (${team.members.length}):
+${memberLines || "  No members yet"}` };
+          }
+          const teams = teamManager.getAll();
+          if (teams.length === 0) {
+            return { content: "No teams created yet." };
+          }
+          const lines = teams.map((t) => `${t.status === "active" ? "\uD83D\uDFE2" : t.status === "completed" ? "✅" : "\uD83D\uDD35"} ${t.name} (${t.id}) - Lead: ${t.lead} - Members: ${t.members.length}`);
+          return { content: `Teams (${teams.length}):
+${lines.join(`
+`)}` };
+        }
+      });
+      editor.add({
+        name: "team.activate",
+        description: "Activate a team to start execution",
+        input: {
+          type: "object",
+          properties: {
+            teamId: { type: "string", description: "Team ID" }
+          },
+          required: ["teamId"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { teamId } = input;
+          const team = teamManager.get(teamId);
+          if (!team) {
+            return { content: `Team ${teamId} not found.` };
+          }
+          if (team.members.length === 0) {
+            return { content: `Team '${team.name}' has no members. Add members before activating.` };
+          }
+          teamManager.activate(teamId);
+          return { content: `Team '${team.name}' activated!
+
+Team is now ready for parallel execution with ${team.members.length} members:
+${team.members.map((m) => `  - ${m.role}: ${m.model}`).join(`
+`)}` };
+        }
+      });
+      editor.add({
+        name: "astgrep.search",
+        description: "Search for AST patterns in codebase",
+        input: {
+          type: "object",
+          properties: {
+            pattern: { type: "string", description: "AST pattern to search for" },
+            language: { type: "string", description: "Programming language (typescript, python, etc.)" },
+            directory: { type: "string", description: "Directory to search in" }
+          },
+          required: ["pattern", "language", "directory"],
+          additionalProperties: false
+        },
+        execute: async (input) => {
+          const { pattern, language, directory } = input;
+          const results = astGrep.search(pattern, language, directory);
+          if (results.length === 0)
+            return { content: `No matches found for "${pattern}" in ${language}` };
+          const lines = results.map((r) => `${r.file}:${r.line} — ${r.match}`);
+          return { content: `Found ${results.length} matches:
+${lines.join(`
+`)}` };
+        }
+      });
+      editor.add({
+        name: "astgrep.status",
+        description: "Check if ast-grep is installed",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          const available = astGrep.isAvailable();
+          return { content: available ? "✅ ast-grep is installed" : "❌ ast-grep is not installed. Install with: cargo install ast-grep" };
+        }
+      });
     });
     await ctx.session.hook("prompt", (event) => {
       if (event.prompt.text.startsWith("/nexus")) {
@@ -11777,9 +12906,11 @@ ${lastMsg.content}` };
   }
 });
 export {
+  AstGrep,
   CostForecaster,
   CustomRoleManager,
   DEFAULT_CONFIG,
+  GoalManager,
   HealthMonitor,
   LearningModule,
   MessageRouter,
@@ -11793,6 +12924,8 @@ export {
   SecurityScanner,
   StateBroadcaster,
   TEMPLATES,
+  TeamManager,
+  TodoEnforcer,
   WorktreeManager,
   src_default as default,
   detectCycles,