@wrongstack/core 0.272.2 → 0.273.0

package/dist/defaults/index.js

@@ -1,14 +1,15 @@
 import * as crypto2 from 'crypto';
 import { randomBytes, createCipheriv, createDecipheriv, randomUUID, scryptSync, createHash } from 'crypto';
 import * as fsp2 from 'fs/promises';
+import { readFile, writeFile, mkdir } from 'fs/promises';
 import * as path4 from 'path';
-import { isAbsolute, resolve } from 'path';
+import { isAbsolute, join, resolve, sep } from 'path';
 import * as fs4 from 'fs';
 import { createReadStream } from 'fs';
 import { createInterface } from 'readline';
 import * as os from 'os';
 import { hostname } from 'os';
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
 
@@ -107,7 +108,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
       if (Date.now() - started >= timeoutMs) {
         throw new Error(`Timed out waiting for file lock: ${targetPath}`);
       }
-      await new Promise((resolve7) => setTimeout(resolve7, 25));
+      await new Promise((resolve8) => setTimeout(resolve8, 25));
     }
   }
   try {
@@ -140,7 +141,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve7) => setTimeout(resolve7, delays[i]));
+      await new Promise((resolve8) => setTimeout(resolve8, delays[i]));
     }
   }
   throw lastErr;
