@wrongstack/core 0.281.1 → 0.282.0

package/dist/coordination/index.js

@@ -1855,6 +1855,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",
@@ -2121,6 +2149,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",
@@ -3977,6 +4033,28 @@ var FLEET_ROSTER_WITHACP = {
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
 };
 
+// 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 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 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 read or write inter-agent mailbox messages. */
+  COORDINATION_MAIL: "coordination.mail",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+
 // src/coordination/delegate-tool.ts
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 30 * 60 * 1e3;
@@ -4048,6 +4126,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;
@@ -4647,9 +4726,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();
@@ -4692,10 +4786,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) {
@@ -4705,6 +4796,49 @@ var DirectorStateCheckpoint = class {
     }
   }
 };
+
+// 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) {
@@ -4929,32 +5063,57 @@ function makeLLMClassifier(complete) {
   };
 }
 
-// src/security/capabilities.ts
-var ToolCapabilities = {
-  /** 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 read or write inter-agent mailbox messages. */
-  COORDINATION_MAIL: "coordination.mail"};
-
 // 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: []
   };
@@ -4973,7 +5132,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, {
@@ -4997,16 +5157,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 };
@@ -5027,13 +5197,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"]
@@ -5047,7 +5606,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 };
     }
@@ -5063,22 +5628,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);
@@ -5096,9 +5678,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"]
     },
@@ -5144,7 +5734,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 };
     }
@@ -5160,9 +5753,17 @@ 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"]
     },
     async execute(input) {
@@ -5179,7 +5780,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);
@@ -5197,7 +5802,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.`
+      };
     }
   };
 }
@@ -5239,7 +5847,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()
           };
@@ -5272,7 +5885,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) {
@@ -5284,7 +5900,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.`
+          };
       }
     }
   };
@@ -5728,6 +6346,31 @@ function providerStatusToCode(status, type) {
   if (status >= 500) return ERROR_CODES.PROVIDER_SERVER_ERROR;
   return ERROR_CODES.PROVIDER_INVALID_REQUEST;
 }
