@wrongstack/core 0.281.1 → 0.282.0

package/dist/defaults/index.js

@@ -2052,20 +2052,20 @@ function compactDiff(diff) {
       merged.push(current);
     }
   }
-  const excerpt = [];
+  const excerpt2 = [];
   let prevLine = -1;
   for (const [start, end] of merged) {
     if (start > prevLine + 1) {
       const omitted = prevLine === -1 ? start : start - prevLine - 1;
-      excerpt.push(`[serializer omitted ${omitted} diff line(s)]`);
+      excerpt2.push(`[serializer omitted ${omitted} diff line(s)]`);
     }
     for (let j = start; j <= end; j++) {
-      excerpt.push(lines[j] ?? "");
+      excerpt2.push(lines[j] ?? "");
     }
     prevLine = end;
   }
   const trailing = lines.length - prevLine - 1;
-  if (trailing > 0) excerpt.push(`[serializer omitted ${trailing} trailing diff line(s)]`);
+  if (trailing > 0) excerpt2.push(`[serializer omitted ${trailing} trailing diff line(s)]`);
   return joinSections([
     renderHeader("diff_summary", {
       files: fileCount,
@@ -2075,7 +2075,7 @@ function compactDiff(diff) {
       removed,
       lines: lines.length
     }),
-    excerpt.join("\n")
+    excerpt2.join("\n")
   ]);
 }
 function compactFailureOutput(output) {
@@ -3923,6 +3923,34 @@ var BUILD_AGENTS = [
 
 // src/coordination/agents/phase4-verify.ts
 var VERIFY_AGENTS = [
+  {
+    config: {
+      id: "verifier",
+      name: "Verifier",
+      role: "verifier",
+      tools: [...TOOLS.inspect, "bash", "exec", "lint", "typecheck", "test", "git"],
+      prompt: agentPrompt("verifier")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Independent verification gate: runs the relevant checks until they pass or returns exact failures that need another implementation pass.",
+      keywords: [
+        "verify",
+        "verification",
+        "quality gate",
+        "prove it works",
+        "run checks",
+        "run tests until pass",
+        "test pass",
+        "green build",
+        "typecheck",
+        "lint",
+        "regression check",
+        "acceptance gate"
+      ]
+    }
+  },
   {
     config: {
       id: "test",
@@ -4189,6 +4217,34 @@ var VERIFY_AGENTS = [
 
 // src/coordination/agents/phase5-review.ts
 var REVIEW_AGENTS = [
+  {
+    config: {
+      id: "reviewer",
+      name: "Reviewer",
+      role: "reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: agentPrompt("reviewer")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Independent AI reviewer: audits another agent's output, flags uncertainty, correlated-failure risk, and must-fix defects.",
+      keywords: [
+        "reviewer",
+        "independent review",
+        "ai review",
+        "review agent",
+        "quality review",
+        "second opinion",
+        "check another agent",
+        "cross check",
+        "uncertainty",
+        "correlated error",
+        "verify output",
+        "quality control"
+      ]
+    }
+  },
   {
     config: {
       id: "code-reviewer",
@@ -5174,6 +5230,77 @@ FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations:
 // src/coordination/delegate-tool.ts
 init_safe_json();
 init_error();
+
+// src/security/capabilities.ts
+var ToolCapabilities = {
+  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
+  SHELL_ARBITRARY: "shell.arbitrary",
+  /** Can execute a restricted set of commands (the `exec` tool). */
+  SHELL_RESTRICTED: "shell.restricted",
+  /** Can run a restricted project formatter/linter-style command. */
+  SHELL_EXEC: "shell.exec",
+  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
+  FS_READ: "fs.read",
+  /** Can write / modify / delete files inside the project. */
+  FS_WRITE: "fs.write",
+  /** Can write files outside the current project root (very high risk). */
+  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can perform outbound network requests. */
+  NET_OUTBOUND: "net.outbound",
+  /** Can invoke arbitrary registered tools through a meta-tool. */
+  TOOL_MUTATE_ANY: "tool.mutate.any",
+  /** Can write persistent memory. */
+  MEMORY_WRITE: "memory.write",
+  /** Can delete persistent memory. */
+  MEMORY_DELETE: "memory.delete",
+  /** Proxies tools from external MCP servers (unknown capability). */
+  MCP_PROXY: "mcp.proxy",
+  /** Can spawn or manage subagents / multi-agent tasks. */
+  SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can inspect fleet/subagent coordination state without mutating it. */
+  COORDINATION_FLEET_READ: "coordination.fleet.read",
+  /** Can mutate global or session configuration / trust state. */
+  CONFIG_MUTATE: "config.mutate",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+var DANGEROUS_FOR_SUBAGENTS = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.TOOL_MUTATE_ANY,
+  ToolCapabilities.MEMORY_WRITE,
+  ToolCapabilities.MEMORY_DELETE,
+  ToolCapabilities.MCP_PROXY,
+  ToolCapabilities.SUBAGENT_SPAWN,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.PACKAGE_INSTALL
+];
+function hasDangerousCapabilityForSubagents(toolOrCaps) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
+}
+function hasCapability(toolOrCaps, capability) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  const toCheck = Array.isArray(capability) ? capability : [capability];
+  return toCheck.some((c) => caps.includes(c));
+}
+function getDangerousCapabilities(toolOrCaps) {
+  if (!toolOrCaps) return [];
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  return caps.filter(
+    (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
+  );
+}
+
+// src/coordination/delegate-tool.ts
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 30 * 60 * 1e3;
   const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
@@ -5244,6 +5371,7 @@ function createDelegateTool(opts) {
     usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster (audit-log, bug-hunter, refactor-planner, security-scanner) or pass `name` to run a free-form coding agent. For non-trivial work, also pass `timeoutMs`, `maxIterations`, and `maxToolCalls`. Returns the subagent's `TaskResult` \u2014 including the textual `result`, iteration count, tool count, and duration. Auto-promotes the host into director mode on first call.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input) {
       const sessionId = opts.directorRunId;
@@ -5714,9 +5842,24 @@ var DirectorStateCheckpoint = class {
   recordTaskStatus(taskId, patch) {
     this.snapshot = {
       ...this.snapshot,
-      tasks: this.snapshot.tasks.map(
-        (t) => t.taskId === taskId ? { ...t, ...patch } : t
-      )
+      tasks: this.snapshot.tasks.map((t) => t.taskId === taskId ? { ...t, ...patch } : t)
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskWorktree(taskId, worktree) {
+    const exists = this.snapshot.tasks.some((t) => t.taskId === taskId);
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: exists ? this.snapshot.tasks.map((t) => t.taskId === taskId ? { ...t, worktree } : t) : [
+        ...this.snapshot.tasks,
+        {
+          taskId,
+          subagentId: worktree.subagentId,
+          status: "running",
+          worktree
+        }
+      ]
     };
     this.bumpUpdatedAt();
     this.schedule();
@@ -5759,10 +5902,7 @@ var DirectorStateCheckpoint = class {
         mode: 384
       });
     } catch (err) {
-      console.warn(
-        "[director-state] checkpoint write failed:",
-        toErrorMessage(err)
-      );
+      console.warn("[director-state] checkpoint write failed:", toErrorMessage(err));
     } finally {
       this.writing = false;
       if (this.rewriteRequested) {
@@ -6368,6 +6508,49 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     this.snapshot.files.length = 0;
   }
 };
+
+// src/coordination/director/director-errors.ts
+var FleetSpawnBudgetError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(kind, limit, observed, message) {
+    const defaultMsg = kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`;
+    super(message ?? defaultMsg);
+    this.name = "FleetSpawnBudgetError";
+    this.kind = kind;
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var FleetCostCapError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
+    );
+    this.name = "FleetCostCapError";
+    this.kind = "max_cost_usd";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var FleetContextOverflowError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Leader context overflow: leader has ${observed} tokens in flight (limit: ${limit}). Compact the leader context before spawning more subagents.`
+    );
+    this.name = "FleetContextOverflowError";
+    this.kind = "max_context_load";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
 function readBundledInstructionText(relativePath) {
@@ -6469,6 +6652,7 @@ function rosterSummaryFromConfigs(roster) {
   }
   return lines.join("\n");
 }
+init_error();
 
 // src/coordination/dispatcher.ts
 init_safe_json();
@@ -6593,95 +6777,57 @@ function makeLLMClassifier(complete) {
   };
 }
 
-// src/coordination/director-tools.ts
-init_error();
-
-// src/security/capabilities.ts
-var ToolCapabilities = {
-  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
-  SHELL_ARBITRARY: "shell.arbitrary",
-  /** Can execute a restricted set of commands (the `exec` tool). */
-  SHELL_RESTRICTED: "shell.restricted",
-  /** Can run a restricted project formatter/linter-style command. */
-  SHELL_EXEC: "shell.exec",
-  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
-  FS_READ: "fs.read",
-  /** Can write / modify / delete files inside the project. */
-  FS_WRITE: "fs.write",
-  /** Can write files outside the current project root (very high risk). */
-  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
-  /** Can perform outbound network requests. */
-  NET_OUTBOUND: "net.outbound",
-  /** Can invoke arbitrary registered tools through a meta-tool. */
-  TOOL_MUTATE_ANY: "tool.mutate.any",
-  /** Can write persistent memory. */
-  MEMORY_WRITE: "memory.write",
-  /** Can delete persistent memory. */
-  MEMORY_DELETE: "memory.delete",
-  /** Proxies tools from external MCP servers (unknown capability). */
-  MCP_PROXY: "mcp.proxy",
-  /** Can spawn or manage subagents / multi-agent tasks. */
-  SUBAGENT_SPAWN: "subagent.spawn",
-  /** Can inspect fleet/subagent coordination state without mutating it. */
-  COORDINATION_FLEET_READ: "coordination.fleet.read",
-  /** Can mutate global or session configuration / trust state. */
-  CONFIG_MUTATE: "config.mutate",
-  /** Can install packages or run package managers with side effects. */
-  PACKAGE_INSTALL: "package.install"
-};
-var DANGEROUS_FOR_SUBAGENTS = [
-  ToolCapabilities.SHELL_ARBITRARY,
-  ToolCapabilities.SHELL_RESTRICTED,
-  ToolCapabilities.SHELL_EXEC,
-  ToolCapabilities.FS_WRITE,
-  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
-  ToolCapabilities.TOOL_MUTATE_ANY,
-  ToolCapabilities.MEMORY_WRITE,
-  ToolCapabilities.MEMORY_DELETE,
-  ToolCapabilities.MCP_PROXY,
-  ToolCapabilities.SUBAGENT_SPAWN,
-  ToolCapabilities.CONFIG_MUTATE,
-  ToolCapabilities.PACKAGE_INSTALL
-];
-function hasDangerousCapabilityForSubagents(toolOrCaps) {
-  if (!toolOrCaps) return false;
-  const input = toolOrCaps;
-  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
-  return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
-}
-function hasCapability(toolOrCaps, capability) {
-  if (!toolOrCaps) return false;
-  const input = toolOrCaps;
-  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
-  const toCheck = Array.isArray(capability) ? capability : [capability];
-  return toCheck.some((c) => caps.includes(c));
-}
-function getDangerousCapabilities(toolOrCaps) {
-  if (!toolOrCaps) return [];
-  const input = toolOrCaps;
-  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
-  return caps.filter(
-    (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
-  );
-}
-
 // src/coordination/director-tools.ts
 function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
     properties: {
-      role: { type: "string", description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields." },
-      description: { type: "string", description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name." },
-      name: { type: "string", description: "Display name for the subagent. Used as a fallback when description-based dispatch does not resolve a role." },
-      provider: { type: "string", description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.' },
-      model: { type: "string", description: "Model id within the provider. Defaults to the leader model when omitted." },
-      systemPromptOverride: { type: "string", description: "Extra prompt text appended after the role-base prompt." },
+      role: {
+        type: "string",
+        description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields."
+      },
+      description: {
+        type: "string",
+        description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name."
+      },
+      name: {
+        type: "string",
+        description: "Display name for the subagent. Used as a fallback when description-based dispatch does not resolve a role."
+      },
+      provider: {
+        type: "string",
+        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.'
+      },
+      model: {
+        type: "string",
+        description: "Model id within the provider. Defaults to the leader model when omitted."
+      },
+      systemPromptOverride: {
+        type: "string",
+        description: "Extra prompt text appended after the role-base prompt."
+      },
       maxIterations: { type: "number", minimum: 1 },
       maxToolCalls: { type: "number", minimum: 1 },
       maxCostUsd: { type: "number", minimum: 0 },
-      timeoutMs: { type: "number", minimum: 1, description: "Hard wall-clock cap in milliseconds. Defaults to none (idle timeout is the default reaper)." },
-      idleTimeoutMs: { type: "number", minimum: 1, description: "Idle timeout in ms: reap the subagent after this long with no activity. Resets on every iteration/tool call. Default is role/coordinator-specific." },
-      maxTokens: { type: "number", minimum: 1, description: "Maximum total tokens (input + output) the subagent may use." }
+      timeoutMs: {
+        type: "number",
+        minimum: 1,
+        description: "Hard wall-clock cap in milliseconds. Defaults to none (idle timeout is the default reaper)."
+      },
+      idleTimeoutMs: {
+        type: "number",
+        minimum: 1,
+        description: "Idle timeout in ms: reap the subagent after this long with no activity. Resets on every iteration/tool call. Default is role/coordinator-specific."
+      },
+      maxTokens: {
+        type: "number",
+        minimum: 1,
+        description: "Maximum total tokens (input + output) the subagent may use."
+      },
+      worktree: {
+        anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+        description: 'Git-worktree isolation override. true/"required" requires an isolated worktree; false/"off" disables it; "auto" follows fleet policy.'
+      }
     },
     required: []
   };
@@ -6700,7 +6846,8 @@ function makeSpawnTool(director, roster) {
       let cfg;
       if (role && roster) {
         const base = roster[role];
-        if (!base) return { error: `unknown role "${role}". roster has: ${Object.keys(roster).join(", ")}` };
+        if (!base)
+          return { error: `unknown role "${role}". roster has: ${Object.keys(roster).join(", ")}` };
         cfg = instantiateRosterConfig2(role, base);
       } else if (description && !role) {
         const dispatchResult = await dispatchAgent(description, {
@@ -6724,16 +6871,26 @@ function makeSpawnTool(director, roster) {
       if (typeof i.name === "string") cfg.name = i.name;
       if (typeof i.provider === "string") cfg.provider = i.provider;
       if (typeof i.model === "string") cfg.model = i.model;
-      if (typeof i.systemPromptOverride === "string") cfg.systemPromptOverride = i.systemPromptOverride;
+      if (typeof i.systemPromptOverride === "string")
+        cfg.systemPromptOverride = i.systemPromptOverride;
       if (typeof i.maxIterations === "number") cfg.maxIterations = i.maxIterations;
       if (typeof i.maxToolCalls === "number") cfg.maxToolCalls = i.maxToolCalls;
       if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
       if (typeof i.timeoutMs === "number") cfg.timeoutMs = i.timeoutMs;
       if (typeof i.idleTimeoutMs === "number") cfg.idleTimeoutMs = i.idleTimeoutMs;
       if (typeof i.maxTokens === "number") cfg.maxTokens = i.maxTokens;
+      if (typeof i.worktree === "boolean" || i.worktree === "auto" || i.worktree === "required" || i.worktree === "off") {
+        cfg.worktree = i.worktree;
+      }
       try {
         const subagentId = await director.spawn(cfg);
-        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name, role: cfg.role };
+        return {
+          subagentId,
+          provider: cfg.provider,
+          model: cfg.model,
+          name: cfg.name,
+          role: cfg.role
+        };
       } catch (err) {
         if (err instanceof FleetSpawnBudgetError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
@@ -6754,13 +6911,402 @@ function instantiateRosterConfig2(role, base) {
     id: `${role}-${randomUUID().slice(0, 8)}`
   };
 }
+function makeQualityGateTool(director, roster) {
+  return {
+    name: "quality_gate",
+    description: "Run a first-class implementation quality gate. It can await implementer task ids, spawn independent verifier/reviewer agents, summarize their verdicts, and optionally send must-fix feedback back to an implementer until the gate passes or the repair-attempt limit is reached.",
+    usageHint: "Use after code-changing work. Provide implementerTaskIds when available. Add repairSubagentId to iterate fixes automatically. Verdict only passes when every enabled reviewer/verifier explicitly passes.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "Original implementation task or acceptance goal being gated."
+        },
+        implementerTaskIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional completed or in-flight implementer task ids to await and include as implementation evidence."
+        },
+        repairSubagentId: {
+          type: "string",
+          description: "Optional implementer subagent id. When set and the gate fails, quality_gate assigns a repair task with reviewer/verifier feedback and reruns the gate."
+        },
+        maxRepairAttempts: {
+          type: "number",
+          minimum: 0,
+          maximum: 5,
+          description: "Maximum automatic repair iterations. Default: 2 when repairSubagentId is set, otherwise 0."
+        },
+        targets: {
+          type: "array",
+          items: { type: "string" },
+          description: "Files, packages, or paths that reviewer/verifier should focus on."
+        },
+        commands: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Verification commands that should pass, e.g. ["pnpm --filter @wrongstack/core typecheck"].'
+        },
+        expected: {
+          type: "string",
+          description: "Expected behavior or acceptance criteria."
+        },
+        evidence: {
+          type: "string",
+          description: "Known implementation notes, diff summary, or commands already run."
+        },
+        reviewer: {
+          type: "boolean",
+          description: "Whether to run the reviewer lane. Default true."
+        },
+        verifier: {
+          type: "boolean",
+          description: "Whether to run the verifier lane. Default true."
+        },
+        timeoutMs: {
+          type: "number",
+          minimum: 1,
+          description: "Optional per reviewer/verifier/repair task timeout."
+        },
+        reviewerWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Reviewer worktree override. Default off because reviewer is read-only."
+        },
+        verifierWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Verifier worktree override. Default auto so test artifacts stay isolated when fleet policy wants it."
+        }
+      }
+    },
+    async execute(input) {
+      const i = normalizeQualityGateInput(input);
+      const runReviewer = i.reviewer !== false;
+      const runVerifier = i.verifier !== false;
+      if (!runReviewer && !runVerifier) {
+        return {
+          verdict: "inconclusive",
+          passed: false,
+          error: "quality_gate requires reviewer, verifier, or both."
+        };
+      }
+      const implementerResults = i.implementerTaskIds && i.implementerTaskIds.length > 0 ? await director.awaitTasks(i.implementerTaskIds) : [];
+      const maxRepairAttempts = clampRepairAttempts(
+        i.maxRepairAttempts ?? (i.repairSubagentId ? 2 : 0)
+      );
+      const repairResults = [];
+      const attempts = [];
+      for (let attempt = 1; ; attempt++) {
+        const gateTaskIds = [];
+        const taskRoleById = /* @__PURE__ */ new Map();
+        if (runVerifier) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
+          );
+          const taskId = await director.assign({
+            id: randomUUID(),
+            subagentId,
+            description: buildVerifierTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
+          });
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "verifier");
+        }
+        if (runReviewer) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
+          );
+          const taskId = await director.assign({
+            id: randomUUID(),
+            subagentId,
+            description: buildReviewerTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
+          });
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "reviewer");
+        }
+        const gateResults = await director.awaitTasks(gateTaskIds);
+        const reports = gateResults.map((r) => assessRoleResult(taskRoleById.get(r.taskId), r));
+        const assessment = assessQualityGate(reports);
+        attempts.push({ attempt, reports, ...assessment });
+        if (assessment.passed || !i.repairSubagentId || attempt > maxRepairAttempts) {
+          return {
+            verdict: assessment.verdict,
+            passed: assessment.passed,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: assessment.passed ? "accept" : i.repairSubagentId && attempt > maxRepairAttempts ? "manual_intervention_or_raise_repair_limit" : "inspect_failures"
+          };
+        }
+        const repairTaskId = await director.assign({
+          id: randomUUID(),
+          subagentId: i.repairSubagentId,
+          description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
+          timeoutMs: i.timeoutMs
+        });
+        const [repairResult] = await director.awaitTasks([repairTaskId]);
+        if (repairResult) repairResults.push(repairResult);
+        if (repairResult?.status !== "success") {
+          return {
+            verdict: "fail",
+            passed: false,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            repairResult: repairResult ? summarizeTaskResult(repairResult) : void 0,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: "repair_failed"
+          };
+        }
+      }
+    }
+  };
+}
+function normalizeQualityGateInput(input) {
+  const raw = input ?? {};
+  return {
+    task: typeof raw.task === "string" ? raw.task : void 0,
+    implementerTaskIds: stringArray(raw.implementerTaskIds),
+    repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
+    maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
+    targets: stringArray(raw.targets),
+    commands: stringArray(raw.commands),
+    expected: typeof raw.expected === "string" ? raw.expected : void 0,
+    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
+    reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
+    verifier: typeof raw.verifier === "boolean" ? raw.verifier : void 0,
+    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
+    reviewerWorktree: normalizeWorktreeOverride(raw.reviewerWorktree),
+    verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
+  };
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((v) => typeof v === "string" && v.trim().length > 0);
+  return strings.length > 0 ? strings : void 0;
+}
+function normalizeWorktreeOverride(value) {
+  if (typeof value === "boolean") return value;
+  if (value === "auto" || value === "required" || value === "off") return value;
+  return void 0;
+}
+function clampRepairAttempts(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(5, Math.floor(value)));
+}
+function makeQualityGateSubagentConfig(role, roster, worktree) {
+  const base = roster?.[role] ?? getAgentDefinition(role)?.config ?? { name: role, role };
+  return {
+    ...instantiateRosterConfig2(role, base),
+    worktree
+  };
+}
+function buildVerifierTask(input, state) {
+  return [
+    "Run the independent verification gate for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict word exactly `pass`, `fail`, or `blocked`.",
+    "Do not edit code. Run the smallest meaningful command set and include exact failures.",
+    "",
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Required or suggested commands:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
+}
+function buildReviewerTask(input, state) {
+  return [
+    "Run independent code review for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict phrase exactly `approve`, `request changes`, or `needs verification`.",
+    "Do not edit code. Treat missing proof, vague tests, and uncertainty as blocking until verifier evidence exists.",
+    "",
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
+}
+function buildRepairTask(input, attempt, attemptNumber) {
+  return [
+    `Repair the implementation after quality gate attempt ${attemptNumber} failed.`,
+    "Address every must-fix item. Run relevant checks before returning.",
+    "Do not claim done unless verifier/reviewer feedback is resolved.",
+    "",
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Commands expected to pass:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    attempt.mustFix.length ? `Must fix:
+${attempt.mustFix.map((f) => `- ${f}`).join("\n")}` : void 0,
+    attempt.uncertaintyFlags.length ? `Uncertainty flags to resolve:
+${attempt.uncertaintyFlags.map((f) => `- ${f}`).join("\n")}` : void 0,
+    `Reviewer/verifier reports:
+${attempt.reports.map((r) => `### ${r.role} (${r.verdict})
+${r.summary}`).join("\n\n")}`
+  ].filter((part) => !!part).join("\n\n");
+}
+function taskResultsBlock(title, results) {
+  if (results.length === 0) return void 0;
+  return `${title}:
+${results.map((r) => `### ${r.subagentId}/${r.taskId}
+${summarizeTaskResult(r).summary}`).join("\n\n")}`;
+}
+function priorAttemptsBlock(attempts) {
+  if (attempts.length === 0) return void 0;
+  return `Prior quality gate attempts:
+${attempts.map(
+    (a) => `### Attempt ${a.attempt}
+${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : ""}`).join("\n")}`
+  ).join("\n\n")}`;
+}
+function summarizeTaskResult(result) {
+  const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
+  const error = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
+  return {
+    taskId: result.taskId,
+    subagentId: result.subagentId,
+    status: result.status,
+    summary: excerpt(text || error || "(no output)", 4e3),
+    error
+  };
+}
+function assessRoleResult(role, result) {
+  const resolvedRole = role ?? (result.subagentId.includes("review") ? "reviewer" : "verifier");
+  const summary = summarizeTaskResult(result);
+  const text = summary.summary;
+  const uncertaintyFlags = extractSection(text, "Uncertainty Flags");
+  if (result.status !== "success") {
+    return {
+      role: resolvedRole,
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      status: result.status,
+      verdict: "fail",
+      summary: text,
+      uncertaintyFlags,
+      error: summary.error ?? result.status
+    };
+  }
+  return {
+    role: resolvedRole,
+    subagentId: result.subagentId,
+    taskId: result.taskId,
+    status: result.status,
+    verdict: parseQualityVerdict(resolvedRole, text),
+    summary: text,
+    uncertaintyFlags
+  };
+}
+function assessQualityGate(reports) {
+  const mustFix = [];
+  const uncertaintyFlags = [];
+  let hasFail = false;
+  let hasInconclusive = false;
+  for (const report of reports) {
+    if (report.verdict === "fail") hasFail = true;
+    if (report.verdict === "inconclusive") hasInconclusive = true;
+    const blocking = extractSection(report.summary, "Must Fix") || extractSection(report.summary, "Failures") || extractSection(report.summary, "Verification Gaps");
+    if (blocking) mustFix.push(`${report.role}: ${excerpt(blocking, 1e3)}`);
+    if (report.uncertaintyFlags) {
+      uncertaintyFlags.push(`${report.role}: ${excerpt(report.uncertaintyFlags, 1e3)}`);
+    }
+    if (report.error) mustFix.push(`${report.role}: ${report.error}`);
+  }
+  if (hasFail) return { verdict: "fail", passed: false, mustFix, uncertaintyFlags };
+  if (hasInconclusive || reports.length === 0) {
+    return { verdict: "inconclusive", passed: false, mustFix, uncertaintyFlags };
+  }
+  return { verdict: "pass", passed: true, mustFix, uncertaintyFlags };
+}
+function parseQualityVerdict(role, text) {
+  const normalized = text.toLowerCase();
+  const verdictBlock = normalized.match(/(?:^|\n)\s*(?:#+\s*)?verdict\b[^\n]*(?:\n|:|-)?([\s\S]{0,500})/)?.[0] ?? normalized.slice(0, 1e3);
+  if (role === "reviewer") {
+    if (/\b(request\s+changes|needs\s+verification|reject|rejected|fail|failed|blocked)\b/.test(
+      verdictBlock
+    )) {
+      return "fail";
+    }
+    if (/\b(approve|approved|pass|passed)\b/.test(verdictBlock)) return "pass";
+    if (sectionHasBlockingContent(text, "Must Fix") || sectionHasBlockingContent(text, "Verification Gaps")) {
+      return "fail";
+    }
+    return "inconclusive";
+  }
+  if (/\b(fail|failed|blocked|red)\b/.test(verdictBlock)) return "fail";
+  if (/\b(pass|passed|green|approve|approved)\b/.test(verdictBlock)) return "pass";
+  if (sectionHasBlockingContent(text, "Failures")) return "fail";
+  return "inconclusive";
+}
+function sectionHasBlockingContent(text, heading) {
+  const section = extractSection(text, heading);
+  if (!section) return false;
+  return !/^\s*(none|n\/a|no\b|no issues|empty|\(none\))\s*\.?\s*$/i.test(section.trim());
+}
+function extractSection(text, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:^|\\n)\\s*#{1,6}\\s*${escaped}\\s*\\n([\\s\\S]*?)(?=\\n\\s*#{1,6}\\s+|$)`,
+    "i"
+  );
+  const match = text.match(pattern);
+  const body = match?.[1]?.trim();
+  return body ? body : void 0;
+}
+function excerpt(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 20).trimEnd()}
+...(truncated)`;
+}
 function makeAssignTool(director) {
   const inputSchema = {
     type: "object",
     properties: {
       subagentId: { type: "string", minLength: 1, description: "Target subagent id. Required." },
-      description: { type: "string", minLength: 1, description: "The task in natural language \u2014 what you want this subagent to do." },
-      maxToolCalls: { type: "number", minimum: 1, description: "Optional per-task tool-call budget override." },
+      description: {
+        type: "string",
+        minLength: 1,
+        description: "The task in natural language \u2014 what you want this subagent to do."
+      },
+      maxToolCalls: {
+        type: "number",
+        minimum: 1,
+        description: "Optional per-task tool-call budget override."
+      },
       timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
     },
     required: ["subagentId", "description"]
@@ -6774,7 +7320,13 @@ function makeAssignTool(director) {
     inputSchema,
     async execute(input) {
       const i = input;
-      const task = { id: randomUUID(), description: i.description, subagentId: i.subagentId, maxToolCalls: i.maxToolCalls, timeoutMs: i.timeoutMs };
+      const task = {
+        id: randomUUID(),
+        description: i.description,
+        subagentId: i.subagentId,
+        maxToolCalls: i.maxToolCalls,
+        timeoutMs: i.timeoutMs
+      };
       const taskId = await director.assign(task);
       return { taskId, subagentId: i.subagentId };
     }
@@ -6790,22 +7342,39 @@ function makeAwaitTasksTool(director) {
     inputSchema: {
       type: "object",
       properties: {
-        taskIds: { type: "array", items: { type: "string" }, description: "One or more task ids returned by `assign_task`." },
-        mode: { type: "string", enum: ["all", "any"], description: '"all" (default): block until every task completes. "any": return on the first completion with the rest listed as pending.' },
-        timeoutMs: { type: "number", minimum: 1, description: 'mode:"any" only \u2014 return {timedOut:true, completed:[]} if nothing completes within this window instead of blocking.' }
+        taskIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "One or more task ids returned by `assign_task`."
+        },
+        mode: {
+          type: "string",
+          enum: ["all", "any"],
+          description: '"all" (default): block until every task completes. "any": return on the first completion with the rest listed as pending.'
+        },
+        timeoutMs: {
+          type: "number",
+          minimum: 1,
+          description: 'mode:"any" only \u2014 return {timedOut:true, completed:[]} if nothing completes within this window instead of blocking.'
+        }
       },
       required: ["taskIds"]
     },
     async execute(input) {
       const i = input;
       if (i.mode === "any") {
-        const r = await director.awaitTasksAny(i.taskIds, i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : void 0);
+        const r = await director.awaitTasksAny(
+          i.taskIds,
+          i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : void 0
+        );
         return {
           mode: "any",
           completed: r.completed,
           pending: r.pending,
           ...r.timedOut ? { timedOut: true } : {},
-          ...r.pending.length > 0 ? { hint: 'Handle the completed results now. Re-call await_tasks with the pending ids (mode:"any") for the next finisher \u2014 or assign new work to the now-idle subagent first.' } : {}
+          ...r.pending.length > 0 ? {
+            hint: 'Handle the completed results now. Re-call await_tasks with the pending ids (mode:"any") for the next finisher \u2014 or assign new work to the now-idle subagent first.'
+          } : {}
         };
       }
       const results = await director.awaitTasks(i.taskIds);
@@ -6823,9 +7392,17 @@ function makeAskTool(director) {
     inputSchema: {
       type: "object",
       properties: {
-        subagentId: { type: "string", minLength: 1, description: "Subagent to ask. Must be a previously spawned id." },
+        subagentId: {
+          type: "string",
+          minLength: 1,
+          description: "Subagent to ask. Must be a previously spawned id."
+        },
         question: { type: "string", minLength: 1, description: "The question or instruction." },
-        timeoutMs: { type: "number", minimum: 1, description: "Optional timeout in ms (default 30s)." }
+        timeoutMs: {
+          type: "number",
+          minimum: 1,
+          description: "Optional timeout in ms (default 30s)."
+        }
       },
       required: ["subagentId", "question"]
     },
@@ -6871,7 +7448,10 @@ function makeAskResultTool(director) {
       const i = input;
       const value = director.largeAnswerStore.retrieveAnswer(i.key);
       if (value === void 0) {
-        return { ok: false, error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.` };
+        return {
+          ok: false,
+          error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.`
+        };
       }
       return { ok: true, value };
     }
@@ -6887,8 +7467,16 @@ function makeRollUpTool(director) {
     inputSchema: {
       type: "object",
       properties: {
-        taskIds: { type: "array", items: { type: "string" }, description: "Completed task ids to aggregate." },
-        style: { type: "string", enum: ["markdown", "json"], description: "Output flavor \u2014 markdown (default) or json." }
+        taskIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Completed task ids to aggregate."
+        },
+        style: {
+          type: "string",
+          enum: ["markdown", "json"],
+          description: "Output flavor \u2014 markdown (default) or json."
+        }
       },
       required: ["taskIds"]
     },
@@ -6906,7 +7494,11 @@ function makeTerminateTool(director) {
     permission: "auto",
     mutating: true,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
+    inputSchema: {
+      type: "object",
+      properties: { subagentId: { type: "string", description: "Subagent to abort." } },
+      required: ["subagentId"]
+    },
     async execute(input) {
       const i = input;
       await director.terminate(i.subagentId);
@@ -6924,7 +7516,10 @@ function makeTerminateAllTool(director) {
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
       await director.terminateAll();
-      return { ok: true, message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.` };
+      return {
+        ok: true,
+        message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.`
+      };
     }
   };
 }
@@ -6966,7 +7561,12 @@ function makeFleetTool(director) {
           return {
             action: "status",
             subagents: base.subagents,
-            coordinatorStats: stats ? { total: stats.total, running: stats.running, idle: stats.idle, stopped: stats.stopped } : void 0,
+            coordinatorStats: stats ? {
+              total: stats.total,
+              running: stats.running,
+              idle: stats.idle,
+              stopped: stats.stopped
+            } : void 0,
             pending: fleetStatus?.pending ?? [],
             usage: fm?.snapshot()
           };
@@ -6999,7 +7599,10 @@ function makeFleetTool(director) {
         case "session": {
           const subagentId = i.subagentId;
           if (!subagentId) {
-            return { action: "session", error: 'fleet: subagentId is required for action: "session"' };
+            return {
+              action: "session",
+              error: 'fleet: subagentId is required for action: "session"'
+            };
           }
           const result = await director.readSession(subagentId, i.tail);
           if (!result) {
@@ -7011,7 +7614,9 @@ function makeFleetTool(director) {
           return { action: "session", ...result };
         }
         default:
-          return { error: `fleet: unknown action "${action}". Valid: status, usage, health, session.` };
+          return {
+            error: `fleet: unknown action "${action}". Valid: status, usage, health, session.`
+          };
       }
     }
   };
@@ -7487,14 +8092,18 @@ var ROLE_TO_PHASE = (() => {
 function phaseForRole(role) {
   return role ? ROLE_TO_PHASE[role] : void 0;
 }
-function resolveModelMatrix(matrix, role) {
+function resolveModelMatrixResolution(matrix, role) {
   if (!matrix) return void 0;
-  if (role && matrix[role]) return matrix[role];
+  if (role && matrix[role]) return { entry: matrix[role], source: "role", key: role };
   const phase = phaseForRole(role);
-  if (phase && matrix[phase]) return matrix[phase];
-  if (matrix["*"]) return matrix["*"];
+  if (phase && matrix[phase]) return { entry: matrix[phase], source: "phase", key: phase };
+  if (matrix["*"]) return { entry: matrix["*"], source: "default", key: "*" };
   return void 0;
 }
+function roleNeedsIndependentReviewModel(role) {
+  if (!role) return false;
+  return role === "reviewer" || phaseForRole(role) === "review";
+}
 
 // src/coordination/coordinator/error-classifier.ts
 init_errors();
@@ -8518,48 +9127,201 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   }
 };
 
-// src/coordination/director/director-errors.ts
-var FleetSpawnBudgetError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(kind, limit, observed, message) {
-    const defaultMsg = kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`;
-    super(message ?? defaultMsg);
-    this.name = "FleetSpawnBudgetError";
-    this.kind = kind;
-    this.limit = limit;
-    this.observed = observed;
+// src/coordination/worktree-task-runner.ts
+init_error();
+var WorktreeIntegrationError = class extends Error {
+  taskId;
+  subagentId;
+  branch;
+  conflictFiles;
+  constructor(message, opts) {
+    super(message);
+    this.name = "WorktreeIntegrationError";
+    this.taskId = opts.taskId;
+    this.subagentId = opts.subagentId;
+    this.branch = opts.branch;
+    this.conflictFiles = opts.conflictFiles;
   }
 };
-var FleetCostCapError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(limit, observed) {
-    super(
-      `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
-    );
-    this.name = "FleetCostCapError";
-    this.kind = "max_cost_usd";
-    this.limit = limit;
-    this.observed = observed;
+var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "write",
+  "edit",
+  "replace",
+  "patch",
+  "task",
+  "plan",
+  "design",
+  "document",
+  "scaffold",
+  "bash",
+  "exec",
+  "lint",
+  "format",
+  "typecheck",
+  "test",
+  "install"
+]);
+var MUTATING_CAPABILITIES = /* @__PURE__ */ new Set([
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.PACKAGE_INSTALL
+]);
+function subagentNeedsWorktree(config) {
+  if (config.provider === "acp") return false;
+  if (config.tools?.some((tool) => MUTATING_TOOL_NAMES.has(tool))) return true;
+  if (config.allowedCapabilities?.some((cap) => MUTATING_CAPABILITIES.has(cap))) return true;
+  return !config.tools && !config.allowedCapabilities;
+}
+function resolveSubagentWorktreeDecision(config, policy) {
+  if (policy?.enabled === false || policy?.mode === "off") return "off";
+  if (config.worktree === false || config.worktree === "off") return "off";
+  if (config.worktree === true || config.worktree === "required") return "required";
+  const needsIsolation = subagentNeedsWorktree(config);
+  if (!needsIsolation) return "off";
+  return policy?.mode === "required" ? "required" : "optional";
+}
+function wrapSubagentRunnerWithWorktrees(opts) {
+  return async (task, ctx) => {
+    const decision = resolveSubagentWorktreeDecision(ctx.config, opts.policy);
+    if (decision === "off") return opts.runner(task, ctx);
+    if (!opts.worktrees) {
+      if (decision === "required") {
+        throw new WorktreeIntegrationError(
+          "worktree isolation is required but no WorktreeManager is configured",
+          {
+            taskId: task.id,
+            subagentId: ctx.subagentId
+          }
+        );
+      }
+      return opts.runner(task, ctx);
+    }
+    const handle = await opts.worktrees.allocate(task.id, {
+      slugHint: worktreeSlugHint(task, ctx.config),
+      ownerLabel: worktreeOwnerLabel(task, ctx.config)
+    });
+    if (handle.status !== "active") {
+      emitUpdate(opts, task, ctx, handle, {
+        status: "fallback",
+        error: handle.lastError ?? "worktree allocation failed"
+      });
+      if (decision === "required") {
+        throw new WorktreeIntegrationError(
+          `worktree allocation failed: ${handle.lastError ?? "unknown error"}`,
+          {
+            taskId: task.id,
+            subagentId: ctx.subagentId,
+            branch: handle.branch
+          }
+        );
+      }
+      return opts.runner(task, ctx);
+    }
+    emitUpdate(opts, task, ctx, handle, { status: "allocated" });
+    const isolatedConfig = { ...ctx.config, cwd: handle.dir };
+    const isolatedCtx = { ...ctx, config: isolatedConfig };
+    let outcome;
+    try {
+      outcome = await opts.runner(task, isolatedCtx);
+    } catch (err) {
+      await parkFailedWorktree(opts, task, ctx, handle, err);
+      throw err;
+    }
+    await integrateSuccessfulWorktree(opts, task, ctx, isolatedConfig, handle);
+    return outcome;
+  };
+}
+async function integrateSuccessfulWorktree(opts, task, ctx, config, handle) {
+  const committed = await opts.worktrees.commitAll(
+    handle,
+    `subagent(${config.role ?? config.name}): ${task.id}`
+  );
+  if (!committed.committed) {
+    await opts.worktrees.release(handle, { keep: false });
+    emitUpdate(opts, task, ctx, handle, { status: "released" });
+    return;
   }
-};
-var FleetContextOverflowError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(limit, observed) {
-    super(
-      `Leader context overflow: leader has ${observed} tokens in flight (limit: ${limit}). Compact the leader context before spawning more subagents.`
+  emitUpdate(opts, task, ctx, handle, { status: "committed", commitSha: handle.sha });
+  if (opts.policy?.autoMerge === false) {
+    await opts.worktrees.release(handle, { keep: true });
+    emitUpdate(opts, task, ctx, handle, { status: "kept", commitSha: handle.sha });
+    return;
+  }
+  const merged = await opts.worktrees.merge(handle, {
+    squash: true,
+    message: `merge subagent ${ctx.subagentId} task ${task.id} (squash)`,
+    ...opts.conflictResolver ? {
+      resolve: (info) => opts.conflictResolver({
+        task,
+        config,
+        conflictFiles: info.conflictFiles,
+        cwd: info.cwd
+      })
+    } : {}
+  });
+  if (!merged.ok) {
+    await opts.worktrees.release(handle, { keep: true }).catch(() => void 0);
+    const conflictFiles = merged.conflictFiles ?? [];
+    emitUpdate(opts, task, ctx, handle, {
+      status: merged.conflict ? "conflict" : "failed",
+      commitSha: handle.sha,
+      conflictFiles,
+      error: merged.stderr || (merged.conflict ? "merge conflict" : "worktree merge failed")
+    });
+    throw new WorktreeIntegrationError(
+      merged.conflict ? `worktree merge conflict${conflictFiles.length ? `: ${conflictFiles.join(", ")}` : ""}` : `worktree merge failed: ${merged.stderr ?? "unknown error"}`,
+      {
+        taskId: task.id,
+        subagentId: ctx.subagentId,
+        branch: handle.branch,
+        conflictFiles
+      }
     );
-    this.name = "FleetContextOverflowError";
-    this.kind = "max_context_load";
-    this.limit = limit;
-    this.observed = observed;
   }
-};
+  await opts.worktrees.release(handle, { keep: false });
+  emitUpdate(opts, task, ctx, handle, { status: "merged", commitSha: handle.sha });
+}
+async function parkFailedWorktree(opts, task, ctx, handle, err) {
+  let committed = false;
+  try {
+    const res = await opts.worktrees.commitAll(
+      handle,
+      `subagent(${ctx.config.role ?? ctx.config.name}) failed: ${task.id}`
+    );
+    committed = res.committed;
+  } catch {
+    committed = false;
+  }
+  const keep = (opts.policy?.keepFailed ?? true) && committed;
+  await opts.worktrees.release(handle, { keep }).catch(() => void 0);
+  emitUpdate(opts, task, ctx, handle, {
+    status: keep ? "kept" : "released",
+    commitSha: handle.sha,
+    error: toErrorMessage(err)
+  });
+}
+function emitUpdate(opts, task, ctx, handle, patch) {
+  opts.onUpdate?.({
+    taskId: task.id,
+    subagentId: ctx.subagentId,
+    handleId: handle.id,
+    dir: handle.dir,
+    branch: handle.branch,
+    baseBranch: handle.baseBranch,
+    ...patch
+  });
+}
+function worktreeSlugHint(task, config) {
+  return `${config.role ?? config.name ?? "subagent"}-${task.id}`;
+}
+function worktreeOwnerLabel(task, config) {
+  const who = config.name || config.role || "Subagent";
+  const brief = task.description.trim().replace(/\s+/g, " ").slice(0, 80);
+  return brief ? `${who}: ${brief}` : who;
+}
 
 // src/coordination/director.ts
 var Director = class _Director {
@@ -8691,6 +9453,8 @@ var Director = class _Director {
   /** Resolves task descriptions back from `assign()` so completion events
    *  can also carry a human-readable title. */
   taskDescriptions = /* @__PURE__ */ new Map();
+  /** Latest worktree state per task id (allocated/committed/merged/conflict/etc.). */
+  taskWorktrees = /* @__PURE__ */ new Map();
   /** Snapshot of which subagent owns each task — drives state-checkpoint
    *  status updates without re-walking the manifest. */
   taskOwners = /* @__PURE__ */ new Map();
@@ -8804,9 +9568,16 @@ var Director = class _Director {
         (id) => this.subagentMeta.get(id)
       );
     }
+    const runner = opts.runner && (opts.worktrees || opts.worktreePolicy) ? wrapSubagentRunnerWithWorktrees({
+      runner: opts.runner,
+      worktrees: opts.worktrees,
+      policy: opts.worktreePolicy,
+      conflictResolver: opts.worktreeConflictResolver,
+      onUpdate: (update) => this.recordWorktreeTaskUpdate(update)
+    }) : opts.runner;
     this.coordinator = new DefaultMultiAgentCoordinator(
       { ...opts.config, coordinatorId: this.id },
-      { runner: opts.runner, sessionId: () => this.currentSessionId() }
+      { runner, sessionId: () => this.currentSessionId() }
     );
     this.coordinator.setFleetBus(this.fleet);
     this.fleetManager?.setCoordinator(this.coordinator);
@@ -9176,6 +9947,17 @@ var Director = class _Director {
     clearTimeout(this.manifestTimer);
     this.manifestTimer = null;
   }
+  recordWorktreeTaskUpdate(update) {
+    this.taskWorktrees.set(update.taskId, update);
+    const owner = this.taskOwners.get(update.taskId) ?? update.subagentId;
+    const entry = this.manifestEntries.get(owner);
+    if (entry) {
+      entry.worktrees = { ...entry.worktrees ?? {}, [update.taskId]: update };
+    }
+    this.stateCheckpoint?.recordTaskWorktree(update.taskId, update);
+    this.fleetManager?.recordTaskWorktree(update);
+    if (!this.fleetManager) this.scheduleManifest();
+  }
   /**
    * Spawn a subagent. Identical to the coordinator's `spawn()` but
    * captures provider/model metadata for the usage aggregator and
@@ -9197,7 +9979,8 @@ var Director = class _Director {
     const config = { ...callerConfig };
     if (!config.model && this.modelMatrix) {
       const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
-      const entry = resolveModelMatrix(matrix, config.role);
+      const resolution = resolveModelMatrixResolution(matrix, config.role);
+      const entry = resolution?.source === "default" && roleNeedsIndependentReviewModel(config.role) ? void 0 : resolution?.entry;
       if (entry?.model) {
         config.model = entry.model;
         if (entry.provider) config.provider = entry.provider;
@@ -9417,13 +10200,15 @@ var Director = class _Director {
         // success/failure state.
         results: e.taskIds.map((tid) => {
           const r = this.completed.get(tid);
+          const worktree = e.worktrees?.[tid];
           return r ? {
             taskId: tid,
             status: r.status,
             iterations: r.iterations,
             toolCalls: r.toolCalls,
-            durationMs: r.durationMs
-          } : { taskId: tid, status: "pending" };
+            durationMs: r.durationMs,
+            ...worktree ? { worktree } : {}
+          } : { taskId: tid, status: "pending", ...worktree ? { worktree } : {} };
         })
       })),
       usage: this.usage.snapshot()
@@ -9862,6 +10647,7 @@ var Director = class _Director {
       makeAskTool(this),
       makeAskResultTool(this),
       makeRollUpTool(this),
+      makeQualityGateTool(this, effectiveRoster),
       makeTerminateTool(this),
       makeTerminateAllTool(this),
       makeFleetTool(this),
@@ -17319,11 +18105,16 @@ ${errorDetails}`,
             ctx
           );
           if (post.additionalContext) {
-            const appended = `
+            if (post.contextAs === "separate") {
+              const block = { type: "text", text: post.additionalContext };
+              ctx.state.appendMessage({ role: "user", content: [block] });
+            } else {
+              const appended = `
 
 ${post.additionalContext}`;
-            result = { ...result, content: `${result.content}${appended}` };
-            budget = Math.max(0, budget - Buffer.byteLength(appended, "utf8"));
+              result = { ...result, content: `${result.content}${appended}` };
+              budget = Math.max(0, budget - Buffer.byteLength(appended, "utf8"));
+            }
           }
         }
         const outputChars = typeof result.content === "string" ? result.content.length : 0;
@@ -17557,6 +18348,11 @@ ${progressTail}`;
           break;
         }
         if (ev.type === "partial_output" && typeof ev.text === "string") {
+          if (ev.data?.["livePreview"] === true) {
+            flushProgressTail(true);
+            emitProgress(ev);
+            continue;
+          }
           if (!headComplete) {
             const remaining = _ToolExecutor.PROGRESS_HEAD_CHARS - progressHead.length;
             if (ev.text.length <= remaining) {
@@ -17602,9 +18398,9 @@ ${progressTail}`;
     let content = `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`;
     if (raw) {
       const max = 800;
-      const excerpt = raw.length > max ? `${raw.slice(0, max)}\u2026 (truncated, ${raw.length} chars total)` : raw;
+      const excerpt2 = raw.length > max ? `${raw.slice(0, max)}\u2026 (truncated, ${raw.length} chars total)` : raw;
       content += ` Common cause: a string field (e.g. code in old_string/new_string) contains literal newlines, quotes, or backslashes that must be JSON-escaped, or the payload was cut off mid-stream. The raw arguments received were:
-${excerpt}`;
+${excerpt2}`;
     }
     return {
       type: "tool_result",
@@ -18376,7 +19172,7 @@ var CODEX_MODELS = [
   {
     id: "gpt-5.3-codex-spark",
     name: "GPT-5.3 Codex Spark",
-    description: "Ultra-fast coding model."
+    description: "Ultra-fast coding model (research preview)."
   }
 ];
 var BY_ID = new Map(CODEX_MODELS.map((m) => [m.id, m]));
@@ -18653,6 +19449,7 @@ var FAMILY_BY_NPM = {
   "@ai-sdk/gateway": "openai-compatible",
   "@aihubmix/ai-sdk-provider": "openai-compatible",
   "venice-ai-sdk-provider": "openai-compatible",
+  "@ai-sdk/deepseek": "openai-compatible",
   "@ai-sdk/google": "google"
 };
 function classifyFamily(npm) {
@@ -18752,7 +19549,9 @@ var DefaultModelsRegistry = class {
       }
       if (overlayAvailable) {
         console.warn(
-          `ModelsRegistry: models.dev unavailable (${toErrorMessage(err)}); serving curated overlay only.`
+          `ModelsRegistry: models.dev unavailable (${toErrorMessage(
+            err
+          )}); serving curated overlay only.`
         );
         return {};
       }
@@ -18829,11 +19628,12 @@ var DefaultModelsRegistry = class {
         method: "GET",
         headers: { accept: "application/json" }
       });
-      if (!res.ok) throw new FetchError({
-        message: `HTTP ${res.status}`,
-        status: res.status,
-        context: { url: this.url, op: "refreshModels" }
-      });
+      if (!res.ok)
+        throw new FetchError({
+          message: `HTTP ${res.status}`,
+          status: res.status,
+          context: { url: this.url, op: "refreshModels" }
+        });
       const json = await res.json();
       const envelope = {
         fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -22236,6 +23036,15 @@ var WorktreeManager = class {
   async merge(handle, opts = {}) {
     const squash = opts.squash ?? true;
     this.setStatus(handle, "merging");
+    const status = await this.runGit(
+      ["status", "--porcelain", "--untracked-files=no"],
+      this.projectRoot
+    );
+    if (status.stdout.trim().length > 0) {
+      const reason = "working tree has uncommitted changes \u2014 commit or stash first";
+      this.fail(handle, reason);
+      return { ok: false, stderr: reason };
+    }
     const checkout = await this.runGit(["checkout", handle.baseBranch], this.projectRoot);
     if (checkout.code !== 0) {
       this.fail(handle, checkout.stderr || `checkout ${handle.baseBranch} failed`);
@@ -22463,7 +23272,12 @@ ${merged.stderr}`);
       const fromIndex = await this.unmergedFiles();
       const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
       await this.runGit(["reset", "--hard", "HEAD"], this.projectRoot).catch(() => void 0);
-      return { ok: false, conflict: true, conflictFiles, reason: merged.stderr || "merge conflict" };
+      return {
+        ok: false,
+        conflict: true,
+        conflictFiles,
+        reason: merged.stderr || "merge conflict"
+      };
     }
     const idArgs = await this.identityArgs(this.projectRoot);
     const commit = await this.runGit(
@@ -22565,7 +23379,11 @@ ${merged.stderr}`);
     if (shas.length === 0) return { ok: true, reverted: 0, reason: "nothing to revert" };
     const status = await this.runGit(["status", "--porcelain"], this.projectRoot);
     if (status.stdout.trim().length > 0) {
-      return { ok: false, reverted: 0, reason: "working tree has uncommitted changes \u2014 commit or stash first" };
+      return {
+        ok: false,
+        reverted: 0,
+        reason: "working tree has uncommitted changes \u2014 commit or stash first"
+      };
     }
     const co = await this.runGit(["checkout", baseBranch], this.projectRoot);
     if (co.code !== 0) {