@@ -449,6 +450,126 @@ function assertNever(x, message) {
 
 // src/utils/index.ts
 init_atomic_write();
+
+// src/utils/child-env.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "USERNAME",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TZ",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "PWD",
+  "OLDPWD",
+  "COMSPEC",
+  "SYSTEMROOT",
+  "SYSTEMDRIVE",
+  "WINDIR",
+  "PROGRAMFILES",
+  "PROGRAMFILES(X86)",
+  "PROGRAMDATA",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "PUBLIC",
+  "PATHEXT"
+]);
+var SECRET_NAME_PARTS = [
+  "TOKEN",
+  "SECRET",
+  "PASSWORD",
+  "PASSWD",
+  "AUTH",
+  "CRED",
+  "BEARER",
+  "COOKIE",
+  "PRIVATE"
+];
+function looksSecret(name) {
+  const upper = name.toUpperCase();
+  for (const p of SECRET_NAME_PARTS) {
+    if (upper.includes(p)) return true;
+  }
+  if (/(?:^|_)KEY(?:$|_|S$)/i.test(upper)) return true;
+  if (/API[_-]?KEY/i.test(upper)) return true;
+  if (/ACCESS[_-]?KEY/i.test(upper)) return true;
+  if (/SESSION[_-]?ID/i.test(upper) === false && /SESSION/i.test(upper)) {
+    return true;
+  }
+  return false;
+}
+function valueHasEmbeddedCredential(value) {
+  return /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:[^/\s@]+@/i.test(value);
+}
+var NODE_OPTIONS_INJECTION_FLAG = /^(?:--require|-r|--import|--loader|--experimental-loader)$/;
+var NODE_OPTIONS_INJECTION_FLAG_EQ = /^(?:--require|-r|--import|--loader|--experimental-loader)=/;
+function sanitizeNodeOptions(value) {
+  const tokens = value.split(/\s+/).filter(Boolean);
+  const kept = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (NODE_OPTIONS_INJECTION_FLAG_EQ.test(tok)) continue;
+    if (NODE_OPTIONS_INJECTION_FLAG.test(tok)) {
+      i++;
+      continue;
+    }
+    kept.push(tok);
+  }
+  return kept.join(" ");
+}
+function buildChildEnv(optsOrSessionId) {
+  const opts = {};
+  const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
+  const legacyHasOwn = Object.hasOwn(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
+  const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
+  if (passthrough && !process.env["CI"]) {
+    console.warn(
+      "[agent] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
+    );
+  }
+  const out = {};
+  const nodeEnvDefaulted = process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] === "1";
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (nodeEnvDefaulted && (k === "NODE_ENV" || k === "WRONGSTACK_NODE_ENV_DEFAULTED")) continue;
+    if (passthrough) {
+      out[k] = v;
+      continue;
+    }
+    const upper = k.toUpperCase();
+    if (valueHasEmbeddedCredential(v)) continue;
+    if (ALLOWED_KEYS.has(upper)) {
+      out[k] = v;
+      continue;
+    }
+    if (looksSecret(upper)) continue;
+    if (upper === "NODE_OPTIONS") {
+      const sanitized = sanitizeNodeOptions(v);
+      if (sanitized) out[k] = sanitized;
+      continue;
+    }
+    if (upper.startsWith("NODE_") || upper.startsWith("NPM_") || upper.startsWith("PNPM_") || upper.startsWith("YARN_") || upper.startsWith("GIT_") || upper.startsWith("CI") || upper.startsWith("XDG_") || // Our own non-secret knobs (WRONGSTACK_HOME, WRONGSTACK_SESSION_ID, …).
+    // Secrets never live in WRONGSTACK_* env vars (they're in the encrypted
+    // vault). Forwarding keeps child wstack processes — e.g. ones spawned
+    // by the test suite — inside the same redirected global root.
+    upper.startsWith("WRONGSTACK_") || upper === "EDITOR" || upper === "VISUAL" || upper === "PAGER") {
+      out[k] = v;
+    }
+  }
+  if (opts.extra) {
+    Object.assign(out, opts.extra);
+  }
+  if (opts.sessionId) out["WRONGSTACK_SESSION_ID"] = opts.sessionId;
+  return out;
+}
 var MAX_DIGEST_CHARS = 4e3;
 function createContextEvidenceState() {
   return {
@@ -882,11 +1003,11 @@ function validateAgainstSchema(value, schema) {
   walk(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path22, errors) {
+function walk(value, schema, path23, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path22 || "<root>",
+        path: path23 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -895,7 +1016,7 @@ function walk(value, schema, path22, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path22 || "<root>",
+        path: path23 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -905,20 +1026,20 @@ function walk(value, schema, path22, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path22, req), message: "required property missing" });
+        errors.push({ path: joinPath(path23, 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(path22, key), errors);
+          walk(obj[key], subSchema, joinPath(path23, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path22}[${i}]`, errors);
+      walk(value[i], schema.items, `${path23}[${i}]`, errors);
     }
   }
 }
@@ -1088,7 +1209,7 @@ function safeParse(input, maxBytes = 5e6) {
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 
 // src/utils/string.ts
@@ -2079,6 +2200,7 @@ function resolveWstackPaths(opts) {
     projectSddSession: path4.join(projectDir, "sdd-session.json"),
     projectPlan: path4.join(projectDir, "plan.json"),
     projectAutophase: path4.join(projectDir, "autophase"),
+    projectSddBoards: path4.join(projectDir, "sdd-boards"),
     syncConfig: path4.join(globalRoot, "sync.json"),
     projectStatus: (projectHash2) => path4.join(globalRoot, "projects", projectHash2, "status.json")
   };
@@ -3429,7 +3551,6 @@ var FileSessionWriter = class _FileSessionWriter {
       }
       const writeFd = await fsp2.open(tmpPath, "w", 384);
       try {
-        let copied = 0;
         let readOffset = 0;
         while (readOffset < newlineAfterCheckpoint) {
           const toCopy = Math.min(CHUNK_SIZE, newlineAfterCheckpoint - readOffset);
@@ -3438,7 +3559,6 @@ var FileSessionWriter = class _FileSessionWriter {
           if (r === 0) break;
           await writeFd.write(copyBuf, 0, r);
           readOffset += r;
-          copied += r;
         }
         const raw = await fsp2.readFile(this.filePath);
         const tail = raw.subarray(newlineAfterCheckpoint).toString("utf8");
@@ -4647,9 +4767,9 @@ ${body.trim()}`);
     if (!this.persistBackup || scope === "project-agents") return;
     try {
       const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile5, mkdir: mkdir7 } = await import('fs/promises');
-      await mkdir7(this.backupDir, { recursive: true });
-      await writeFile5(`${this.backupDir}/${scope}.md`, content, "utf8");
+      const { writeFile: writeFile7, mkdir: mkdir8 } = await import('fs/promises');
+      await mkdir8(this.backupDir, { recursive: true });
+      await writeFile7(`${this.backupDir}/${scope}.md`, content, "utf8");
     } catch {
     }
   }
@@ -5397,6 +5517,7 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   iterationTimeoutMs: 3e5,
   sessionTimeoutMs: 18e5,
   perIterationOutputCapBytes: 1e5,
+  descriptionMode: Object.freeze({}),
   autoExtendLimit: true,
   restrictToProjectRoot: false
 });
@@ -5441,6 +5562,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
   },
@@ -7355,6 +7477,8 @@ 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 mutate global or session configuration / trust state. */
   CONFIG_MUTATE: "config.mutate",
   /** Can install packages or run package managers with side effects. */
@@ -8468,8 +8592,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve7) => {
-            drainTimer = setTimeout(resolve7, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve8) => {
+            drainTimer = setTimeout(resolve8, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -8576,7 +8700,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve7, reject) => {
+      await new Promise((resolve8, reject) => {
         let settled = false;
         const cleanup = () => {
           clearTimeout(t);
@@ -8592,7 +8716,7 @@ async function runProviderWithRetry(opts) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve7();
+          resolve8();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -11505,8 +11629,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned, this.opts.events);
     }
     try {
-      const { unlink: unlink11 } = await import('fs/promises');
-      await unlink11(this.goalPath);
+      const { unlink: unlink13 } = await import('fs/promises');
+      await unlink13(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -11892,13 +12016,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve7(d);
+        resolve8(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       bus.emit("budget.threshold_reached", {
@@ -15253,14 +15377,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
 
@@ -15284,31 +15409,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 = {
@@ -15363,8 +15487,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])
   )
@@ -15803,7 +15932,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -15812,7 +15941,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve7(result);
+              resolve8(result);
             }
           };
           this.on("task.completed", handler);
@@ -16080,12 +16209,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve7 = (d) => {
+              const resolve8 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve7("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve8("stop"), DECISION_TIMEOUT_MS);
               budget._events?.emit("budget.threshold_reached", {
                 kind: "timeout",
                 used,
@@ -16101,11 +16230,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve7({ extend: extra }));
+                  queueMicrotask(() => resolve8({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve7("stop");
+                  resolve8("stop");
                 }
               });
             });
@@ -17015,7 +17144,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -17034,7 +17163,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve7,
+        resolve: resolve8,
         reject,
         timer
       });
@@ -17839,6 +17968,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 ?? {};
@@ -17917,6 +18047,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;
@@ -17932,6 +18063,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;
@@ -17946,6 +18078,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: {
@@ -17981,6 +18114,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: {
@@ -18008,6 +18142,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: {
@@ -18029,6 +18164,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;
@@ -18043,6 +18179,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();
@@ -18056,6 +18193,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();
@@ -18077,6 +18215,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();
@@ -18089,6 +18228,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: {
@@ -18115,6 +18255,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();
@@ -18145,6 +18286,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: {
@@ -18208,6 +18350,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: {
@@ -18240,6 +18383,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();
@@ -18689,6 +18833,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();
@@ -18802,17 +18949,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;
@@ -19482,6 +19633,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
@@ -19496,11 +19664,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve7;
+        let resolve8;
         const promise = new Promise((res) => {
-          resolve7 = res;
+          resolve8 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve7 });
+        this.taskWaiters.set(id, { promise, resolve: resolve8 });
         return promise;
       })
     );
@@ -19896,7 +20064,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve7) => {
+        const result = await new Promise((resolve8) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -19906,7 +20074,7 @@ function createDelegateTool(opts) {
             offTool();
             offIter();
             offProgress();
-            resolve7(value);
+            resolve8(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -21238,6 +21406,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;
@@ -21245,15 +21421,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: [],
@@ -21268,7 +21447,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) {
@@ -21279,31 +21458,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),
@@ -21312,7 +21497,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) {
@@ -21501,6 +21687,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).
@@ -21545,6 +21752,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") {
@@ -21561,6 +21769,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",
@@ -21592,6 +21862,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({
@@ -21609,9 +21885,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);
@@ -21790,7 +22068,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;
   }
@@ -22269,27 +22550,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");
@@ -22358,10 +22649,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp16 = await import('fs/promises');
-      const path22 = await import('path');
+      const fsp18 = await import('fs/promises');
+      const path23 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp16.mkdir(path22.dirname(this.sessionPath), { recursive: true });
+      await fsp18.mkdir(path23.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -22370,8 +22661,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp16 = await import('fs/promises');
-      const raw = await fsp16.readFile(this.sessionPath, "utf8");
+      const fsp18 = await import('fs/promises');
+      const raw = await fsp18.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -22385,8 +22676,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp16 = await import('fs/promises');
-      await fsp16.unlink(this.sessionPath);
+      const fsp18 = await import('fs/promises');
+      await fsp18.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -23088,15 +23379,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path22 = [];
+  const path23 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path22.unshift(current);
+    path23.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path22;
+  return path23;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -23515,6 +23806,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
   // -------------------------------------------------------------------
@@ -23554,65 +23863,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) {
-        break;
+    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((t) => !running.has(t.id));
+        for (const task of ready) {
+          if (running.size >= this.slots) break;
+          dispatch(task);
+          dispatchedThisRound++;
+        }
       }
-      if (batch.tasks.length === 0 && batch.allDone) {
+      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;
       }
-      const waveResult = await this.executeWave(batch);
-      totalWaves++;
-      totalCompleted += waveResult.successCount;
-      totalFailed += waveResult.failCount;
-      this.decomposer.acknowledgeBatch(batch.tasks.map((t) => t.id));
-      this.opts.onWave?.(waveResult);
-      const progress = this.buildProgress();
-      this.opts.onProgress?.(progress);
-      if (this.stopRequested) break;
+      const moreReadyNow = running.size < this.slots && this.decomposer.readyNodes().some((t) => !running.has(t.id));
+      if (!moreReadyNow) {
+        await Promise.race(running.values());
+        this.opts.onProgress?.(this.buildProgress());
+      }
     }
+    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
   // -------------------------------------------------------------------
@@ -23620,7 +24342,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();
@@ -23634,22 +24363,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.",
@@ -23657,91 +24453,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.opts.tracker.updateNodeStatus(taskId, "completed");
+    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();
@@ -23760,6 +24762,1611 @@ var SddParallelRun = class {
   }
 };
 
+// src/core/fallback-model.ts
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+
+// 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((resolve8) => {
+      const child = spawn(cmd, { cwd: info.cwd, shell: true, windowsHide: true, stdio: "ignore" });
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve8({ ok: false, reason: `verification timed out: ${cmd}` });
+      }, timeoutMs);
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        resolve8(
+          code === 0 ? { ok: true } : { ok: false, reason: `verification failed (exit ${code}): ${cmd}` }
+        );
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve8({ ok: false, reason: `verification spawn error: ${String(err)}` });
+      });
+    });
+  };
+}
+
+// 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 = path4.join(this.baseDir, "_index.json");
+  }
+  snapshotPath(runId) {
+    return path4.join(this.baseDir, `${this.safe(runId)}.json`);
+  }
+  eventsPath(runId) {
+    return path4.join(this.baseDir, `${this.safe(runId)}.events.jsonl`);
+  }
+  controlPath(runId) {
+    return path4.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 fsp2.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 fsp2.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 fsp2.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 fsp2.readFile(p, "utf8");
+    } catch {
+      return [];
+    }
+    try {
+      await fsp2.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([
+      fsp2.unlink(this.snapshotPath(runId)),
+      fsp2.unlink(this.eventsPath(runId)),
+      fsp2.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 fsp2.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 t = this.o.graph.nodes.get(taskId)?.title;
+    if (!t) return "";
+    return ` (${t.length > 40 ? `${t.slice(0, 39)}\u2026` : t})`;
+  }
+  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(
+      (t) => t && typeof t === "object" && typeof t.title === "string" && t.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 rm3 = await this.runGit(["worktree", "remove", "--force", dir], this.projectRoot);
+          if (rm3.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];
+}
+
+// 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 fsp2.rm(dir, { recursive: true, force: true });
+      deleted.push(label);
+    } catch {
+    }
+  };
+  const rmFile = async (file, label) => {
+    try {
+      await fsp2.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) {
@@ -23919,9 +26526,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve7) => {
+    const timeout = new Promise((resolve8) => {
       timer = setTimeout(
-        () => resolve7({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve8({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -24104,7 +26711,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path22 = opts.path ?? "/metrics";
+  const path23 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -24114,7 +26721,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path22) {
+    if (url === path23) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -24160,14 +26767,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve8, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve7();
+      resolve8();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -24178,9 +26785,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path22}`,
-    close: () => new Promise((resolve7, reject) => {
-      server.close((err) => err ? reject(err) : resolve7());
+    url: `${protocol}://${host}:${boundPort}${path23}`,
+    close: () => new Promise((resolve8, reject) => {
+      server.close((err) => err ? reject(err) : resolve8());
     })
   };
 }
@@ -24852,6 +27459,6 @@ var allServers = () => ({
   ssh: { ...sshManagerServer(), enabled: false }
 });
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SddParallelRun, SddTaskDecomposer, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, createSessionEventBridge, createStrategyCompactor, decryptConfigSecrets, deriveTodosFromPlanItem, describeCatalogModel, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, migratePlaintextSecrets, miniMaxVisionServer, playwrightServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, resolveAuditLevel, resolveProviderModelList, resolveSessionLoggingConfig, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, sshManagerServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SddBoardProjector, SddBoardStore, SddInterviewDriver, SddParallelRun, SddRunRegistry, SddSupervisor, SddTaskDecomposer, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBoardSnapshot, buildBoardTasks, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, cleanupSddWorktrees, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, createSessionEventBridge, createStrategyCompactor, decryptConfigSecrets, deriveTodosFromPlanItem, describeCatalogModel, destroySddProject, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, extractVerificationCommand, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, hasConflictMarkers, isExplanatoryText, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeCommandVerifier, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeLlmConflictResolver, makeLlmSubtaskGenerator, makePreferSideConflictResolver, makeRollUpTool, makeSpawnTool, makeTerminateTool, migratePlaintextSecrets, miniMaxVisionServer, playwrightServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, resolveAuditLevel, resolveConflictText, resolveProviderModelList, resolveSessionLoggingConfig, rewriteConfigEncrypted, rollbackSddRunFromDisk, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, shortIdMap, slackServer, sshManagerServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startSddRun, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map