+
+// src/core/fallback-model.ts
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+function fallbackProfileChain(config, profileName) {
+  if (!profileName) return [];
+  const chain = config.fallbackProfiles?.[profileName];
+  return Array.isArray(chain) ? chain.filter((ref) => parseModelRef(ref).model) : [];
+}
+
+// src/coordination/model-matrix.ts
+var MATRIX_PHASE_KEYS = Object.keys(AGENTS_BY_PHASE);
 var ROLE_TO_PHASE = (() => {
   const map = {};
   for (const [phase, defs] of Object.entries(AGENTS_BY_PHASE)) {
@@ -5741,14 +6384,162 @@ 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 resolveModelMatrix(matrix, role) {
+  return resolveModelMatrixResolution(matrix, role)?.entry;
+}
+function resolveModelTargetFromEntry(config, entry) {
+  if (!entry) return void 0;
+  if (entry.model) {
+    return {
+      provider: entry.provider,
+      model: entry.model,
+      modelRuntime: entry.modelRuntime,
+      fallbackProfile: entry.fallbackProfile,
+      fallbackModels: fallbackProfileChain(config, entry.fallbackProfile)
+    };
+  }
+  const chain = fallbackProfileChain(config, entry.fallbackProfile);
+  const first = chain[0];
+  if (!first) {
+    return entry.modelRuntime ? { modelRuntime: entry.modelRuntime } : void 0;
+  }
+  const parsed = parseModelRef(first);
+  return {
+    provider: parsed.provider,
+    model: parsed.model,
+    modelRuntime: entry.modelRuntime,
+    fallbackProfile: entry.fallbackProfile,
+    fallbackModels: chain.slice(1)
+  };
+}
+function roleNeedsIndependentReviewModel(role) {
+  if (!role) return false;
+  return role === "reviewer" || phaseForRole(role) === "review";
+}
+function resolveSubagentModelTarget(config, role, opts = {}) {
+  const resolution = resolveModelMatrixResolution(config.modelMatrix, role);
+  const matrixTarget = resolveModelTargetFromEntry(config, resolution?.entry);
+  const implementationTarget = opts.implementationTarget ?? resolveImplementationModelTarget(config);
+  if (!roleNeedsIndependentReviewModel(role)) {
+    if (!matrixTarget) return void 0;
+    return {
+      ...matrixTarget,
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const matrixRef = materializeTarget(config, matrixTarget);
+  if (resolution?.source === "role" || resolution?.source === "phase") {
+    return matrixTarget ? { ...matrixTarget, source: "matrix", matrixSource: resolution.source } : void 0;
+  }
+  if (matrixRef && !sameModelReference(matrixRef, implementationTarget)) {
+    return {
+      ...matrixTarget ?? {},
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const diverse = chooseDiverseModelTarget(config, implementationTarget);
+  if (diverse) {
+    return {
+      provider: diverse.provider,
+      model: diverse.model,
+      modelRuntime: matrixTarget?.modelRuntime,
+      fallbackModels: matrixTarget?.fallbackModels,
+      fallbackProfile: matrixTarget?.fallbackProfile,
+      source: "diversity",
+      matrixSource: resolution?.source,
+      diversified: true
+    };
+  }
+  if (!matrixTarget) return void 0;
+  return {
+    ...matrixTarget,
+    source: "matrix",
+    matrixSource: resolution?.source
+  };
+}
+function resolveImplementationModelTarget(config) {
+  const target = resolveModelTargetFromEntry(
+    config,
+    resolveModelMatrix(config.modelMatrix, "executor")
+  );
+  return materializeTarget(config, target) ?? {
+    provider: config.provider,
+    model: config.model
+  };
+}
+function sameModelReference(a, b) {
+  if (!a?.model || !b?.model) return false;
+  const providerA = a.provider ?? "";
+  const providerB = b.provider ?? "";
+  return providerA === providerB && a.model === b.model;
+}
+function materializeTarget(config, target) {
+  if (!target?.model) return void 0;
+  return {
+    provider: target.provider ?? config.provider,
+    model: target.model
+  };
+}
+function chooseDiverseModelTarget(config, avoid) {
+  const candidates = collectConfiguredModelTargets(config).filter(
+    (candidate) => !sameModelReference(candidate, avoid)
+  );
+  candidates.sort((a, b) => modelDiversityScore(b, avoid) - modelDiversityScore(a, avoid));
+  return candidates[0];
+}
+function collectConfiguredModelTargets(config) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (provider, model) => {
+    if (!provider || !model) return;
+    const key = `${provider}\0${model}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ provider, model });
+  };
+  add(config.provider, config.model);
+  for (const [providerId, provider] of Object.entries(config.providers ?? {})) {
+    if (!isProviderAvailable(providerId, provider, config.provider)) continue;
+    for (const model of provider.models ?? []) add(providerId, model);
+    for (const model of Object.keys(provider.customModels ?? {})) add(providerId, model);
+  }
+  for (const model of Object.keys(config.models ?? {})) add(config.provider, model);
+  return out;
+}
+function isProviderAvailable(providerId, provider, leaderProvider) {
+  if (providerId === leaderProvider) return true;
+  if (typeof provider.apiKey === "string" && provider.apiKey.length > 0) return true;
+  if (Array.isArray(provider.apiKeys) && provider.apiKeys.some((key) => key?.apiKey)) return true;
+  if (typeof provider.baseUrl === "string" && provider.baseUrl.length > 0) return true;
+  return false;
+}
+function modelDiversityScore(candidate, avoid) {
+  let score = 0;
+  if (candidate.provider !== avoid.provider) score += 100;
+  if (candidate.model !== avoid.model) score += 20;
+  if (/opus|gpt-5|o3|o4|gemini.*pro|deepseek-r1/i.test(candidate.model)) score += 10;
+  if (/mini|haiku|flash/i.test(candidate.model)) score -= 5;
+  return score;
+}
+function matrixKeyKind(key) {
+  if (key === "*") return "default";
+  if (key in AGENT_CATALOG) return "role";
+  if (MATRIX_PHASE_KEYS.includes(key)) return "phase";
+  return "unknown";
+}
+function isValidMatrixKey(key) {
+  return matrixKeyKind(key) !== "unknown";
+}
 
 // src/coordination/coordinator/error-classifier.ts
 function classifySubagentError(err, hints = {}) {
@@ -6770,48 +7561,200 @@ 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
+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 {
@@ -6943,6 +7886,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();
@@ -7056,9 +8001,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);
@@ -7428,6 +8380,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
@@ -7449,7 +8412,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;
@@ -7669,13 +8633,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()
@@ -8114,6 +9080,7 @@ var Director = class _Director {
       makeAskTool(this),
       makeAskResultTool(this),
       makeRollUpTool(this),
+      makeQualityGateTool(this, effectiveRoster),
       makeTerminateTool(this),
       makeTerminateAllTool(this),
       makeFleetTool(this),
@@ -10207,14 +11174,17 @@ var FleetManager = class {
       model: config.model,
       taskIds: []
     });
-    this.stateCheckpoint?.recordSpawn({
-      id: subagentId,
-      name: config.name,
-      role: config.role,
-      provider: config.provider,
-      model: config.model,
-      spawnedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }, this.spawnCount);
+    this.stateCheckpoint?.recordSpawn(
+      {
+        id: subagentId,
+        name: config.name,
+        role: config.role,
+        provider: config.provider,
+        model: config.model,
+        spawnedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      this.spawnCount
+    );
     void this.appendSessionEvent({
       type: "agent_spawned",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10242,7 +11212,8 @@ var FleetManager = class {
         role: entry.role,
         provider: entry.provider,
         model: entry.model,
-        taskIds: entry.taskIds
+        taskIds: entry.taskIds,
+        worktrees: entry.worktrees
       })),
       usage: this.usage.snapshot()
     };
@@ -10258,6 +11229,14 @@ var FleetManager = class {
     const entry = this.manifestEntries.get(subagentId);
     if (entry) entry.taskIds.push(taskId);
   }
+  recordTaskWorktree(update) {
+    const entry = this.manifestEntries.get(update.subagentId);
+    if (entry) {
+      entry.worktrees = { ...entry.worktrees ?? {}, [update.taskId]: update };
+    }
+    this.stateCheckpoint?.recordTaskWorktree(update.taskId, update);
+    this.scheduleManifest();
+  }
   /**
    * Debounced manifest write. Call after any state mutation
    * (spawn, assign, complete) so a burst collapses into one write.
@@ -10269,10 +11248,7 @@ var FleetManager = class {
     if (this.manifestDebounceMs === 0) {
       void this.writeManifest().catch((err) => {
         const detail = toErrorMessage(err);
-        process.emitWarning(
-          `FleetManager manifest write failed: ${detail}`,
-          "FleetManagerWarning"
-        );
+        process.emitWarning(`FleetManager manifest write failed: ${detail}`, "FleetManagerWarning");
       });
       return;
     }
@@ -10282,10 +11258,7 @@ var FleetManager = class {
       this.manifestTimer = null;
       void this.writeManifest().catch((err) => {
         const detail = toErrorMessage(err);
-        process.emitWarning(
-          `FleetManager manifest write failed: ${detail}`,
-          "FleetManagerWarning"
-        );
+        process.emitWarning(`FleetManager manifest write failed: ${detail}`, "FleetManagerWarning");
       });
     }, this.manifestDebounceMs);
   }
@@ -10298,10 +11271,7 @@ var FleetManager = class {
     this.clearManifestTimer();
     await this.writeManifest().catch((err) => {
       const detail = toErrorMessage(err);
-      process.emitWarning(
-        `FleetManager manifest write failed: ${detail}`,
-        "FleetManagerWarning"
-      );
+      process.emitWarning(`FleetManager manifest write failed: ${detail}`, "FleetManagerWarning");
     });
   }
   clearManifestTimer() {
@@ -11467,166 +12437,6 @@ function formatMessage(m, readerId) {
   };
 }
 
-// src/coordination/mail-tools.ts
-function makeResolver(opts) {
-  return opts.resolveMailbox ?? ((ctx) => new GlobalMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
-}
-async function register(mb, ctx) {
-  const identity = resolveMailboxIdentity(ctx);
-  try {
-    await mb.registerAgent({
-      agentId: identity.callerId,
-      sessionId: identity.sessionId,
-      name: identity.name,
-      role: identity.role,
-      pid: process.pid,
-      source: ctx.meta["source"] ?? "cli"
-    });
-    await mb.heartbeat({ agentId: identity.callerId });
-  } catch {
-  }
-  return identity;
-}
-function makeMailSendTool(opts = {}) {
-  const resolveMailbox = makeResolver(opts);
-  return {
-    name: "mail_send",
-    description: 'Send a mail to other agents working on this project (other terminals, TUIs, WebUIs). Use it to hand off work, ask questions, announce what you just did, or request a review (type="review" \u2014 passive ask, no immediate reply required). to="*" broadcasts to everyone; to="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. Recipients see your mail automatically before their next step. Pick the type that matches the intent: note (default), ask (blocking question), assign (task), steer (mid-task direction), result (completion notice), review (passive ask), btw/status/broadcast/control (informational).',
-    usageHint: 'mail_send to="<id>" type="review" body="please skim <file>"',
-    category: "Coordination",
-    permission: "auto",
-    mutating: true,
-    capabilities: [ToolCapabilities.COORDINATION_MAIL],
-    inputSchema: {
-      type: "object",
-      properties: {
-        to: {
-          type: "string",
-          description: 'Recipient: exact agent id ("leader@a1b2c3d4"), base alias ("leader"), or "*" / "all" for everyone.'
-        },
-        subject: { type: "string", description: "Short subject line." },
-        body: { type: "string", description: "The message." },
-        type: {
-          type: "string",
-          enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result", "review"],
-          description: 'Message intent. Default: "broadcast" when to="*", otherwise "note". Actionable types: ask (blocking question), assign (task), result (completion notice), review (passive ask \u2014 code/doc/PR review, no immediate reply required). Behavioral: steer (mid-task direction change), btw (low-priority aside). Informational: note/status/broadcast/control.'
-        },
-        priority: { type: "string", enum: ["low", "normal", "high"] },
-        replyTo: { type: "string", description: "Message id this replies to." }
-      },
-      required: ["to", "subject", "body"]
-    },
-    async execute(input, ctx) {
-      const i = input ?? {};
-      const rawTo = i.to;
-      const subject = i.subject;
-      const body = i.body;
-      if (!rawTo || !subject || body === void 0 || body === null) {
-        return { ok: false, error: '"to", "subject" and "body" are required.' };
-      }
-      const to = normalizeRecipient(rawTo);
-      const mb = resolveMailbox(ctx);
-      const identity = await register(mb, ctx);
-      const type = i.type ?? (to === "*" ? "broadcast" : "note");
-      const msg = await mb.send({
-        from: identity.callerId,
-        to,
-        type,
-        subject,
-        body,
-        priority: i.priority ?? "normal",
-        replyTo: i.replyTo
-      });
-      return {
-        ok: true,
-        messageId: msg.id,
-        from: identity.callerId,
-        to: msg.to,
-        summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity.callerId}.`
-      };
-    }
-  };
-}
-function makeMailInboxTool(opts = {}) {
-  const resolveMailbox = makeResolver(opts);
-  return {
-    name: "mail_inbox",
-    description: 'Read your unread mail from other agents on this project and mark it read. Covers mail addressed to you directly, to your base name (e.g. "leader"), and broadcasts ("*"). Urgent steer/btw mail is already injected automatically \u2014 use this to catch up on notes, questions, handoffs, results, and review requests (type="review" \u2014 passive asks where no reply is required). Best called after a long stretch of tool work. Set completed=true to finish every returned message in the same call.',
-    usageHint: 'mail_inbox  (optionally: limit=10, markRead=false to peek, completed=true outcome="handled")',
-    category: "Coordination",
-    permission: "auto",
-    mutating: true,
-    capabilities: [ToolCapabilities.COORDINATION_MAIL],
-    inputSchema: {
-      type: "object",
-      properties: {
-        limit: { type: "number", description: "Max messages to return (default 20)." },
-        markRead: {
-          type: "boolean",
-          description: "Add a read receipt for each returned message (default true)."
-        },
-        completed: {
-          type: "boolean",
-          description: "Also mark each returned message completed (default false)."
-        },
-        outcome: {
-          type: "string",
-          description: "Completion outcome to store when completed=true."
-        }
-      }
-    },
-    async execute(input, ctx) {
-      const i = input ?? {};
-      const limit = i.limit ?? 20;
-      const markRead = i.markRead ?? true;
-      const completed = i.completed ?? false;
-      const outcome = i.outcome;
-      const mb = resolveMailbox(ctx);
-      const identity = await register(mb, ctx);
-      const targets = [identity.callerId];
-      if (identity.baseId !== identity.callerId) targets.push(identity.baseId);
-      const batches = await Promise.all(
-        targets.map(
-          (to) => mb.query({ to, unreadBy: identity.callerId, limit }).catch(() => [])
-        )
-      );
-      const seen = /* @__PURE__ */ new Set();
-      const messages = batches.flat().filter((m) => {
-        if (seen.has(m.id) || m.from === identity.callerId) return false;
-        seen.add(m.id);
-        return true;
-      }).slice(0, limit);
-      if (markRead || completed) {
-        await mb.ackMany({
-          acks: messages.map((m) => ({
-            messageId: m.id,
-            readerId: identity.callerId,
-            read: markRead,
-            completed,
-            outcome: completed ? outcome : void 0
-          }))
-        }).catch(() => null);
-      }
-      return {
-        ok: true,
-        you: identity.callerId,
-        count: messages.length,
-        messages: messages.map((m) => ({
-          id: m.id,
-          from: m.from,
-          to: m.to,
-          type: m.type,
-          subject: m.subject,
-          body: m.body.length > 2e3 ? `${m.body.slice(0, 2e3)}\u2026 [truncated]` : m.body,
-          timestamp: m.timestamp,
-          replyTo: m.replyTo
-        })),
-        summary: messages.length === 0 ? "Inbox empty." : `${messages.length} unread message(s)${markRead ? " (marked read)" : ""}${completed ? " (completed)" : ""}. Reply with mail_send using the sender id.`
-      };
-    }
-  };
-}
-
 // src/coordination/fleet-status-tool.ts
 var TASK_SNIPPET_CHARS = 120;
 function snippet(s) {
@@ -12271,6 +13081,166 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
     }
   }
 };
+
+// src/coordination/mail-tools.ts
+function makeResolver(opts) {
+  return opts.resolveMailbox ?? ((ctx) => new GlobalMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
+}
+async function register(mb, ctx) {
+  const identity = resolveMailboxIdentity(ctx);
+  try {
+    await mb.registerAgent({
+      agentId: identity.callerId,
+      sessionId: identity.sessionId,
+      name: identity.name,
+      role: identity.role,
+      pid: process.pid,
+      source: ctx.meta["source"] ?? "cli"
+    });
+    await mb.heartbeat({ agentId: identity.callerId });
+  } catch {
+  }
+  return identity;
+}
+function makeMailSendTool(opts = {}) {
+  const resolveMailbox = makeResolver(opts);
+  return {
+    name: "mail_send",
+    description: 'Send a mail to other agents working on this project (other terminals, TUIs, WebUIs). Use it to hand off work, ask questions, announce what you just did, or request a review (type="review" \u2014 passive ask, no immediate reply required). to="*" broadcasts to everyone; to="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. Recipients see your mail automatically before their next step. Pick the type that matches the intent: note (default), ask (blocking question), assign (task), steer (mid-task direction), result (completion notice), review (passive ask), btw/status/broadcast/control (informational).',
+    usageHint: 'mail_send to="<id>" type="review" body="please skim <file>"',
+    category: "Coordination",
+    permission: "auto",
+    mutating: true,
+    capabilities: [ToolCapabilities.COORDINATION_MAIL],
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: 'Recipient: exact agent id ("leader@a1b2c3d4"), base alias ("leader"), or "*" / "all" for everyone.'
+        },
+        subject: { type: "string", description: "Short subject line." },
+        body: { type: "string", description: "The message." },
+        type: {
+          type: "string",
+          enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result", "review"],
+          description: 'Message intent. Default: "broadcast" when to="*", otherwise "note". Actionable types: ask (blocking question), assign (task), result (completion notice), review (passive ask \u2014 code/doc/PR review, no immediate reply required). Behavioral: steer (mid-task direction change), btw (low-priority aside). Informational: note/status/broadcast/control.'
+        },
+        priority: { type: "string", enum: ["low", "normal", "high"] },
+        replyTo: { type: "string", description: "Message id this replies to." }
+      },
+      required: ["to", "subject", "body"]
+    },
+    async execute(input, ctx) {
+      const i = input ?? {};
+      const rawTo = i.to;
+      const subject = i.subject;
+      const body = i.body;
+      if (!rawTo || !subject || body === void 0 || body === null) {
+        return { ok: false, error: '"to", "subject" and "body" are required.' };
+      }
+      const to = normalizeRecipient(rawTo);
+      const mb = resolveMailbox(ctx);
+      const identity = await register(mb, ctx);
+      const type = i.type ?? (to === "*" ? "broadcast" : "note");
+      const msg = await mb.send({
+        from: identity.callerId,
+        to,
+        type,
+        subject,
+        body,
+        priority: i.priority ?? "normal",
+        replyTo: i.replyTo
+      });
+      return {
+        ok: true,
+        messageId: msg.id,
+        from: identity.callerId,
+        to: msg.to,
+        summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity.callerId}.`
+      };
+    }
+  };
+}
+function makeMailInboxTool(opts = {}) {
+  const resolveMailbox = makeResolver(opts);
+  return {
+    name: "mail_inbox",
+    description: 'Read your unread mail from other agents on this project and mark it read. Covers mail addressed to you directly, to your base name (e.g. "leader"), and broadcasts ("*"). Urgent steer/btw mail is already injected automatically \u2014 use this to catch up on notes, questions, handoffs, results, and review requests (type="review" \u2014 passive asks where no reply is required). Best called after a long stretch of tool work. Set completed=true to finish every returned message in the same call.',
+    usageHint: 'mail_inbox  (optionally: limit=10, markRead=false to peek, completed=true outcome="handled")',
+    category: "Coordination",
+    permission: "auto",
+    mutating: true,
+    capabilities: [ToolCapabilities.COORDINATION_MAIL],
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max messages to return (default 20)." },
+        markRead: {
+          type: "boolean",
+          description: "Add a read receipt for each returned message (default true)."
+        },
+        completed: {
+          type: "boolean",
+          description: "Also mark each returned message completed (default false)."
+        },
+        outcome: {
+          type: "string",
+          description: "Completion outcome to store when completed=true."
+        }
+      }
+    },
+    async execute(input, ctx) {
+      const i = input ?? {};
+      const limit = i.limit ?? 20;
+      const markRead = i.markRead ?? true;
+      const completed = i.completed ?? false;
+      const outcome = i.outcome;
+      const mb = resolveMailbox(ctx);
+      const identity = await register(mb, ctx);
+      const targets = [identity.callerId];
+      if (identity.baseId !== identity.callerId) targets.push(identity.baseId);
+      const batches = await Promise.all(
+        targets.map(
+          (to) => mb.query({ to, unreadBy: identity.callerId, limit }).catch(() => [])
+        )
+      );
+      const seen = /* @__PURE__ */ new Set();
+      const messages = batches.flat().filter((m) => {
+        if (seen.has(m.id) || m.from === identity.callerId) return false;
+        seen.add(m.id);
+        return true;
+      }).slice(0, limit);
+      if (markRead || completed) {
+        await mb.ackMany({
+          acks: messages.map((m) => ({
+            messageId: m.id,
+            readerId: identity.callerId,
+            read: markRead,
+            completed,
+            outcome: completed ? outcome : void 0
+          }))
+        }).catch(() => null);
+      }
+      return {
+        ok: true,
+        you: identity.callerId,
+        count: messages.length,
+        messages: messages.map((m) => ({
+          id: m.id,
+          from: m.from,
+          to: m.to,
+          type: m.type,
+          subject: m.subject,
+          body: m.body.length > 2e3 ? `${m.body.slice(0, 2e3)}\u2026 [truncated]` : m.body,
+          timestamp: m.timestamp,
+          replyTo: m.replyTo
+        })),
+        summary: messages.length === 0 ? "Inbox empty." : `${messages.length} unread message(s)${markRead ? " (marked read)" : ""}${completed ? " (completed)" : ""}. Reply with mail_send using the sender id.`
+      };
+    }
+  };
+}
 var MAILBOX_FILE2 = "_mailbox.jsonl";
 var LINE_SEPARATOR2 = "\n";
 var MESSAGE_CACHE_MAX_ENTRIES2 = 1e4;
@@ -16272,6 +17242,6 @@ ${input.detail}`
   }
 };
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetSupervisor, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MEDIUM_BUDGET, META_AGENTS, MailboxHealthWatchdog, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, acquireOrJoin, actionToAckInput, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, finalize, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetTool as makeFleetHealthTool, makeFleetTool as makeFleetSessionTool, makeFleetStatusTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, readLiveLock, recordPackageAction, release, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus, validateWatchdogOptions, withDisabledToolFiltering };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetSupervisor, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MATRIX_PHASE_KEYS, MEDIUM_BUDGET, META_AGENTS, MailboxHealthWatchdog, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, WorktreeIntegrationError, acquireOrJoin, actionToAckInput, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, finalize, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, isValidMatrixKey, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetTool as makeFleetHealthTool, makeFleetTool as makeFleetSessionTool, makeFleetStatusTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeQualityGateTool, makeRollUpTool, makeSpawnTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, matrixKeyKind, normalizeRecipient, phaseForRole, readLiveLock, recordPackageAction, release, resolveImplementationModelTarget, resolveMailboxIdentity, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveProjectDir, resolveSubagentModelTarget, resolveSubagentWorktreeDecision, roleNeedsIndependentReviewModel, rosterSummaryFromConfigs, sameModelReference, scoreAgents, startPackageOutdatedWatcher, subagentNeedsWorktree, updatePackageOutdatedStatus, validateWatchdogOptions, withDisabledToolFiltering, wrapSubagentRunnerWithWorktrees };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map