@wrongstack/core 0.272.1 → 0.273.0

package/dist/index.js

@@ -1,9 +1,9 @@
 import * as crypto2 from 'crypto';
 import { randomBytes, randomUUID, createHash, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
 import * as fsp3 from 'fs/promises';
-import { readFile, readdir, stat, mkdir } from 'fs/promises';
+import { readFile, readdir, stat, writeFile, mkdir } from 'fs/promises';
 import * as path3 from 'path';
-import { join, extname, relative, isAbsolute, basename, resolve, sep } from 'path';
+import { join, extname, relative, isAbsolute, resolve, sep, basename } from 'path';
 import * as dns from 'dns/promises';
 import * as net from 'net';
 import * as os6 from 'os';
@@ -754,9 +754,9 @@ async function updateJsonObjectFile(filePath, mutator) {
   await writeJsonObjectFile(filePath, next);
   return next;
 }
-function getJsonPath(root, path51) {
+function getJsonPath(root, path52) {
   let current = root;
-  for (const segment of path51) {
+  for (const segment of path52) {
     if (typeof segment === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[segment];
@@ -767,13 +767,13 @@ function getJsonPath(root, path51) {
   }
   return current;
 }
-function setJsonPath(root, path51, value) {
-  if (path51.length === 0) {
+function setJsonPath(root, path52, value) {
+  if (path52.length === 0) {
     if (!isJsonObject(value)) throw new Error("Root config value must be an object");
     return value;
   }
-  const parent = ensureJsonParent(root, path51);
-  const leaf = lastPathSegment(path51);
+  const parent = ensureJsonParent(root, path52);
+  const leaf = lastPathSegment(path52);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent)) throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
     parent[leaf] = value;
@@ -783,10 +783,10 @@ function setJsonPath(root, path51, value) {
   }
   return root;
 }
-function removeJsonPath(root, path51) {
-  if (path51.length === 0) return false;
-  const parent = getJsonPath(root, path51.slice(0, -1));
-  const leaf = lastPathSegment(path51);
+function removeJsonPath(root, path52) {
+  if (path52.length === 0) return false;
+  const parent = getJsonPath(root, path52.slice(0, -1));
+  const leaf = lastPathSegment(path52);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent) || leaf < 0 || leaf >= parent.length) return false;
     parent.splice(leaf, 1);
@@ -796,27 +796,27 @@ function removeJsonPath(root, path51) {
   delete parent[leaf];
   return true;
 }
-async function setJsonPathInFile(filePath, path51, value) {
-  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path51, value));
+async function setJsonPathInFile(filePath, path52, value) {
+  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path52, value));
 }
-async function removeJsonPathInFile(filePath, path51) {
+async function removeJsonPathInFile(filePath, path52) {
   return updateJsonObjectFile(filePath, (config) => {
-    removeJsonPath(config, path51);
+    removeJsonPath(config, path52);
   });
 }
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lastPathSegment(path51) {
-  const segment = path51[path51.length - 1];
+function lastPathSegment(path52) {
+  const segment = path52[path52.length - 1];
   if (segment === void 0) throw new Error("Invalid empty JSON path");
   return segment;
 }
-function ensureJsonParent(root, path51) {
+function ensureJsonParent(root, path52) {
   let current = root;
-  for (let i = 0; i < path51.length - 1; i += 1) {
-    const segment = path51[i];
-    const nextSegment = path51[i + 1];
+  for (let i = 0; i < path52.length - 1; i += 1) {
+    const segment = path52[i];
+    const nextSegment = path52[i + 1];
     if (segment === void 0) throw new Error("Invalid empty JSON path segment");
     const nextContainer = typeof nextSegment === "number" ? [] : {};
     if (typeof segment === "number") {
@@ -1772,11 +1772,11 @@ function validateAgainstSchema(value, schema) {
   walk(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path51, errors) {
+function walk(value, schema, path52, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path51 || "<root>",
+        path: path52 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -1785,7 +1785,7 @@ function walk(value, schema, path51, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path51 || "<root>",
+        path: path52 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -1795,20 +1795,20 @@ function walk(value, schema, path51, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path51, req), message: "required property missing" });
+        errors.push({ path: joinPath(path52, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path51, key), errors);
+          walk(obj[key], subSchema, joinPath(path52, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path51}[${i}]`, errors);
+      walk(value[i], schema.items, `${path52}[${i}]`, errors);
     }
   }
 }
@@ -3315,6 +3315,114 @@ function sizeSignals(toolName, content) {
   }
   return { outputBytes, outputTokens, outputLines };
 }
+
+// src/utils/tool-description-mode.ts
+var DEFAULT_TOOL_DESCRIPTION_MODE = "extend";
+var ORIGINAL_TOOL_DESCRIPTION = /* @__PURE__ */ Symbol.for("wrongstack.tool.originalDescription");
+function normalizeToolDescriptionMode(value) {
+  if (typeof value !== "string") return void 0;
+  const raw = value.trim().toLowerCase();
+  if (raw === "extend" || raw === "extended" || raw === "full") return "extend";
+  if (raw === "simple" || raw === "short" || raw === "brief") return "simple";
+  return void 0;
+}
+function resolveToolDescriptionMode(modes, toolName) {
+  return normalizeToolDescriptionMode(modes?.[toolName]) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
+}
+function simplifyToolDescription(text, opts = {}) {
+  const maxSentences = Math.max(1, opts.maxSentences ?? 2);
+  const maxChars = Math.max(40, opts.maxChars ?? 180);
+  const normalized = text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  const sentences = normalized.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [normalized];
+  const selected = [];
+  for (const sentence of sentences) {
+    selected.push(sentence.trim());
+    const candidate = selected.join(" ");
+    if (selected.length >= maxSentences || candidate.length >= maxChars) break;
+  }
+  const summary = selected.join(" ").trim() || normalized;
+  if (summary.length <= maxChars) return summary;
+  const hardLimit = maxChars - 4;
+  const boundary = findWordBoundary(summary, hardLimit);
+  return `${summary.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd()} ...`;
+}
+function applyToolDescriptionModeToTool(tool, mode) {
+  const existingOriginal = getOriginalDescription(tool);
+  if (mode === "extend" && !existingOriginal) return tool;
+  const original = existingOriginal ?? {
+    description: tool.description,
+    usageHint: tool.usageHint
+  };
+  const next = mode === "simple" ? withDescription(tool, {
+    description: simplifyToolDescription(original.description),
+    usageHint: original.usageHint === void 0 ? void 0 : simplifyToolDescription(original.usageHint)
+  }) : withDescription(tool, original);
+  return attachOriginalDescription(next, original);
+}
+function setToolDescriptionMode(registry, name, mode) {
+  if (typeof registry.setDescriptionMode === "function") {
+    return registry.setDescriptionMode(name, mode);
+  }
+  if (!registry.get(name) || typeof registry.wrap !== "function") return false;
+  registry.wrap(
+    name,
+    (tool) => applyToolDescriptionModeToTool(tool, mode),
+    "tool-description-mode"
+  );
+  return true;
+}
+function getToolDescriptionMode(registry, name) {
+  return registry.getDescriptionMode?.(name) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
+}
+function applyToolDescriptionModes(registry, modes) {
+  if (typeof registry.applyDescriptionModes === "function") {
+    return registry.applyDescriptionModes(modes);
+  }
+  const entries = Object.entries(modes ?? {});
+  const missing = [];
+  let applied = 0;
+  for (const [name, rawMode] of entries) {
+    const mode = normalizeToolDescriptionMode(rawMode);
+    if (!mode) continue;
+    if (setToolDescriptionMode(registry, name, mode)) applied++;
+    else missing.push(name);
+  }
+  return { applied, missing };
+}
+function getOriginalDescription(tool) {
+  return tool[ORIGINAL_TOOL_DESCRIPTION];
+}
+function attachOriginalDescription(tool, original) {
+  Object.defineProperty(tool, ORIGINAL_TOOL_DESCRIPTION, {
+    configurable: true,
+    enumerable: false,
+    value: original,
+    writable: true
+  });
+  return tool;
+}
+function withDescription(tool, next) {
+  const copy = {
+    ...tool,
+    description: next.description,
+    usageHint: next.usageHint
+  };
+  if (next.usageHint === void 0) {
+    delete copy.usageHint;
+  }
+  return copy;
+}
+function findWordBoundary(text, limit) {
+  const semantic = Math.max(
+    text.lastIndexOf(". ", limit),
+    text.lastIndexOf("; ", limit),
+    text.lastIndexOf(", ", limit)
+  );
+  if (semantic > 40) return semantic + 1;
+  const space = text.lastIndexOf(" ", limit);
+  return space > 40 ? space : limit;
+}
 function projectHash(absRoot) {
   return createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 12);
 }
@@ -3368,6 +3476,7 @@ function resolveWstackPaths(opts) {
     projectSddSession: path3.join(projectDir, "sdd-session.json"),
     projectPlan: path3.join(projectDir, "plan.json"),
     projectAutophase: path3.join(projectDir, "autophase"),
+    projectSddBoards: path3.join(projectDir, "sdd-boards"),
     syncConfig: path3.join(globalRoot, "sync.json"),
     projectStatus: (projectHash2) => path3.join(globalRoot, "projects", projectHash2, "status.json")
   };
@@ -4455,6 +4564,7 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   iterationTimeoutMs: 3e5,
   sessionTimeoutMs: 18e5,
   perIterationOutputCapBytes: 1e5,
+  descriptionMode: Object.freeze({}),
   autoExtendLimit: true,
   restrictToProjectRoot: false
 });
@@ -6007,7 +6117,9 @@ function buildRecoveryStrategies(opts) {
           if (!provider) return null;
           const currentModel = await registry.getModel(providerId, ctx.model);
           if (!currentModel) return null;
+          const visibleModels = opts?.getConfig?.().providers?.[providerId]?.models;
           const candidates = provider.models.filter((m) => {
+            if (visibleModels !== void 0 && !visibleModels.includes(m.id)) return false;
             const modelCost = m.cost?.input ?? Number.POSITIVE_INFINITY;
             const currentCost = currentModel.cost?.input ?? Number.POSITIVE_INFINITY;
             if (modelCost >= currentCost) return false;
@@ -7249,6 +7361,12 @@ var ToolCapabilities = {
   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 read or write inter-agent mailbox messages. */
+  COORDINATION_MAIL: "coordination.mail",
+  /** Can schedule, inspect, or cancel in-session cron jobs. */
+  COORDINATION_CRON: "coordination.cron",
   /** Can mutate global or session configuration / trust state. */
   CONFIG_MUTATE: "config.mutate",
   /** Can install packages or run package managers with side effects. */
@@ -9712,7 +9830,6 @@ var FileSessionWriter = class _FileSessionWriter {
       }
       const writeFd = await fsp3.open(tmpPath, "w", 384);
       try {
-        let copied = 0;
         let readOffset = 0;
         while (readOffset < newlineAfterCheckpoint) {
           const toCopy = Math.min(CHUNK_SIZE, newlineAfterCheckpoint - readOffset);
@@ -9721,7 +9838,6 @@ var FileSessionWriter = class _FileSessionWriter {
           if (r === 0) break;
           await writeFd.write(copyBuf, 0, r);
           readOffset += r;
-          copied += r;
         }
         const raw = await fsp3.readFile(this.filePath);
         const tail = raw.subarray(newlineAfterCheckpoint).toString("utf8");
@@ -10918,9 +11034,9 @@ ${body.trim()}`);
     if (!this.persistBackup || scope === "project-agents") return;
     try {
       const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile14, mkdir: mkdir24 } = await import('fs/promises');
+      const { writeFile: writeFile16, mkdir: mkdir24 } = await import('fs/promises');
       await mkdir24(this.backupDir, { recursive: true });
-      await writeFile14(`${this.backupDir}/${scope}.md`, content, "utf8");
+      await writeFile16(`${this.backupDir}/${scope}.md`, content, "utf8");
     } catch {
     }
   }
@@ -11031,6 +11147,7 @@ var BEHAVIOR_DEFAULTS = {
     iterationTimeoutMs: DEFAULT_TOOLS_CONFIG.iterationTimeoutMs,
     sessionTimeoutMs: DEFAULT_TOOLS_CONFIG.sessionTimeoutMs,
     perIterationOutputCapBytes: DEFAULT_TOOLS_CONFIG.perIterationOutputCapBytes,
+    descriptionMode: DEFAULT_TOOLS_CONFIG.descriptionMode,
     autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit,
     restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot
   },
@@ -15634,8 +15751,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned, this.opts.events);
     }
     try {
-      const { unlink: unlink17 } = await import('fs/promises');
-      await unlink17(this.goalPath);
+      const { unlink: unlink19 } = await import('fs/promises');
+      await unlink19(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -19382,14 +19499,15 @@ var SHADOW_AGENT = {
   id: "shadow-agent",
   name: "Shadow",
   role: "shadow-agent",
-  prompt: `You are the Shadow Agent \u2014 a silent background monitor for the WrongStack fleet.
+  prompt: `You are the Shadow Agent \u2014 a quiet, one-shot monitor for the WrongStack fleet.
 
-Your job is to observe, detect anomalies, and be ready to intervene \u2014 but only when commanded.
+Your job is to inspect the fleet when the host explicitly assigns a Shadow pass, detect anomalies, and be ready to intervene \u2014 but only when commanded.
 
 ## Core Responsibilities
 
-1. **Fleet Monitoring** (every 30s)
-   - Call \`fleet_status\` + \`fleet_health\` on each heartbeat
+1. **Fleet Monitoring** (host-assigned one-shot checks)
+   - The host assigns one-shot check tasks; it does not expect routine heartbeats
+   - On each assigned check, call \`fleet_status\` + \`fleet_health\`
    - Track what each agent is doing (task descriptions)
    - Detect stuck agents (>5min no events), idle agents, crashed agents
 
@@ -19413,31 +19531,30 @@ Your job is to observe, detect anomalies, and be ready to intervene \u2014 but o
    - \`hoop <agentId>\` \u2014 terminate specific agent
    - \`hoop all\` \u2014 terminate all running agents
    - \`shadow status\` \u2014 report current fleet snapshot
-   - \`shadow mute\` \u2014 pause heartbeat monitoring
-   - \`shadow resume\` \u2014 resume heartbeat monitoring
-   - \`shadow interval <ms>\` \u2014 change heartbeat interval
+   - \`shadow mute\` \u2014 pause anomaly reporting
+   - \`shadow resume\` \u2014 resume anomaly reporting
+   - \`shadow interval <ms>\` \u2014 update the legacy interval setting
    - \`shadow model <model-id>\` \u2014 change analysis model
 
 ## Operating Rules
 
-- **Silent by default**: Use DEBUG level logging unless anomaly detected
+- **Silent by default**: Do not send mail or status reports for healthy checks
 - **Deterministic**: Same state always produces same actions \u2014 no randomness
-- **Report on anomaly**: When anomaly detected, use \`mail_send\` to broadcast warning
+- **Report only when needed**: Use \`mail_send\` only for high/critical anomalies or explicit control replies
 - **Never auto-intervene**: Always report unless explicitly commanded
 - **Minimal footprint**: Small state, efficient snapshots
+- **One-shot lifecycle**: Finish the assigned check and stop; do not schedule follow-up work
 
 ## Startup Sequence
 
-1. Send broadcast: \`shadow:started { intervalMs, model, startTime }\`
-2. Subscribe to FleetBus for all relevant events
-3. Schedule heartbeat cron job at configured interval
-4. Wait for commands or anomalies
+1. Run one fleet snapshot with \`fleet_status\` + \`fleet_health\`
+2. Check \`mail_inbox\` for explicit control messages
+3. If healthy, do not send mail; final answer may be exactly \`shadow: quiet\`
 
 ## Shutdown Sequence
 
-1. Cancel all cron jobs (\`cron_cancel\`)
-2. Send broadcast: \`shadow:stopped { reason, finalState }\`
-3. Clean up FleetBus subscriptions`
+1. Return only anomalies, command results, or \`shadow: quiet\`
+2. The host stops this Shadow Agent after the assigned pass`
   // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
 var CRITIC_AGENT = {
@@ -19492,8 +19609,13 @@ var FLEET_ROSTER_BUDGETS = {
   "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
   "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
   "critic": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
-  "shadow-agent": { timeoutMs: 24 * 60 * 60 * 1e3, maxIterations: 1e4, maxToolCalls: 5e3 },
-  // Long-running background monitor
+  "shadow-agent": {
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 2e3,
+    maxToolCalls: 5e3,
+    maxTokens: 6e4,
+    maxCostUsd: 1
+  },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -21811,6 +21933,7 @@ function makeSpawnTool(director, roster) {
     usageHint: "Pass `role` (matches the roster), `description` (smart dispatch to best agent), or `name` + `provider`/`model`. Returns `{ subagentId }`.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input) {
       const i = input ?? {};
@@ -21889,6 +22012,7 @@ function makeAssignTool(director) {
     description: "Hand a task to a previously spawned subagent. Returns the task id.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input) {
       const i = input;
@@ -21904,6 +22028,7 @@ function makeAwaitTasksTool(director) {
     description: "Block until every named task completes. Returns the array of TaskResult.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: { type: "object", properties: { taskIds: { type: "array", items: { type: "string" }, description: "One or more task ids returned by `assign_task`." } }, required: ["taskIds"] },
     async execute(input) {
       const i = input;
@@ -21918,6 +22043,7 @@ function makeAskTool(director) {
     description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
@@ -21953,6 +22079,7 @@ function makeAskResultTool(director) {
     description: "Retrieve a large `ask_subagent` response that was stored out-of-context (>2K chars). Returns the full stored value.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
@@ -21980,6 +22107,7 @@ function makeRollUpTool(director) {
     description: "Aggregate completed task results into a single formatted summary.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
@@ -22001,6 +22129,7 @@ function makeTerminateTool(director) {
     description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
     permission: "auto",
     mutating: true,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
     async execute(input) {
       const i = input;
@@ -22015,6 +22144,7 @@ function makeTerminateAllTool(director) {
     description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
     permission: "auto",
     mutating: true,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
       await director.terminateAll();
@@ -22028,6 +22158,7 @@ function makeFleetStatusTool(director) {
     description: "Snapshot of the fleet \u2014 every subagent's current status, coordinator counts (total/running/idle/stopped), pending task descriptions, and usage rollup.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
       const base = director.status();
@@ -22049,6 +22180,7 @@ function makeFleetUsageTool(director) {
     description: "Token + cost breakdown across the fleet, per-subagent and totals.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
       return director.snapshot();
@@ -22061,6 +22193,7 @@ function makeFleetSessionTool(director) {
     description: "Read a subagent's JSONL transcript and extract its last assistant text, stop reason, and tool-use count. Use this to see what a running or timed-out subagent actually produced.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
@@ -22087,6 +22220,7 @@ function makeFleetHealthTool(director) {
     description: "Per-subagent health report: budget pressure (pct of limits consumed), last activity timestamp, and current status. Use to decide whether to assign more work to a subagent or spawn a fresh one.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
       const status = director.status();
@@ -22117,6 +22251,7 @@ function makeCollabDebugTool(director) {
     description: "Start a collaborative debugging session: BugHunter, RefactorPlanner, and Critic run in parallel on the same target files. BugHunter finds bugs and emits bug.found events. RefactorPlanner listens for bug.found and emits refactor.plan events. Critic evaluates both and emits critic.evaluation events. Returns a structured report with overall verdict (approve / needs_revision / reject).",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema: {
       type: "object",
       properties: {
@@ -22180,6 +22315,7 @@ function makeFleetEmitTool(director) {
     description: "Emit a structured event on the FleetBus. Any subagent can emit any event type; the Director routes it to all listeners. Use it to stream findings, progress updates, or final results to other agents in real time.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
@@ -22212,6 +22348,7 @@ function makeWorkCompleteTool(director) {
     description: "Signal that the director is satisfied with the results and the fleet should wind down. After calling this, spawn_subagent will refuse with a budget error and assign_task will instantly complete any queued tasks as aborted. Running subagents finish naturally. Call terminate_subagent separately to stop specific subagents immediately.",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
       director.workComplete();
@@ -22673,6 +22810,9 @@ var Director = class _Director {
   /** Snapshot of which subagent owns each task — drives state-checkpoint
    *  status updates without re-walking the manifest. */
   taskOwners = /* @__PURE__ */ new Map();
+  /** Infrastructure-owned task ids that should not appear in user-visible
+   *  manifest/session/checkpoint/rollup state. */
+  internalTaskIds = /* @__PURE__ */ new Set();
   /** Cumulative auto-extension grants per subagent (all budget kinds). Lets
    *  /fleet render "⚡ extended ×N" without replaying the event stream. */
   extendTotals = /* @__PURE__ */ new Map();
@@ -22786,17 +22926,21 @@ var Director = class _Director {
     this.fleetManager?.setCoordinator(this.coordinator);
     this.taskCompletedListener = (payload) => {
       const r = payload.result;
-      this.completed.set(r.taskId, r);
-      if (this.completed.size > _Director.MAX_COMPLETED) {
-        const toDelete = this.completed.size - _Director.MAX_COMPLETED;
-        const keys = [...this.completed.keys()].slice(0, toDelete);
-        for (const k of keys) this.completed.delete(k);
+      const internalTask = this.internalTaskIds.delete(r.taskId);
+      if (!internalTask) {
+        this.completed.set(r.taskId, r);
+        if (this.completed.size > _Director.MAX_COMPLETED) {
+          const toDelete = this.completed.size - _Director.MAX_COMPLETED;
+          const keys = [...this.completed.keys()].slice(0, toDelete);
+          for (const k of keys) this.completed.delete(k);
+        }
       }
       const waiter = this.taskWaiters.get(r.taskId);
       if (waiter) {
         waiter.resolve(r);
         this.taskWaiters.delete(r.taskId);
       }
+      if (internalTask) return;
       const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
       const failed = r.status !== "success";
       const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
@@ -23466,6 +23610,23 @@ var Director = class _Director {
     this.scheduleManifest();
     return taskWithId.id;
   }
+  /**
+   * Assign infrastructure-owned work directly to the coordinator without
+   * manifest/session/checkpoint bookkeeping. The task still uses the normal
+   * subagent runner, budget, and completion events, but it is excluded from
+   * rollups and persisted fleet task history.
+   */
+  async assignInternal(task) {
+    const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    this.internalTaskIds.add(taskWithId.id);
+    try {
+      await this.coordinator.assign(taskWithId);
+    } catch (err) {
+      this.internalTaskIds.delete(taskWithId.id);
+      throw err;
+    }
+    return taskWithId.id;
+  }
   /**
    * Block until every task id resolves. Returns results in the same
    * order as the input. If any task hasn't completed by the time this
@@ -24610,6 +24771,14 @@ var SpecParser = class {
 };
 
 // src/sdd/task-generator.ts
+function extractVerificationCommand(criteria) {
+  const marker = /^\s*(?:\$\s+|(?:run|verify|cmd)\s*:\s*)(.+\S)\s*$/i;
+  for (const c of criteria) {
+    const m = marker.exec(c);
+    if (m?.[1]) return m[1].trim();
+  }
+  return void 0;
+}
 var TaskGenerator = class {
   constructor(opts) {
     this.opts = opts;
@@ -24617,15 +24786,18 @@ var TaskGenerator = class {
   opts;
   async generateFromSpec(spec) {
     const graph = await this.opts.taskTracker.createGraph(spec.id, spec.title);
+    const featureIds = [];
     const overview = spec.sections.find((s) => s.type === "overview");
     if (overview) {
-      this.opts.taskTracker.addNode({
-        title: `Implement ${spec.title}`,
-        description: overview.content,
-        type: "feature",
-        priority: "high",
-        status: "pending"
-      });
+      featureIds.push(
+        this.opts.taskTracker.addNode({
+          title: `Implement ${spec.title}`,
+          description: overview.content,
+          type: "feature",
+          priority: "high",
+          status: "pending"
+        }).id
+      );
     }
     const byPriority = {
       critical: [],
@@ -24640,7 +24812,7 @@ var TaskGenerator = class {
     const order = ["critical", "high", "medium", "low"];
     for (const p of order) {
       for (const req of byPriority[p]) {
-        this.opts.taskTracker.addNode(this.createTaskFromRequirement(req));
+        featureIds.push(this.opts.taskTracker.addNode(this.createTaskFromRequirement(req)).id);
       }
     }
     if (spec.apiEndpoints && spec.apiEndpoints.length > 0) {
@@ -24651,31 +24823,37 @@ var TaskGenerator = class {
         priority: "high",
         status: "pending"
       });
+      featureIds.push(apiParent.id);
       for (const endpoint of spec.apiEndpoints) {
         const task = this.createTaskFromEndpoint(endpoint);
-        this.opts.taskTracker.addNode({
-          ...task,
-          parentId: apiParent.id
-        });
+        featureIds.push(
+          this.opts.taskTracker.addNode({
+            ...task,
+            parentId: apiParent.id
+          }).id
+        );
       }
     }
-    this.opts.taskTracker.addNode({
+    const testId = this.opts.taskTracker.addNode({
       title: "Write Tests",
       description: "Comprehensive test coverage for all features",
       type: "test",
       priority: "high",
       status: "pending"
-    });
-    this.opts.taskTracker.addNode({
+    }).id;
+    for (const f of featureIds) this.opts.taskTracker.addDependency(f, testId);
+    const docsId = this.opts.taskTracker.addNode({
       title: "Update Documentation",
       description: "Update docs for new features",
       type: "docs",
       priority: "medium",
       status: "pending"
-    });
+    }).id;
+    for (const f of [...featureIds, testId]) this.opts.taskTracker.addDependency(f, docsId);
     return graph;
   }
   createTaskFromRequirement(req) {
+    const verificationCommand = this.opts.verificationFromAcceptance ? extractVerificationCommand(req.acceptanceCriteria) : void 0;
     return {
       title: req.description,
       description: this.buildDescription(req),
@@ -24684,7 +24862,8 @@ var TaskGenerator = class {
       status: "pending",
       specRequirementId: req.id,
       tags: [req.type, req.priority],
-      estimateHours: this.estimateHours(req)
+      estimateHours: this.estimateHours(req),
+      ...verificationCommand ? { metadata: { verificationCommand } } : {}
     };
   }
   createTaskFromEndpoint(endpoint) {
@@ -24803,6 +24982,27 @@ var TaskTracker = class {
   opts;
   graph = null;
   transitions = [];
+  listeners = [];
+  /**
+   * Subscribe to live task mutations (add / update / status change). Returns an
+   * unsubscribe fn. This is the hook the board projector uses to stream a live
+   * snapshot — the tracker was previously fire-and-forget with no observability.
+   */
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const i = this.listeners.indexOf(listener);
+      if (i >= 0) this.listeners.splice(i, 1);
+    };
+  }
+  notifyChange(change) {
+    for (const l of this.listeners) {
+      try {
+        l(change);
+      } catch {
+      }
+    }
+  }
   /**
    * Attach an existing graph (used by PhaseOrchestrator to associate a tracker
    * with a phase's pre-built task graph without re-creating it).
@@ -24847,6 +25047,7 @@ var TaskTracker = class {
     }
     this.graph.updatedAt = now;
     this.persist();
+    this.notifyChange({ type: "node_added", nodeId: newNode.id, node: newNode });
     return newNode;
   }
   addEdge(from, to, type = "depends_on") {
@@ -24863,6 +25064,68 @@ var TaskTracker = class {
     this.graph.updatedAt = Date.now();
     this.persist();
   }
+  /**
+   * Declare that `taskId` depends on `depId` (a `depends_on` edge `depId → taskId`),
+   * guarding against self-loops, duplicates, missing nodes, and cycles. Returns
+   * true if the dependency now holds (added or already present), false if it was
+   * rejected (would create a cycle / unknown node). This is the safe entry point
+   * for wiring agent-declared `dependsOn` references into the graph.
+   */
+  addDependency(depId, taskId) {
+    if (!this.graph) return false;
+    if (depId === taskId) return false;
+    if (!this.graph.nodes.has(depId) || !this.graph.nodes.has(taskId)) return false;
+    if (this.getBlockers(taskId).includes(depId)) return true;
+    if (this.dependsOnTransitively(depId, taskId, /* @__PURE__ */ new Set())) return false;
+    this.addEdge(depId, taskId, "depends_on");
+    return true;
+  }
+  /** True when `taskId` transitively depends on `targetId` (follows depends_on blockers). */
+  dependsOnTransitively(taskId, targetId, seen) {
+    if (taskId === targetId) return true;
+    if (seen.has(taskId)) return false;
+    seen.add(taskId);
+    for (const blocker of this.getBlockers(taskId)) {
+      if (this.dependsOnTransitively(blocker, targetId, seen)) return true;
+    }
+    return false;
+  }
+  /**
+   * Merge `patch` into a node's `metadata` (used for per-task model/provider/
+   * fallback assignment and the cancel marker). Persists + notifies as a node
+   * update. No-op if the node is missing.
+   */
+  patchMetadata(id, patch) {
+    if (!this.graph) return;
+    const node = this.graph.nodes.get(id);
+    if (!node) return;
+    node.metadata = { ...node.metadata, ...patch };
+    node.updatedAt = Date.now();
+    this.graph.updatedAt = node.updatedAt;
+    this.persist();
+    this.notifyChange({ type: "node_updated", nodeId: id, node });
+  }
+  /**
+   * Remove a node and every edge touching it. Intended for deleting a task that
+   * has not started yet — callers must gate on status (do not remove a running
+   * task). Dependents simply lose this blocker (re-evaluated by `canStart`).
+   * Returns true if a node was removed.
+   */
+  removeNode(id) {
+    if (!this.graph) return false;
+    const node = this.graph.nodes.get(id);
+    if (!node) return false;
+    this.graph.nodes.delete(id);
+    this.graph.edges = this.graph.edges.filter((e) => e.from !== id && e.to !== id);
+    this.graph.rootNodes = this.graph.rootNodes.filter((r) => r !== id);
+    for (const n of this.graph.nodes.values()) {
+      if (n.children?.includes(id)) n.children = n.children.filter((c) => c !== id);
+    }
+    this.graph.updatedAt = Date.now();
+    this.persist();
+    this.notifyChange({ type: "node_removed", nodeId: id, node });
+    return true;
+  }
   updateNodeStatus(id, status, reason) {
     if (!this.graph) throw new SddError({
       message: "No graph loaded",
@@ -24894,6 +25157,12 @@ var TaskTracker = class {
     }
     this.graph.updatedAt = now;
     this.persist();
+    this.notifyChange({
+      type: "status_changed",
+      nodeId: id,
+      node,
+      transition: { from, to: status, timestamp: now, reason }
+    });
   }
   updateNode(id, patch) {
     if (!this.graph) throw new SddError({
@@ -24911,9 +25180,11 @@ var TaskTracker = class {
     if (patch.priority !== void 0) node.priority = patch.priority;
     if (patch.estimateHours !== void 0) node.estimateHours = patch.estimateHours;
     if (patch.tags !== void 0) node.tags = patch.tags;
+    if (patch.assignee !== void 0) node.assignee = patch.assignee;
     node.updatedAt = Date.now();
     this.graph.updatedAt = node.updatedAt;
     this.persist();
+    this.notifyChange({ type: "node_updated", nodeId: id, node });
   }
   getNode(id) {
     return this.graph?.nodes.get(id);
@@ -25092,7 +25363,10 @@ var TaskFlow = class {
       throw err;
     }
     this.setPhase("generating");
-    const generator = new TaskGenerator({ taskTracker: this.opts.tracker });
+    const generator = new TaskGenerator({
+      taskTracker: this.opts.tracker,
+      verificationFromAcceptance: process.env["WRONGSTACK_SDD_VERIFY_FROM_ACCEPTANCE"] === "1"
+    });
     this.graph = await generator.generateFromSpec(this.spec);
     return this.graph;
   }
@@ -25571,27 +25845,37 @@ function buildImplementationPrompt(session) {
     "```json",
     "[",
     "  {",
+    '    "id": "t1",',
     '    "title": "Create auth middleware",',
     '    "description": "Implement JWT verification middleware for protected routes",',
     '    "type": "feature",',
     '    "priority": "critical",',
     '    "estimateHours": 3,',
+    '    "dependsOn": [],',
     '    "tags": ["auth", "middleware"]',
     "  },",
     "  {",
+    '    "id": "t2",',
     '    "title": "Write auth tests",',
     '    "description": "Unit and integration tests for authentication flow",',
     '    "type": "test",',
     '    "priority": "high",',
     '    "estimateHours": 2,',
+    '    "dependsOn": ["t1"],',
     '    "tags": ["test", "auth"]',
     "  }",
     "]",
     "```",
     "",
     "Rules:",
-    "- Each task must be independently executable",
-    "- Order tasks by dependency (things that block others come first)",
+    '- Give every task a short stable "id" (t1, t2, \u2026). Reference prerequisites in "dependsOn"',
+    "  as a list of those ids \u2014 this builds the real dependency graph that drives parallel vs",
+    "  sequential execution.",
+    '- "dependsOn": [] means the task is independent and may run in parallel with other roots.',
+    "- A task with dependsOn runs ONLY after every listed task completes. Model true ordering:",
+    "  tests depend on the feature they test, docs/integration depend on the parts they cover.",
+    "- Do NOT create cycles (t1\u2192t2\u2192t1). Keep chains as shallow as correctness allows so",
+    "  independent work runs concurrently.",
     '- Use type: "feature" for code, "test" for tests, "docs" for documentation, "chore" for config',
     '- Use priority: "critical" for blockers, "high" for core features, "medium" for nice-to-haves, "low" for polish'
   ].join("\n");
@@ -25660,10 +25944,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp26 = await import('fs/promises');
-      const path51 = await import('path');
+      const fsp28 = await import('fs/promises');
+      const path52 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp26.mkdir(path51.dirname(this.sessionPath), { recursive: true });
+      await fsp28.mkdir(path52.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -25672,8 +25956,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp26 = await import('fs/promises');
-      const raw = await fsp26.readFile(this.sessionPath, "utf8");
+      const fsp28 = await import('fs/promises');
+      const raw = await fsp28.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -25687,8 +25971,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp26 = await import('fs/promises');
-      await fsp26.unlink(this.sessionPath);
+      const fsp28 = await import('fs/promises');
+      await fsp28.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -26390,15 +26674,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path51 = [];
+  const path52 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path51.unshift(current);
+    path52.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path51;
+  return path52;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -26817,6 +27101,24 @@ var SddTaskDecomposer = class {
   getWaveCount() {
     return this.wave;
   }
+  /**
+   * All ready (dependency-satisfied) pending tasks, priority-sorted — UNSLICED.
+   * The continuous scheduler fills its own free slots from this list, so unlike
+   * `nextBatch()` it does not cap at `slots`.
+   */
+  readyNodes() {
+    return this.pendingReadyNodes();
+  }
+  /**
+   * True when every node has reached a terminal state (completed or failed).
+   * This — not `isDone()` (which requires ALL completed) — is the correct loop
+   * exit for the continuous scheduler: a terminally-failed task must not keep
+   * the run spinning to its backstop.
+   */
+  isSettled() {
+    const nodes = this.tracker.getAllNodes();
+    return nodes.length > 0 && nodes.every((n) => n.status === "completed" || n.status === "failed");
+  }
   // -------------------------------------------------------------------
   // Internal helpers
   // -------------------------------------------------------------------
@@ -26856,65 +27158,478 @@ var SddTaskDecomposer = class {
 var SddParallelRun = class {
   constructor(opts) {
     this.opts = opts;
-    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
-    this.timeoutMs = opts.taskTimeoutMs ?? 3e5;
-    this.maxRetries = Math.max(0, opts.maxRetries ?? 2);
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 2));
+    this.timeoutMs = opts.taskTimeoutMs;
+    this.idleTimeoutMs = Math.max(1, opts.taskIdleTimeoutMs ?? 6e5);
+    this.maxRetries = Math.max(0, opts.maxRetries ?? 3);
+    this.maxSupervisorEscalations = Math.max(0, opts.maxSupervisorEscalations ?? 2);
+    this.maxFailedSweeps = Math.max(0, opts.maxFailedRetrySweeps ?? 2);
+    this.runId = opts.runId ?? `sdd-${randomUUID().slice(0, 8)}`;
+    this.events = opts.events;
+    this.maxTotalWaves = opts.maxTotalWaves ?? opts.graph.nodes.size * (this.maxRetries + 2) + 10;
+    this.maxWallClockMs = opts.maxWallClockMs;
+    this.maxRecoveryRounds = Math.max(0, opts.maxRecoveryRounds ?? 0);
     this.decomposer = new SddTaskDecomposer(opts.tracker, opts.graph, { parallelSlots: this.slots });
   }
   opts;
   slots;
+  /** Opt-in hard wall-clock cap (undefined → no cap; idle reaper guards instead). */
   timeoutMs;
+  /** Idle reaper window (ms) — resets on activity; reaps only a genuine stall. */
+  idleTimeoutMs;
   maxRetries;
+  /** Max supervisor rescues per task before it must terminal-fail (loop guard). */
+  maxSupervisorEscalations;
+  /** Per-task count of supervisor rescues used (resets nothing — bounds the loop). */
+  supervisorEscalations = /* @__PURE__ */ new Map();
+  /** Max end-of-run failed-task sweeps (see `maxFailedRetrySweeps`). */
+  maxFailedSweeps;
+  /** How many failed-task sweeps have run this `run()` so far. */
+  failedSweeps = 0;
+  /** Completed-count snapshot at the last sweep, to detect a no-progress sweep. */
+  lastSweepCompleted = 0;
   decomposer;
   coordinator = null;
   stopRequested = false;
   retryMap = /* @__PURE__ */ new Map();
+  runId;
+  events;
+  maxTotalWaves;
+  maxWallClockMs;
+  maxRecoveryRounds;
+  recoveryRounds = 0;
+  /** Per-run worker identities, so the board shows "who is on what". */
+  usedNicknames = /* @__PURE__ */ new Set();
+  /** Per-task git worktree cwd (Layer 2 worktree isolation; empty otherwise). */
+  taskCwds = /* @__PURE__ */ new Map();
+  /** Per-task git worktree branch, for board display. */
+  taskBranches = /* @__PURE__ */ new Map();
+  /** Live worktree handles keyed by task id (for commit/merge/release). */
+  taskWorktrees = /* @__PURE__ */ new Map();
+  /** Live subagent id per running task — lets cancelTask() abort exactly one. */
+  taskSubagents = /* @__PURE__ */ new Map();
+  /** Tasks the user cancelled mid-flight — skip retry, mark terminal-cancelled. */
+  cancelledTasks = /* @__PURE__ */ new Set();
+  /**
+   * Base branch the run's squash commits land on (captured once at start when
+   * worktrees are enabled). Anchors a later `rollback()`.
+   */
+  baseBranch;
+  /**
+   * Squash-merge commits this run landed on the base branch, in landing order.
+   * `rollback()` reverts these (newest → oldest). Persisted via the board
+   * snapshot so a post-run rollback can read them off disk.
+   */
+  mergedCommits = [];
+  /** Monotonic dispatch counter (unique subagent ids) + dispatch-round counter. */
+  dispatchSeq = 0;
+  round = 0;
+  /** Type-safe emit on the optional EventBus (no-op when unwired). */
+  emit(event, payload) {
+    this.events?.emit(event, payload);
+  }
   // -------------------------------------------------------------------
   // Public API
   // -------------------------------------------------------------------
+  paused = false;
   /** Trigger stop — causes run() to abort after the current wave. */
   stop() {
     this.stopRequested = true;
+    this.paused = false;
     this.coordinator?.stopAll();
   }
-  /** Execute all waves until completion or deadlock. Returns final summary. */
+  /** Pause: no new wave starts until resume() (the current wave finishes). */
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  isRunning() {
+    return !this.stopRequested && !this.decomposer.isSettled();
+  }
+  /** Base branch the run's squash commits land on (undefined when worktrees off). */
+  getBaseBranch() {
+    return this.baseBranch;
+  }
+  /** Squash commits this run landed on the base branch, in landing order. */
+  getMergedCommits() {
+    return this.mergedCommits;
+  }
+  /**
+   * Remove every git worktree + branch this run (and any prior run) created.
+   * Refuses while the run is still live — cleaning a checkout under an active
+   * worker would corrupt it. Stop first. Returns the number of worktrees removed
+   * (0 when worktrees are disabled). Idempotent.
+   */
+  async cleanupWorktrees() {
+    if (this.isRunning()) return 0;
+    const wt = this.opts.worktrees;
+    if (!wt) return 0;
+    for (const [taskId, handle] of [...this.taskWorktrees]) {
+      await wt.release(handle, { keep: false }).catch(() => {
+      });
+      this.forgetWorktree(taskId);
+    }
+    const { removed } = await wt.cleanupAllManaged();
+    return removed;
+  }
+  /**
+   * Undo the run's merged commits by reverting each on the base branch (history
+   * preserving). Refuses while the run is still live (stop first). Returns the
+   * revert outcome; a dirty tree or revert conflict surfaces as `ok:false`.
+   */
+  async rollback() {
+    if (this.isRunning()) return { ok: false, reverted: 0, reason: "run still active \u2014 stop it first" };
+    const wt = this.opts.worktrees;
+    if (!wt || !this.baseBranch) {
+      return { ok: false, reverted: 0, reason: "no worktree run to roll back" };
+    }
+    return wt.revertCommits(
+      this.baseBranch,
+      this.mergedCommits.map((c) => c.sha)
+    );
+  }
+  /** Requeue a task to `pending` so the scheduler re-runs it (clears retries + cancel marker). */
+  retryTask(taskId) {
+    if (!this.opts.tracker.getNode(taskId)) return false;
+    this.retryMap.delete(taskId);
+    this.persistRetries(taskId, 0);
+    this.cancelledTasks.delete(taskId);
+    this.opts.tracker.patchMetadata(taskId, { cancelled: void 0 });
+    this.opts.tracker.updateNodeStatus(taskId, "pending", "manual retry");
+    return true;
+  }
+  /** Reassign a task to a specific agent name (reflected on the board). */
+  reassignTask(taskId, agentName) {
+    if (!this.opts.tracker.getNode(taskId)) return false;
+    this.opts.tracker.updateNode(taskId, { assignee: agentName });
+    return true;
+  }
+  /**
+   * Set/override a task's worker model (and optionally provider) — applied on its
+   * NEXT dispatch (a running task must be cancelled + retried to take effect). The
+   * assignment lives on node metadata so it survives crash → resume.
+   */
+  setTaskModel(taskId, model, provider) {
+    if (!this.opts.tracker.getNode(taskId)) return false;
+    this.opts.tracker.patchMetadata(taskId, { model, ...provider !== void 0 ? { provider } : {} });
+    return true;
+  }
+  /** Set/override a task's fallback model chain (applied on its next dispatch). */
+  setTaskFallbacks(taskId, fallbackModels) {
+    if (!this.opts.tracker.getNode(taskId)) return false;
+    this.opts.tracker.patchMetadata(taskId, { fallbackModels });
+    return true;
+  }
+  /**
+   * Set/override a task's verification command (the completion gate runs it in
+   * the task's cwd and only lets the task complete on exit 0). Empty/undefined
+   * clears it. Applied on the task's next verification — i.e. its next dispatch.
+   */
+  setTaskVerification(taskId, verificationCommand) {
+    if (!this.opts.tracker.getNode(taskId)) return false;
+    const cmd = verificationCommand?.trim();
+    this.opts.tracker.patchMetadata(taskId, { verificationCommand: cmd ? cmd : void 0 });
+    return true;
+  }
+  /**
+   * Cancel a task. If it is currently running, abort its subagent and mark the
+   * node terminally failed+cancelled (so the scheduler frees the slot and does
+   * NOT retry it). If it has not started, it is simply marked cancelled. Use
+   * `retryTask` to bring a cancelled task back. Returns false for an unknown task.
+   */
+  async cancelTask(taskId) {
+    const node = this.opts.tracker.getNode(taskId);
+    if (!node) return false;
+    this.cancelledTasks.add(taskId);
+    this.opts.tracker.patchMetadata(taskId, { cancelled: true });
+    this.opts.tracker.updateNodeStatus(taskId, "failed", "cancelled by user");
+    this.emit("sdd.task.failed", { runId: this.runId, taskId, subagentId: "", error: "cancelled by user" });
+    const subagentId = this.taskSubagents.get(taskId);
+    if (subagentId && this.coordinator) {
+      await this.coordinator.stop(subagentId).catch(() => {
+      });
+    }
+    return true;
+  }
+  /**
+   * Delete a not-yet-started task from the graph (pending/blocked/failed only —
+   * never a running task; cancel it first). Removes the node and every edge
+   * touching it; dependents lose this blocker. Returns false if missing or running.
+   */
+  deleteTask(taskId) {
+    const node = this.opts.tracker.getNode(taskId);
+    if (!node) return false;
+    if (node.status === "in_progress" || this.taskSubagents.has(taskId)) return false;
+    this.cancelledTasks.delete(taskId);
+    this.retryMap.delete(taskId);
+    return this.opts.tracker.removeNode(taskId);
+  }
+  /**
+   * Split a task into sub-tasks and delegate them to separate workers. The new
+   * leaves inherit the parent's blockers (so they don't start before the
+   * parent's dependencies are met), every existing dependent is rewired to
+   * depend on ALL leaves (so downstream work waits for the whole split), and the
+   * parent becomes a `completed` container. Refuses a running task (cancel it
+   * first) or empty subtask list. Returns the new leaf ids (empty on refusal).
+   * The scheduler picks the new pending leaves up on its next dispatch pass.
+   */
+  splitTask(taskId, subtasks) {
+    const tracker = this.opts.tracker;
+    const node = tracker.getNode(taskId);
+    if (!node) return [];
+    if (node.status === "in_progress" || this.taskSubagents.has(taskId)) return [];
+    if (!subtasks.length) return [];
+    const blockers = tracker.getBlockers(taskId);
+    const dependents = tracker.getDependents(taskId);
+    const leafIds = subtasks.map(
+      (s) => tracker.addNode({
+        title: s.title,
+        description: s.description,
+        type: s.type ?? node.type,
+        priority: s.priority ?? node.priority,
+        status: "pending",
+        parentId: taskId
+      }).id
+    );
+    for (const leaf of leafIds) {
+      for (const b of blockers) tracker.addDependency(b, leaf);
+      for (const dep of dependents) tracker.addDependency(leaf, dep);
+    }
+    this.retryMap.delete(taskId);
+    this.persistRetries(taskId, 0);
+    tracker.updateNodeStatus(taskId, "completed", `split into ${leafIds.length} subtasks`);
+    this.emit("sdd.task.split", { runId: this.runId, taskId, subtaskIds: leafIds });
+    return leafIds;
+  }
+  async waitWhilePaused() {
+    while (this.paused && !this.stopRequested) {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+  /**
+   * Continuous dependency-driven execution. Unlike a wave-barrier loop (where a
+   * whole batch must finish before the next starts), this fills free worker
+   * slots the instant a task's dependencies are satisfied: a fast task's
+   * dependent starts immediately rather than waiting for a slow sibling. Truly
+   * independent tasks run in parallel; dependency chains run in order. Returns
+   * the final summary when the graph settles, deadlocks, stops, or hits a backstop.
+   */
   async run() {
     this.stopRequested = false;
-    this.retryMap.clear();
+    this.restoreRetryMap();
     const startTime = Date.now();
-    let totalCompleted = 0;
-    let totalFailed = 0;
-    let totalWaves = 0;
+    this.round = 0;
+    this.dispatchSeq = 0;
+    let totalDispatched = 0;
     this.buildCoordinator();
-    while (!this.stopRequested && !this.decomposer.isDone()) {
-      const batch = this.decomposer.nextBatch();
-      if (batch.deadlocked) {
+    if (this.opts.worktrees && !this.baseBranch) {
+      const base = await this.opts.worktrees.currentBase().catch(() => null);
+      if (base) this.baseBranch = base.branch;
+    }
+    this.emit("sdd.run.started", {
+      runId: this.runId,
+      graphId: this.opts.graph.id,
+      specId: this.opts.graph.specId,
+      total: this.opts.graph.nodes.size,
+      baseBranch: this.baseBranch
+    });
+    this.recoveryRounds = 0;
+    this.failedSweeps = 0;
+    this.lastSweepCompleted = 0;
+    let deadlocked = false;
+    const running = /* @__PURE__ */ new Map();
+    const dispatch = (task) => {
+      totalDispatched++;
+      const tracked = (async () => {
+        try {
+          return await this.executeOne(task);
+        } catch (err) {
+          this.opts.tracker.updateNodeStatus(task.id, "failed", `dispatch error: ${String(err)}`);
+          this.emit("sdd.task.failed", { runId: this.runId, taskId: task.id, subagentId: "", error: String(err) });
+          return { taskId: task.id, success: false };
+        } finally {
+          running.delete(task.id);
+        }
+      })();
+      running.set(task.id, tracked);
+    };
+    while (!this.stopRequested) {
+      if (totalDispatched >= this.maxTotalWaves) break;
+      if (this.maxWallClockMs && Date.now() - startTime >= this.maxWallClockMs) break;
+      await this.waitWhilePaused();
+      if (this.stopRequested) break;
+      let dispatchedThisRound = 0;
+      if (running.size < this.slots) {
+        const ready = this.decomposer.readyNodes().filter((t2) => !running.has(t2.id));
+        for (const task of ready) {
+          if (running.size >= this.slots) break;
+          dispatch(task);
+          dispatchedThisRound++;
+        }
+      }
+      if (dispatchedThisRound > 0) {
+        this.emit("sdd.wave", { runId: this.runId, wave: this.round, batchSize: dispatchedThisRound });
+        this.round++;
+      }
+      if (running.size === 0) {
+        if (this.decomposer.isSettled()) {
+          const completed = this.opts.tracker.getProgress().completed;
+          const madeProgress = this.failedSweeps === 0 || completed > this.lastSweepCompleted;
+          if (this.failedSweeps < this.maxFailedSweeps && madeProgress && this.requeueFailedTasks() > 0) {
+            this.lastSweepCompleted = completed;
+            this.failedSweeps++;
+            continue;
+          }
+          break;
+        }
+        const chains = this.computeDeadlockChains();
+        if (chains.length > 0) {
+          this.emit("sdd.deadlock", { runId: this.runId, chains });
+          if (this.recoveryRounds < this.maxRecoveryRounds && this.recoverFailedBlockers()) {
+            this.recoveryRounds++;
+            continue;
+          }
+          deadlocked = true;
+        }
         break;
       }
-      if (batch.tasks.length === 0 && batch.allDone) {
-        break;
+      const moreReadyNow = running.size < this.slots && this.decomposer.readyNodes().some((t2) => !running.has(t2.id));
+      if (!moreReadyNow) {
+        await Promise.race(running.values());
+        this.opts.onProgress?.(this.buildProgress());
       }
-      const waveResult = await this.executeWave(batch);
-      totalWaves++;
-      totalCompleted += waveResult.successCount;
-      totalFailed += waveResult.failCount;
-      this.decomposer.acknowledgeBatch(batch.tasks.map((t2) => t2.id));
-      this.opts.onWave?.(waveResult);
-      const progress = this.buildProgress();
-      this.opts.onProgress?.(progress);
-      if (this.stopRequested) break;
     }
+    if (running.size > 0) await Promise.allSettled(running.values());
+    if (this.stopRequested) await this.teardown();
     const finalProgress = this.opts.tracker.getProgress();
+    this.emit("sdd.run.finished", {
+      runId: this.runId,
+      deadlocked,
+      completed: finalProgress.completed,
+      failed: finalProgress.failed,
+      stopped: this.stopRequested
+    });
     return {
-      totalWaves,
-      totalCompleted,
-      totalFailed,
+      totalWaves: this.round,
+      totalCompleted: finalProgress.completed,
+      totalFailed: finalProgress.failed,
       totalDurationMs: Date.now() - startTime,
-      deadlocked: !this.decomposer.isDone() && this.stopRequested === false,
+      deadlocked,
       stopRequested: this.stopRequested,
       finalProgress
     };
   }
+  /**
+   * Compute the blocking chains for a deadlock: every still-incomplete task and
+   * the blockers (by node id) that are NOT completed. Failed blockers are
+   * included since they're the usual deadlock cause once retries are exhausted.
+   */
+  computeDeadlockChains() {
+    const tracker = this.opts.tracker;
+    const chains = [];
+    for (const node of tracker.getAllNodes()) {
+      if (node.status === "completed" || node.status === "failed") continue;
+      const blockedBy = tracker.getBlockers(node.id).filter((id) => tracker.getNode(id)?.status !== "completed");
+      if (blockedBy.length > 0) chains.push({ blocked: node.id, blockedBy });
+    }
+    return chains;
+  }
+  /** Requeue failed tasks that block an incomplete dependent. Returns true if any. */
+  recoverFailedBlockers() {
+    const tracker = this.opts.tracker;
+    let recovered = false;
+    for (const node of tracker.getAllNodes({ status: ["failed"] })) {
+      const blocksIncomplete = tracker.getDependents(node.id).some((d) => {
+        const s = tracker.getNode(d)?.status;
+        return s !== "completed" && s !== "failed";
+      });
+      if (blocksIncomplete) {
+        this.retryMap.delete(node.id);
+        this.persistRetries(node.id, 0);
+        tracker.updateNodeStatus(node.id, "pending", "deadlock recovery");
+        recovered = true;
+      }
+    }
+    return recovered;
+  }
+  /**
+   * Requeue every terminal-failed task that the user did NOT cancel, giving each
+   * a fresh `maxRetries` budget. Shared by the automatic end-of-run sweep and
+   * the manual "retry all failed" control. Returns the number requeued.
+   */
+  requeueFailedTasks(reason = "retry failed sweep") {
+    const tracker = this.opts.tracker;
+    let n = 0;
+    for (const node of tracker.getAllNodes({ status: ["failed"] })) {
+      if (this.cancelledTasks.has(node.id) || node.metadata?.cancelled) continue;
+      this.retryMap.delete(node.id);
+      this.persistRetries(node.id, 0);
+      tracker.updateNodeStatus(node.id, "pending", reason);
+      this.emit("sdd.task.retrying", {
+        runId: this.runId,
+        taskId: node.id,
+        attempt: 0,
+        maxRetries: this.maxRetries
+      });
+      n++;
+    }
+    return n;
+  }
+  /**
+   * Manually requeue all failed tasks to `pending` (board "Retry all failed").
+   * Unlike the automatic sweep this also clears any `cancelled` marker, so a
+   * user can bring cancelled tasks back in the same action — mirroring
+   * `retryTask`. Picked up by the running scheduler on its next dispatch pass.
+   * Returns the number of tasks requeued.
+   */
+  retryAllFailed() {
+    const failed = this.opts.tracker.getAllNodes({ status: ["failed"] });
+    for (const node of failed) {
+      this.cancelledTasks.delete(node.id);
+      this.opts.tracker.patchMetadata(node.id, { cancelled: void 0 });
+    }
+    return this.requeueFailedTasks("manual retry all");
+  }
+  /** Restore per-task retry counts persisted in node metadata (resume support). */
+  restoreRetryMap() {
+    this.retryMap.clear();
+    for (const node of this.opts.tracker.getAllNodes()) {
+      const r = node.metadata?.retries;
+      if (typeof r === "number" && r > 0) this.retryMap.set(node.id, r);
+    }
+  }
+  /**
+   * Reset orphaned `in_progress` tasks (no agent runs them after a crash) back
+   * to `pending` so a fresh run re-executes them. Call before constructing a run
+   * from a reloaded graph. Static so callers don't need a run instance.
+   */
+  static resetOrphans(tracker) {
+    let n = 0;
+    for (const node of tracker.getAllNodes({ status: ["in_progress"] })) {
+      tracker.updateNodeStatus(node.id, "pending", "resume: orphaned in_progress");
+      n++;
+    }
+    return n;
+  }
+  /** Clean teardown after a stop: reset interrupted tasks + release worktrees. */
+  async teardown() {
+    for (const node of this.opts.tracker.getAllNodes({ status: ["in_progress"] })) {
+      this.opts.tracker.updateNodeStatus(node.id, "pending", "run stopped");
+    }
+    const wt = this.opts.worktrees;
+    if (wt) {
+      for (const [taskId, handle] of [...this.taskWorktrees]) {
+        await wt.release(handle, { keep: true }).catch(() => {
+        });
+        this.forgetWorktree(taskId);
+      }
+    }
+  }
   // -------------------------------------------------------------------
   // Internal
   // -------------------------------------------------------------------
@@ -26922,7 +27637,14 @@ var SddParallelRun = class {
     const config = {
       coordinatorId: `sdd-parallel-${randomUUID().slice(0, 8)}`,
       maxConcurrent: this.slots,
-      doneCondition: { type: "all_tasks_done" }
+      doneCondition: { type: "all_tasks_done" },
+      // Default budget guard for every spawned worker: idle reaper (resets on
+      // activity) plus the opt-in wall-clock cap when one was configured. This
+      // ensures the reaper applies even if a per-spawn config path is bypassed.
+      defaultBudget: {
+        idleTimeoutMs: this.idleTimeoutMs,
+        ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
+      }
     };
     this.coordinator = new DefaultMultiAgentCoordinator(config);
     const baseFactory = this.opts.subagentFactory ?? this.defaultFactory();
@@ -26936,22 +27658,89 @@ var SddParallelRun = class {
       events: this.opts.agent.events
     });
   }
+  /**
+   * Execute a batch of tasks together. Retained as a thin wrapper over the
+   * single-task primitive `executeOne` so the wave-oriented tests and any
+   * batch callers keep working; the continuous scheduler in `run()` calls
+   * `executeOne` directly. Throws if no coordinator is wired or a spawn fails
+   * (surfaced from `executeOne`), preserving the original all-or-nothing contract.
+   */
   async executeWave(batch) {
-    const wave = batch.wave;
-    const tasks = batch.tasks;
     const waveStart = Date.now();
-    for (const task of tasks) {
-      this.opts.tracker.updateNodeStatus(task.id, "in_progress");
+    const outcomes = await Promise.all(batch.tasks.map((task) => this.executeOne(task)));
+    const results = outcomes.map((o) => o.result).filter((r) => Boolean(r));
+    const successCount = outcomes.filter((o) => o.success).length;
+    const failCount = outcomes.length - successCount;
+    return {
+      wave: batch.wave,
+      batch,
+      results,
+      successCount,
+      failCount,
+      durationMs: Date.now() - waveStart,
+      stopRequested: this.stopRequested
+    };
+  }
+  /**
+   * Execute one task end-to-end: assign a worker identity, allocate its worktree,
+   * spawn + assign the subagent, await its result, then update tracker status
+   * (success / retry / terminal-fail / cancelled) and resolve the worktree. This
+   * is the unit the continuous scheduler dispatches into a free slot. Throws on a
+   * missing coordinator or failed spawn so callers can enforce all-or-nothing.
+   */
+  async executeOne(task) {
+    const taskId = task.id;
+    let agentName = task.assignee;
+    if (!agentName) {
+      const nick = assignNickname("executor", this.usedNicknames);
+      this.usedNicknames.add(nick.key);
+      agentName = nick.display.replace(/\s*\([^)]*\)\s*$/, "");
+      this.opts.tracker.updateNode(taskId, { assignee: agentName });
+    }
+    this.opts.tracker.updateNodeStatus(taskId, "in_progress");
+    await this.allocateWorktrees([task]);
+    if (!this.coordinator) throw new SddError({
+      message: "SDD parallel runner requires a coordinator",
+      code: ERROR_CODES.SDD_INVALID_STATE
+    });
+    const coordinator = this.coordinator;
+    const subagentId = `sdd-d${this.dispatchSeq++}`;
+    const correlationId = randomUUID();
+    const meta = task.metadata ?? {};
+    const model = (typeof meta.model === "string" ? meta.model : void 0) ?? this.opts.defaultModel;
+    const provider = (typeof meta.provider === "string" ? meta.provider : void 0) ?? this.opts.defaultProvider;
+    const fallbackModels = Array.isArray(meta.fallbackModels) ? meta.fallbackModels : this.opts.fallbackModels;
+    const spawnResult = await coordinator.spawn({
+      id: subagentId,
+      name: agentName ?? subagentId,
+      role: "executor",
+      // Idle reaper is always on; the hard wall-clock cap only when opted in.
+      idleTimeoutMs: this.idleTimeoutMs,
+      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {},
+      cwd: this.taskCwds.get(taskId),
+      disabledTools: ["delegate"],
+      ...model ? { model } : {},
+      ...provider ? { provider } : {},
+      ...fallbackModels && fallbackModels.length ? { fallbackModels } : {}
+    });
+    if (!spawnResult.subagentId) {
+      throw new SddError({
+        message: "One or more subagent spawns failed",
+        code: ERROR_CODES.SDD_INVALID_STATE
+      });
     }
-    const progress = computeTaskProgress(this.opts.graph);
-    const taskIds = tasks.map(() => randomUUID());
-    const subagentIds = tasks.map((_, i) => `sdd-wave${wave}-${i}`);
+    this.taskSubagents.set(taskId, subagentId);
+    this.emit("sdd.task.started", {
+      runId: this.runId,
+      taskId,
+      subagentId,
+      agentName: agentName ?? "",
+      worktreeBranch: this.taskBranches.get(taskId)
+    });
     const directivePreamble = [
       "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
       "",
-      `Wave ${wave + 1} of ~${Math.ceil(progress.total / this.slots)}`,
       `Graph: ${this.opts.graph.title}`,
-      `Parallel slots: ${tasks.length}`,
       "",
       "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
       "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
@@ -26959,91 +27748,297 @@ var SddParallelRun = class {
       "\u2022 Do not ask before routine in-project tool use; if a permission gate appears, wait for that flow.",
       "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
     ].join("\n");
-    if (!this.coordinator) throw new SddError({
-      message: "SDD parallel runner requires a coordinator",
-      code: ERROR_CODES.SDD_INVALID_STATE
-    });
-    const coordinator = this.coordinator;
-    const spawns = subagentIds.map(
-      (subagentId) => coordinator.spawn({
-        id: subagentId,
-        name: subagentId,
-        role: "executor",
-        timeoutMs: this.timeoutMs,
-        // Disable delegation — subagents are leaf workers, not orchestrators
-        disabledTools: ["delegate"]
-      })
-    );
-    const spawnResults = await Promise.all(spawns);
-    if (!spawnResults.every((r) => Boolean(r.subagentId))) {
-      throw new SddError({
-        message: "One or more subagent spawns failed",
-        code: ERROR_CODES.SDD_INVALID_STATE
-      });
-    }
-    const assignPromises = tasks.map((task, i) => {
-      const spec = {
-        id: taskIds[i] ?? task.id,
-        description: [
-          directivePreamble,
-          "",
-          `\u2500\u2500 TASK ${i + 1}/${tasks.length} \u2500\u2500`,
-          `[${task.priority.toUpperCase()}] ${task.title}`,
-          "",
-          task.description
-        ].join("\n"),
-        subagentId: subagentIds[i] ?? spawnResults[i]?.subagentId ?? task.id,
-        timeoutMs: this.timeoutMs
-      };
-      return this.coordinator?.assign(spec);
+    await coordinator.assign({
+      id: correlationId,
+      description: [
+        directivePreamble,
+        "",
+        `\u2500\u2500 TASK \u2500\u2500`,
+        `[${task.priority.toUpperCase()}] ${task.title}`,
+        "",
+        task.description
+      ].join("\n"),
+      subagentId,
+      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
     });
-    await Promise.all(assignPromises);
-    let results;
+    let result;
     try {
-      results = await coordinator.awaitTasks(taskIds);
+      const got = await coordinator.awaitTasks([correlationId]);
+      result = expectDefined(got[0]);
     } catch (err) {
-      results = taskIds.map((id) => ({
-        subagentId: "",
-        taskId: id,
+      result = {
+        subagentId,
+        taskId: correlationId,
         status: "failed",
         error: { kind: "unknown", message: String(err), retryable: false },
         iterations: 0,
         toolCalls: 0,
         durationMs: 0
-      }));
+      };
     }
-    const successCount = results.filter((r) => r.status === "success").length;
-    const failCount = results.length - successCount;
-    for (let i = 0; i < results.length; i++) {
-      const result = expectDefined(results[i]);
-      const taskId = expectDefined(tasks[i]).id;
-      if (result.status === "success") {
+    this.taskSubagents.delete(taskId);
+    if (this.cancelledTasks.has(taskId)) {
+      await this.resolveWorktrees([task]);
+      return { taskId, success: false, result };
+    }
+    let verificationFailReason;
+    if (result.status === "success" && this.opts.verifyTask) {
+      const cwd = this.taskCwds.get(taskId) ?? this.opts.projectRoot;
+      try {
+        const verdict = await this.opts.verifyTask({ task, result, cwd });
+        if (!verdict.ok) {
+          verificationFailReason = `verification failed: ${verdict.reason ?? "acceptance criteria not met"}`;
+        }
+      } catch (err) {
+        verificationFailReason = `verification error: ${String(err)}`;
+      }
+      if (verificationFailReason) {
+        this.emit("sdd.task.verification_failed", {
+          runId: this.runId,
+          taskId,
+          reason: verificationFailReason
+        });
+      }
+    }
+    let success = false;
+    if (result.status === "success" && !verificationFailReason) {
+      const merged = await this.integrateWorktree(task, result);
+      if (merged.ok) {
+        success = true;
         this.opts.tracker.updateNodeStatus(taskId, "completed");
         this.retryMap.delete(taskId);
+        this.persistRetries(taskId, 0);
+        this.emit("sdd.task.completed", {
+          runId: this.runId,
+          taskId,
+          subagentId,
+          durationMs: result.durationMs
+        });
+      } else if (merged.reason) {
+        this.emit("sdd.task.verification_failed", {
+          runId: this.runId,
+          taskId,
+          reason: merged.reason
+        });
+        await this.applyTaskFailure(taskId, subagentId, merged.reason);
       } else {
-        const errMsg = result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error";
-        const currentRetries = this.retryMap.get(taskId) ?? 0;
-        if (currentRetries < this.maxRetries) {
-          this.retryMap.set(taskId, currentRetries + 1);
-          this.opts.tracker.updateNodeStatus(
-            taskId,
-            "pending",
-            `Retry ${currentRetries + 1}/${this.maxRetries}: ${errMsg}`
-          );
+        this.emit("sdd.task.conflict", {
+          runId: this.runId,
+          taskId,
+          conflictFiles: merged.conflictFiles ?? []
+        });
+        const reason = `merge conflict${merged.conflictFiles?.length ? `: ${merged.conflictFiles.join(", ")}` : ""}`;
+        await this.applyTaskFailure(taskId, subagentId, reason);
+      }
+    } else {
+      const errMsg = verificationFailReason ?? (result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error");
+      await this.applyTaskFailure(taskId, subagentId, errMsg);
+      await this.resolveWorktrees([task]);
+    }
+    return { taskId, success, result };
+  }
+  /**
+   * Apply a task failure: retry (→ pending, bump retry count) while attempts
+   * remain, else consult the optional supervisor (which can rescue via
+   * retry/reassign/split), else terminal-fail (→ failed). Shared by the
+   * worker-failure, verification-gate, and merge-conflict paths so all three
+   * negotiate the same retry budget and emit the same events.
+   */
+  async applyTaskFailure(taskId, subagentId, errMsg) {
+    const currentRetries = this.retryMap.get(taskId) ?? 0;
+    if (currentRetries < this.maxRetries) {
+      this.retryMap.set(taskId, currentRetries + 1);
+      this.persistRetries(taskId, currentRetries + 1);
+      this.opts.tracker.updateNodeStatus(
+        taskId,
+        "pending",
+        `Retry ${currentRetries + 1}/${this.maxRetries}: ${errMsg}`
+      );
+      this.emit("sdd.task.retrying", {
+        runId: this.runId,
+        taskId,
+        attempt: currentRetries + 1,
+        maxRetries: this.maxRetries
+      });
+      return;
+    }
+    if (await this.trySupervisorRescue(taskId, errMsg)) return;
+    this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+    this.emit("sdd.task.failed", { runId: this.runId, taskId, subagentId, error: errMsg });
+  }
+  /**
+   * Consult `superviseFailure` for a task that has exhausted its retries.
+   * Applies the verdict (retry / reassign+retry / split) and returns true when
+   * the task was rescued (caller must NOT terminal-fail it). Bounded per task by
+   * `maxSupervisorEscalations` so an always-"retry" supervisor can't loop forever.
+   */
+  async trySupervisorRescue(taskId, errMsg) {
+    const supervise = this.opts.superviseFailure;
+    if (!supervise) return false;
+    const used = this.supervisorEscalations.get(taskId) ?? 0;
+    if (used >= this.maxSupervisorEscalations) return false;
+    const node = this.opts.tracker.getNode(taskId);
+    if (!node) return false;
+    let verdict;
+    try {
+      verdict = await supervise({ task: node, error: errMsg, attempts: used });
+    } catch {
+      return false;
+    }
+    if (!verdict || verdict.action === "fail") return false;
+    this.supervisorEscalations.set(taskId, used + 1);
+    const requeue = (reason) => {
+      this.retryMap.delete(taskId);
+      this.persistRetries(taskId, 0);
+      this.opts.tracker.updateNodeStatus(taskId, "pending", reason);
+    };
+    if (verdict.action === "reassign") {
+      this.setTaskModel(taskId, verdict.model, verdict.provider);
+      requeue(`supervisor reassign: ${verdict.model ?? "default"}`);
+      this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "reassign" });
+      return true;
+    }
+    if (verdict.action === "split") {
+      const ids = this.splitTask(taskId, verdict.subtasks);
+      if (ids.length === 0) return false;
+      this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "split" });
+      return true;
+    }
+    requeue("supervisor retry");
+    this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "retry" });
+    return true;
+  }
+  /**
+   * Integrate a verified-successful task's worktree into the base branch.
+   * Commits, squash-merges (optionally running `conflictResolver` first), and on
+   * success releases the worktree. On an UNRESOLVED conflict it returns
+   * `{ok:false}` with the conflicting files so the caller routes the task into
+   * the failure path (a retry forks a fresh worktree off the now-advanced base,
+   * which usually clears the conflict). No-op `{ok:true}` when worktrees are
+   * disabled or none was allocated for this task. Never throws — a merge hiccup
+   * degrades to a (retryable) failure rather than wedging the run.
+   */
+  async integrateWorktree(task, result) {
+    const wt = this.opts.worktrees;
+    if (!wt) return { ok: true };
+    const handle = this.taskWorktrees.get(task.id);
+    if (!handle) return { ok: true };
+    try {
+      await wt.commitAll(handle, `sdd(${task.title}): ${task.id}`);
+      const baseShaBefore = await wt.baseHead(handle);
+      const baseSha = this.opts.conflictResolver ? baseShaBefore : null;
+      const res = await wt.merge(handle, {
+        squash: true,
+        ...this.opts.conflictResolver ? {
+          resolve: (info) => this.opts.conflictResolver({ task, conflictFiles: info.conflictFiles, cwd: info.cwd })
+        } : {}
+      });
+      if (res.ok) {
+        if (res.resolved && this.opts.verifyTask && baseSha) {
+          let regressed;
+          try {
+            const verdict = await this.opts.verifyTask({
+              task,
+              result: result ?? {},
+              cwd: this.opts.projectRoot
+            });
+            if (!verdict.ok) regressed = verdict.reason ?? "verification failed after conflict resolution";
+          } catch (err) {
+            regressed = `verification error after conflict resolution: ${String(err)}`;
+          }
+          if (regressed) {
+            await wt.revertBaseTo(handle, baseSha).catch(() => {
+            });
+            await wt.release(handle, { keep: false }).catch(() => {
+            });
+            this.forgetWorktree(task.id, { keepBranchLabel: true });
+            return { ok: false, conflictFiles: [], reason: regressed };
+          }
+        }
+        const baseShaAfter = await wt.baseHead(handle);
+        if (baseShaAfter && baseShaAfter !== baseShaBefore) {
+          this.mergedCommits.push({ taskId: task.id, sha: baseShaAfter, title: task.title });
+          this.emit("sdd.task.merged", { runId: this.runId, taskId: task.id, sha: baseShaAfter });
+        }
+        await wt.release(handle, { keep: false });
+        this.forgetWorktree(task.id);
+        return { ok: true };
+      }
+      await wt.release(handle, { keep: false }).catch(() => {
+      });
+      this.forgetWorktree(task.id, { keepBranchLabel: true });
+      return { ok: false, conflictFiles: res.conflictFiles ?? [] };
+    } catch {
+      this.forgetWorktree(task.id);
+      return { ok: false, conflictFiles: [] };
+    }
+  }
+  /** Allocate a fresh git worktree per task in the batch (no-op without a manager). */
+  async allocateWorktrees(tasks) {
+    const wt = this.opts.worktrees;
+    if (!wt) return;
+    for (const task of tasks) {
+      if (this.taskWorktrees.has(task.id)) continue;
+      try {
+        const handle = await wt.allocate(`sdd-${task.id}`, {
+          slugHint: task.title,
+          ownerLabel: task.title
+        });
+        if (handle.status === "active") {
+          this.taskWorktrees.set(task.id, handle);
+          this.taskCwds.set(task.id, handle.dir);
+          this.taskBranches.set(task.id, handle.branch);
+          const node = this.opts.tracker.getNode(task.id);
+          if (node) node.metadata = { ...node.metadata, worktreeBranch: handle.branch };
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Resolve each task's worktree after its result is known. Serialized merges
+   * (one at a time) keep the base branch consistent; the wave structure already
+   * guarantees dependency order (a task's blockers merged in an earlier wave).
+   */
+  async resolveWorktrees(tasks) {
+    const wt = this.opts.worktrees;
+    if (!wt) return;
+    for (const task of tasks) {
+      const handle = this.taskWorktrees.get(task.id);
+      if (!handle) continue;
+      const node = this.opts.tracker.getNode(task.id);
+      const status = node?.status;
+      const cancelled = Boolean(node?.metadata?.cancelled);
+      try {
+        if (cancelled) {
+          await wt.release(handle, { keep: false });
+          this.forgetWorktree(task.id, { keepBranchLabel: false });
+        } else if (status === "completed") {
+          await wt.commitAll(handle, `sdd(${task.title}): ${task.id}`);
+          await wt.merge(handle, { squash: true });
+          await wt.release(handle, { keep: false });
+          this.forgetWorktree(task.id);
+        } else if (status === "failed") {
+          await wt.release(handle, { keep: false });
+          this.forgetWorktree(task.id, { keepBranchLabel: false });
         } else {
-          this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+          await wt.release(handle, { keep: false });
+          this.forgetWorktree(task.id, { keepBranchLabel: false });
         }
+      } catch {
+        this.forgetWorktree(task.id);
       }
     }
-    return {
-      wave,
-      batch,
-      results,
-      successCount,
-      failCount,
-      durationMs: Date.now() - waveStart,
-      stopRequested: this.stopRequested
-    };
+  }
+  forgetWorktree(taskId, opts = {}) {
+    this.taskWorktrees.delete(taskId);
+    this.taskCwds.delete(taskId);
+    if (!opts.keepBranchLabel) this.taskBranches.delete(taskId);
+  }
+  /** Persist a task's retry count into node metadata (survives crash → resume). */
+  persistRetries(taskId, retries) {
+    const node = this.opts.tracker.getNode(taskId);
+    if (node) node.metadata = { ...node.metadata, retries };
   }
   buildProgress() {
     const gp = this.opts.tracker.getProgress();
@@ -27062,145 +28057,1881 @@ var SddParallelRun = class {
   }
 };
 
-// src/observability/metrics.ts
-var RESERVOIR_SIZE = 1024;
-function labelKey(labels) {
-  if (!labels) return "";
-  const keys = Object.keys(labels).sort();
-  return keys.map((k) => `${k}=${labels[k]}`).join(",");
-}
-function quantile(sorted, q) {
-  if (sorted.length === 0) return 0;
-  const idx = Math.min(sorted.length - 1, Math.floor(q * sorted.length));
-  return sorted[idx] ?? 0;
+// src/core/fallback-model.ts
+function visibleProviderModels(config, providerId, providerModels) {
+  const entry = config.providers?.[providerId];
+  return entry?.models !== void 0 ? [...entry.models] : providerModels;
 }
-var InMemoryMetricsSink = class {
-  counters = /* @__PURE__ */ new Map();
-  gauges = /* @__PURE__ */ new Map();
-  histograms = /* @__PURE__ */ new Map();
-  counter(name, value = 1, labels) {
-    const series = this.getOrCreate(this.counters, name);
-    const key = labelKey(labels);
-    const state = series.get(key) ?? { value: 0 };
-    state.value += value;
-    series.set(key, state);
+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()
+    };
   }
-  gauge(name, value, labels) {
-    const series = this.getOrCreate(this.gauges, name);
-    series.set(labelKey(labels), { value });
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
   }
-  histogram(name, value, labels) {
-    const series = this.getOrCreate(this.histograms, name);
-    const key = labelKey(labels);
-    let state = series.get(key);
-    if (!state) {
-      state = { count: 0, sum: 0, min: value, max: value, samples: [] };
-      series.set(key, state);
-    }
-    state.count++;
-    state.sum += value;
-    if (value < state.min) state.min = value;
-    if (value > state.max) state.max = value;
-    if (state.samples.length < RESERVOIR_SIZE) {
-      state.samples.push(value);
-    } else {
-      const r = Math.floor(Math.random() * state.count);
-      if (r < RESERVOIR_SIZE) state.samples[r] = value;
-    }
+  return { model: trimmed };
+}
+function shouldFallback(err) {
+  if (err instanceof StreamHangError) {
+    return 599;
   }
-  snapshot() {
-    const series = [];
-    for (const [name, byLabel] of this.counters) {
-      for (const [key, state] of byLabel) {
-        series.push({
-          name,
-          type: "counter",
-          labels: parseLabelKey(key),
-          values: { value: state.value }
-        });
-      }
-    }
-    for (const [name, byLabel] of this.gauges) {
-      for (const [key, state] of byLabel) {
-        series.push({
-          name,
-          type: "gauge",
-          labels: parseLabelKey(key),
-          values: { value: state.value }
-        });
+  if (!(err instanceof ProviderError)) return null;
+  const s = err.status;
+  if (s === 0) return s;
+  if (s === 429 || s === 529 || s >= 500) return s;
+  return null;
+}
+function providerHasKey(entry) {
+  if (!entry) return false;
+  if (typeof entry.apiKey === "string" && entry.apiKey.length > 0) return true;
+  if (Array.isArray(entry.apiKeys) && entry.apiKeys.some((k) => k?.apiKey)) return true;
+  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => !!process.env[v])) return true;
+  return false;
+}
+var SMART_DEFAULT_MAX = 4;
+function smartDefaultFallbackChain(config) {
+  const leaderProvider = config.provider;
+  const leaderModel = config.model;
+  const providers = config.providers ?? {};
+  const seen = /* @__PURE__ */ new Set();
+  const sameProvider = [];
+  const crossProvider = [];
+  const ids = Object.keys(providers).sort(
+    (a, b) => a === leaderProvider ? -1 : b === leaderProvider ? 1 : a.localeCompare(b)
+  );
+  for (const id of ids) {
+    const entry = providers[id];
+    if (!providerHasKey(entry)) continue;
+    const models = visibleProviderModels(config, id, entry?.models ?? []);
+    for (const model of models) {
+      if (id === leaderProvider && model === leaderModel) continue;
+      const ref = `${id}/${model}`;
+      if (seen.has(ref)) continue;
+      seen.add(ref);
+      (id === leaderProvider ? sameProvider : crossProvider).push(ref);
+    }
+  }
+  return [...sameProvider, ...crossProvider].slice(0, SMART_DEFAULT_MAX);
+}
+function effectiveFallbackChain(config) {
+  const explicit = config.fallbackModels ?? [];
+  const filteredExplicit = explicit.filter((ref) => {
+    const parsed = parseModelRef(ref);
+    if (!parsed.model) return false;
+    const providerId = parsed.provider ?? config.provider;
+    const entry = config.providers?.[providerId];
+    if (!entry?.models) return true;
+    return entry.models.includes(parsed.model);
+  });
+  if (filteredExplicit.length > 0) return filteredExplicit;
+  if (config.fallbackAuto === false) return [];
+  return smartDefaultFallbackChain(config);
+}
+function createFallbackModelExtension(deps) {
+  let dirty = false;
+  return {
+    name: "fallback-model",
+    beforeRun: async (ctx) => {
+      if (!dirty) return;
+      const cfg = deps.getConfig();
+      try {
+        ctx.provider = await deps.buildProvider(cfg.provider);
+        ctx.model = cfg.model;
+        await deps.onModelSwitch?.(cfg.provider, cfg.model);
+      } catch (err) {
+        deps.logger?.warn(
+          `fallback-model: could not restore primary "${cfg.provider}/${cfg.model}": ${err instanceof Error ? err.message : String(err)}`
+        );
       }
-    }
-    for (const [name, byLabel] of this.histograms) {
-      for (const [key, state] of byLabel) {
-        const sorted = [...state.samples].sort((a, b) => a - b);
-        series.push({
-          name,
-          type: "histogram",
-          labels: parseLabelKey(key),
-          values: {
-            count: state.count,
-            sum: state.sum,
-            min: state.min,
-            max: state.max,
-            p50: quantile(sorted, 0.5),
-            p95: quantile(sorted, 0.95),
-            p99: quantile(sorted, 0.99)
+      dirty = false;
+    },
+    wrapProviderRunner: async (ctx, request, inner) => {
+      try {
+        return await inner(ctx, request);
+      } catch (firstErr) {
+        let lastErr = firstErr;
+        const cfg = deps.getConfig();
+        const chain = effectiveFallbackChain(cfg);
+        for (const ref of chain) {
+          const status = shouldFallback(lastErr);
+          if (status === null) break;
+          const parsed = parseModelRef(ref);
+          if (!parsed.model) continue;
+          const targetProviderId = parsed.provider ?? cfg.provider;
+          const from = { providerId: ctx.provider.id, model: ctx.model };
+          let nextProvider;
+          try {
+            nextProvider = await deps.buildProvider(targetProviderId);
+          } catch (err) {
+            deps.logger?.warn(
+              `fallback-model: skipping "${ref}" \u2014 cannot build provider "${targetProviderId}": ${err instanceof Error ? err.message : String(err)}`
+            );
+            continue;
           }
-        });
+          const providerSwitched = nextProvider.id !== from.providerId;
+          ctx.provider = nextProvider;
+          ctx.model = parsed.model;
+          request.model = parsed.model;
+          dirty = true;
+          await deps.onModelSwitch?.(targetProviderId, parsed.model);
+          deps.events.emit("provider.fallback", {
+            from,
+            to: { providerId: nextProvider.id, model: parsed.model },
+            status,
+            providerSwitched
+          });
+          try {
+            return await inner(ctx, request);
+          } catch (err) {
+            lastErr = err;
+          }
+        }
+        throw lastErr;
       }
     }
-    return { timestamp: Date.now(), series };
-  }
-  reset() {
-    this.counters.clear();
-    this.gauges.clear();
-    this.histograms.clear();
-  }
-  getOrCreate(bag, name) {
-    let series = bag.get(name);
-    if (!series) {
-      series = /* @__PURE__ */ new Map();
-      bag.set(name, series);
-    }
-    return series;
-  }
-};
-function parseLabelKey(key) {
-  if (!key) return {};
-  const labels = {};
-  for (const pair of key.split(",")) {
-    const eq = pair.indexOf("=");
-    if (eq > 0) labels[pair.slice(0, eq)] = pair.slice(eq + 1);
-  }
-  return labels;
+  };
 }
-var NoopMetricsSink = class {
-  counter() {
-  }
-  gauge() {
-  }
-  histogram() {
-  }
-  snapshot() {
-    return { timestamp: Date.now(), series: [] };
-  }
-  reset() {
+
+// src/sdd/sdd-supervisor.ts
+var SddSupervisor = class {
+  constructor(opts) {
+    this.opts = opts;
   }
+  opts;
+  /**
+   * Bind this as `SddParallelRunOptions.superviseFailure`. Returns a verdict the
+   * run applies, or `undefined`/`{action:'fail'}` to let the task terminal-fail.
+   */
+  superviseFailure = async (info) => {
+    const { task, error, attempts } = info;
+    const canReassign = (this.opts.reassignModels?.length ?? 0) > 0;
+    const canSplit = Boolean(this.opts.generateSubtasks);
+    const decision = await this.opts.brain.decide({
+      id: `sdd-supervisor-${task.id}-${attempts}`,
+      source: "system",
+      question: `SDD task "${task.title}" exhausted its retries. How should the run proceed?`,
+      context: `Error: ${error}
+Supervisor rescues already used: ${attempts}`,
+      options: [
+        { id: "retry", label: "Retry the task as-is", recommended: true },
+        ...canReassign ? [{ id: "reassign", label: "Reassign to a different model" }] : [],
+        ...canSplit ? [{ id: "split", label: "Split into smaller sub-tasks" }] : [],
+        { id: "fail", label: "Give up and mark the task failed" }
+      ],
+      // Higher risk once we've already rescued it once — pushes a wired LLM/human
+      // toward a decisive verdict instead of looping retries.
+      risk: attempts >= 1 ? "high" : "medium",
+      // `continue` → policy answers in place (bounded retry, LLM never runs).
+      // `ask_human` → policy escalates so the autonomous LLM layer can actually
+      // pick reassign/split (see requestLlmVerdict's safety contract).
+      fallback: this.opts.requestLlmVerdict ? "ask_human" : "continue"
+    });
+    if (decision.type === "deny") return { action: "fail" };
+    if (decision.type !== "answer") return { action: "retry" };
+    const choice = decision.optionId ?? "retry";
+    if (choice === "fail") return { action: "fail" };
+    if (choice === "reassign" && canReassign) {
+      const models = this.opts.reassignModels;
+      const ref = models[attempts % models.length];
+      const parsed = ref ? parseModelRef(ref) : void 0;
+      return { action: "reassign", model: parsed?.model, provider: parsed?.provider };
+    }
+    if (choice === "split" && this.opts.generateSubtasks) {
+      const subtasks = await this.opts.generateSubtasks({ task, error }).catch(() => []);
+      return subtasks.length ? { action: "split", subtasks } : { action: "retry" };
+    }
+    return { action: "retry" };
+  };
 };
+function makeCommandVerifier(options = {}) {
+  const metadataKey = options.metadataKey ?? "verificationCommand";
+  const timeoutMs = options.timeoutMs ?? 18e4;
+  return async function verifyTask(info) {
+    const cmd = info.task.metadata?.[metadataKey];
+    if (typeof cmd !== "string" || !cmd.trim()) return { ok: true };
+    return await new Promise((resolve19) => {
+      const child = spawn(cmd, { cwd: info.cwd, shell: true, windowsHide: true, stdio: "ignore" });
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve19({ ok: false, reason: `verification timed out: ${cmd}` });
+      }, timeoutMs);
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        resolve19(
+          code === 0 ? { ok: true } : { ok: false, reason: `verification failed (exit ${code}): ${cmd}` }
+        );
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve19({ ok: false, reason: `verification spawn error: ${String(err)}` });
+      });
+    });
+  };
+}
 
-// src/observability/health.ts
-var SEVERITY = {
-  healthy: 0,
-  degraded: 1,
-  unhealthy: 2
-};
-var DefaultHealthRegistry = class {
-  checks = /* @__PURE__ */ new Map();
-  timeoutMs;
-  constructor(opts = {}) {
-    this.timeoutMs = opts.timeoutMs ?? 5e3;
-  }
-  register(check) {
+// src/sdd/decompose-task.ts
+var TASK_TYPES = /* @__PURE__ */ new Set(["feature", "bugfix", "refactor", "docs", "test", "chore"]);
+var PRIORITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low"]);
+function extractJsonArray(text) {
+  const fence = text.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
+  if (fence?.[1]) return fence[1].trim();
+  const bare = text.match(/(\[[\s\S]*\])/);
+  if (bare?.[1]) {
+    try {
+      if (Array.isArray(JSON.parse(bare[1]))) return bare[1];
+    } catch {
+    }
+  }
+  return null;
+}
+function buildPrompt(task, error, min, max) {
+  return [
+    "You are an engineering lead triaging a software task that FAILED after every",
+    "automated retry was exhausted. Break it into smaller, independently-executable",
+    `sub-tasks (between ${min} and ${max}) so separate workers can each tackle a`,
+    "narrower slice. Each sub-task must be strictly smaller than the parent \u2014 never",
+    "restate the whole task as one sub-task.",
+    "",
+    `Parent task title: ${task.title}`,
+    `Parent description: ${task.description}`,
+    `Failure / error: ${error || "(none recorded)"}`,
+    "",
+    "Respond with ONLY a JSON array (no prose) of objects with this shape:",
+    '[{"title": "...", "description": "...", "type": "feature|bugfix|refactor|docs|test|chore", "priority": "critical|high|medium|low"}]',
+    "`type` and `priority` are optional (they default to the parent's)."
+  ].join("\n");
+}
+function makeLlmSubtaskGenerator(opts) {
+  const min = Math.max(2, opts.minSubtasks ?? 2);
+  const max = Math.max(min, opts.maxSubtasks ?? 4);
+  return async function generateSubtasks(info) {
+    let text;
+    try {
+      text = await opts.run(buildPrompt(info.task, info.error, min, max));
+    } catch {
+      return [];
+    }
+    const json = extractJsonArray(text ?? "");
+    if (!json) return [];
+    let raw;
+    try {
+      raw = JSON.parse(json);
+    } catch {
+      return [];
+    }
+    if (!Array.isArray(raw)) return [];
+    const specs = [];
+    for (const item of raw) {
+      if (!item || typeof item !== "object") continue;
+      const r = item;
+      const title = typeof r["title"] === "string" ? r["title"].trim() : "";
+      const description = typeof r["description"] === "string" ? r["description"].trim() : "";
+      if (!title || !description) continue;
+      const type = TASK_TYPES.has(r["type"]) ? r["type"] : void 0;
+      const priority = PRIORITIES.has(r["priority"]) ? r["priority"] : void 0;
+      specs.push({ title, description, type, priority });
+      if (specs.length >= max) break;
+    }
+    return specs.length >= min ? specs : [];
+  };
+}
+var START = "<<<<<<<";
+var BASE = "|||||||";
+var SEP2 = "=======";
+var END = ">>>>>>>";
+function resolveConflictText(text, side) {
+  const out = [];
+  let state = "normal";
+  for (const line of text.split("\n")) {
+    const marker = line.slice(0, 7);
+    if (state === "normal" && marker === START) {
+      state = "ours";
+      continue;
+    }
+    if (state !== "normal" && marker === BASE) {
+      state = "base";
+      continue;
+    }
+    if (state !== "normal" && marker === SEP2) {
+      state = "theirs";
+      continue;
+    }
+    if (state !== "normal" && marker === END) {
+      state = "normal";
+      continue;
+    }
+    if (state === "normal") out.push(line);
+    else if (state === "ours" && side === "base") out.push(line);
+    else if (state === "theirs" && side === "incoming") out.push(line);
+  }
+  return out.join("\n");
+}
+function hasConflictMarkers(text) {
+  return text.split("\n").some((l) => {
+    const m = l.slice(0, 7);
+    return m === START || m === SEP2 || m === END || m === BASE;
+  });
+}
+function makePreferSideConflictResolver(side) {
+  return async function conflictResolver(info) {
+    if (info.conflictFiles.length === 0) return false;
+    for (const rel of info.conflictFiles) {
+      const abs = isAbsolute(rel) ? rel : join(info.cwd, rel);
+      let content;
+      try {
+        content = await readFile(abs, "utf8");
+      } catch {
+        return false;
+      }
+      const resolved = resolveConflictText(content, side);
+      if (hasConflictMarkers(resolved)) return false;
+      try {
+        await writeFile(abs, resolved, "utf8");
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function unfence(text) {
+  const m = text.match(/^[\s\S]*?```[^\n]*\n([\s\S]*?)\n```[\s\S]*$/);
+  return m?.[1] !== void 0 ? m[1] : text.trim();
+}
+function nonMarkerLineCount(text) {
+  return text.split("\n").filter((l) => {
+    const m = l.slice(0, 7);
+    return m !== START && m !== SEP2 && m !== END && m !== BASE;
+  }).length;
+}
+function makeLlmConflictResolver(opts) {
+  const minFraction = opts.minRetainedFraction ?? 0.5;
+  return async function conflictResolver(info) {
+    if (info.conflictFiles.length === 0) return false;
+    for (const rel of info.conflictFiles) {
+      const abs = isAbsolute(rel) ? rel : join(info.cwd, rel);
+      let content;
+      try {
+        content = await readFile(abs, "utf8");
+      } catch {
+        return false;
+      }
+      if (!hasConflictMarkers(content)) continue;
+      const prompt = [
+        "You are resolving a git MERGE CONFLICT in a single file. Below is the",
+        "full file with conflict markers (<<<<<<<, =======, >>>>>>>, and possibly",
+        "||||||| for diff3). Combine both sides into the correct, complete file \u2014",
+        "keep ALL non-conflicting content verbatim and reconcile each hunk sensibly.",
+        "Return ONLY the fully resolved file contents (no conflict markers, no",
+        "commentary), optionally wrapped in a single ``` code fence.",
+        "",
+        `File: ${rel}`,
+        "--- BEGIN ---",
+        content,
+        "--- END ---"
+      ].join("\n");
+      let out;
+      try {
+        out = await opts.run(prompt);
+      } catch {
+        return false;
+      }
+      const resolved = unfence(out ?? "");
+      if (!resolved.trim() || hasConflictMarkers(resolved)) return false;
+      if (resolved.split("\n").length < Math.floor(nonMarkerLineCount(content) * minFraction)) {
+        return false;
+      }
+      try {
+        await writeFile(abs, resolved, "utf8");
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
+// src/sdd/board-types.ts
+function shortIdMap(graph) {
+  const nodes = Array.from(graph.nodes.values()).sort((a, b) => a.createdAt - b.createdAt);
+  const m = /* @__PURE__ */ new Map();
+  nodes.forEach((n, i) => {
+    m.set(n.id, `t${String(i + 1).padStart(2, "0")}`);
+  });
+  return m;
+}
+function buildBoardTasks(graph) {
+  const nodes = Array.from(graph.nodes.values()).sort((a, b) => a.createdAt - b.createdAt);
+  const shortId = shortIdMap(graph);
+  const blockers = /* @__PURE__ */ new Map();
+  for (const n of nodes) blockers.set(n.id, []);
+  for (const e of graph.edges) {
+    if (e.type === "depends_on") blockers.get(e.to)?.push(e.from);
+  }
+  const statusOf = (id) => graph.nodes.get(id)?.status;
+  const depthCache = /* @__PURE__ */ new Map();
+  const depthOf = (id, seen = /* @__PURE__ */ new Set()) => {
+    const cached = depthCache.get(id);
+    if (cached !== void 0) return cached;
+    if (seen.has(id)) return 0;
+    seen.add(id);
+    const deps = blockers.get(id) ?? [];
+    const d = deps.length === 0 ? 0 : 1 + Math.max(...deps.map((b) => depthOf(b, seen)));
+    depthCache.set(id, d);
+    return d;
+  };
+  const toTask = (n) => {
+    const deps = blockers.get(n.id) ?? [];
+    const allDepsDone = deps.every((b) => statusOf(b) === "completed");
+    const meta = n.metadata ?? {};
+    const cancelled = Boolean(meta["cancelled"]);
+    const displayStatus = cancelled ? "cancelled" : n.status === "pending" && deps.length > 0 && allDepsDone ? "queued" : n.status;
+    return {
+      id: n.id,
+      shortId: shortId.get(n.id) ?? n.id.slice(0, 6),
+      title: n.title,
+      description: n.description,
+      status: n.status,
+      displayStatus,
+      priority: n.priority,
+      type: n.type,
+      deps: deps.map((b) => shortId.get(b) ?? b.slice(0, 6)),
+      agentName: n.assignee,
+      worktreeBranch: typeof meta["worktreeBranch"] === "string" ? meta["worktreeBranch"] : void 0,
+      startedAt: n.startedAt,
+      completedAt: n.completedAt,
+      retries: typeof meta["retries"] === "number" ? meta["retries"] : 0,
+      model: typeof meta["model"] === "string" ? meta["model"] : void 0,
+      provider: typeof meta["provider"] === "string" ? meta["provider"] : void 0,
+      fallbackModels: Array.isArray(meta["fallbackModels"]) ? meta["fallbackModels"] : void 0,
+      verificationCommand: typeof meta["verificationCommand"] === "string" ? meta["verificationCommand"] : void 0
+    };
+  };
+  const tasks = nodes.map(toTask);
+  const byDepth = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const d = depthOf(n.id);
+    if (!byDepth.has(d)) byDepth.set(d, []);
+    byDepth.get(d)?.push(shortId.get(n.id) ?? n.id.slice(0, 6));
+  }
+  const columns = [...byDepth.keys()].sort((a, b) => a - b).map((d) => ({ label: d === 0 ? "Start" : `Phase ${d}`, taskIds: byDepth.get(d) ?? [] }));
+  return { tasks, columns };
+}
+function buildBoardSnapshot(graph, run, now) {
+  const { tasks, columns } = buildBoardTasks(graph);
+  return {
+    runId: run.runId,
+    specId: run.specId,
+    graphId: graph.id,
+    title: graph.title,
+    status: run.status,
+    startedAt: run.startedAt,
+    updatedAt: now,
+    progress: computeTaskProgress(graph),
+    wave: run.wave,
+    tasks,
+    columns,
+    diagnostics: run.deadlockChains?.length ? { deadlockChains: run.deadlockChains } : void 0,
+    defaultModel: run.defaultModel,
+    defaultProvider: run.defaultProvider,
+    fallbackModels: run.fallbackModels,
+    baseBranch: run.baseBranch,
+    mergedCommits: run.mergedCommits?.length ? run.mergedCommits : void 0
+  };
+}
+
+// src/sdd/sdd-board-store.ts
+init_atomic_write();
+var SddBoardStore = class {
+  baseDir;
+  indexPath;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.indexPath = path3.join(this.baseDir, "_index.json");
+  }
+  snapshotPath(runId) {
+    return path3.join(this.baseDir, `${this.safe(runId)}.json`);
+  }
+  eventsPath(runId) {
+    return path3.join(this.baseDir, `${this.safe(runId)}.events.jsonl`);
+  }
+  controlPath(runId) {
+    return path3.join(this.baseDir, `${this.safe(runId)}.control.jsonl`);
+  }
+  async saveSnapshot(snapshot) {
+    await ensureDir(this.baseDir);
+    await atomicWrite(this.snapshotPath(snapshot.runId), JSON.stringify(snapshot, null, 2), {
+      mode: 384
+    });
+    await this.updateIndex(snapshot);
+  }
+  async load(runId) {
+    try {
+      const raw = await fsp3.readFile(this.snapshotPath(runId), "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async list() {
+    const index = await this.readIndex();
+    return index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async loadLatestForSpec(specId) {
+    const entry = (await this.list()).find((e) => e.specId === specId);
+    return entry ? this.load(entry.runId) : null;
+  }
+  /** Append one line to the board's JSONL event log (best-effort, never throws). */
+  async appendEvent(runId, event) {
+    try {
+      await ensureDir(this.baseDir);
+      await fsp3.appendFile(this.eventsPath(runId), `${JSON.stringify(event)}
+`, { mode: 384 });
+    } catch {
+    }
+  }
+  /** Append a control command (used by readers to steer a CLI-owned run). */
+  async appendControl(runId, command) {
+    await ensureDir(this.baseDir);
+    await fsp3.appendFile(this.controlPath(runId), `${JSON.stringify(command)}
+`, { mode: 384 });
+  }
+  /** Read + truncate the control queue (the run drains it). Returns parsed commands. */
+  async drainControl(runId) {
+    const p = this.controlPath(runId);
+    let raw;
+    try {
+      raw = await fsp3.readFile(p, "utf8");
+    } catch {
+      return [];
+    }
+    try {
+      await fsp3.writeFile(p, "", { mode: 384 });
+    } catch {
+    }
+    return raw.split("\n").filter((l) => l.trim()).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter((c) => c !== null);
+  }
+  async delete(runId) {
+    await Promise.allSettled([
+      fsp3.unlink(this.snapshotPath(runId)),
+      fsp3.unlink(this.eventsPath(runId)),
+      fsp3.unlink(this.controlPath(runId))
+    ]);
+    await this.removeFromIndex(runId);
+  }
+  // ── internal ────────────────────────────────────────────────────────────
+  safe(runId) {
+    return runId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  }
+  async readIndex() {
+    try {
+      const raw = await fsp3.readFile(this.indexPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.version === 1) return parsed;
+    } catch {
+    }
+    return { version: 1, entries: [] };
+  }
+  async updateIndex(snapshot) {
+    const index = await this.readIndex();
+    const entry = {
+      runId: snapshot.runId,
+      specId: snapshot.specId,
+      title: snapshot.title,
+      status: snapshot.status,
+      total: snapshot.progress.total,
+      completed: snapshot.progress.completed,
+      updatedAt: snapshot.updatedAt
+    };
+    const idx = index.entries.findIndex((e) => e.runId === snapshot.runId);
+    if (idx >= 0) index.entries[idx] = entry;
+    else index.entries.push(entry);
+    await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+  }
+  async removeFromIndex(runId) {
+    const index = await this.readIndex();
+    index.entries = index.entries.filter((e) => e.runId !== runId);
+    await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+  }
+};
+
+// src/sdd/sdd-board-projector.ts
+var SddBoardProjector = class _SddBoardProjector {
+  o;
+  now;
+  throttleMs;
+  shortId;
+  status = "idle";
+  wave = 0;
+  startedAt;
+  deadlockChains = [];
+  /** Live activity feed, most recent first (capped). */
+  feed = [];
+  static FEED_CAP = 60;
+  finished = false;
+  runDeadlocked = false;
+  runStopped = false;
+  /** Squash commits the run landed on the base branch (for post-run rollback). */
+  mergedCommits = [];
+  /** Base branch reported by the run at start (overrides the constructor option). */
+  runBaseBranch;
+  dirty = false;
+  timer = null;
+  unsubs = [];
+  /** Tail of in-flight persistence, so callers can await a settled state. */
+  lastSave = Promise.resolve();
+  constructor(opts) {
+    this.o = opts;
+    this.now = opts.now ?? Date.now;
+    this.throttleMs = opts.throttleMs ?? 250;
+    this.shortId = shortIdMap(opts.graph);
+    this.startedAt = this.now();
+    this.unsubs.push(opts.tracker.subscribe(() => this.markDirty()));
+    this.onRun("sdd.run.started", (e) => {
+      this.status = "running";
+      this.startedAt = this.now();
+      if (e.baseBranch) this.runBaseBranch = e.baseBranch;
+      this.markDirty();
+    });
+    this.onRun("sdd.run.finished", (e) => {
+      this.finished = true;
+      this.runDeadlocked = e.deadlocked;
+      this.runStopped = e.stopped;
+      this.flush();
+    });
+    this.onRun("sdd.wave", (e) => {
+      this.wave = e.wave;
+      this.pushFeed({ ts: this.now(), kind: "wave", text: `Wave ${e.wave + 1} started \xB7 ${e.batchSize} task(s) in parallel` });
+      this.markDirty();
+    });
+    this.onRun("sdd.deadlock", (e) => {
+      this.deadlockChains = e.chains.map((c) => ({
+        blocked: this.shortId.get(c.blocked) ?? c.blocked.slice(0, 6),
+        blockedBy: c.blockedBy.map((b) => this.shortId.get(b) ?? b.slice(0, 6))
+      }));
+      this.pushFeed({ ts: this.now(), kind: "deadlock", text: `Deadlock \u2014 ${e.chains.length} task(s) blocked by failed work` });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.started", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "started",
+        taskShortId: sid,
+        agentName: e.agentName,
+        text: `${e.agentName || "a worker"} picked up ${sid ?? "a task"}${this.titleOf(e.taskId)}`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.completed", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      const agent = this.assigneeOf(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "completed",
+        taskShortId: sid,
+        agentName: agent,
+        text: `${sid ?? "task"}${this.titleOf(e.taskId)} completed${agent ? ` by ${agent}` : ""} \xB7 ${(e.durationMs / 1e3).toFixed(1)}s`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.failed", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "failed",
+        taskShortId: sid,
+        agentName: this.assigneeOf(e.taskId),
+        text: `${sid ?? "task"}${this.titleOf(e.taskId)} failed \u2014 ${e.error}`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.retrying", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "retrying",
+        taskShortId: sid,
+        text: `${sid ?? "task"}${this.titleOf(e.taskId)} retrying (${e.attempt}/${e.maxRetries})`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.verification_failed", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "verification_failed",
+        taskShortId: sid,
+        agentName: this.assigneeOf(e.taskId),
+        text: `${sid ?? "task"}${this.titleOf(e.taskId)} failed verification \u2014 ${e.reason}`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.conflict", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      const files = e.conflictFiles.length;
+      this.pushFeed({
+        ts: this.now(),
+        kind: "conflict",
+        taskShortId: sid,
+        agentName: this.assigneeOf(e.taskId),
+        text: `${sid ?? "task"}${this.titleOf(e.taskId)} merge conflict \u2014 ${files} file(s)${files ? `: ${e.conflictFiles.slice(0, 3).join(", ")}${files > 3 ? "\u2026" : ""}` : ""}`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.merged", (e) => {
+      const title = this.o.graph.nodes.get(e.taskId)?.title ?? "";
+      this.mergedCommits.push({ taskId: e.taskId, sha: e.sha, title });
+      const sid = this.shortId.get(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "completed",
+        taskShortId: sid,
+        text: `${sid ?? "task"}${this.titleOf(e.taskId)} merged \u2192 ${this.runBaseBranch ?? this.o.baseBranch ?? "base"} (${e.sha.slice(0, 8)})`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.task.split", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "split",
+        taskShortId: sid,
+        text: `${sid ?? "task"}${this.titleOf(e.taskId)} split into ${e.subtaskIds.length} sub-task(s)`
+      });
+      this.markDirty();
+    });
+    this.onRun("sdd.supervisor.decision", (e) => {
+      const sid = this.shortId.get(e.taskId);
+      this.pushFeed({
+        ts: this.now(),
+        kind: "supervisor",
+        taskShortId: sid,
+        text: `supervisor \u2192 ${e.action} for ${sid ?? "task"}${this.titleOf(e.taskId)}${e.rationale ? ` (${e.rationale})` : ""}`
+      });
+      this.markDirty();
+    });
+  }
+  pushFeed(entry) {
+    this.feed.unshift(entry);
+    if (this.feed.length > _SddBoardProjector.FEED_CAP) this.feed.length = _SddBoardProjector.FEED_CAP;
+  }
+  /** ` (title…)` suffix for a feed line, or '' when the node/title is missing. */
+  titleOf(taskId) {
+    const t2 = this.o.graph.nodes.get(taskId)?.title;
+    if (!t2) return "";
+    return ` (${t2.length > 40 ? `${t2.slice(0, 39)}\u2026` : t2})`;
+  }
+  assigneeOf(taskId) {
+    return this.o.graph.nodes.get(taskId)?.assignee;
+  }
+  /** Latest snapshot, built on demand (e.g. for a late-joining client). */
+  snapshot() {
+    return this.build();
+  }
+  /** Resolve once all in-flight snapshot persistence has settled. */
+  async drain() {
+    await this.lastSave;
+  }
+  /** Stop projecting and release subscriptions. */
+  dispose() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    for (const u of this.unsubs) u();
+    this.unsubs.length = 0;
+  }
+  // ── internal ────────────────────────────────────────────────────────────
+  /** Subscribe to a run event scoped to this run id; also append to JSONL. */
+  onRun(event, handler) {
+    const wrapped = (e) => {
+      if (e.runId !== this.o.runId) return;
+      void this.o.store?.appendEvent(this.o.runId, { ts: this.now(), type: event, payload: e });
+      handler(e);
+    };
+    const off = this.o.events.on(event, wrapped);
+    this.unsubs.push(off);
+  }
+  resolveStatus(completed, total) {
+    if (!this.finished) return this.status;
+    if (this.runDeadlocked) return "deadlocked";
+    if (total > 0 && completed >= total) return "completed";
+    if (this.runStopped) return "paused";
+    return "failed";
+  }
+  build() {
+    const snap = buildBoardSnapshot(
+      this.o.graph,
+      {
+        runId: this.o.runId,
+        specId: this.o.specId,
+        status: "running",
+        startedAt: this.startedAt,
+        wave: this.wave,
+        deadlockChains: this.deadlockChains,
+        defaultModel: this.o.defaultModel,
+        defaultProvider: this.o.defaultProvider,
+        fallbackModels: this.o.fallbackModels,
+        baseBranch: this.runBaseBranch ?? this.o.baseBranch,
+        mergedCommits: this.mergedCommits
+      },
+      this.now()
+    );
+    snap.status = this.resolveStatus(snap.progress.completed, snap.progress.total);
+    snap.feed = this.feed.slice(0, _SddBoardProjector.FEED_CAP);
+    return snap;
+  }
+  markDirty() {
+    this.dirty = true;
+    if (this.timer || this.finished) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      if (this.dirty) this.flush();
+    }, this.throttleMs);
+  }
+  flush() {
+    this.dirty = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const snap = this.build();
+    this.o.events.emit("sdd.board.snapshot", { runId: this.o.runId, snapshot: snap });
+    if (this.o.store) {
+      const store = this.o.store;
+      this.lastSave = this.lastSave.then(() => store.saveSnapshot(snap)).catch(() => {
+      });
+    }
+  }
+};
+
+// src/sdd/sdd-run-registry.ts
+var SddRunRegistry = class {
+  current = null;
+  register(control) {
+    this.current = control;
+  }
+  clear(runId) {
+    if (this.current?.runId === runId) this.current = null;
+  }
+  getActive() {
+    return this.current;
+  }
+};
+
+// src/sdd/sdd-interview-driver.ts
+var SddInterviewDriver = class {
+  builder;
+  o;
+  minQuestions;
+  maxQuestions;
+  tracker = null;
+  graph = null;
+  constructor(opts) {
+    this.o = opts;
+    this.minQuestions = opts.minQuestions ?? 2;
+    this.maxQuestions = opts.maxQuestions ?? 10;
+    this.builder = new AISpecBuilder({
+      store: opts.specStore,
+      sessionPath: opts.sessionPath,
+      projectContext: opts.projectContext,
+      minQuestions: this.minQuestions,
+      maxQuestions: this.maxQuestions
+    });
+  }
+  /** Begin a fresh interview. Returns the first AI prompt (a question kickoff). */
+  start(title, intent) {
+    this.builder.startSession(title, intent);
+    this.tracker = null;
+    this.graph = null;
+    return this.builder.getAIPrompt();
+  }
+  /**
+   * Resume a previously-persisted interview from disk. Re-hydrates the task
+   * graph too when one was already produced. Returns true if a session loaded.
+   */
+  async loadExisting() {
+    const loaded = await this.builder.loadSession();
+    if (!loaded) return false;
+    const graphId = this.builder.getTaskGraphId();
+    if (graphId) {
+      const graph = await this.o.graphStore.load(graphId);
+      if (graph) {
+        this.graph = graph;
+        const tracker = new TaskTracker({ store: new DefaultTaskStore() });
+        tracker.setGraph(graph);
+        this.tracker = tracker;
+      }
+    }
+    return true;
+  }
+  phase() {
+    return this.builder.getPhase();
+  }
+  currentPrompt() {
+    return this.builder.getAIPrompt();
+  }
+  getTracker() {
+    return this.tracker;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  /** Record a Q/A pair (the agent asked `question`, the user replied `answer`). */
+  submitAnswer(question, answer) {
+    this.builder.addAnswer(question, answer);
+  }
+  /**
+   * Feed the agent's text output back into the interview. Detects, in order:
+   *  1. a Specification JSON  → setSpec (phase → spec_review) + persist to SpecStore
+   *  2. an implementation plan (implementation phase) → setImplementation
+   *  3. a task JSON array      → build + persist a TaskGraph
+   * Each step is independent and best-effort; a malformed payload is ignored
+   * rather than thrown, so a chatty agent turn never breaks the interview.
+   */
+  async ingestAgentOutput(text) {
+    const result = {
+      specDetected: false,
+      implementationDetected: false,
+      tasksDetected: false
+    };
+    if (!this.builder.getSession().spec) {
+      const spec = this.builder.tryParseSpecFromOutput(text);
+      if (spec) {
+        this.builder.setSpec(spec);
+        await this.persistSpec(spec);
+        result.specDetected = true;
+      }
+    }
+    if (this.builder.getPhase() === "implementation") {
+      if (this.trySaveImplementationPlan(text)) result.implementationDetected = true;
+    }
+    const session = this.builder.getSession();
+    if (session.spec) {
+      const built = await this.tryBuildTasksFromOutput(text);
+      if (built) {
+        result.tasksDetected = true;
+        result.graphId = built;
+      }
+    }
+    return result;
+  }
+  /**
+   * Advance to the next phase (mirrors `/sdd approve`). When moving into the
+   * executing phase, guarantees a task graph exists — deterministically
+   * generating one from the approved spec if the agent never emitted a valid
+   * task array. Returns the new phase and its AI prompt.
+   */
+  async approve() {
+    const phase = this.builder.approve();
+    if (phase === "executing") {
+      await this.ensureTaskGraph();
+    }
+    return { phase, prompt: this.builder.getAIPrompt() };
+  }
+  /**
+   * Ensure a TaskGraph exists for the approved spec. If the agent already
+   * produced one (via `ingestAgentOutput`), returns it; otherwise builds a
+   * deterministic graph from the spec's requirements via TaskGenerator. This is
+   * the robustness backstop: a run can always start, even if the model never
+   * emitted a parseable task array.
+   */
+  async ensureTaskGraph() {
+    if (this.graph) return this.graph;
+    const spec = this.builder.getSession().spec;
+    if (!spec) return null;
+    const tracker = new TaskTracker({ store: new DefaultTaskStore() });
+    const generator = new TaskGenerator({
+      taskTracker: tracker,
+      verificationFromAcceptance: process.env["WRONGSTACK_SDD_VERIFY_FROM_ACCEPTANCE"] === "1"
+    });
+    const graph = await generator.generateFromSpec(spec);
+    this.tracker = tracker;
+    this.graph = graph;
+    await this.persistGraph(graph);
+    this.builder.setTaskGraphId(graph.id);
+    await this.builder.saveSession();
+    return graph;
+  }
+  snapshot() {
+    const s = this.builder.getSession();
+    const spec = s.spec;
+    return {
+      sessionId: s.id,
+      phase: s.phase,
+      title: s.title,
+      questionCount: s.questionCount,
+      minQuestions: this.minQuestions,
+      maxQuestions: this.maxQuestions,
+      answers: s.answers.map((a) => ({ question: a.question, answer: a.answer })),
+      spec: spec ? {
+        id: spec.id,
+        title: spec.title,
+        overview: spec.overview,
+        requirements: spec.requirements.map((r) => ({
+          priority: r.priority,
+          description: r.description
+        }))
+      } : void 0,
+      graphId: s.taskGraphId,
+      taskCount: this.graph ? this.graph.nodes.size : 0,
+      board: this.graph ? buildBoardTasks(this.graph) : void 0,
+      prompt: this.builder.getAIPrompt()
+    };
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  async persistSpec(spec) {
+    try {
+      await this.o.specStore.save(spec);
+    } catch {
+    }
+  }
+  async persistGraph(graph) {
+    try {
+      await this.o.graphStore.save(graph);
+    } catch {
+    }
+  }
+  /**
+   * Port of the CLI `trySaveImplementationPlan` operating on this driver's
+   * builder. Captures the prose plan that precedes the task JSON block.
+   */
+  trySaveImplementationPlan(text) {
+    const current = this.builder.getSession().implementation ?? "";
+    const jsonStart = text.match(/```json\s*\[/);
+    if (jsonStart?.index && jsonStart.index > 0) {
+      const plan = text.substring(0, jsonStart.index).trim();
+      if (plan.length > 50 && plan !== current && !isExplanatoryText(plan)) {
+        this.builder.setImplementation(plan);
+        return true;
+      }
+    }
+    if (text.length > 100 && !text.includes("```json") && text.trim() !== current && !isExplanatoryText(text)) {
+      this.builder.setImplementation(text.trim());
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Port of the CLI `trySaveTasksFromAIOutput`: parse a task JSON array from the
+   * agent output, build (or extend) the tracker + graph, persist to disk, and
+   * link the graphId to the session. Returns the graphId on success.
+   */
+  async tryBuildTasksFromOutput(text) {
+    const json = this.builder.extractJSONArray(text);
+    if (!json) return void 0;
+    let tasks;
+    try {
+      tasks = JSON.parse(json);
+    } catch {
+      return void 0;
+    }
+    const valid = tasks.filter(
+      (t2) => t2 && typeof t2 === "object" && typeof t2.title === "string" && t2.title.length > 0
+    );
+    if (valid.length === 0) return void 0;
+    const spec = this.builder.getSession().spec;
+    if (!spec) return void 0;
+    if (!this.tracker || !this.graph) {
+      const tracker = new TaskTracker({ store: new DefaultTaskStore() });
+      this.graph = await tracker.createGraph(spec.id, spec.title);
+      this.tracker = tracker;
+    }
+    const refMap = /* @__PURE__ */ new Map();
+    const created = [];
+    valid.forEach((task, i) => {
+      const node = addTaskToTracker(this.tracker, task);
+      created.push({ nodeId: node.id, task });
+      if (typeof task.id === "string" && task.id.trim()) {
+        refMap.set(task.id.trim().toLowerCase(), node.id);
+      }
+      refMap.set(`t${i + 1}`, node.id);
+      refMap.set(String(i + 1), node.id);
+      refMap.set(normalizeTaskRef(String(task.title)), node.id);
+    });
+    for (const { nodeId, task } of created) {
+      const deps = Array.isArray(task.dependsOn) ? task.dependsOn : [];
+      for (const ref of deps) {
+        const depId = refMap.get(normalizeTaskRef(String(ref)));
+        if (depId && depId !== nodeId) this.tracker.addDependency(depId, nodeId);
+      }
+    }
+    await this.persistGraph(this.graph);
+    this.builder.setTaskGraphId(this.graph.id);
+    await this.builder.saveSession();
+    return this.graph.id;
+  }
+};
+var TASK_TYPES2 = ["feature", "bugfix", "refactor", "docs", "test", "chore"];
+var TASK_PRIORITIES = ["critical", "high", "medium", "low"];
+function normalizeTaskRef(ref) {
+  return ref.trim().toLowerCase();
+}
+function addTaskToTracker(tracker, task) {
+  return tracker.addNode({
+    title: String(task.title),
+    description: String(task.description ?? ""),
+    type: TASK_TYPES2.includes(String(task.type)) ? String(task.type) : "feature",
+    priority: TASK_PRIORITIES.includes(String(task.priority)) ? String(task.priority) : "medium",
+    status: "pending",
+    estimateHours: Number(task.estimateHours) || 2,
+    tags: Array.isArray(task.tags) ? task.tags.map(String) : []
+  });
+}
+function isExplanatoryText(text) {
+  const lower = text.toLowerCase();
+  return lower.startsWith("i'") || lower.startsWith("i will") || lower.startsWith("let me") || lower.startsWith("here's my") || lower.startsWith("here is my") || lower.startsWith("i'm going to") || lower.startsWith("first, let me") || lower.startsWith("sure") || lower.startsWith("of course") || lower.startsWith("okay") || lower.startsWith("ok,") || lower.startsWith("sounds good") || lower.startsWith("no problem") || text.split("\n").length < 3 && !text.includes(".");
+}
+
+// src/sdd/start-sdd-run.ts
+function startSddRun(opts) {
+  SddParallelRun.resetOrphans(opts.tracker);
+  const run = new SddParallelRun({
+    tracker: opts.tracker,
+    graph: opts.graph,
+    agent: opts.agent,
+    projectRoot: opts.projectRoot,
+    parallelSlots: opts.parallelSlots,
+    taskTimeoutMs: opts.taskTimeoutMs,
+    taskIdleTimeoutMs: opts.taskIdleTimeoutMs,
+    maxFailedRetrySweeps: opts.maxFailedRetrySweeps,
+    verifyTask: opts.verifyTask,
+    conflictResolver: opts.conflictResolver,
+    superviseFailure: opts.superviseFailure,
+    subagentFactory: opts.subagentFactory,
+    events: opts.events,
+    worktrees: opts.worktrees,
+    maxRecoveryRounds: opts.maxRecoveryRounds ?? 1,
+    onProgress: opts.onProgress,
+    defaultModel: opts.defaultModel,
+    defaultProvider: opts.defaultProvider,
+    fallbackModels: opts.fallbackModels
+  });
+  const projector = new SddBoardProjector({
+    runId: run.runId,
+    graph: opts.graph,
+    tracker: opts.tracker,
+    events: opts.events,
+    store: opts.boardStore,
+    specId: opts.graph.specId,
+    defaultModel: opts.defaultModel,
+    defaultProvider: opts.defaultProvider,
+    fallbackModels: opts.fallbackModels
+  });
+  opts.registry?.register({
+    runId: run.runId,
+    specId: opts.graph.specId,
+    pause: () => run.pause(),
+    resume: () => run.resume(),
+    stop: () => run.stop(),
+    retryTask: (id) => run.retryTask(id),
+    retryAllFailed: () => run.retryAllFailed(),
+    reassignTask: (id, name) => run.reassignTask(id, name),
+    setTaskModel: (id, model, provider) => run.setTaskModel(id, model, provider),
+    setTaskFallbacks: (id, fb) => run.setTaskFallbacks(id, fb),
+    setTaskVerification: (id, cmd) => run.setTaskVerification(id, cmd),
+    cancelTask: (id) => run.cancelTask(id),
+    deleteTask: (id) => run.deleteTask(id),
+    splitTask: (id, subtasks) => run.splitTask(id, subtasks),
+    cleanupWorktrees: () => run.cleanupWorktrees(),
+    rollback: () => run.rollback(),
+    getBaseBranch: () => run.getBaseBranch(),
+    getMergedCommits: () => run.getMergedCommits(),
+    snapshot: () => projector.snapshot(),
+    isRunning: () => run.isRunning()
+  });
+  const drainMs = opts.controlDrainMs ?? 500;
+  const controlTimer = setInterval(() => {
+    void opts.boardStore.drainControl(run.runId).then((cmds) => {
+      for (const c of cmds) {
+        const p = c.payload ?? {};
+        if (c.type === "pause") run.pause();
+        else if (c.type === "resume") run.resume();
+        else if (c.type === "stop") run.stop();
+        else if (c.type === "retry" && p.taskId) run.retryTask(p.taskId);
+        else if (c.type === "retry_all_failed") run.retryAllFailed();
+        else if (c.type === "reassign" && p.taskId) run.reassignTask(p.taskId, p.agentName ?? "");
+        else if (c.type === "set_task_model" && p.taskId) run.setTaskModel(p.taskId, p.model, p.provider);
+        else if (c.type === "set_task_fallbacks" && p.taskId) run.setTaskFallbacks(p.taskId, p.fallbackModels);
+        else if (c.type === "set_task_verification" && p.taskId)
+          run.setTaskVerification(p.taskId, p.verificationCommand);
+        else if (c.type === "cancel_task" && p.taskId) void run.cancelTask(p.taskId);
+        else if (c.type === "delete_task" && p.taskId) run.deleteTask(p.taskId);
+        else if (c.type === "split_task" && p.taskId && p.subtasks?.length) run.splitTask(p.taskId, p.subtasks);
+        else if (c.type === "cleanup_worktrees") void run.cleanupWorktrees();
+        else if (c.type === "rollback") void run.rollback();
+      }
+    });
+  }, drainMs);
+  controlTimer.unref?.();
+  const completion = (async () => {
+    try {
+      return await run.run();
+    } finally {
+      clearInterval(controlTimer);
+      await projector.drain().catch(() => {
+      });
+      projector.dispose();
+      opts.registry?.clear(run.runId);
+    }
+  })();
+  return {
+    run,
+    runId: run.runId,
+    projector,
+    completion,
+    stop: () => run.stop()
+  };
+}
+var MAX_SLUG = 40;
+var WorktreeManager = class {
+  projectRoot;
+  events;
+  gitBin;
+  runGit;
+  /** Keyed by ownerId. */
+  handles = /* @__PURE__ */ new Map();
+  usedSlugs = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.projectRoot = resolve(opts.projectRoot);
+    this.events = opts.events;
+    this.gitBin = opts.gitBin ?? "git";
+    this.runGit = opts.run ?? ((args, cwd) => this.defaultRun(args, cwd));
+  }
+  /** Create a fresh worktree + branch forked from the current base branch. */
+  async allocate(ownerId, opts = {}) {
+    const existing = this.handles.get(ownerId);
+    if (existing && (existing.status === "allocating" || existing.status === "active")) {
+      return existing;
+    }
+    const slug = this.makeSlug(opts.slugHint ?? ownerId);
+    const branch = `wstack/ap/${slug}`;
+    const dir = join(this.worktreesRoot(), slug);
+    const absDir = resolve(dir);
+    const absRoot = resolve(this.projectRoot);
+    if (!absDir.startsWith(absRoot + sep)) {
+      throw new Error(`Worktree dir "${absDir}" resolves outside project root`);
+    }
+    const baseBranch = opts.baseBranch ?? await this.detectBaseBranch();
+    const handle = {
+      id: slug,
+      ownerId,
+      ownerLabel: opts.ownerLabel ?? opts.slugHint ?? ownerId,
+      slug,
+      dir,
+      branch,
+      baseBranch,
+      status: "allocating",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      insertions: 0,
+      deletions: 0,
+      files: 0
+    };
+    this.handles.set(ownerId, handle);
+    try {
+      await mkdir(this.worktreesRoot(), { recursive: true });
+      const res = await this.runGit(
+        ["worktree", "add", "-b", branch, dir, baseBranch],
+        this.projectRoot
+      );
+      if (res.code !== 0) {
+        return this.fail(handle, res.stderr || "git worktree add failed");
+      }
+    } catch (err) {
+      return this.fail(handle, toErrorMessage(err));
+    }
+    this.setStatus(handle, "active");
+    this.emit("worktree.allocated", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      ownerLabel: handle.ownerLabel,
+      slug: handle.slug,
+      dir: handle.dir,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch
+    });
+    return handle;
+  }
+  /** Stage everything and commit inside the worktree. */
+  async commitAll(handle, message) {
+    this.setStatus(handle, "committing");
+    await this.runGit(["add", "-A"], handle.dir);
+    const staged = await this.runGit(["diff", "--cached", "--quiet"], handle.dir);
+    if (staged.code === 0) {
+      this.emitCommitted(handle, false);
+      return { committed: false };
+    }
+    const idArgs = await this.identityArgs(handle.dir);
+    const committed = await this.runGit([...idArgs, "commit", "-m", message], handle.dir);
+    if (committed.code !== 0) {
+      this.fail(handle, committed.stderr || "git commit failed");
+      return { committed: false };
+    }
+    const stats = await this.collectStats(handle.dir);
+    handle.insertions = stats.insertions;
+    handle.deletions = stats.deletions;
+    handle.files = stats.files;
+    handle.sha = stats.sha;
+    handle.updatedAt = Date.now();
+    this.emitCommitted(handle, true);
+    return { committed: true };
+  }
+  /** Merge the worktree branch back into the base branch (squash by default). */
+  async merge(handle, opts = {}) {
+    const squash = opts.squash ?? true;
+    this.setStatus(handle, "merging");
+    const checkout = await this.runGit(["checkout", handle.baseBranch], this.projectRoot);
+    if (checkout.code !== 0) {
+      this.fail(handle, checkout.stderr || `checkout ${handle.baseBranch} failed`);
+      return { ok: false, stderr: checkout.stderr };
+    }
+    const mergeArgs = squash ? ["merge", "--squash", handle.branch] : ["merge", "--no-ff", handle.branch];
+    const merged = await this.runGit(mergeArgs, this.projectRoot);
+    if (merged.code !== 0) {
+      const fromOutput = parseConflictPaths(`${merged.stdout}
+${merged.stderr}`);
+      const fromIndex = await this.unmergedFiles();
+      const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
+      if (opts.resolve) {
+        const finalized = await this.tryResolveConflict(handle, conflictFiles, opts);
+        if (finalized) return finalized;
+      }
+      await this.runGit(["reset", "--hard", "HEAD"], this.projectRoot);
+      handle.conflictFiles = conflictFiles;
+      this.setStatus(handle, "needs-review", { lastError: merged.stderr });
+      this.emit("worktree.conflict", {
+        handleId: handle.id,
+        ownerId: handle.ownerId,
+        branch: handle.branch,
+        conflictFiles
+      });
+      return { ok: false, conflict: true, conflictFiles, stderr: merged.stderr };
+    }
+    if (squash) {
+      const msg = opts.message ?? `merge ${handle.branch} (squash)`;
+      const idArgs = await this.identityArgs(this.projectRoot);
+      const commit = await this.runGit([...idArgs, "commit", "-m", msg], this.projectRoot);
+      if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
+        this.fail(handle, commit.stderr || "squash commit failed");
+        return { ok: false, stderr: commit.stderr };
+      }
+    }
+    this.setStatus(handle, "merged");
+    this.emit("worktree.merged", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch,
+      squash
+    });
+    return { ok: true };
+  }
+  /**
+   * Current tip SHA of a handle's base branch (without checking it out). Capture
+   * this before a merge so a regressed merge can be reverted to exactly this
+   * commit — unambiguous even when a squash produced no diff. Returns null on
+   * failure (caller then skips the revert).
+   */
+  async baseHead(handle) {
+    const res = await this.runGit(["rev-parse", handle.baseBranch], this.projectRoot);
+    const sha = res.stdout.trim();
+    return res.code === 0 && sha ? sha : null;
+  }
+  /**
+   * Hard-reset the base branch back to `sha` (a value previously returned by
+   * {@link baseHead}). Used to undo a squash-merge whose integrated result failed
+   * re-verification, so an auto-resolved-but-broken merge never sticks on base.
+   * Safe because SDD merges are serialized — no other commit lands in between.
+   */
+  async revertBaseTo(handle, sha) {
+    const co = await this.runGit(["checkout", handle.baseBranch], this.projectRoot);
+    if (co.code !== 0) return false;
+    const reset = await this.runGit(["reset", "--hard", sha], this.projectRoot);
+    return reset.code === 0;
+  }
+  /**
+   * Current base branch + tip SHA, captured WITHOUT a handle. The SDD run calls
+   * this once at start so a later rollback knows which branch the run's squash
+   * commits landed on. Returns null when not in a usable git state.
+   */
+  async currentBase() {
+    const branch = await this.detectBaseBranch();
+    const head = await this.runGit(["rev-parse", "HEAD"], this.projectRoot);
+    const sha = head.stdout.trim();
+    return head.code === 0 && sha ? { branch, sha } : null;
+  }
+  /**
+   * Force-remove EVERY managed worktree + branch this project owns, without
+   * relying on the in-memory `handles` map — so it works post-run (a fresh
+   * manager can clean up a previous run's leftovers). Enumerates
+   * `git worktree list --porcelain`, removes every checkout living under the
+   * `.wrongstack/worktrees` root, deletes every `wstack/ap/*` branch, then prunes.
+   * Returns the number of worktrees removed. Never throws — best-effort cleanup.
+   */
+  async cleanupAllManaged() {
+    const root = resolve(this.worktreesRoot());
+    let removed = 0;
+    try {
+      const listed = await this.runGit(["worktree", "list", "--porcelain"], this.projectRoot);
+      for (const line of listed.stdout.split("\n")) {
+        const m = line.match(/^worktree\s+(.+?)\s*$/);
+        if (!m?.[1]) continue;
+        const dir = resolve(m[1]);
+        if (dir !== root && (dir === root || dir.startsWith(root + sep))) {
+          const rm6 = await this.runGit(["worktree", "remove", "--force", dir], this.projectRoot);
+          if (rm6.code === 0) removed++;
+        }
+      }
+    } catch {
+    }
+    try {
+      const branches = await this.runGit(
+        ["branch", "--list", "--format=%(refname:short)", "wstack/ap/*"],
+        this.projectRoot
+      );
+      for (const b of branches.stdout.split("\n").map((s) => s.trim()).filter(Boolean)) {
+        await this.runGit(["branch", "-D", b], this.projectRoot);
+      }
+    } catch {
+    }
+    await this.runGit(["worktree", "prune"], this.projectRoot).catch(() => void 0);
+    this.handles.clear();
+    this.emit("worktree.released", {
+      handleId: "cleanup-all",
+      ownerId: "cleanup-all",
+      branch: "wstack/ap/*",
+      kept: false
+    });
+    return { removed };
+  }
+  /**
+   * Undo a run's squash commits by reverting each (newest → oldest) on the base
+   * branch — history-preserving, never a destructive reset. Refuses on a dirty
+   * working tree (so uncommitted work is never clobbered) and aborts cleanly if a
+   * revert conflicts, reporting which SHA. `shas` are the run commit SHAs in the
+   * order they landed; this reverses them. Returns the count reverted.
+   */
+  async revertCommits(baseBranch, shas) {
+    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" };
+    }
+    const co = await this.runGit(["checkout", baseBranch], this.projectRoot);
+    if (co.code !== 0) {
+      return { ok: false, reverted: 0, reason: co.stderr || `checkout ${baseBranch} failed` };
+    }
+    const idArgs = await this.identityArgs(this.projectRoot);
+    let reverted = 0;
+    for (const sha of [...shas].reverse()) {
+      const res = await this.runGit([...idArgs, "revert", "--no-edit", sha], this.projectRoot);
+      if (res.code !== 0) {
+        await this.runGit(["revert", "--abort"], this.projectRoot).catch(() => void 0);
+        return {
+          ok: false,
+          reverted,
+          reason: `revert of ${sha.slice(0, 8)} failed: ${(res.stderr || res.stdout).trim().split("\n")[0] ?? "conflict"}`
+        };
+      }
+      reverted++;
+    }
+    return { ok: true, reverted };
+  }
+  /**
+   * Run the caller-supplied resolver against a conflicted squash-merge, then
+   * commit if it cleared every marker. Returns a successful `MergeResult` on a
+   * clean resolution, or `null` to signal the caller should fall back to the
+   * abort path. Never leaves the base tree committed-but-dirty: a partial or
+   * failed resolution returns `null` and the caller hard-resets.
+   */
+  async tryResolveConflict(handle, conflictFiles, opts) {
+    let resolved = false;
+    try {
+      resolved = opts.resolve ? await opts.resolve({ conflictFiles, cwd: this.projectRoot }) : false;
+    } catch {
+      resolved = false;
+    }
+    if (!resolved) return null;
+    await this.runGit(["add", "-A"], this.projectRoot);
+    if (await this.hasConflictMarkers()) return null;
+    const idArgs = await this.identityArgs(this.projectRoot);
+    const msg = opts.message ?? `merge ${handle.branch} (squash, conflict resolved)`;
+    const commit = await this.runGit([...idArgs, "commit", "-m", msg], this.projectRoot);
+    if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
+      return null;
+    }
+    handle.conflictFiles = conflictFiles;
+    this.setStatus(handle, "merged");
+    this.emit("worktree.merged", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      baseBranch: handle.baseBranch,
+      squash: true
+    });
+    return { ok: true, resolved: true, conflictFiles };
+  }
+  /**
+   * True when staged content still carries conflict markers. `git diff --cached
+   * --check` exits nonzero and prints a "leftover conflict marker" line for each
+   * survivor; whitespace-only errors (also flagged by --check) are ignored so a
+   * clean resolution with unrelated whitespace is not rejected.
+   */
+  async hasConflictMarkers() {
+    const check = await this.runGit(["diff", "--cached", "--check"], this.projectRoot);
+    if (check.code === 0) return false;
+    return /conflict marker/i.test(`${check.stdout}
+${check.stderr}`);
+  }
+  /**
+   * Remove the worktree + branch. Conflicted/failed handles (or `keep:true`)
+   * are left on disk for inspection.
+   */
+  async release(handle, opts = {}) {
+    const keep = opts.keep || handle.status === "needs-review" || handle.status === "failed";
+    if (!keep) {
+      await this.runGit(["worktree", "remove", "--force", handle.dir], this.projectRoot);
+      await this.runGit(["branch", "-D", handle.branch], this.projectRoot);
+      await this.runGit(["worktree", "prune"], this.projectRoot);
+      this.handles.delete(handle.ownerId);
+    }
+    this.emit("worktree.released", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      kept: keep
+    });
+  }
+  get(ownerId) {
+    return this.handles.get(ownerId);
+  }
+  list() {
+    return [...this.handles.values()];
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  worktreesRoot() {
+    return join(this.projectRoot, ".wrongstack", "worktrees");
+  }
+  async detectBaseBranch() {
+    const head = await this.runGit(["rev-parse", "--abbrev-ref", "HEAD"], this.projectRoot);
+    const name = head.stdout.trim();
+    if (name && name !== "HEAD") return name;
+    const sha = await this.runGit(["rev-parse", "HEAD"], this.projectRoot);
+    return sha.stdout.trim() || "HEAD";
+  }
+  makeSlug(hint) {
+    let base = hint.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+/, "").replace(/[-.]+$/, "").slice(0, MAX_SLUG).replace(/[-.]+$/, "");
+    if (!base) base = "wt";
+    let slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
+    while (this.usedSlugs.has(slug)) slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
+    this.usedSlugs.add(slug);
+    return slug;
+  }
+  async collectStats(dir) {
+    const sha = (await this.runGit(["rev-parse", "HEAD"], dir)).stdout.trim();
+    const numstat = await this.runGit(["show", "--numstat", "--format=", "HEAD"], dir);
+    let insertions = 0;
+    let deletions = 0;
+    let files = 0;
+    for (const line of numstat.stdout.split("\n")) {
+      const m = line.trim().match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+      if (!m) continue;
+      files++;
+      if (m[1] !== "-") insertions += Number(m[1]);
+      if (m[2] !== "-") deletions += Number(m[2]);
+    }
+    return { insertions, deletions, files, sha };
+  }
+  /**
+   * `git -c user.*` fallback so commits succeed on machines and CI runners
+   * that have no global git identity configured. Returns `[]` when both
+   * `user.name` and `user.email` are already set (the common case), so a real
+   * user's identity is never overridden. The worktree branch commits are
+   * squashed away on merge, so the fallback identity never reaches the base
+   * branch history.
+   */
+  async identityArgs(cwd) {
+    const name = (await this.runGit(["config", "user.name"], cwd)).stdout.trim();
+    const email = (await this.runGit(["config", "user.email"], cwd)).stdout.trim();
+    if (name && email) return [];
+    return [
+      "-c",
+      `user.name=${name || "AutoPhase"}`,
+      "-c",
+      `user.email=${email || "autophase@agent.local"}`
+    ];
+  }
+  async unmergedFiles() {
+    const res = await this.runGit(["diff", "--name-only", "--diff-filter=U"], this.projectRoot);
+    return res.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  emitCommitted(handle, committed) {
+    this.emit("worktree.committed", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      committed,
+      insertions: handle.insertions,
+      deletions: handle.deletions,
+      files: handle.files,
+      sha: handle.sha
+    });
+  }
+  fail(handle, error) {
+    this.setStatus(handle, "failed", { lastError: error });
+    this.emit("worktree.failed", {
+      handleId: handle.id,
+      ownerId: handle.ownerId,
+      branch: handle.branch,
+      error
+    });
+    return handle;
+  }
+  setStatus(handle, status, patch) {
+    handle.status = status;
+    handle.updatedAt = Date.now();
+    if (patch) Object.assign(handle, patch);
+  }
+  emit(event, payload) {
+    this.events?.emit(event, payload);
+  }
+  defaultRun(args, cwd) {
+    return new Promise((res) => {
+      let stdout = "";
+      let stderr = "";
+      const MAX_GIT_OUTPUT = 1e6;
+      const child = spawn(this.gitBin, args, {
+        cwd,
+        env: buildChildEnv(),
+        stdio: ["ignore", "pipe", "pipe"],
+        signal: AbortSignal.timeout(3e4),
+        windowsHide: true
+      });
+      child.stdout?.on("data", (c) => {
+        if (stdout.length < MAX_GIT_OUTPUT) stdout += c.toString();
+      });
+      child.stderr?.on("data", (c) => {
+        if (stderr.length < MAX_GIT_OUTPUT) stderr += c.toString();
+      });
+      child.on("error", (err) => res({ code: 1, stdout, stderr: err.message }));
+      child.on("close", (code) => res({ code: code ?? 1, stdout, stderr }));
+    });
+  }
+};
+function parseConflictPaths(output) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of output.split("\n")) {
+    const m = line.match(/^CONFLICT \([^)]*\): Merge conflict in (.+?)\s*$/);
+    if (m?.[1]) paths.add(m[1]);
+  }
+  return [...paths];
+}
+function assertSafePath(dir, projectRoot) {
+  const root = resolve(projectRoot);
+  const abs = resolve(dir);
+  if (abs !== root && !abs.startsWith(root + sep)) {
+    throw new Error(`worktree path escapes project root: ${dir}`);
+  }
+}
+
+// src/sdd/sdd-lifecycle.ts
+async function cleanupSddWorktrees(projectRoot) {
+  const wt = new WorktreeManager({ projectRoot });
+  return wt.cleanupAllManaged();
+}
+async function rollbackSddRunFromDisk(opts) {
+  const store = new SddBoardStore({ baseDir: opts.boardsDir });
+  const runId = opts.runId ?? (await store.list())[0]?.runId;
+  if (!runId) return { ok: false, reverted: 0, reason: "no SDD board found to roll back" };
+  const snap = await store.load(runId);
+  if (!snap) return { ok: false, reverted: 0, reason: `board "${runId}" not found` };
+  if (!snap.baseBranch) {
+    return { ok: false, reverted: 0, reason: "this run did not record a base branch (no worktree run)" };
+  }
+  const shas = (snap.mergedCommits ?? []).map((c) => c.sha);
+  if (shas.length === 0) {
+    return { ok: false, reverted: 0, reason: "no merged commits recorded for this run" };
+  }
+  const wt = new WorktreeManager({ projectRoot: opts.projectRoot });
+  return wt.revertCommits(snap.baseBranch, shas);
+}
+async function destroySddProject(opts) {
+  const { removed } = await cleanupSddWorktrees(opts.projectRoot).catch(() => ({ removed: 0 }));
+  const deleted = [];
+  const rmDir = async (dir, label) => {
+    try {
+      await fsp3.rm(dir, { recursive: true, force: true });
+      deleted.push(label);
+    } catch {
+    }
+  };
+  const rmFile = async (file, label) => {
+    try {
+      await fsp3.unlink(file);
+      deleted.push(label);
+    } catch {
+    }
+  };
+  await rmFile(opts.paths.projectSddSession, "session");
+  await rmDir(opts.paths.projectSpecs, "specs");
+  await rmDir(opts.paths.projectTaskGraphs, "task-graphs");
+  await rmDir(opts.paths.projectSddBoards, "boards");
+  return { worktreesRemoved: removed, deleted };
+}
+
+// src/observability/metrics.ts
+var RESERVOIR_SIZE = 1024;
+function labelKey(labels) {
+  if (!labels) return "";
+  const keys = Object.keys(labels).sort();
+  return keys.map((k) => `${k}=${labels[k]}`).join(",");
+}
+function quantile(sorted, q) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.floor(q * sorted.length));
+  return sorted[idx] ?? 0;
+}
+var InMemoryMetricsSink = class {
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  counter(name, value = 1, labels) {
+    const series = this.getOrCreate(this.counters, name);
+    const key = labelKey(labels);
+    const state = series.get(key) ?? { value: 0 };
+    state.value += value;
+    series.set(key, state);
+  }
+  gauge(name, value, labels) {
+    const series = this.getOrCreate(this.gauges, name);
+    series.set(labelKey(labels), { value });
+  }
+  histogram(name, value, labels) {
+    const series = this.getOrCreate(this.histograms, name);
+    const key = labelKey(labels);
+    let state = series.get(key);
+    if (!state) {
+      state = { count: 0, sum: 0, min: value, max: value, samples: [] };
+      series.set(key, state);
+    }
+    state.count++;
+    state.sum += value;
+    if (value < state.min) state.min = value;
+    if (value > state.max) state.max = value;
+    if (state.samples.length < RESERVOIR_SIZE) {
+      state.samples.push(value);
+    } else {
+      const r = Math.floor(Math.random() * state.count);
+      if (r < RESERVOIR_SIZE) state.samples[r] = value;
+    }
+  }
+  snapshot() {
+    const series = [];
+    for (const [name, byLabel] of this.counters) {
+      for (const [key, state] of byLabel) {
+        series.push({
+          name,
+          type: "counter",
+          labels: parseLabelKey(key),
+          values: { value: state.value }
+        });
+      }
+    }
+    for (const [name, byLabel] of this.gauges) {
+      for (const [key, state] of byLabel) {
+        series.push({
+          name,
+          type: "gauge",
+          labels: parseLabelKey(key),
+          values: { value: state.value }
+        });
+      }
+    }
+    for (const [name, byLabel] of this.histograms) {
+      for (const [key, state] of byLabel) {
+        const sorted = [...state.samples].sort((a, b) => a - b);
+        series.push({
+          name,
+          type: "histogram",
+          labels: parseLabelKey(key),
+          values: {
+            count: state.count,
+            sum: state.sum,
+            min: state.min,
+            max: state.max,
+            p50: quantile(sorted, 0.5),
+            p95: quantile(sorted, 0.95),
+            p99: quantile(sorted, 0.99)
+          }
+        });
+      }
+    }
+    return { timestamp: Date.now(), series };
+  }
+  reset() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+  }
+  getOrCreate(bag, name) {
+    let series = bag.get(name);
+    if (!series) {
+      series = /* @__PURE__ */ new Map();
+      bag.set(name, series);
+    }
+    return series;
+  }
+};
+function parseLabelKey(key) {
+  if (!key) return {};
+  const labels = {};
+  for (const pair of key.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) labels[pair.slice(0, eq)] = pair.slice(eq + 1);
+  }
+  return labels;
+}
+var NoopMetricsSink = class {
+  counter() {
+  }
+  gauge() {
+  }
+  histogram() {
+  }
+  snapshot() {
+    return { timestamp: Date.now(), series: [] };
+  }
+  reset() {
+  }
+};
+
+// src/observability/health.ts
+var SEVERITY = {
+  healthy: 0,
+  degraded: 1,
+  unhealthy: 2
+};
+var DefaultHealthRegistry = class {
+  checks = /* @__PURE__ */ new Map();
+  timeoutMs;
+  constructor(opts = {}) {
+    this.timeoutMs = opts.timeoutMs ?? 5e3;
+  }
+  register(check) {
     this.checks.set(check.name, check);
   }
   unregister(name) {
@@ -27406,7 +30137,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path51 = opts.path ?? "/metrics";
+  const path52 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -27416,7 +30147,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path51) {
+    if (url === path52) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -27480,7 +30211,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path51}`,
+    url: `${protocol}://${host}:${boundPort}${path52}`,
     close: () => new Promise((resolve19, reject) => {
       server.close((err) => err ? reject(err) : resolve19());
     })
@@ -35306,16 +38037,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile49 } = await import('fs/promises');
-      const content = await readFile49(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile51 } = await import('fs/promises');
+      const content = await readFile51(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile49 } = await import('fs/promises');
-      const content = await readFile49(join(reportsDir, match), "utf-8");
+      const { readFile: readFile51 } = await import('fs/promises');
+      const content = await readFile51(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -36413,6 +39144,7 @@ function makeMailboxTool(opts = {}) {
     category: "coordination",
     permission: "auto",
     mutating: true,
+    capabilities: [ToolCapabilities.COORDINATION_MAIL],
     inputSchema: {
       type: "object",
       properties: {
@@ -36676,6 +39408,7 @@ function makeMailSendTool(opts = {}) {
     category: "coordination",
     permission: "auto",
     mutating: true,
+    capabilities: [ToolCapabilities.COORDINATION_MAIL],
     inputSchema: {
       type: "object",
       properties: {
@@ -36735,6 +39468,7 @@ function makeMailInboxTool(opts = {}) {
     category: "coordination",
     permission: "auto",
     mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_MAIL],
     inputSchema: {
       type: "object",
       properties: {
@@ -42620,8 +45354,8 @@ var InputBuilder = class {
   async registerFile(input) {
     const ref = await this.store.add({ ...input, kind: "file" });
     this.refs.push(ref);
-    const path51 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
-    return `[file:${path51}]`;
+    const path52 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path52}]`;
   }
   /**
    * Whether `appendPaste(text)` would collapse the text to a placeholder
@@ -43614,6 +46348,7 @@ function compactTrigger(trigger) {
 // src/registry/tool-registry.ts
 var ToolRegistry = class _ToolRegistry {
   tools = /* @__PURE__ */ new Map();
+  descriptionModes = /* @__PURE__ */ new Map();
   /** Monotonic version bumped on every registry mutation. */
   _version = 0;
   /** Cached `list()` result, frozen after build. Invalidated on _version change. */
@@ -43625,6 +46360,10 @@ var ToolRegistry = class _ToolRegistry {
       tool._estDefTokens = estimateToolDefTokens(tool);
     }
   }
+  _prepareForStorage(tool) {
+    const mode = this.descriptionModes.get(tool.name) ?? "extend";
+    return applyToolDescriptionModeToTool(tool, mode);
+  }
   register(tool, owner = "core") {
     if (this.tools.has(tool.name)) {
       throw new WrongStackError({
@@ -43642,8 +46381,9 @@ var ToolRegistry = class _ToolRegistry {
         context: { tool: tool.name }
       });
     }
-    this._stampDefTokens(tool);
-    this.tools.set(tool.name, { tool, owner });
+    const stored = this._prepareForStorage(tool);
+    this._stampDefTokens(stored);
+    this.tools.set(tool.name, { tool: stored, owner });
     this._version++;
   }
   /**
@@ -43656,8 +46396,9 @@ var ToolRegistry = class _ToolRegistry {
     if (!tool.inputSchema || typeof tool.inputSchema !== "object") {
       return false;
     }
-    this._stampDefTokens(tool);
-    this.tools.set(tool.name, { tool, owner });
+    const stored = this._prepareForStorage(tool);
+    this._stampDefTokens(stored);
+    this.tools.set(tool.name, { tool: stored, owner });
     this._version++;
     return true;
   }
@@ -43683,11 +46424,15 @@ var ToolRegistry = class _ToolRegistry {
    */
   registerDefault(tool, owner = "core") {
     if (this.tools.has(tool.name)) return;
-    this._stampDefTokens(tool);
-    this.tools.set(tool.name, { tool, owner });
+    const stored = this._prepareForStorage(tool);
+    this._stampDefTokens(stored);
+    this.tools.set(tool.name, { tool: stored, owner });
+    this._version++;
   }
   unregister(name) {
-    return this.tools.delete(name);
+    const deleted = this.tools.delete(name);
+    if (deleted) this._version++;
+    return deleted;
   }
   /**
    * Override an existing tool. Throws if the tool is not already registered.
@@ -43702,8 +46447,10 @@ var ToolRegistry = class _ToolRegistry {
         context: { tool: name }
       });
     }
-    this._stampDefTokens(tool);
-    this.tools.set(name, { tool, owner });
+    const stored = this._prepareForStorage(tool);
+    this._stampDefTokens(stored);
+    this.tools.set(name, { tool: stored, owner });
+    this._version++;
   }
   /**
    * Wrap (decorate) an existing tool. The wrapper receives the current
@@ -43726,12 +46473,49 @@ var ToolRegistry = class _ToolRegistry {
         context: { tool: name }
       });
     }
-    const wrapped = wrapper(entry.tool);
+    const current = applyToolDescriptionModeToTool(entry.tool, "extend");
+    const wrapped = this._prepareForStorage(wrapper(current));
     wrapped._estDefTokens = void 0;
     this._stampDefTokens(wrapped);
     this.tools.set(name, { tool: wrapped, owner: `${entry.owner}+${owner}` });
     this._version++;
   }
+  setDescriptionMode(name, mode) {
+    const normalized = normalizeToolDescriptionMode(mode);
+    if (!normalized) return false;
+    const entry = this.tools.get(name);
+    if (!entry) return false;
+    if (normalized === "extend") {
+      this.descriptionModes.delete(name);
+    } else {
+      this.descriptionModes.set(name, normalized);
+    }
+    const stored = applyToolDescriptionModeToTool(entry.tool, normalized);
+    stored._estDefTokens = void 0;
+    this._stampDefTokens(stored);
+    this.tools.set(name, { ...entry, tool: stored });
+    this._version++;
+    return true;
+  }
+  getDescriptionMode(name) {
+    return this.descriptionModes.get(name) ?? "extend";
+  }
+  applyDescriptionModes(modes = {}) {
+    const missing = [];
+    let applied = 0;
+    for (const [name, rawMode] of Object.entries(modes)) {
+      const mode = normalizeToolDescriptionMode(rawMode);
+      if (!mode) continue;
+      if (this.tools.has(name)) {
+        if (this.setDescriptionMode(name, mode)) applied++;
+      } else {
+        if (mode === "simple") this.descriptionModes.set(name, mode);
+        else this.descriptionModes.delete(name);
+        missing.push(name);
+      }
+    }
+    return { applied, missing };
+  }
   get(name) {
     return this.tools.get(name)?.tool;
   }
@@ -43770,6 +46554,8 @@ var ToolRegistry = class _ToolRegistry {
   }
   clear() {
     this.tools.clear();
+    this.descriptionModes.clear();
+    this._version++;
   }
   /**
    * Return a new ToolRegistry with the same registered tools and owners.
@@ -43777,6 +46563,9 @@ var ToolRegistry = class _ToolRegistry {
    */
   clone() {
     const copy = new _ToolRegistry();
+    for (const [name, mode] of this.descriptionModes) {
+      copy.descriptionModes.set(name, mode);
+    }
     for (const { tool, owner } of this.listWithOwner()) copy.register(tool, owner);
     return copy;
   }
@@ -45138,6 +47927,12 @@ var PhaseOrchestrator = class {
   async executeSingleTask(task, phase) {
     const tracker = this.getTrackerForPhase(phase);
     tracker.updateNodeStatus(task.id, "in_progress");
+    this.emit("phase.taskStarted", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title,
+      agentName: task.assignee
+    });
     const handle = this.phaseWorktrees.get(phase.id);
     return this.ctx.executeTask(task, phase.id, { cwd: handle?.dir, branch: handle?.branch });
   }
@@ -45342,6 +48137,92 @@ var PhaseOrchestrator = class {
     phase.assignedAgents = phase.assignedAgents.filter((id) => id !== agentId);
     this.emit("agent.released", { phaseId, agentId });
   }
+  // ─── Interactive board mutations ──────────────────────────────────────────
+  //
+  // These are driven by an interactive board (WebUI/TUI), not the autonomous
+  // loop. Each mutates the live graph, emits a typed event so every surface
+  // stays in sync, and bumps updatedAt so the host re-persists.
+  /** Find the phase whose task graph currently holds `taskId`. */
+  findPhaseOfTask(taskId) {
+    for (const phase of this.graph.phases.values()) {
+      if (phase.taskGraph.nodes.has(taskId)) return phase;
+    }
+    return void 0;
+  }
+  /**
+   * Move a task to another phase's task graph. Edges that referenced the task
+   * are dropped (cross-phase dependencies are not modeled). No-op when the task
+   * or target phase is missing, or it is already in the target phase.
+   */
+  moveTask(taskId, toPhaseId) {
+    const from = this.findPhaseOfTask(taskId);
+    const to = this.graph.phases.get(toPhaseId);
+    if (!from || !to || from.id === toPhaseId) return false;
+    const node = from.taskGraph.nodes.get(taskId);
+    if (!node) return false;
+    from.taskGraph.nodes.delete(taskId);
+    from.taskGraph.rootNodes = from.taskGraph.rootNodes.filter((id) => id !== taskId);
+    from.taskGraph.edges = from.taskGraph.edges.filter((e) => e.from !== taskId && e.to !== taskId);
+    from.taskGraph.updatedAt = Date.now();
+    node.parentId = void 0;
+    node.children = void 0;
+    node.updatedAt = Date.now();
+    to.taskGraph.nodes.set(taskId, node);
+    to.taskGraph.rootNodes.push(taskId);
+    to.taskGraph.updatedAt = Date.now();
+    this.trackerCache.delete(from.id);
+    this.trackerCache.delete(to.id);
+    this.graph.updatedAt = Date.now();
+    this.emit("phase.taskMoved", { taskId, fromPhaseId: from.id, toPhaseId });
+    return true;
+  }
+  /** (Re)assign a task to a specific agent (or clear with agentName/agentId omitted). */
+  setTaskAssignee(taskId, agentId, agentName) {
+    const phase = this.findPhaseOfTask(taskId);
+    if (!phase) return false;
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNode(taskId, { assignee: agentName ?? agentId ?? "" });
+    this.graph.updatedAt = Date.now();
+    this.emit("phase.taskAssigned", { phaseId: phase.id, taskId, agentId, agentName });
+    return true;
+  }
+  /** Add a new task to a phase. Returns the created task id, or null if the phase is missing. */
+  addTask(phaseId, spec) {
+    const phase = this.graph.phases.get(phaseId);
+    if (!phase) return null;
+    const tracker = this.getTrackerForPhase(phase);
+    const node = tracker.addNode({
+      title: spec.title,
+      description: spec.description ?? "",
+      type: spec.type ?? "feature",
+      priority: spec.priority ?? "medium",
+      status: "pending"
+    });
+    this.graph.updatedAt = Date.now();
+    this.emit("phase.taskAdded", { phaseId, taskId: node.id, taskTitle: node.title });
+    return node.id;
+  }
+  /**
+   * Requeue a task to `pending` (clearing its retry counter) and nudge a
+   * terminal/paused phase back to `ready` so the loop re-runs it. Backs both the
+   * board's "retry" and "start" affordances.
+   */
+  requeueTask(taskId) {
+    const phase = this.findPhaseOfTask(taskId);
+    if (!phase) return false;
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(taskId, "pending");
+    this.taskRetryCounts.delete(`${phase.id}:${taskId}`);
+    if (phase.status === "completed" || phase.status === "failed" || phase.status === "paused") {
+      this.graph.failedPhaseIds = this.graph.failedPhaseIds.filter((id) => id !== phase.id);
+      this.graph.completedPhaseIds = this.graph.completedPhaseIds.filter((id) => id !== phase.id);
+      this.graph.activePhaseIds = this.graph.activePhaseIds.filter((id) => id !== phase.id);
+      this.phaseWorktrees.delete(phase.id);
+      this.updatePhaseStatus(phase, "pending");
+    }
+    this.graph.updatedAt = Date.now();
+    return true;
+  }
   // ─── Events ───────────────────────────────────────────────────────────────
   emit(event, payload) {
     this.events.emit(event, payload);
@@ -46067,346 +48948,6 @@ var CheckpointManager = class {
     }
   }
 };
-var MAX_SLUG = 40;
-var WorktreeManager = class {
-  projectRoot;
-  events;
-  gitBin;
-  runGit;
-  /** Keyed by ownerId. */
-  handles = /* @__PURE__ */ new Map();
-  usedSlugs = /* @__PURE__ */ new Set();
-  constructor(opts) {
-    this.projectRoot = resolve(opts.projectRoot);
-    this.events = opts.events;
-    this.gitBin = opts.gitBin ?? "git";
-    this.runGit = opts.run ?? ((args, cwd) => this.defaultRun(args, cwd));
-  }
-  /** Create a fresh worktree + branch forked from the current base branch. */
-  async allocate(ownerId, opts = {}) {
-    const existing = this.handles.get(ownerId);
-    if (existing && (existing.status === "allocating" || existing.status === "active")) {
-      return existing;
-    }
-    const slug = this.makeSlug(opts.slugHint ?? ownerId);
-    const branch = `wstack/ap/${slug}`;
-    const dir = join(this.worktreesRoot(), slug);
-    const absDir = resolve(dir);
-    const absRoot = resolve(this.projectRoot);
-    if (!absDir.startsWith(absRoot + sep)) {
-      throw new Error(`Worktree dir "${absDir}" resolves outside project root`);
-    }
-    const baseBranch = opts.baseBranch ?? await this.detectBaseBranch();
-    const handle = {
-      id: slug,
-      ownerId,
-      ownerLabel: opts.ownerLabel ?? opts.slugHint ?? ownerId,
-      slug,
-      dir,
-      branch,
-      baseBranch,
-      status: "allocating",
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      insertions: 0,
-      deletions: 0,
-      files: 0
-    };
-    this.handles.set(ownerId, handle);
-    try {
-      await mkdir(this.worktreesRoot(), { recursive: true });
-      const res = await this.runGit(
-        ["worktree", "add", "-b", branch, dir, baseBranch],
-        this.projectRoot
-      );
-      if (res.code !== 0) {
-        return this.fail(handle, res.stderr || "git worktree add failed");
-      }
-    } catch (err) {
-      return this.fail(handle, toErrorMessage(err));
-    }
-    this.setStatus(handle, "active");
-    this.emit("worktree.allocated", {
-      handleId: handle.id,
-      ownerId: handle.ownerId,
-      ownerLabel: handle.ownerLabel,
-      slug: handle.slug,
-      dir: handle.dir,
-      branch: handle.branch,
-      baseBranch: handle.baseBranch
-    });
-    return handle;
-  }
-  /** Stage everything and commit inside the worktree. */
-  async commitAll(handle, message) {
-    this.setStatus(handle, "committing");
-    await this.runGit(["add", "-A"], handle.dir);
-    const staged = await this.runGit(["diff", "--cached", "--quiet"], handle.dir);
-    if (staged.code === 0) {
-      this.emitCommitted(handle, false);
-      return { committed: false };
-    }
-    const idArgs = await this.identityArgs(handle.dir);
-    const committed = await this.runGit([...idArgs, "commit", "-m", message], handle.dir);
-    if (committed.code !== 0) {
-      this.fail(handle, committed.stderr || "git commit failed");
-      return { committed: false };
-    }
-    const stats = await this.collectStats(handle.dir);
-    handle.insertions = stats.insertions;
-    handle.deletions = stats.deletions;
-    handle.files = stats.files;
-    handle.sha = stats.sha;
-    handle.updatedAt = Date.now();
-    this.emitCommitted(handle, true);
-    return { committed: true };
-  }
-  /** Merge the worktree branch back into the base branch (squash by default). */
-  async merge(handle, opts = {}) {
-    const squash = opts.squash ?? true;
-    this.setStatus(handle, "merging");
-    const checkout = await this.runGit(["checkout", handle.baseBranch], this.projectRoot);
-    if (checkout.code !== 0) {
-      this.fail(handle, checkout.stderr || `checkout ${handle.baseBranch} failed`);
-      return { ok: false, stderr: checkout.stderr };
-    }
-    const mergeArgs = squash ? ["merge", "--squash", handle.branch] : ["merge", "--no-ff", handle.branch];
-    const merged = await this.runGit(mergeArgs, this.projectRoot);
-    if (merged.code !== 0) {
-      const fromOutput = parseConflictPaths(`${merged.stdout}
-${merged.stderr}`);
-      const fromIndex = await this.unmergedFiles();
-      const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
-      if (opts.resolve) {
-        const finalized = await this.tryResolveConflict(handle, conflictFiles, opts);
-        if (finalized) return finalized;
-      }
-      await this.runGit(["reset", "--hard", "HEAD"], this.projectRoot);
-      handle.conflictFiles = conflictFiles;
-      this.setStatus(handle, "needs-review", { lastError: merged.stderr });
-      this.emit("worktree.conflict", {
-        handleId: handle.id,
-        ownerId: handle.ownerId,
-        branch: handle.branch,
-        conflictFiles
-      });
-      return { ok: false, conflict: true, conflictFiles, stderr: merged.stderr };
-    }
-    if (squash) {
-      const msg = opts.message ?? `merge ${handle.branch} (squash)`;
-      const idArgs = await this.identityArgs(this.projectRoot);
-      const commit = await this.runGit([...idArgs, "commit", "-m", msg], this.projectRoot);
-      if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
-        this.fail(handle, commit.stderr || "squash commit failed");
-        return { ok: false, stderr: commit.stderr };
-      }
-    }
-    this.setStatus(handle, "merged");
-    this.emit("worktree.merged", {
-      handleId: handle.id,
-      ownerId: handle.ownerId,
-      branch: handle.branch,
-      baseBranch: handle.baseBranch,
-      squash
-    });
-    return { ok: true };
-  }
-  /**
-   * Run the caller-supplied resolver against a conflicted squash-merge, then
-   * commit if it cleared every marker. Returns a successful `MergeResult` on a
-   * clean resolution, or `null` to signal the caller should fall back to the
-   * abort path. Never leaves the base tree committed-but-dirty: a partial or
-   * failed resolution returns `null` and the caller hard-resets.
-   */
-  async tryResolveConflict(handle, conflictFiles, opts) {
-    let resolved = false;
-    try {
-      resolved = opts.resolve ? await opts.resolve({ conflictFiles, cwd: this.projectRoot }) : false;
-    } catch {
-      resolved = false;
-    }
-    if (!resolved) return null;
-    await this.runGit(["add", "-A"], this.projectRoot);
-    if (await this.hasConflictMarkers()) return null;
-    const idArgs = await this.identityArgs(this.projectRoot);
-    const msg = opts.message ?? `merge ${handle.branch} (squash, conflict resolved)`;
-    const commit = await this.runGit([...idArgs, "commit", "-m", msg], this.projectRoot);
-    if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
-      return null;
-    }
-    handle.conflictFiles = conflictFiles;
-    this.setStatus(handle, "merged");
-    this.emit("worktree.merged", {
-      handleId: handle.id,
-      ownerId: handle.ownerId,
-      branch: handle.branch,
-      baseBranch: handle.baseBranch,
-      squash: true
-    });
-    return { ok: true, resolved: true, conflictFiles };
-  }
-  /**
-   * True when staged content still carries conflict markers. `git diff --cached
-   * --check` exits nonzero and prints a "leftover conflict marker" line for each
-   * survivor; whitespace-only errors (also flagged by --check) are ignored so a
-   * clean resolution with unrelated whitespace is not rejected.
-   */
-  async hasConflictMarkers() {
-    const check = await this.runGit(["diff", "--cached", "--check"], this.projectRoot);
-    if (check.code === 0) return false;
-    return /conflict marker/i.test(`${check.stdout}
-${check.stderr}`);
-  }
-  /**
-   * Remove the worktree + branch. Conflicted/failed handles (or `keep:true`)
-   * are left on disk for inspection.
-   */
-  async release(handle, opts = {}) {
-    const keep = opts.keep || handle.status === "needs-review" || handle.status === "failed";
-    if (!keep) {
-      await this.runGit(["worktree", "remove", "--force", handle.dir], this.projectRoot);
-      await this.runGit(["branch", "-D", handle.branch], this.projectRoot);
-      await this.runGit(["worktree", "prune"], this.projectRoot);
-      this.handles.delete(handle.ownerId);
-    }
-    this.emit("worktree.released", {
-      handleId: handle.id,
-      ownerId: handle.ownerId,
-      branch: handle.branch,
-      kept: keep
-    });
-  }
-  get(ownerId) {
-    return this.handles.get(ownerId);
-  }
-  list() {
-    return [...this.handles.values()];
-  }
-  // ── internals ────────────────────────────────────────────────────────────
-  worktreesRoot() {
-    return join(this.projectRoot, ".wrongstack", "worktrees");
-  }
-  async detectBaseBranch() {
-    const head = await this.runGit(["rev-parse", "--abbrev-ref", "HEAD"], this.projectRoot);
-    const name = head.stdout.trim();
-    if (name && name !== "HEAD") return name;
-    const sha = await this.runGit(["rev-parse", "HEAD"], this.projectRoot);
-    return sha.stdout.trim() || "HEAD";
-  }
-  makeSlug(hint) {
-    let base = hint.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+/, "").replace(/[-.]+$/, "").slice(0, MAX_SLUG).replace(/[-.]+$/, "");
-    if (!base) base = "wt";
-    let slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
-    while (this.usedSlugs.has(slug)) slug = `${base}-${crypto.randomUUID().slice(0, 6)}`;
-    this.usedSlugs.add(slug);
-    return slug;
-  }
-  async collectStats(dir) {
-    const sha = (await this.runGit(["rev-parse", "HEAD"], dir)).stdout.trim();
-    const numstat = await this.runGit(["show", "--numstat", "--format=", "HEAD"], dir);
-    let insertions = 0;
-    let deletions = 0;
-    let files = 0;
-    for (const line of numstat.stdout.split("\n")) {
-      const m = line.trim().match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
-      if (!m) continue;
-      files++;
-      if (m[1] !== "-") insertions += Number(m[1]);
-      if (m[2] !== "-") deletions += Number(m[2]);
-    }
-    return { insertions, deletions, files, sha };
-  }
-  /**
-   * `git -c user.*` fallback so commits succeed on machines and CI runners
-   * that have no global git identity configured. Returns `[]` when both
-   * `user.name` and `user.email` are already set (the common case), so a real
-   * user's identity is never overridden. The worktree branch commits are
-   * squashed away on merge, so the fallback identity never reaches the base
-   * branch history.
-   */
-  async identityArgs(cwd) {
-    const name = (await this.runGit(["config", "user.name"], cwd)).stdout.trim();
-    const email = (await this.runGit(["config", "user.email"], cwd)).stdout.trim();
-    if (name && email) return [];
-    return [
-      "-c",
-      `user.name=${name || "AutoPhase"}`,
-      "-c",
-      `user.email=${email || "autophase@agent.local"}`
-    ];
-  }
-  async unmergedFiles() {
-    const res = await this.runGit(["diff", "--name-only", "--diff-filter=U"], this.projectRoot);
-    return res.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
-  }
-  emitCommitted(handle, committed) {
-    this.emit("worktree.committed", {
-      handleId: handle.id,
-      ownerId: handle.ownerId,
-      branch: handle.branch,
-      committed,
-      insertions: handle.insertions,
-      deletions: handle.deletions,
-      files: handle.files,
-      sha: handle.sha
-    });
-  }
-  fail(handle, error) {
-    this.setStatus(handle, "failed", { lastError: error });
-    this.emit("worktree.failed", {
-      handleId: handle.id,
-      ownerId: handle.ownerId,
-      branch: handle.branch,
-      error
-    });
-    return handle;
-  }
-  setStatus(handle, status, patch) {
-    handle.status = status;
-    handle.updatedAt = Date.now();
-    if (patch) Object.assign(handle, patch);
-  }
-  emit(event, payload) {
-    this.events?.emit(event, payload);
-  }
-  defaultRun(args, cwd) {
-    return new Promise((res) => {
-      let stdout = "";
-      let stderr = "";
-      const MAX_GIT_OUTPUT = 1e6;
-      const child = spawn(this.gitBin, args, {
-        cwd,
-        env: buildChildEnv(),
-        stdio: ["ignore", "pipe", "pipe"],
-        signal: AbortSignal.timeout(3e4),
-        windowsHide: true
-      });
-      child.stdout?.on("data", (c) => {
-        if (stdout.length < MAX_GIT_OUTPUT) stdout += c.toString();
-      });
-      child.stderr?.on("data", (c) => {
-        if (stderr.length < MAX_GIT_OUTPUT) stderr += c.toString();
-      });
-      child.on("error", (err) => res({ code: 1, stdout, stderr: err.message }));
-      child.on("close", (code) => res({ code: code ?? 1, stdout, stderr }));
-    });
-  }
-};
-function parseConflictPaths(output) {
-  const paths = /* @__PURE__ */ new Set();
-  for (const line of output.split("\n")) {
-    const m = line.match(/^CONFLICT \([^)]*\): Merge conflict in (.+?)\s*$/);
-    if (m?.[1]) paths.add(m[1]);
-  }
-  return [...paths];
-}
-function assertSafePath(dir, projectRoot) {
-  const root = resolve(projectRoot);
-  const abs = resolve(dir);
-  if (abs !== root && !abs.startsWith(root + sep)) {
-    throw new Error(`worktree path escapes project root: ${dir}`);
-  }
-}
 
 // src/coordination/collab-bus.ts
 var CollaborationBus = class {
@@ -46905,8 +49446,8 @@ function extractManifestPath(msg) {
   }
   return void 0;
 }
-function isManifestFile(path51) {
-  const name = pathBasename(path51).toLowerCase();
+function isManifestFile(path52) {
+  const name = pathBasename(path52).toLowerCase();
   const manifests = [
     "package.json",
     "package-lock.json",
@@ -48416,6 +50957,6 @@ function createChimeraPlugin() {
   };
 }
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, Agent, AgentError, AgentMonitorService, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousBrain, AutonomousCoordinator, AutonomousRunner, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, ChangeManager, CheckpointManager, CloudSync, CollabSession, CollaborationBus, ConfigError, ConfigMigrationError, ConsensusProtocol, Container, Context, ConversationState, DANGEROUS_FOR_SUBAGENTS, DECISION_TIMEOUT_MS, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_HQ_REDACTION_POLICY, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_QUALITY_CHECKS, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEFAULT_TUI_THINKING_WORD, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorAlertLevel, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetNotifier, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HEAVY_BUDGET, HQ_AUTH_FILE_VERSION, HQ_PROTOCOL_VERSION, HookRegistry, HookRunner, HqPublisher, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, KNOWLEDGE_AGENTS, KnowledgeGraph, LAYER_1_IDENTITY, LIGHT_BUDGET, LLMSelector, LargeAnswerStore, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MAX_TUI_THINKING_WORD_LENGTH, MEDIUM_BUDGET, MEMORY_TYPE_LABELS, META_AGENTS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PLANNING_AGENTS, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddError, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TOKENS, TaskAuctioneer, TaskDAG, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolCapabilities, ToolError, ToolErrorCategory, ToolExecutor, ToolRegistry, VERIFY_AGENTS, WIDE_SUBAGENT_CAPABILITIES, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyModelRuntime, applyRosterBudget, asBlocks, asText, assertNever, assertNotPrivateHost, assertSafePath, assessCommitSafety, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildContextEvidenceDigest, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, buildTranscriptFromEvents, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compactSchemaDescriptions, compactToolDefinitionForWire, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAgentMonitorService, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextEvidenceState, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createGlobalMailbox, createHqEventEnvelope, createHqPublisherFromEnv, createMailboxChecker, createMailboxEventPayload, createMailboxHooks, createMailboxSnapshotPayload, createMailboxSnapshotPayloadFromMailbox, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultHqDataDir, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, definePlugin, deriveTodosFromPlanItem, describeCatalogModel, detectEcosystem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyHqAuthFile, emptyPlan, emptyTaskFile, encryptConfigSecrets, encryptedPrefixForVersion, enhanceUserPrompt, ensureDir, ensureHqFirstRunAuthFile, escapeGlobSubject, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expandIPv6, expectDefined, extractRunEnv, extractText, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, gatedEnhancerReasoning, generateSessionId, getAgentDefinition, getCalibrationState, getContextWindowMode, getDangerousCapabilities, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getJsonPath, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasCapability, hasDangerousCapabilityForSubagents, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, hqAuthFilePath, hqRuntimeFilePath, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isJsonObject, isPathSubjectKey, isPluginError, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, jsonObjectFileExists, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, mapMailboxAgentToHqSummary, mapMailboxMessageToHqSummary, mapSessionEventToEntries, markAssistantReferencedEvidence, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, mergeToolResults, migratePlaintextSecrets, miniMaxVisionServer, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizePathSubject, normalizeRecipient, normalizeToLf, normalizeTokenSavingTier, normalizeTuiThinkingWord, normalizedEqual, onResize, parseContinueDirective, parseEncryptedVersion, parseEntries, parseHqEventPayload, parseHqFrame, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, playwrightServer, projectHash, projectSlug, readHqAuthFile, readHqRuntimeFileSync, readJsonObjectFile, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, recordToolOutputEvidence, recordUserIntentEvidence, redactHqEvent, redactHqValue, removeJsonPath, removeJsonPathInFile, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, repeatedReadPressure, resetCalibration, resolveAuditLevel, resolveCacheForRequest, resolveChimeraConfig, resolveContextWindowPolicy, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, resolveMailboxIdentity, resolveModelMatrix, resolveModelRuntime, resolveProjectDir, resolveProviderModelList, resolveReasoningForRequest, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, rotateConfigKeys, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, sanitizeModel, sanitizeNodeOptions, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, scrubAndTruncateHqPreview, securitySlashCommand, sentinelServer, setBtwNote, setJsonPath, setJsonPathInFile, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, sshManagerServer, stableStringify, startAgentMonitorEventBridge, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startSessionTelemetryBridge, startTechStackConsumer, stripAnsi, subjectForToolInput, summarizeHqToolArgs, summarizeUsage, templateToMarkdown, toErrorMessage, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updateJsonObjectFile, updatePackageOutdatedStatus, validateAgainstSchema, watchHqAuthFile, wireMetricsToEvents, withDisabledToolFiltering, withFileLock, wrapAsState, writeErr, writeHqAuthFile, writeHqRuntimeFile, writeJsonObjectFile, writeOut, wstackGlobalRoot, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, Agent, AgentError, AgentMonitorService, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousBrain, AutonomousCoordinator, AutonomousRunner, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, ChangeManager, CheckpointManager, CloudSync, CollabSession, CollaborationBus, ConfigError, ConfigMigrationError, ConsensusProtocol, Container, Context, ConversationState, DANGEROUS_FOR_SUBAGENTS, DECISION_TIMEOUT_MS, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_HQ_REDACTION_POLICY, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_QUALITY_CHECKS, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEFAULT_TOOL_DESCRIPTION_MODE, DEFAULT_TUI_THINKING_WORD, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorAlertLevel, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetNotifier, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HEAVY_BUDGET, HQ_AUTH_FILE_VERSION, HQ_PROTOCOL_VERSION, HookRegistry, HookRunner, HqPublisher, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, KNOWLEDGE_AGENTS, KnowledgeGraph, LAYER_1_IDENTITY, LIGHT_BUDGET, LLMSelector, LargeAnswerStore, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MAX_TUI_THINKING_WORD_LENGTH, MEDIUM_BUDGET, MEMORY_TYPE_LABELS, META_AGENTS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PLANNING_AGENTS, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddBoardProjector, SddBoardStore, SddError, SddInterviewDriver, SddParallelRun, SddRunRegistry, SddSupervisor, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TOKENS, TaskAuctioneer, TaskDAG, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolCapabilities, ToolError, ToolErrorCategory, ToolExecutor, ToolRegistry, VERIFY_AGENTS, WIDE_SUBAGENT_CAPABILITIES, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyModelRuntime, applyRosterBudget, applyToolDescriptionModeToTool, applyToolDescriptionModes, asBlocks, asText, assertNever, assertNotPrivateHost, assertSafePath, assessCommitSafety, assignNickname, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBoardSnapshot, buildBoardTasks, buildBtwBlock, buildChildEnv, buildContextEvidenceDigest, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, buildTranscriptFromEvents, classifyFamily, cleanupSddWorktrees, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compactSchemaDescriptions, compactToolDefinitionForWire, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAgentMonitorService, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextEvidenceState, createContextManagerTool, createDefaultPipelines, createDelegateTool, createFallbackModelExtension, createGitPlugin, createGlobalMailbox, createHqEventEnvelope, createHqPublisherFromEnv, createMailboxChecker, createMailboxEventPayload, createMailboxHooks, createMailboxSnapshotPayload, createMailboxSnapshotPayloadFromMailbox, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultHqDataDir, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, definePlugin, deriveTodosFromPlanItem, describeCatalogModel, destroySddProject, detectEcosystem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, effectiveFallbackChain, eliseOldToolResults, emptyGoal, emptyHqAuthFile, emptyPlan, emptyTaskFile, encryptConfigSecrets, encryptedPrefixForVersion, enhanceUserPrompt, ensureDir, ensureHqFirstRunAuthFile, escapeGlobSubject, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expandIPv6, expectDefined, extractRunEnv, extractText, extractVerificationCommand, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, gatedEnhancerReasoning, generateSessionId, getAgentDefinition, getCalibrationState, getContextWindowMode, getDangerousCapabilities, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getJsonPath, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, getToolDescriptionMode, githubServer, goalFilePath, googleMapsServer, hasCapability, hasConflictMarkers, hasDangerousCapabilityForSubagents, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, hqAuthFilePath, hqRuntimeFilePath, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isExplanatoryText, isFsError, isImageBlock, isInteractive, isJsonObject, isPathSubjectKey, isPluginError, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, jsonObjectFileExists, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeCommandVerifier, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeLlmConflictResolver, makeLlmSubtaskGenerator, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makePreferSideConflictResolver, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, mapMailboxAgentToHqSummary, mapMailboxMessageToHqSummary, mapSessionEventToEntries, markAssistantReferencedEvidence, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, mergeToolResults, migratePlaintextSecrets, miniMaxVisionServer, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, mutatePlan, mutateTasks, nicknameKeyFromDisplay, noOpLogger, noOpVault, normalizePathSubject, normalizeRecipient, normalizeToLf, normalizeTokenSavingTier, normalizeToolDescriptionMode, normalizeTuiThinkingWord, normalizedEqual, onResize, parseContinueDirective, parseEncryptedVersion, parseEntries, parseHqEventPayload, parseHqFrame, parseModelRef, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, playwrightServer, projectHash, projectSlug, readHqAuthFile, readHqRuntimeFileSync, readJsonObjectFile, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, recordToolOutputEvidence, recordUserIntentEvidence, redactHqEvent, redactHqValue, removeJsonPath, removeJsonPathInFile, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, repeatedReadPressure, resetCalibration, resolveAuditLevel, resolveCacheForRequest, resolveChimeraConfig, resolveConflictText, resolveContextWindowPolicy, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, resolveMailboxIdentity, resolveModelMatrix, resolveModelRuntime, resolveProjectDir, resolveProviderModelList, resolveReasoningForRequest, resolveSessionLoggingConfig, resolveToolDescriptionMode, resolveWstackPaths, rewriteConfigEncrypted, rollbackSddRunFromDisk, rosterSummaryFromConfigs, rotateConfigKeys, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, sanitizeModel, sanitizeNodeOptions, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, scrubAndTruncateHqPreview, securitySlashCommand, sentinelServer, setBtwNote, setJsonPath, setJsonPathInFile, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, setToolDescriptionMode, shortIdMap, shouldEnhance, simplifyToolDescription, slackServer, sleep, smartDefaultFallbackChain, sshManagerServer, stableStringify, startAgentMonitorEventBridge, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startSddRun, startSessionTelemetryBridge, startTechStackConsumer, stripAnsi, subjectForToolInput, summarizeHqToolArgs, summarizeUsage, templateToMarkdown, toErrorMessage, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updateJsonObjectFile, updatePackageOutdatedStatus, validateAgainstSchema, watchHqAuthFile, wireMetricsToEvents, withDisabledToolFiltering, withFileLock, wrapAsState, writeErr, writeHqAuthFile, writeHqRuntimeFile, writeJsonObjectFile, writeOut, wstackGlobalRoot, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map