@wrongstack/sdd 0.284.0

package/dist/index.js

@@ -0,0 +1,4229 @@
+import { SddError, ERROR_CODES, ensureDir, atomicWrite, toErrorMessage, assignNickname, expectDefined, WorktreeManager, truncate, assertNever, parseModelRef, renderInstructionTemplate, readBundledInstructionText } from '@wrongstack/core';
+import { DefaultTaskStore, TaskTracker } from '@wrongstack/core/tasking';
+export { DefaultTaskStore, TaskTracker } from '@wrongstack/core/tasking';
+import * as fsp3 from 'fs/promises';
+import { readFile, writeFile } from 'fs/promises';
+import * as path3 from 'path';
+import { isAbsolute, join } from 'path';
+import { randomUUID } from 'crypto';
+import { computeTaskProgress, topologicalSort } from '@wrongstack/core/types';
+import { DefaultMultiAgentCoordinator, withDisabledToolFiltering, makeAgentSubagentRunner } from '@wrongstack/core/coordination';
+import { spawn } from 'child_process';
+
+// src/spec-parser.ts
+var SpecParser = class {
+  parse(content) {
+    const lines = content.split("\n");
+    const sections = this.extractSections(lines);
+    const requirements = this.extractRequirements(lines);
+    const now = Date.now();
+    return {
+      id: crypto.randomUUID(),
+      title: this.extractTitle(lines),
+      version: this.extractVersion(lines),
+      status: "draft",
+      overview: this.extractOverview(lines),
+      sections,
+      requirements,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  extractTitle(lines) {
+    for (const line of lines) {
+      const m = /^#\s+(.+)/.exec(line.trim());
+      if (m?.[1]) return m[1];
+    }
+    return "Untitled Specification";
+  }
+  extractVersion(lines) {
+    for (const line of lines) {
+      const m = /version[:\s]+(\d+\.\d+\.\d+)/i.exec(line.trim());
+      if (m?.[1]) return m[1];
+    }
+    return "0.0.1";
+  }
+  extractOverview(lines) {
+    const overviewLines = [];
+    let inOverview = false;
+    let foundHeading = false;
+    for (const line of lines) {
+      if (/^##\s+Overview/i.test(line.trim())) {
+        inOverview = true;
+        foundHeading = true;
+        continue;
+      }
+      if (foundHeading && /^##\s+/.test(line.trim())) break;
+      if (inOverview) overviewLines.push(line);
+    }
+    return overviewLines.join("\n").trim() || "No overview provided";
+  }
+  extractSections(lines) {
+    const sections = [];
+    let currentSection = null;
+    let currentLines = [];
+    let depth = 1;
+    for (const line of lines) {
+      const h2 = /^##\s+(.+)/.exec(line.trim());
+      const h3 = /^###\s+(.+)/.exec(line.trim());
+      if (h2) {
+        if (currentSection && currentLines.length > 0) {
+          sections.push({
+            type: this.mapSectionType(currentSection.title ?? "unknown"),
+            title: currentSection.title ?? "Unknown",
+            level: depth,
+            content: currentLines.join("\n").trim()
+          });
+        }
+        currentSection = { title: h2[1] ?? "Unknown" };
+        currentLines = [];
+        depth = 2;
+        continue;
+      }
+      if (h3) {
+        currentLines.push(line);
+        continue;
+      }
+      if (currentSection) {
+        currentLines.push(line);
+      }
+    }
+    if (currentSection && currentLines.length > 0) {
+      sections.push({
+        type: this.mapSectionType(currentSection.title ?? "unknown"),
+        title: currentSection.title ?? "Unknown",
+        level: depth,
+        content: currentLines.join("\n").trim()
+      });
+    }
+    return sections;
+  }
+  extractRequirements(lines) {
+    const requirements = [];
+    let inRequirements = false;
+    let idCounter = 0;
+    for (const line of lines) {
+      if (/^##\s+Requirements/i.test(line.trim())) {
+        inRequirements = true;
+        continue;
+      }
+      if (inRequirements && /^##\s+/.test(line.trim())) break;
+      if (inRequirements) {
+        const req = this.parseRequirementLine(line, `REQ-${++idCounter}`);
+        if (req) requirements.push(req);
+      }
+    }
+    return requirements;
+  }
+  parseRequirementLine(line, id) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return null;
+    const lower = trimmed.toLowerCase();
+    const types = [
+      "functional",
+      "non-functional",
+      "security",
+      "performance",
+      "ux"
+    ];
+    let type = "functional";
+    for (const t of types) {
+      if (lower.includes(`[${t}]`)) type = t;
+    }
+    let priority = "medium";
+    if (trimmed.includes("[critical]") || trimmed.includes("[prio:high]")) {
+      priority = "critical";
+    } else if (trimmed.includes("[high]")) {
+      priority = "high";
+    } else if (trimmed.includes("[low]")) {
+      priority = "low";
+    }
+    return {
+      id,
+      type,
+      priority,
+      description: trimmed.replace(/\[[^\]]+\]/g, "").trim(),
+      acceptanceCriteria: []
+    };
+  }
+  mapSectionType(title) {
+    const t = title.toLowerCase();
+    if (t.includes("overview")) return "overview";
+    if (t.includes("requirement")) return "requirements";
+    if (t.includes("architect")) return "architecture";
+    if (t.includes("api")) return "api";
+    if (t.includes("data")) return "data";
+    if (t.includes("security")) return "security";
+    if (t.includes("acceptance")) return "acceptance";
+    return "overview";
+  }
+  analyze(spec) {
+    const gaps = [];
+    const suggestions = [];
+    const risks = [];
+    const hasOverview = spec.sections.some((s) => s.type === "overview");
+    const hasRequirements = spec.sections.some((s) => s.type === "requirements");
+    const hasAcceptance = spec.sections.some((s) => s.type === "acceptance");
+    if (!hasOverview) gaps.push("Missing Overview section");
+    if (!hasRequirements) gaps.push("Missing Requirements section");
+    if (!hasAcceptance) gaps.push("Missing Acceptance Criteria section");
+    if (spec.requirements.length === 0) {
+      gaps.push("No requirements defined");
+      suggestions.push("Add specific functional and non-functional requirements");
+    }
+    const unverifiedReqs = spec.requirements.filter((r) => r.acceptanceCriteria.length === 0);
+    if (unverifiedReqs.length > 0) {
+      gaps.push(`${unverifiedReqs.length} requirements without acceptance criteria`);
+      suggestions.push("Define clear acceptance criteria for each requirement");
+    }
+    const criticalUnresolved = spec.requirements.filter(
+      (r) => r.priority === "critical" && r.blockedBy && r.blockedBy.length > 0
+    );
+    for (const req of criticalUnresolved) {
+      risks.push({
+        requirement: req.id,
+        risk: `Critical requirement blocked by ${req.blockedBy?.length} other requirements`,
+        severity: "high"
+      });
+    }
+    const completeness = Math.round(
+      ((hasOverview ? 1 : 0) + (hasRequirements ? 1 : 0) + (hasAcceptance ? 1 : 0) + (spec.requirements.length > 0 ? 1 : 0) + (spec.sections.length > 3 ? 1 : 0)) / 5 * 100
+    );
+    return {
+      specId: spec.id,
+      completeness,
+      coverage: {
+        requirements: spec.requirements.length,
+        apiEndpoints: spec.apiEndpoints?.length ?? 0,
+        edgeCases: 0,
+        errorHandling: 0
+      },
+      gaps,
+      risks,
+      suggestions
+    };
+  }
+  validate(spec) {
+    const errors = [];
+    const warnings = [];
+    if (!spec.title.trim()) {
+      errors.push({ path: "title", message: "Title is required" });
+    }
+    if (!spec.version.trim()) {
+      errors.push({ path: "version", message: "Version is required" });
+    }
+    for (const req of spec.requirements) {
+      if (!req.description.trim()) {
+        errors.push({ path: `requirement.${req.id}`, message: "Requirement description is empty" });
+      }
+      if (req.acceptanceCriteria.length === 0) {
+        warnings.push({ path: `requirement.${req.id}`, message: "No acceptance criteria defined" });
+      }
+    }
+    const reqIds = new Set(spec.requirements.map((r) => r.id));
+    const blockedByIds = new Set(spec.requirements.flatMap((r) => r.blockedBy ?? []));
+    for (const id of blockedByIds) {
+      if (!reqIds.has(id)) {
+        errors.push({
+          path: "requirements",
+          message: `BlockedBy references non-existent requirement: ${id}`
+        });
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+};
+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;
+  }
+  opts;
+  async generateFromSpec(spec) {
+    const graph = await this.opts.taskTracker.createGraph(spec.id, spec.title);
+    return graph;
+  }
+  async generateSubtasks(parentTaskId, spec) {
+    const reqId = this.opts.taskTracker.getNode(parentTaskId)?.specRequirementId;
+    if (!reqId) return;
+    const req = spec.requirements.find((r) => r.id === reqId);
+    if (!req) return;
+    if (req.acceptanceCriteria.length > 0) {
+      for (const criterion of req.acceptanceCriteria) {
+        this.opts.taskTracker.addNode({
+          title: criterion,
+          description: `Verify: ${criterion}`,
+          type: "test",
+          priority: "medium",
+          status: "pending",
+          parentId: parentTaskId
+        });
+      }
+    }
+  }
+};
+var TaskFlow = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.setPhase("idle");
+  }
+  opts;
+  phase = "idle";
+  spec = null;
+  graph = null;
+  stopped = false;
+  emit(event, payload) {
+    this.opts.events.emit(event, payload);
+  }
+  async fromSpec(specContent) {
+    this.setPhase("parsing");
+    const parser = new SpecParser();
+    this.spec = parser.parse(specContent);
+    this.setPhase("analyzing");
+    const analysis = parser.analyze(this.spec);
+    this.emit("spec.analyzed", { analysis });
+    if (analysis.completeness < 50) {
+      const err = new SddError({
+        message: `Spec completeness too low: ${analysis.completeness}%`,
+        code: ERROR_CODES.SDD_VALIDATION_FAILED,
+        context: { completeness: analysis.completeness }
+      });
+      this.emit("error", { phase: "analyzing", error: err });
+      this.setPhase("failed");
+      throw err;
+    }
+    this.setPhase("generating");
+    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;
+  }
+  async execute(ctx) {
+    if (!this.graph) throw new SddError({
+      message: "No graph loaded. Call fromSpec first.",
+      code: ERROR_CODES.SDD_INVALID_STATE,
+      context: { phase: this.phase }
+    });
+    this.setPhase("executing");
+    this.stopped = false;
+    const pendingTasks = this.getExecutableTasks();
+    const maxConcurrent = this.opts.maxConcurrent ?? 2;
+    while (pendingTasks.length > 0 && !this.stopped) {
+      const batch = pendingTasks.splice(0, maxConcurrent);
+      const results = await Promise.allSettled(
+        batch.map((task) => this.executeSingleTask(task, ctx))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const task = batch[i];
+        if (!result || !task) continue;
+        if (result.status === "rejected") {
+          const reason = result.reason;
+          this.opts.tracker.updateNodeStatus(task.id, "failed", reason?.message);
+          this.emit("task.failed", { taskId: task.id, error: reason?.message ?? "unknown" });
+          ctx.onTaskFail?.(task, reason);
+        } else {
+          this.opts.tracker.updateNodeStatus(task.id, "completed");
+          this.emit("task.completed", { taskId: task.id, result: result.value });
+          ctx.onTaskComplete?.(task, result.value);
+        }
+        this.emitProgress();
+      }
+      const stillPending = this.getExecutableTasks();
+      pendingTasks.length = 0;
+      pendingTasks.push(...stillPending);
+      if (this.checkDoneCondition()) {
+        break;
+      }
+    }
+    this.setPhase("completing");
+    this.emit("done", { graph: this.graph });
+    this.setPhase("done");
+    return this.graph;
+  }
+  async reviewTask(taskId, approved, comment) {
+    const task = this.opts.tracker.getNode(taskId);
+    if (!task) throw new SddError({
+      message: `Task ${taskId} not found`,
+      code: ERROR_CODES.SDD_NOT_READY,
+      context: { taskId }
+    });
+    if (approved) {
+      this.opts.tracker.updateNodeStatus(taskId, "completed", comment);
+      this.emit("task.completed", { taskId });
+    } else {
+      this.opts.tracker.updateNodeStatus(taskId, "in_progress", comment ?? "Needs revision");
+      this.emit("task.review", { taskId });
+    }
+  }
+  stop() {
+    this.stopped = true;
+  }
+  getPhase() {
+    return this.phase;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  getSpec() {
+    return this.spec;
+  }
+  setPhase(phase) {
+    const from = this.phase;
+    this.phase = phase;
+    this.emit("phase.change", { from, to: phase });
+  }
+  getExecutableTasks() {
+    return this.opts.tracker.getAllNodes({ status: ["pending", "blocked"] }).filter((n) => n.status === "pending" && this.opts.tracker.canStart(n.id)).sort((a, b) => {
+      const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4);
+    });
+  }
+  async executeSingleTask(task, ctx) {
+    this.opts.tracker.updateNodeStatus(task.id, "in_progress");
+    this.emit("task.started", { taskId: task.id });
+    return ctx.executeTask(task);
+  }
+  checkDoneCondition() {
+    const condition = this.opts.doneCondition;
+    if (!condition) {
+      const progress = this.opts.tracker.getProgress();
+      return progress.percentComplete === 100;
+    }
+    switch (condition.type) {
+      case "all_tasks_done": {
+        const progress = this.opts.tracker.getProgress();
+        return progress.pending === 0 && progress.inProgress === 0;
+      }
+      case "iterations":
+        return false;
+      // Not tracked here
+      case "tool_calls":
+        return false;
+      default:
+        return false;
+    }
+  }
+  emitProgress() {
+    const progress = this.opts.tracker.getProgress();
+    this.emit("progress", {
+      percent: progress.percentComplete,
+      message: `${progress.completed}/${progress.total} tasks completed`
+    });
+  }
+};
+var SpecDrivenDev = class {
+  store;
+  tracker;
+  events;
+  flows = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.store = new DefaultTaskStore();
+    this.tracker = new TaskTracker({ store: this.store });
+    this.events = opts.events;
+  }
+  async createFlow(specContent, options) {
+    const flow = new TaskFlow({
+      tracker: this.tracker,
+      events: this.events,
+      ...options
+    });
+    const graph = await flow.fromSpec(specContent);
+    this.flows.set(graph.id, flow);
+    return flow;
+  }
+  getTracker() {
+    return this.tracker;
+  }
+  getFlow(graphId) {
+    return this.flows.get(graphId);
+  }
+  listFlows() {
+    return Array.from(this.flows.entries()).map(([id, flow]) => ({
+      id,
+      title: flow.getGraph()?.title ?? "Untitled",
+      phase: flow.getPhase()
+    }));
+  }
+};
+var SpecStore = class {
+  baseDir;
+  indexPath;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.indexPath = path3.join(this.baseDir, "_index.json");
+  }
+  async save(spec) {
+    await ensureDir(this.baseDir);
+    const filePath = this.filePath(spec.id);
+    await atomicWrite(filePath, JSON.stringify(spec, null, 2), { mode: 384 });
+    await this.updateIndex(spec);
+  }
+  async load(id) {
+    try {
+      const raw = await fsp3.readFile(this.filePath(id), "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 delete(id) {
+    try {
+      await fsp3.unlink(this.filePath(id));
+      await this.removeFromIndex(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async exists(id) {
+    try {
+      await fsp3.access(this.filePath(id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Create a new spec with defaults, assign ID, and persist. */
+  async createDraft(title, overview) {
+    const now = Date.now();
+    const spec = {
+      id: randomUUID(),
+      title,
+      version: "0.1.0",
+      status: "draft",
+      overview: overview ?? "",
+      sections: [],
+      requirements: [],
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.save(spec);
+    return spec;
+  }
+  /** Update spec fields and persist. */
+  async update(id, patch) {
+    const spec = await this.load(id);
+    if (!spec) return null;
+    const updated = {
+      ...spec,
+      ...patch,
+      id: spec.id,
+      createdAt: spec.createdAt,
+      updatedAt: Date.now()
+    };
+    await this.save(updated);
+    return updated;
+  }
+  filePath(id) {
+    return path3.join(this.baseDir, `${id}.json`);
+  }
+  async readIndex() {
+    try {
+      const raw = await fsp3.readFile(this.indexPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.version === 1) return parsed;
+    } catch {
+    }
+    return { version: 1, entries: [] };
+  }
+  async updateIndex(spec) {
+    const index = await this.readIndex();
+    const entry = {
+      id: spec.id,
+      title: spec.title,
+      version: spec.version,
+      status: spec.status,
+      updatedAt: spec.updatedAt,
+      filePath: this.filePath(spec.id)
+    };
+    const idx = index.entries.findIndex((e) => e.id === spec.id);
+    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(id) {
+    const index = await this.readIndex();
+    index.entries = index.entries.filter((e) => e.id !== id);
+    await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+  }
+};
+function graphToJSON(graph) {
+  const serialisable = {
+    ...graph,
+    nodes: Array.from(graph.nodes.entries())
+  };
+  return JSON.stringify(serialisable, null, 2);
+}
+function graphFromJSON(raw) {
+  const parsed = JSON.parse(raw);
+  return {
+    ...parsed,
+    nodes: new Map(parsed.nodes)
+  };
+}
+var TaskGraphStore = class {
+  baseDir;
+  indexPath;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.indexPath = path3.join(this.baseDir, "_index.json");
+  }
+  async save(graph) {
+    await ensureDir(this.baseDir);
+    const filePath = this.filePath(graph.id);
+    await atomicWrite(filePath, graphToJSON(graph), { mode: 384 });
+    await this.updateIndex(graph);
+  }
+  async load(id) {
+    try {
+      const raw = await fsp3.readFile(this.filePath(id), "utf8");
+      return graphFromJSON(raw);
+    } catch {
+      return null;
+    }
+  }
+  async list() {
+    const index = await this.readIndex();
+    return index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async delete(id) {
+    try {
+      await fsp3.unlink(this.filePath(id));
+      await this.removeFromIndex(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async exists(id) {
+    try {
+      await fsp3.access(this.filePath(id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  filePath(id) {
+    return path3.join(this.baseDir, `${id}.json`);
+  }
+  async readIndex() {
+    try {
+      const raw = await fsp3.readFile(this.indexPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.version === 1) return parsed;
+    } catch {
+    }
+    return { version: 1, entries: [] };
+  }
+  async updateIndex(graph) {
+    const index = await this.readIndex();
+    const completedCount = Array.from(graph.nodes.values()).filter(
+      (n) => n.status === "completed"
+    ).length;
+    const entry = {
+      id: graph.id,
+      specId: graph.specId,
+      title: graph.title,
+      nodeCount: graph.nodes.size,
+      completedCount,
+      updatedAt: graph.updatedAt,
+      filePath: this.filePath(graph.id)
+    };
+    const idx = index.entries.findIndex((e) => e.id === graph.id);
+    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(id) {
+    const index = await this.readIndex();
+    index.entries = index.entries.filter((e) => e.id !== id);
+    await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+  }
+};
+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
+  };
+}
+var SddBoardStore = class {
+  baseDir;
+  indexPath;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.indexPath = path3.join(this.baseDir, "_index.json");
+  }
+  snapshotPath(runId) {
+    return path3.join(this.baseDir, `${this.safe(runId)}.json`);
+  }
+  eventsPath(runId) {
+    return path3.join(this.baseDir, `${this.safe(runId)}.events.jsonl`);
+  }
+  controlPath(runId) {
+    return path3.join(this.baseDir, `${this.safe(runId)}.control.jsonl`);
+  }
+  async saveSnapshot(snapshot) {
+    await ensureDir(this.baseDir);
+    await atomicWrite(this.snapshotPath(snapshot.runId), JSON.stringify(snapshot, null, 2), {
+      mode: 384
+    });
+    await this.updateIndex(snapshot);
+  }
+  async load(runId) {
+    try {
+      const raw = await fsp3.readFile(this.snapshotPath(runId), "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async list() {
+    const index = await this.readIndex();
+    return index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async loadLatestForSpec(specId) {
+    const entry = (await this.list()).find((e) => e.specId === specId);
+    return entry ? this.load(entry.runId) : null;
+  }
+  /** Append one line to the board's JSONL event log (best-effort, never throws). */
+  async appendEvent(runId, event) {
+    try {
+      await ensureDir(this.baseDir);
+      await fsp3.appendFile(this.eventsPath(runId), `${JSON.stringify(event)}
+`, { mode: 384 });
+    } catch {
+    }
+  }
+  /** Append a control command (used by readers to steer a CLI-owned run). */
+  async appendControl(runId, command) {
+    await ensureDir(this.baseDir);
+    await fsp3.appendFile(this.controlPath(runId), `${JSON.stringify(command)}
+`, { mode: 384 });
+  }
+  /** Read + truncate the control queue (the run drains it). Returns parsed commands. */
+  async drainControl(runId) {
+    const p = this.controlPath(runId);
+    let raw;
+    try {
+      raw = await fsp3.readFile(p, "utf8");
+    } catch {
+      return [];
+    }
+    try {
+      await fsp3.writeFile(p, "", { mode: 384 });
+    } catch {
+    }
+    return raw.split("\n").filter((l) => l.trim()).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter((c) => c !== null);
+  }
+  async delete(runId) {
+    await Promise.allSettled([
+      fsp3.unlink(this.snapshotPath(runId)),
+      fsp3.unlink(this.eventsPath(runId)),
+      fsp3.unlink(this.controlPath(runId))
+    ]);
+    await this.removeFromIndex(runId);
+  }
+  // ── internal ────────────────────────────────────────────────────────────
+  safe(runId) {
+    return runId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  }
+  async readIndex() {
+    try {
+      const raw = await fsp3.readFile(this.indexPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.version === 1) return parsed;
+    } catch {
+    }
+    return { version: 1, entries: [] };
+  }
+  async updateIndex(snapshot) {
+    const index = await this.readIndex();
+    const entry = {
+      runId: snapshot.runId,
+      specId: snapshot.specId,
+      title: snapshot.title,
+      status: snapshot.status,
+      total: snapshot.progress.total,
+      completed: snapshot.progress.completed,
+      updatedAt: snapshot.updatedAt
+    };
+    const idx = index.entries.findIndex((e) => e.runId === snapshot.runId);
+    if (idx >= 0) index.entries[idx] = entry;
+    else index.entries.push(entry);
+    await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+  }
+  async removeFromIndex(runId) {
+    const index = await this.readIndex();
+    index.entries = index.entries.filter((e) => e.runId !== runId);
+    await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+  }
+};
+
+// src/sdd-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 "stopped";
+    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();
+    const sessionId = this.currentSessionId();
+    this.o.events.emit("sdd.board.snapshot", {
+      ...sessionId ? { sessionId } : {},
+      runId: this.o.runId,
+      snapshot: snap
+    });
+    if (this.o.store) {
+      const store = this.o.store;
+      this.lastSave = this.lastSave.then(() => store.saveSnapshot(snap)).catch(() => {
+      });
+    }
+  }
+  currentSessionId() {
+    const value = typeof this.o.sessionId === "function" ? this.o.sessionId() : this.o.sessionId;
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+};
+
+// src/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;
+  }
+};
+function buildQuestioningPrompt(session, min, max) {
+  const answered = session.answers.length;
+  const remaining = Math.max(0, min - answered);
+  const budget = max - answered;
+  const lines = [
+    `\u2550\u2550\u2550 SDD Spec Builder \u2550\u2550\u2550`,
+    `Feature: "${session.title}"`,
+    session.userIntent ? `Intent: ${session.userIntent}` : "",
+    `Phase: Questioning (${answered} answered, ${budget} remaining budget)`,
+    "",
+    "**Instructions for AI:**",
+    "",
+    "You are conducting a specification interview. Your job is to ask the user",
+    "intelligent, contextual questions to understand what they want to build.",
+    "",
+    `You have asked ${answered} questions so far.`
+  ];
+  if (remaining > 0) {
+    lines.push(`You MUST ask at least ${remaining} more question(s) before generating the spec.`);
+  } else if (budget <= 0) {
+    lines.push("You have reached the maximum question budget. Generate the spec NOW.");
+  } else {
+    lines.push(
+      "You may ask more questions if needed, or generate the spec if you have enough information.",
+      "Ask a question ONLY if it reveals something you genuinely need to know."
+    );
+  }
+  lines.push(
+    "",
+    "**Rules:**",
+    "- Ask ONE question at a time",
+    "- Questions must be specific and contextual \u2014 never generic",
+    "- Adapt based on previous answers",
+    "- Cover: scope, constraints, edge cases, integrations, security, performance as relevant",
+    "- When you have enough info, respond with the full specification in JSON format",
+    "- This is a planning interview: respond with TEXT ONLY (a question, or the spec JSON).",
+    "  Do NOT write or edit files, and do NOT run shell/terminal commands \u2014 the code is",
+    "  written later, after the plan is approved.",
+    "",
+    `**Question budget:** ${budget}/${max} remaining`,
+    `**Minimum required:** ${remaining > 0 ? remaining : "met"}`
+  );
+  if (session.projectContext) {
+    lines.push("", "**Project Context:**", "```", session.projectContext, "```");
+  }
+  if (answered > 0) {
+    lines.push("", "**Conversation so far:**");
+    for (let i = 0; i < answered; i++) {
+      const a = expectDefined(session.answers[i]);
+      lines.push(``, `Q${i + 1}: ${a.question}`, `A${i + 1}: ${a.answer}`);
+    }
+  }
+  lines.push(
+    "",
+    "---",
+    "Now either:",
+    `1. Ask your next question (if you need more info)`,
+    `2. Generate the complete specification as JSON (if ready)`,
+    "",
+    "If generating spec, output JSON inside ```json code block with this structure:",
+    "```json",
+    "{",
+    '  "title": "...",',
+    '  "overview": "...",',
+    '  "sections": [{ "type": "overview|requirements|architecture|api|data|security|acceptance", "title": "...", "content": "...", "level": 1 }],',
+    '  "requirements": [{ "id": "REQ-1", "type": "functional|non-functional|security|performance|ux", "priority": "critical|high|medium|low", "description": "...", "acceptanceCriteria": ["..."] }]',
+    "}",
+    "```"
+  );
+  return lines.filter(Boolean).join("\n");
+}
+function buildSpecReviewPrompt(session) {
+  const spec = session.spec;
+  if (!spec) return "No spec generated yet.";
+  const reqSummary = spec.requirements.map((r) => `  [${r.priority}] ${r.description}`).join("\n");
+  return [
+    `\u2550\u2550\u2550 Spec Review \u2550\u2550\u2550`,
+    `Feature: "${spec.title}"`,
+    `Requirements: ${spec.requirements.length}`,
+    "",
+    "**Specification:**",
+    spec.overview,
+    "",
+    "**Requirements:**",
+    reqSummary,
+    "",
+    "---",
+    "Approve this spec? The AI will then generate an implementation plan and tasks.",
+    'Say "approve" to proceed, or describe what needs to change.'
+  ].join("\n");
+}
+function buildImplementationPrompt(session) {
+  const spec = session.spec;
+  if (!spec) return "No spec to implement.";
+  const reqList = spec.requirements.map((r) => `  - [${r.priority}] ${r.description}`).join("\n");
+  return [
+    `\u2550\u2550\u2550 Implementation Planning \u2550\u2550\u2550`,
+    `Feature: "${spec.title}"`,
+    `Requirements: ${spec.requirements.length}`,
+    "",
+    "**Requirements to implement:**",
+    reqList,
+    "",
+    "**Instructions for AI:**",
+    "Generate a detailed implementation plan for this specification.",
+    "This is a PLANNING step \u2014 describe the plan and emit the task JSON as TEXT. Do NOT",
+    "create or edit files and do NOT run shell/terminal commands here; the tasks you list",
+    "are executed later, one by one, after you approve them.",
+    "Include:",
+    "1. Architecture decisions",
+    "2. File structure changes",
+    "3. Key implementation details",
+    "4. Dependency requirements",
+    "5. Testing strategy",
+    "",
+    "**IMPORTANT:** After the plan, you MUST generate executable tasks as a JSON array.",
+    "Each task should be a concrete, actionable step. Output the JSON inside a ```json code block:",
+    "```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:",
+    '- 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");
+}
+function buildTaskReviewPrompt(session) {
+  return [
+    `\u2550\u2550\u2550 Task Review \u2550\u2550\u2550`,
+    `Feature: "${session.spec?.title ?? session.title}"`,
+    "",
+    session.implementation ?? "No implementation plan yet.",
+    "",
+    "---",
+    'Ready to execute these tasks? Say "execute" to begin, or describe changes needed.'
+  ].join("\n");
+}
+function buildExecutingPrompt(session) {
+  return [
+    `\u2550\u2550\u2550 Task Execution \u2550\u2550\u2550`,
+    `Feature: "${session.spec?.title ?? session.title}"`,
+    "",
+    "**Instructions for AI:**",
+    "Execute the tasks one by one in the order shown in the task list above.",
+    "",
+    "For each task:",
+    "1. Implement the code (create/modify files)",
+    "2. Write tests if applicable",
+    "3. After completing a task, tell the user to run: /sdd done <task number or title>",
+    "4. Then move to the next task",
+    "",
+    "**Important:**",
+    "- Focus on ONE task at a time",
+    "- After completing each task, explicitly state what you did",
+    '- Tell the user: "Run /sdd done <N> to mark this task complete"',
+    "- Then proceed to the next task automatically",
+    "- When ALL tasks are done, provide a summary of everything implemented",
+    "",
+    "Start executing the first pending task now."
+  ].join("\n");
+}
+var AISpecBuilder = class {
+  session;
+  store;
+  minQuestions;
+  maxQuestions;
+  sessionPath;
+  constructor(opts) {
+    this.store = opts.store;
+    this.minQuestions = opts.minQuestions ?? 2;
+    this.maxQuestions = opts.maxQuestions ?? 10;
+    this.sessionPath = opts.sessionPath;
+    this.session = {
+      id: crypto.randomUUID(),
+      phase: "questioning",
+      title: "",
+      userIntent: "",
+      projectContext: opts.projectContext ?? "",
+      answers: [],
+      questionCount: 0,
+      approved: false,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+  }
+  // ── Session Persistence ──────────────────────────────────────────────────
+  /** Save session state to disk. */
+  async saveSession() {
+    if (!this.sessionPath) return;
+    try {
+      const fsp5 = await import('fs/promises');
+      const path4 = await import('path');
+      const { atomicWrite: atomicWrite4 } = await import('@wrongstack/core');
+      await fsp5.mkdir(path4.dirname(this.sessionPath), { recursive: true });
+      await atomicWrite4(this.sessionPath, JSON.stringify(this.session, null, 2));
+    } catch {
+    }
+  }
+  /** Load session state from disk. Returns true if a session was loaded. */
+  async loadSession() {
+    if (!this.sessionPath) return false;
+    try {
+      const fsp5 = await import('fs/promises');
+      const raw = await fsp5.readFile(this.sessionPath, "utf8");
+      const loaded = JSON.parse(raw);
+      if (loaded?.id && loaded?.phase && loaded?.title) {
+        this.session = loaded;
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+  /** Delete saved session from disk. */
+  async deleteSession() {
+    if (!this.sessionPath) return;
+    try {
+      const fsp5 = await import('fs/promises');
+      await fsp5.unlink(this.sessionPath);
+    } catch {
+    }
+  }
+  /** Auto-save helper — calls saveSession() but never throws.
+   *  Failures are surfaced via process.emitWarning so a persistent
+   *  ENOSPC / EACCES doesn't silently strand session edits in memory. */
+  autoSave() {
+    this.saveSession().catch((err) => {
+      const detail = toErrorMessage(err);
+      process.emitWarning(
+        `SpecBuilder autoSave failed: ${detail}`,
+        "SpecBuilderWarning"
+      );
+    });
+  }
+  // ── Session Lifecycle ─────────────────────────────────────────────────────
+  /** Start a new session with a title and optional intent. */
+  startSession(title, intent) {
+    this.session.title = title;
+    this.session.userIntent = intent ?? "";
+    this.session.phase = "questioning";
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  /** Get current session state (readonly). */
+  getSession() {
+    return { ...this.session };
+  }
+  /** Get the current phase. */
+  getPhase() {
+    return this.session.phase;
+  }
+  // ── AI Prompt Generation ──────────────────────────────────────────────────
+  /**
+   * Get the AI prompt for the current phase.
+   * This prompt is injected into the conversation so the AI agent knows
+   * what to do next (ask a question, generate a spec, etc.).
+   */
+  getAIPrompt() {
+    switch (this.session.phase) {
+      case "questioning":
+        return buildQuestioningPrompt(this.session, this.minQuestions, this.maxQuestions);
+      case "spec_review":
+        return buildSpecReviewPrompt(this.session);
+      case "implementation":
+        return buildImplementationPrompt(this.session);
+      case "task_review":
+        return buildTaskReviewPrompt(this.session);
+      case "executing":
+        return buildExecutingPrompt(this.session);
+      case "done":
+        return "All tasks completed. Specification is fully implemented.";
+    }
+  }
+  // ── Answer Processing ─────────────────────────────────────────────────────
+  /**
+   * Record a question/answer pair from the AI conversation.
+   * Call this when the AI asks a question and the user responds.
+   */
+  addAnswer(question, answer) {
+    this.session.answers.push({ question, answer, timestamp: Date.now() });
+    this.session.questionCount++;
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  /**
+   * Check if more questions should be asked.
+   * Returns false if max reached or if the AI has signaled it has enough info.
+   */
+  shouldContinueQuestioning() {
+    return this.session.questionCount < this.maxQuestions;
+  }
+  /**
+   * Check if minimum questions have been asked.
+   */
+  hasMetMinimumQuestions() {
+    return this.session.questionCount >= this.minQuestions;
+  }
+  // ── Phase Transitions ─────────────────────────────────────────────────────
+  /**
+   * Set the generated specification and move to spec_review phase.
+   */
+  setSpec(spec) {
+    this.session.spec = spec;
+    this.session.phase = "spec_review";
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  /**
+   * Approve the current phase and advance to the next.
+   * questioning → spec_review (requires spec to be set)
+   * spec_review → implementation
+   * implementation → task_review (requires implementation to be set)
+   * task_review → executing
+   * executing → done
+   */
+  approve() {
+    switch (this.session.phase) {
+      case "questioning":
+        if (!this.session.spec) {
+          throw new SddError({
+            message: "Cannot approve: no spec generated yet.",
+            code: ERROR_CODES.SDD_INVALID_STATE,
+            context: { phase: "questioning", sessionId: this.session.id }
+          });
+        }
+        this.session.phase = "spec_review";
+        break;
+      case "spec_review":
+        this.session.phase = "implementation";
+        break;
+      case "implementation":
+        this.session.phase = "task_review";
+        break;
+      case "task_review":
+        this.session.phase = "executing";
+        break;
+      case "executing":
+        this.session.phase = "done";
+        break;
+    }
+    this.session.approved = true;
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+    return this.session.phase;
+  }
+  /**
+   * Set the implementation plan text.
+   */
+  setImplementation(plan) {
+    this.session.implementation = plan;
+    this.session.phase = "task_review";
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  /**
+   * Mark session as done.
+   */
+  markDone() {
+    this.session.phase = "done";
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  /**
+   * Set the task graph ID for this session.
+   */
+  setTaskGraphId(graphId) {
+    this.session.taskGraphId = graphId;
+    this.autoSave();
+  }
+  /**
+   * Get the task graph ID for this session.
+   */
+  getTaskGraphId() {
+    return this.session.taskGraphId;
+  }
+  // ── Spec Persistence ──────────────────────────────────────────────────────
+  /**
+   * Save the current spec to the store.
+   */
+  async saveSpec() {
+    if (!this.session.spec) {
+      throw new SddError({
+        message: "No spec to save.",
+        code: ERROR_CODES.SDD_NOT_READY,
+        context: { sessionId: this.session.id }
+      });
+    }
+    await this.store.save(this.session.spec);
+    return this.session.spec;
+  }
+  // ── Spec Generation Helpers ───────────────────────────────────────────────
+  /**
+   * Parse a spec from a JSON string (from AI output).
+   * Validates and normalizes the structure.
+   */
+  parseSpecFromJSON(jsonStr) {
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonStr);
+    } catch (e) {
+      throw new SddError({
+        message: "Invalid JSON for spec",
+        code: ERROR_CODES.SDD_PARSE_FAILED,
+        cause: e,
+        context: { detail: e instanceof Error ? e.message : "parse error" }
+      });
+    }
+    if (!parsed || typeof parsed !== "object") {
+      throw new SddError({
+        message: "Spec JSON must be an object",
+        code: ERROR_CODES.SDD_VALIDATION_FAILED,
+        context: { actualType: typeof parsed }
+      });
+    }
+    const raw = parsed;
+    const now = Date.now();
+    const title = String(raw.title ?? this.session.title ?? "Untitled");
+    const overview = String(raw.overview ?? "");
+    if (!overview || overview === "undefined") {
+      throw new SddError({
+        message: "Spec must have an overview",
+        code: ERROR_CODES.SDD_VALIDATION_FAILED,
+        context: { field: "overview", title }
+      });
+    }
+    const rawSections = Array.isArray(raw.sections) ? raw.sections : [];
+    const sections = rawSections.filter((s) => s && typeof s === "object").map((s) => ({
+      type: ["overview", "requirements", "architecture", "api", "data", "security", "acceptance"].includes(String(s.type)) ? String(s.type) : "overview",
+      title: String(s.title ?? ""),
+      content: String(s.content ?? ""),
+      level: Number(s.level) || 1
+    }));
+    const rawReqs = Array.isArray(raw.requirements) ? raw.requirements : [];
+    const requirements = rawReqs.filter((r) => r && typeof r === "object").map((r, i) => ({
+      id: String(r.id ?? `REQ-${i + 1}`),
+      type: ["functional", "non-functional", "security", "performance", "ux"].includes(String(r.type)) ? String(r.type) : "functional",
+      priority: ["critical", "high", "medium", "low"].includes(String(r.priority)) ? String(r.priority) : "medium",
+      description: String(r.description ?? ""),
+      acceptanceCriteria: Array.isArray(r.acceptanceCriteria) ? r.acceptanceCriteria.map(String) : []
+    }));
+    const spec = {
+      id: crypto.randomUUID(),
+      title,
+      version: "0.1.0",
+      status: "draft",
+      overview,
+      sections,
+      requirements,
+      createdAt: now,
+      updatedAt: now,
+      metadata: {
+        generatedBy: "AISpecBuilder",
+        sessionId: this.session.id
+      }
+    };
+    return spec;
+  }
+  /**
+   * Extract JSON from AI output (handles ```json blocks and raw JSON).
+   */
+  extractJSON(text) {
+    const codeBlockMatch = text.match(/```json\s*([\s\S]*?)```/);
+    if (codeBlockMatch?.[1]) {
+      return codeBlockMatch[1].trim();
+    }
+    const genericBlockMatch = text.match(/```\s*([\s\S]*?)```/);
+    if (genericBlockMatch?.[1]) {
+      const trimmed = genericBlockMatch[1].trim();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        return trimmed;
+      }
+    }
+    const jsonMatch = text.match(/(\{[\s\S]*\})/);
+    if (jsonMatch?.[1]) {
+      try {
+        JSON.parse(jsonMatch[1]);
+        return jsonMatch[1];
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Detect if AI output contains a spec (JSON block).
+   */
+  hasSpecInOutput(text) {
+    return this.extractJSON(text) !== null;
+  }
+  /**
+   * Try to parse a spec from AI output text.
+   * Returns null if no valid spec found.
+   */
+  tryParseSpecFromOutput(text) {
+    const json = this.extractJSON(text);
+    if (!json) return null;
+    try {
+      return this.parseSpecFromJSON(json);
+    } catch {
+      return null;
+    }
+  }
+  // ── JSON Array Extraction (for tasks) ─────────────────────────────────────
+  /**
+   * Extract a JSON array from AI output (for task lists).
+   */
+  extractJSONArray(text) {
+    const codeBlockMatch = text.match(/```json\s*([\s\S]*?)```/);
+    if (codeBlockMatch?.[1]) {
+      const trimmed = codeBlockMatch[1].trim();
+      if (trimmed.startsWith("[")) return trimmed;
+    }
+    const arrayMatch = text.match(/(\[[\s\S]*\])/);
+    if (arrayMatch?.[1]) {
+      try {
+        const parsed = JSON.parse(arrayMatch[1]);
+        if (Array.isArray(parsed)) return arrayMatch[1];
+      } catch {
+      }
+    }
+    return null;
+  }
+};
+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,
+      goal: s.userIntent || 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_TYPES = ["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_TYPES.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-task-decomposer.ts
+var SddTaskDecomposer = class {
+  constructor(tracker, _graph, opts = {}) {
+    this.tracker = tracker;
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
+  }
+  tracker;
+  slots;
+  wave = 0;
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  /**
+   * Return the next batch of runnable tasks.
+   * Returns `allDone: true` when every node is completed.
+   * Returns `deadlocked: true` when no batch can be produced because
+   * all remaining tasks are blocked by failed nodes.
+   */
+  nextBatch() {
+    if (this.isDone()) {
+      return { tasks: [], wave: this.wave, allDone: true, deadlocked: false };
+    }
+    const pending = this.pendingReadyNodes();
+    if (pending.length === 0) {
+      const hasBlockedTasks = this.hasAnyBlockedTasks();
+      return { tasks: [], wave: this.wave, allDone: false, deadlocked: hasBlockedTasks };
+    }
+    const batch = pending.slice(0, this.slots);
+    return { tasks: batch, wave: this.wave, allDone: false, deadlocked: false };
+  }
+  /**
+   * Advance the wave counter after a batch completes.
+   * Call this once per `nextBatch()` result that was fan-out.
+   */
+  acknowledgeBatch(_completedTaskIds) {
+    this.wave++;
+  }
+  /**
+   * True when every node in the graph is completed.
+   * Use this to exit the fan-out loop after `isDone() || deadlocked`.
+   */
+  isDone() {
+    const progress = this.tracker.getProgress();
+    return progress.total > 0 && progress.completed === progress.total;
+  }
+  /**
+   * Total waves produced so far.
+   */
+  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
+  // -------------------------------------------------------------------
+  /**
+   * Return pending nodes whose blockers are all completed.
+   * Sorted by priority (critical first), then by creation time.
+   */
+  pendingReadyNodes() {
+    const allPending = this.tracker.getAllNodes({ status: ["pending"] });
+    const ready = [];
+    for (const node of allPending) {
+      if (this.tracker.canStart(node.id)) {
+        ready.push(node);
+      }
+    }
+    const priorityRank = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    ready.sort((a, b) => {
+      const pr = priorityRank[a.priority] - priorityRank[b.priority];
+      if (pr !== 0) return pr;
+      return a.createdAt - b.createdAt;
+    });
+    return ready;
+  }
+  /** True when at least one non-completed, non-failed task is blocked. */
+  hasAnyBlockedTasks() {
+    const nodes = this.tracker.getAllNodes({
+      status: ["pending", "in_progress", "blocked"]
+    });
+    return nodes.some((n) => n.status === "blocked");
+  }
+};
+
+// src/sdd-parallel-run.ts
+var SddParallelRun = class {
+  constructor(opts) {
+    this.opts = opts;
+    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.sessionIdSource = opts.sessionId;
+    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;
+  sessionIdSource;
+  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) {
+    const sessionId = this.currentSessionId();
+    this.events?.emit(
+      event,
+      sessionId ? { ...payload, sessionId } : payload
+    );
+  }
+  currentSessionId() {
+    const value = typeof this.sessionIdSource === "function" ? this.sessionIdSource() : this.sessionIdSource;
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  paused = false;
+  /** Trigger stop — causes run() to abort after the current wave. */
+  stop() {
+    this.stopRequested = true;
+    this.paused = false;
+    this.coordinator?.stopAll();
+  }
+  /** 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.restoreRetryMap();
+    const startTime = Date.now();
+    this.round = 0;
+    this.dispatchSeq = 0;
+    let totalDispatched = 0;
+    this.buildCoordinator();
+    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 (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 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: this.round,
+      totalCompleted: finalProgress.completed,
+      totalFailed: finalProgress.failed,
+      totalDurationMs: Date.now() - startTime,
+      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
+  // -------------------------------------------------------------------
+  buildCoordinator() {
+    const config = {
+      coordinatorId: `sdd-parallel-${randomUUID().slice(0, 8)}`,
+      maxConcurrent: this.slots,
+      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();
+    const filteredFactory = withDisabledToolFiltering(baseFactory);
+    const runner = makeAgentSubagentRunner({ factory: filteredFactory });
+    this.coordinator.setRunner?.(runner);
+  }
+  defaultFactory() {
+    return async (_config) => ({
+      agent: this.opts.agent,
+      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 waveStart = Date.now();
+    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?.length ? { fallbackModels } : {}
+    });
+    if (!spawnResult.subagentId) {
+      throw new SddError({
+        message: "One or more subagent spawns failed",
+        code: ERROR_CODES.SDD_INVALID_STATE
+      });
+    }
+    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",
+      "",
+      `Graph: ${this.opts.graph.title}`,
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
+      "\u2022 Mark the task [done] in the tracker when complete.",
+      "\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");
+    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 } : {}
+    });
+    let result;
+    try {
+      const got = await coordinator.awaitTasks([correlationId]);
+      result = expectDefined(got[0]);
+    } catch (err) {
+      result = {
+        subagentId,
+        taskId: correlationId,
+        status: "failed",
+        error: { kind: "unknown", message: String(err), retryable: false },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      };
+    }
+    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 {
+        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 {
+          await wt.release(handle, { keep: false });
+          this.forgetWorktree(task.id, { keepBranchLabel: false });
+        }
+      } catch {
+        this.forgetWorktree(task.id);
+      }
+    }
+  }
+  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();
+    const isDeadlocked = !this.decomposer.isDone() && this.decomposer.nextBatch().deadlocked;
+    return {
+      wave: this.decomposer.getWaveCount(),
+      total: gp.total,
+      completed: gp.completed,
+      inProgress: gp.inProgress,
+      failed: gp.failed,
+      blocked: gp.blocked,
+      pending: gp.pending,
+      percent: gp.percentComplete,
+      deadlocked: isDeadlocked
+    };
+  }
+};
+
+// src/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,
+    sessionId: opts.sessionId,
+    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,
+    sessionId: opts.sessionId,
+    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).catch(() => {
+        });
+        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().catch(() => {
+        });
+        else if (c.type === "rollback") void run.rollback().catch(() => {
+        });
+      }
+    }).catch(() => {
+    });
+  }, 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()
+  };
+}
+async function cleanupSddWorktrees(projectRoot) {
+  const wt = new WorktreeManager({ projectRoot });
+  return wt.cleanupAllManaged();
+}
+async function cleanupStaleWorktrees(projectRoot) {
+  const wt = new WorktreeManager({ projectRoot });
+  return wt.cleanupStale();
+}
+async function cleanupStaleSddWorktrees(opts) {
+  const now = opts.now?.() ?? Date.now();
+  try {
+    const store = new SddBoardStore({ baseDir: opts.boardsDir });
+    const latest = (await store.list())[0];
+    if (latest) {
+      const age = now - latest.updatedAt;
+      if (latest.status === "running" && age < (opts.runningLiveMs ?? 12e4)) {
+        return { swept: false, removed: 0, detected: 0, skippedReason: "a run appears live (running)" };
+      }
+      if (latest.status === "paused" && age < (opts.pausedLiveMs ?? 18e5)) {
+        return { swept: false, removed: 0, detected: 0, skippedReason: "a run is paused" };
+      }
+    }
+  } catch {
+  }
+  try {
+    const wt = new WorktreeManager({ projectRoot: opts.projectRoot });
+    const { removed, detected } = await wt.cleanupStale();
+    return { swept: detected > 0, removed, detected };
+  } catch {
+    return { swept: false, removed: 0, detected: 0 };
+  }
+}
+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) {
+  let reverted = 0;
+  let revertOk;
+  let revertReason;
+  if (opts.revertMerged) {
+    const r = await rollbackSddRunFromDisk({
+      projectRoot: opts.projectRoot,
+      boardsDir: opts.paths.projectSddBoards,
+      runId: opts.runId
+    }).catch((err) => ({ ok: false, reverted: 0, reason: toReason(err) }));
+    reverted = r.reverted;
+    revertOk = r.ok;
+    revertReason = r.reason;
+  }
+  const { removed } = await cleanupSddWorktrees(opts.projectRoot).catch(() => ({ removed: 0 }));
+  const deleted = [];
+  const rmDir = async (dir, label) => {
+    try {
+      await fsp3.rm(dir, { recursive: true, force: true });
+      deleted.push(label);
+    } catch {
+    }
+  };
+  const rmFile = async (file, label) => {
+    try {
+      await fsp3.unlink(file);
+      deleted.push(label);
+    } catch {
+    }
+  };
+  await rmFile(opts.paths.projectSddSession, "session");
+  await rmDir(opts.paths.projectSpecs, "specs");
+  await rmDir(opts.paths.projectTaskGraphs, "task-graphs");
+  await rmDir(opts.paths.projectSddBoards, "boards");
+  return { worktreesRemoved: removed, deleted, reverted, revertOk, revertReason };
+}
+function toReason(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function applySddLifecycle(op, opts) {
+  try {
+    if (op === "cleanup_worktrees") {
+      const { removed } = await cleanupSddWorktrees(opts.projectRoot);
+      return { op, ok: true, removed };
+    }
+    if (op === "rollback") {
+      const r2 = await rollbackSddRunFromDisk({
+        projectRoot: opts.projectRoot,
+        boardsDir: opts.paths.projectSddBoards,
+        runId: opts.runId
+      });
+      return { op, ok: r2.ok, reverted: r2.reverted, reason: r2.reason };
+    }
+    const r = await destroySddProject({
+      projectRoot: opts.projectRoot,
+      paths: opts.paths,
+      revertMerged: opts.revertMerged,
+      runId: opts.runId
+    });
+    return {
+      op,
+      // The wipe itself is best-effort and always "ok"; a requested-but-refused
+      // revert is surfaced via reason without failing the destroy.
+      ok: true,
+      removed: r.worktreesRemoved,
+      reverted: r.reverted,
+      deleted: r.deleted,
+      reason: r.revertOk === false ? r.revertReason : void 0
+    };
+  } catch (err) {
+    return { op, ok: false, reason: toReason(err) };
+  }
+}
+
+// src/spec-templates.ts
+var SPEC_TEMPLATES = [
+  {
+    id: "feature",
+    name: "New Feature",
+    description: "Template for new feature development",
+    sections: [
+      { type: "overview", title: "Overview", level: 2 },
+      { type: "requirements", title: "Requirements", level: 2 },
+      { type: "architecture", title: "Architecture", level: 2 },
+      { type: "api", title: "API Design", level: 2 },
+      { type: "data", title: "Data Model", level: 2 },
+      { type: "security", title: "Security", level: 2 },
+      { type: "acceptance", title: "Acceptance Criteria", level: 2 }
+    ],
+    defaultRequirements: [
+      { type: "functional", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] },
+      { type: "non-functional", priority: "medium", acceptanceCriteria: [], blockedBy: [], implements: [] }
+    ]
+  },
+  {
+    id: "bugfix",
+    name: "Bug Fix",
+    description: "Template for bug fix specifications",
+    sections: [
+      { type: "overview", title: "Bug Description", level: 2 },
+      { type: "requirements", title: "Root Cause Analysis", level: 2 },
+      { type: "acceptance", title: "Fix Verification", level: 2 }
+    ],
+    defaultRequirements: [
+      { type: "functional", priority: "critical", acceptanceCriteria: [], blockedBy: [], implements: [] }
+    ]
+  },
+  {
+    id: "refactor",
+    name: "Refactor",
+    description: "Template for code refactoring",
+    sections: [
+      { type: "overview", title: "Current State", level: 2 },
+      { type: "requirements", title: "Refactoring Goals", level: 2 },
+      { type: "architecture", title: "Target Architecture", level: 2 },
+      { type: "acceptance", title: "Verification", level: 2 }
+    ],
+    defaultRequirements: [
+      { type: "non-functional", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] }
+    ]
+  },
+  {
+    id: "infra",
+    name: "Infrastructure",
+    description: "Template for infrastructure/tooling changes",
+    sections: [
+      { type: "overview", title: "What and Why", level: 2 },
+      { type: "requirements", title: "Requirements", level: 2 },
+      { type: "architecture", title: "Design", level: 2 },
+      { type: "security", title: "Security Impact", level: 2 },
+      { type: "acceptance", title: "Rollout Plan", level: 2 }
+    ],
+    defaultRequirements: [
+      { type: "functional", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] },
+      { type: "security", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] }
+    ]
+  },
+  {
+    id: "integration",
+    name: "Integration",
+    description: "Template for integrating external services or APIs",
+    sections: [
+      { type: "overview", title: "Integration Overview", level: 2 },
+      { type: "requirements", title: "Integration Requirements", level: 2 },
+      { type: "api", title: "API Contract", level: 2 },
+      { type: "architecture", title: "Architecture", level: 2 },
+      { type: "security", title: "Auth & Security", level: 2 },
+      { type: "acceptance", title: "Testing Strategy", level: 2 }
+    ],
+    defaultRequirements: [
+      { type: "functional", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] },
+      { type: "security", priority: "critical", acceptanceCriteria: [], blockedBy: [], implements: [] },
+      { type: "performance", priority: "medium", acceptanceCriteria: [], blockedBy: [], implements: [] }
+    ]
+  },
+  {
+    id: "cli-command",
+    name: "CLI Command",
+    description: "Template for new CLI commands/slash commands",
+    sections: [
+      { type: "overview", title: "Command Overview", level: 2 },
+      { type: "requirements", title: "Command Requirements", level: 2 },
+      { type: "api", title: "Command Interface", level: 2 },
+      { type: "acceptance", title: "Usage Examples", level: 2 }
+    ],
+    defaultRequirements: [
+      { type: "ux", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] },
+      { type: "functional", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] }
+    ]
+  }
+];
+function getTemplate(id) {
+  return SPEC_TEMPLATES.find((t) => t.id === id);
+}
+function listTemplates() {
+  return SPEC_TEMPLATES.map((t) => ({ id: t.id, name: t.name, description: t.description }));
+}
+function templateToMarkdown(template, title) {
+  const lines = [];
+  lines.push(`# ${title ?? "Untitled Specification"}`);
+  lines.push("Version: 0.1.0");
+  lines.push("");
+  for (const section of template.sections) {
+    lines.push(`${"#".repeat(section.level + 1)} ${section.title}`);
+    lines.push(`_<!-- ${section.type} section content -->_`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var STATUS_ICON = {
+  pending: "\u25CB",
+  in_progress: "\u25D0",
+  blocked: "\u2298",
+  failed: "\u2717",
+  review: "\u25D1",
+  completed: "\u25CF"
+};
+var PRIORITY_ICON = {
+  critical: "\u{1F534}",
+  high: "\u{1F7E0}",
+  medium: "\u{1F7E1}",
+  low: "\u{1F7E2}"
+};
+var TYPE_ICON = {
+  feature: "\u26A1",
+  bugfix: "\u{1F41B}",
+  refactor: "\u267B\uFE0F",
+  docs: "\u{1F4DD}",
+  test: "\u{1F9EA}",
+  chore: "\u{1F527}"
+};
+function renderTaskGraph(graph, opts) {
+  const lines = [];
+  const compact = opts?.compact ?? false;
+  lines.push(`\u256D\u2500 Task Graph: ${graph.title} \u2500\u256E`);
+  lines.push(`\u2502 Spec: ${graph.specId.slice(0, 8)}... \u2502 Nodes: ${graph.nodes.size} \u2502 Edges: ${graph.edges.length} \u2502`);
+  lines.push("\u2570" + "\u2500".repeat(Math.max(50, graph.title.length + 30)) + "\u256F");
+  lines.push("");
+  const progress = computeTaskProgress(graph);
+  lines.push(renderProgress(progress));
+  lines.push("");
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (edge.type === "depends_on") {
+      const deps = childrenMap.get(edge.from) ?? [];
+      deps.push(edge.to);
+      childrenMap.set(edge.from, deps);
+    }
+  }
+  const rendered = /* @__PURE__ */ new Set();
+  const rootNodes = graph.rootNodes.filter((id) => graph.nodes.has(id));
+  const startNodes = rootNodes.length > 0 ? rootNodes : Array.from(graph.nodes.keys()).filter((id) => {
+    const deps = childrenMap.get(id);
+    return !deps || deps.length === 0;
+  });
+  for (const rootId of startNodes) {
+    renderNode(graph, rootId, lines, rendered, childrenMap, compact, "");
+  }
+  for (const [id] of graph.nodes) {
+    if (!rendered.has(id)) {
+      renderNode(graph, id, lines, rendered, childrenMap, compact, "");
+    }
+  }
+  lines.push("");
+  lines.push("Legend: \u25CF done \u25D0 in-progress \u25CB pending \u2297 blocked \u2717 failed \u25D2 review");
+  return lines.join("\n");
+}
+function renderNode(graph, nodeId, lines, rendered, childrenMap, compact, prefix) {
+  if (rendered.has(nodeId)) return;
+  rendered.add(nodeId);
+  const node = graph.nodes.get(nodeId);
+  if (!node) return;
+  const icon = STATUS_ICON[node.status];
+  const prioIcon = PRIORITY_ICON[node.priority];
+  const typeIcon = TYPE_ICON[node.type];
+  const title = compact ? truncate(node.title, 40) : node.title;
+  const blockedBy = childrenMap.get(nodeId) ?? [];
+  const depsStr = blockedBy.length > 0 ? ` \u2190 [${blockedBy.map((d) => graph.nodes.get(d)?.title?.slice(0, 12) ?? "?").join(", ")}]` : "";
+  lines.push(`${prefix}${icon} ${typeIcon} ${prioIcon} ${title}${depsStr}`);
+  if (!compact && node.description) {
+    const descLines = node.description.split("\n").slice(0, 3);
+    for (const dl of descLines) {
+      lines.push(`${prefix}  \u2514 ${truncate(dl, 60)}`);
+    }
+  }
+  const dependents = graph.edges.filter((e) => e.type === "depends_on" && e.to === nodeId).map((e) => e.from).filter((id) => graph.nodes.has(id));
+  for (const depId of dependents) {
+    renderNode(graph, depId, lines, rendered, childrenMap, compact, prefix + "  ");
+  }
+}
+function renderProgress(progress) {
+  const barWidth = 30;
+  const filled = Math.round(progress.percentComplete / 100 * barWidth);
+  const empty = barWidth - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  return [
+    `Progress: [${bar}] ${progress.percentComplete}%`,
+    `  ${progress.completed} done \u2502 ${progress.inProgress} active \u2502 ${progress.pending} pending \u2502 ${progress.blocked} blocked \u2502 ${progress.failed} failed`
+  ].join("\n");
+}
+function renderTaskList(graph) {
+  const lines = [];
+  const nodes = Array.from(graph.nodes.values());
+  const groups = {
+    in_progress: [],
+    pending: [],
+    blocked: [],
+    review: [],
+    failed: [],
+    completed: []
+  };
+  for (const node of nodes) {
+    groups[node.status]?.push(node);
+  }
+  for (const [status, group] of Object.entries(groups)) {
+    if (group.length === 0) continue;
+    const icon = STATUS_ICON[status];
+    lines.push(`${icon} ${status.toUpperCase()} (${group.length})`);
+    for (const node of group) {
+      const prio = PRIORITY_ICON[node.priority];
+      const type = TYPE_ICON[node.type];
+      lines.push(`  ${type} ${prio} ${node.title}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderSpecAnalysis(spec, analysis) {
+  const lines = [];
+  lines.push(`\u256D\u2500 Spec Analysis: ${spec.title} \u2500\u256E`);
+  lines.push("");
+  const barWidth = 20;
+  const filled = Math.round(analysis.completeness / 100 * barWidth);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+  lines.push(`Completeness: [${bar}] ${analysis.completeness}%`);
+  lines.push("");
+  if (analysis.gaps.length > 0) {
+    lines.push("\u26A0 Gaps:");
+    for (const gap of analysis.gaps) {
+      lines.push(`  \u2022 ${gap}`);
+    }
+    lines.push("");
+  }
+  if (analysis.risks.length > 0) {
+    lines.push("\u{1F534} Risks:");
+    for (const risk of analysis.risks) {
+      lines.push(`  \u2022 ${risk}`);
+    }
+    lines.push("");
+  }
+  if (analysis.suggestions.length > 0) {
+    lines.push("\u{1F4A1} Suggestions:");
+    for (const sug of analysis.suggestions) {
+      lines.push(`  \u2022 ${sug}`);
+    }
+  }
+  return lines.join("\n");
+}
+function analyzeCriticalPath(graph) {
+  const nodes = Array.from(graph.nodes.values());
+  const topoOrder = topologicalSort(graph);
+  const blockedByMap = /* @__PURE__ */ new Map();
+  const blocksMap = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (edge.type === "depends_on") {
+      if (!blockedByMap.has(edge.from)) blockedByMap.set(edge.from, /* @__PURE__ */ new Set());
+      blockedByMap.get(edge.from)?.add(edge.to);
+      if (!blocksMap.has(edge.to)) blocksMap.set(edge.to, /* @__PURE__ */ new Set());
+      blocksMap.get(edge.to)?.add(edge.from);
+    }
+  }
+  const readyTasks = [];
+  const blockedTasks = [];
+  for (const node of nodes) {
+    if (node.status === "completed") continue;
+    const blockers = blockedByMap.get(node.id);
+    if (!blockers || blockers.size === 0) {
+      readyTasks.push(node.id);
+    } else {
+      const allCompleted = Array.from(blockers).every((id) => {
+        const n = graph.nodes.get(id);
+        return n?.status === "completed";
+      });
+      if (allCompleted) {
+        readyTasks.push(node.id);
+      } else {
+        blockedTasks.push(node.id);
+      }
+    }
+  }
+  const bottlenecks = [];
+  for (const node of nodes) {
+    if (node.status === "completed") continue;
+    const downstream = getTransitiveBlocked(graph, node.id, blocksMap);
+    if (downstream.size > 0) {
+      const blockedHours = Array.from(downstream).reduce((sum, id) => {
+        const n = graph.nodes.get(id);
+        return sum + (n?.estimateHours ?? 0);
+      }, 0);
+      bottlenecks.push({
+        taskId: node.id,
+        title: node.title,
+        blockedCount: downstream.size,
+        blockedHours,
+        severity: Math.min(100, Math.round(downstream.size / nodes.length * 100))
+      });
+    }
+  }
+  bottlenecks.sort((a, b) => b.severity - a.severity);
+  const criticalPath = computeCriticalPath(graph, topoOrder, blockedByMap);
+  const totalHours = criticalPath.reduce((sum, id) => {
+    const n = graph.nodes.get(id);
+    return sum + (n?.estimateHours ?? 0);
+  }, 0);
+  const parallelGroups = computeParallelGroups(graph, blockedByMap);
+  const executionOrder = topoOrder.filter((id) => {
+    const n = graph.nodes.get(id);
+    return n && n.status !== "completed";
+  });
+  return {
+    criticalPath,
+    totalHours,
+    bottlenecks,
+    parallelGroups,
+    executionOrder,
+    readyTasks,
+    blockedTasks
+  };
+}
+function getTransitiveBlocked(_graph, taskId, blocksMap) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [taskId];
+  while (queue.length > 0) {
+    const current = expectDefined(queue.shift());
+    const blocked = blocksMap.get(current);
+    if (!blocked) continue;
+    for (const id of blocked) {
+      if (!visited.has(id) && id !== taskId) {
+        visited.add(id);
+        queue.push(id);
+      }
+    }
+  }
+  return visited;
+}
+function computeCriticalPath(graph, _topoOrder, blockedByMap) {
+  const allIds = Array.from(graph.nodes.keys());
+  if (allIds.length === 0) return [];
+  const dist = /* @__PURE__ */ new Map();
+  const prev = /* @__PURE__ */ new Map();
+  for (const id of allIds) {
+    dist.set(id, graph.nodes.get(id)?.estimateHours ?? 1);
+    prev.set(id, null);
+  }
+  const blocksMap = /* @__PURE__ */ new Map();
+  for (const [taskId, blockers] of blockedByMap) {
+    for (const blockerId of blockers) {
+      if (!blocksMap.has(blockerId)) blocksMap.set(blockerId, /* @__PURE__ */ new Set());
+      blocksMap.get(blockerId)?.add(taskId);
+    }
+  }
+  const n = allIds.length;
+  for (let i = 0; i < n - 1; i++) {
+    let changed = false;
+    for (const id of allIds) {
+      const blocked = blocksMap.get(id);
+      if (!blocked) continue;
+      for (const blockedId of blocked) {
+        const candidateDist = (dist.get(id) ?? 0) + (graph.nodes.get(blockedId)?.estimateHours ?? 1);
+        if (candidateDist > (dist.get(blockedId) ?? 0)) {
+          dist.set(blockedId, candidateDist);
+          prev.set(blockedId, id);
+          changed = true;
+        }
+      }
+    }
+    if (!changed) break;
+  }
+  let maxDist = 0;
+  let maxId = expectDefined(allIds[0]);
+  for (const id of allIds) {
+    const d = dist.get(id) ?? 0;
+    if (d > maxDist) {
+      maxDist = d;
+      maxId = id;
+    }
+  }
+  const path4 = [];
+  let current = maxId;
+  const visited = /* @__PURE__ */ new Set();
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    path4.unshift(current);
+    current = prev.get(current) ?? null;
+  }
+  return path4;
+}
+function computeParallelGroups(graph, blockedByMap) {
+  const groups = [];
+  const assigned = /* @__PURE__ */ new Set();
+  const nodes = Array.from(graph.nodes.values()).filter((n) => n.status !== "completed");
+  const remaining = new Set(nodes.map((n) => n.id));
+  while (remaining.size > 0) {
+    const group = [];
+    for (const id of remaining) {
+      const blockers = blockedByMap.get(id);
+      if (!blockers || blockers.size === 0) {
+        group.push(id);
+      } else {
+        const allAssigned = Array.from(blockers).every((b) => assigned.has(b));
+        if (allAssigned) {
+          group.push(id);
+        }
+      }
+    }
+    if (group.length === 0) {
+      const first = Array.from(remaining)[0];
+      if (first) group.push(first);
+    }
+    for (const id of group) {
+      assigned.add(id);
+      remaining.delete(id);
+    }
+    groups.push(group);
+  }
+  return groups;
+}
+var SpecVersioning = class {
+  versions = /* @__PURE__ */ new Map();
+  /** Record a new version of a spec. */
+  recordVersion(spec, changeDescription) {
+    const version = {
+      version: spec.version,
+      spec: { ...spec },
+      timestamp: Date.now(),
+      changeDescription
+    };
+    const history = this.versions.get(spec.id) ?? [];
+    history.push(version);
+    this.versions.set(spec.id, history);
+    return version;
+  }
+  /** Get version history for a spec. */
+  getHistory(specId) {
+    return this.versions.get(specId) ?? [];
+  }
+  /** Get a specific version of a spec. */
+  getVersion(specId, version) {
+    const history = this.versions.get(specId) ?? [];
+    return history.find((v) => v.version === version);
+  }
+  /** Get the latest version of a spec. */
+  getLatest(specId) {
+    const history = this.versions.get(specId) ?? [];
+    return history[history.length - 1];
+  }
+  /** Compute diff between two versions of a spec. */
+  diff(oldSpec, newSpec) {
+    const oldReqs = new Map(oldSpec.requirements.map((r) => [r.id, r]));
+    const newReqs = new Map(newSpec.requirements.map((r) => [r.id, r]));
+    const added = [];
+    const removed = [];
+    const modified = [];
+    for (const [id, newReq] of newReqs) {
+      const oldReq = oldReqs.get(id);
+      if (!oldReq) {
+        added.push(newReq);
+      } else {
+        const changes = this.compareRequirements(oldReq, newReq);
+        if (changes.length > 0) {
+          modified.push({
+            requirement: newReq,
+            previousVersion: oldReq,
+            changes
+          });
+        }
+      }
+    }
+    for (const [id, oldReq] of oldReqs) {
+      if (!newReqs.has(id)) {
+        removed.push(oldReq);
+      }
+    }
+    const parts = [];
+    if (added.length > 0) parts.push(`${added.length} added`);
+    if (removed.length > 0) parts.push(`${removed.length} removed`);
+    if (modified.length > 0) parts.push(`${modified.length} modified`);
+    return {
+      added,
+      removed,
+      modified,
+      summary: parts.length > 0 ? parts.join(", ") : "No changes"
+    };
+  }
+  /**
+   * Update a task graph incrementally based on spec changes.
+   * - Added requirements → new tasks
+   * - Removed requirements → remove tasks
+   * - Modified requirements → update task descriptions
+   * Returns the updated graph and list of changes made.
+   */
+  updateTaskGraph(graph, oldSpec, newSpec) {
+    const specDiff = this.diff(oldSpec, newSpec);
+    const changes = [];
+    const reqToTask = /* @__PURE__ */ new Map();
+    for (const node of graph.nodes.values()) {
+      if (node.specRequirementId) {
+        reqToTask.set(node.specRequirementId, node);
+      }
+    }
+    for (const req of specDiff.removed) {
+      const task = reqToTask.get(req.id);
+      if (task) {
+        graph.nodes.delete(task.id);
+        graph.edges = graph.edges.filter((e) => e.from !== task.id && e.to !== task.id);
+        changes.push(`Removed task: ${task.title}`);
+      }
+    }
+    for (const mod of specDiff.modified) {
+      const task = reqToTask.get(mod.requirement.id);
+      if (task) {
+        task.title = mod.requirement.description;
+        task.description = this.buildTaskDescription(mod.requirement);
+        task.priority = mod.requirement.priority;
+        task.updatedAt = Date.now();
+        changes.push(`Updated task: ${task.title} (${mod.changes.join(", ")})`);
+      }
+    }
+    for (const req of specDiff.added) {
+      const now = Date.now();
+      const newTask = {
+        id: crypto.randomUUID(),
+        title: req.description,
+        description: this.buildTaskDescription(req),
+        type: this.mapReqType(req.type),
+        priority: req.priority,
+        status: "pending",
+        specRequirementId: req.id,
+        tags: [req.type, req.priority],
+        createdAt: now,
+        updatedAt: now
+      };
+      graph.nodes.set(newTask.id, newTask);
+      graph.rootNodes.push(newTask.id);
+      changes.push(`Added task: ${newTask.title}`);
+    }
+    graph.updatedAt = Date.now();
+    return { graph, changes };
+  }
+  compareRequirements(old, current) {
+    const changes = [];
+    if (old.description !== current.description) changes.push("description");
+    if (old.priority !== current.priority) changes.push("priority");
+    if (old.type !== current.type) changes.push("type");
+    if (JSON.stringify(old.acceptanceCriteria) !== JSON.stringify(current.acceptanceCriteria)) {
+      changes.push("acceptance criteria");
+    }
+    if (JSON.stringify(old.blockedBy) !== JSON.stringify(current.blockedBy)) {
+      changes.push("dependencies");
+    }
+    return changes;
+  }
+  buildTaskDescription(req) {
+    const lines = [req.description, "", `**Type:** ${req.type}`, `**Priority:** ${req.priority}`];
+    if (req.acceptanceCriteria.length > 0) {
+      lines.push("", "**Acceptance Criteria:**");
+      for (const ac of req.acceptanceCriteria) {
+        lines.push(`- ${ac}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  mapReqType(type) {
+    switch (type) {
+      case "functional":
+        return "feature";
+      case "non-functional":
+        return "feature";
+      case "security":
+        return "feature";
+      case "performance":
+        return "feature";
+      case "ux":
+        return "feature";
+      default:
+        return assertNever(type);
+    }
+  }
+};
+
+// src/auto-executor.ts
+var AutoExecutor = class {
+  opts;
+  stopped = false;
+  retryMap = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Execute all tasks in the graph, respecting dependencies.
+   */
+  async execute(graph, spec) {
+    this.stopped = false;
+    this.retryMap.clear();
+    const startTime = Date.now();
+    const critical = analyzeCriticalPath(graph);
+    let completed = 0;
+    let failed = 0;
+    const skipped = 0;
+    let retried = 0;
+    while (!this.stopped) {
+      const readyTasks = this.getReadyTasks(graph);
+      if (readyTasks.length === 0) {
+        const allDone = Array.from(graph.nodes.values()).every(
+          (n) => n.status === "completed" || n.status === "failed"
+        );
+        if (allDone) break;
+        const hasDeadlock = this.detectDeadlock(graph);
+        if (hasDeadlock) break;
+        break;
+      }
+      const batch = readyTasks.slice(0, this.opts.maxConcurrent ?? 1);
+      const results = await Promise.allSettled(
+        batch.map((task) => this.executeTaskWithRetry(task, graph, spec))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const task = batch[i];
+        if (!result || !task) continue;
+        if (result.status === "fulfilled") {
+          const { result: execResult, retries } = result.value;
+          if (execResult.success) {
+            this.opts.tracker.updateNodeStatus(task.id, "completed");
+            completed++;
+            if (retries > 0) retried++;
+            this.opts.onTaskComplete?.(task, execResult);
+          } else if (execResult.retry) {
+            retried++;
+          } else {
+            this.opts.tracker.updateNodeStatus(task.id, "failed", execResult.error);
+            failed++;
+          }
+        } else {
+          this.opts.tracker.updateNodeStatus(task.id, "failed", String(result.reason));
+          failed++;
+          this.opts.onTaskFail?.(task, result.reason, 0);
+        }
+      }
+    }
+    const duration = Date.now() - startTime;
+    const summary = {
+      total: graph.nodes.size,
+      completed,
+      failed,
+      skipped,
+      retried,
+      duration,
+      criticalPath: critical.criticalPath
+    };
+    this.opts.onDone?.(summary);
+    return summary;
+  }
+  /** Stop execution. */
+  stop() {
+    this.stopped = true;
+  }
+  /** Get tasks that are ready to execute (all dependencies completed). */
+  getReadyTasks(graph) {
+    const ready = [];
+    for (const node of graph.nodes.values()) {
+      if (node.status !== "pending") continue;
+      const blockers = graph.edges.filter((e) => e.type === "depends_on" && e.from === node.id).map((e) => graph.nodes.get(e.to)).filter(Boolean);
+      const allBlockersDone = blockers.every((b) => b.status === "completed");
+      if (allBlockersDone) {
+        ready.push(node);
+      }
+    }
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    ready.sort((a, b) => (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4));
+    return ready;
+  }
+  /** Execute a single task with retry logic. */
+  async executeTaskWithRetry(task, graph, spec) {
+    const maxRetries = this.opts.maxRetries ?? 2;
+    let retryCount = this.retryMap.get(task.id) ?? 0;
+    while (retryCount <= maxRetries) {
+      this.opts.tracker.updateNodeStatus(task.id, "in_progress");
+      this.opts.onTaskStart?.(task);
+      const dependencies = this.getTaskDependencies(task.id, graph);
+      const dependents = this.getTaskDependents(task.id, graph);
+      const context = {
+        spec,
+        graph,
+        task,
+        dependencies,
+        dependents,
+        retryCount
+      };
+      try {
+        const result = await this.opts.executeTask(task, context);
+        if (result.success) {
+          const retriesForTask = this.retryMap.get(task.id) ?? 0;
+          this.retryMap.delete(task.id);
+          return { result, retries: retriesForTask };
+        }
+        if (result.retry && retryCount < maxRetries) {
+          retryCount++;
+          this.retryMap.set(task.id, retryCount);
+          this.opts.tracker.updateNodeStatus(task.id, "pending");
+          continue;
+        }
+        return { result, retries: retryCount };
+      } catch (error) {
+        if (retryCount < maxRetries) {
+          retryCount++;
+          this.retryMap.set(task.id, retryCount);
+          this.opts.tracker.updateNodeStatus(task.id, "pending");
+          this.opts.onTaskFail?.(task, error, retryCount);
+          continue;
+        }
+        return {
+          result: {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          },
+          retries: retryCount
+        };
+      }
+    }
+    return { result: { success: false, error: "Max retries exceeded" }, retries: retryCount };
+  }
+  /** Get tasks that this task depends on. */
+  getTaskDependencies(taskId, graph) {
+    return graph.edges.filter((e) => e.type === "depends_on" && e.from === taskId).map((e) => graph.nodes.get(e.to)).filter(Boolean);
+  }
+  /** Get tasks that depend on this task. */
+  getTaskDependents(taskId, graph) {
+    return graph.edges.filter((e) => e.type === "depends_on" && e.to === taskId).map((e) => graph.nodes.get(e.from)).filter(Boolean);
+  }
+  /** Detect deadlock: all remaining tasks are blocked by failed tasks. */
+  detectDeadlock(graph) {
+    const remaining = Array.from(graph.nodes.values()).filter(
+      (n) => n.status === "pending" || n.status === "blocked"
+    );
+    if (remaining.length === 0) return false;
+    return remaining.every((node) => {
+      const blockers = graph.edges.filter((e) => e.type === "depends_on" && e.from === node.id).map((e) => graph.nodes.get(e.to)).filter(Boolean);
+      return blockers.some((b) => b.status === "failed");
+    });
+  }
+};
+function createAutoExecutor(opts) {
+  return new AutoExecutor({
+    tracker: opts.tracker,
+    events: opts.events,
+    executeTask: opts.executeTask,
+    maxConcurrent: opts.maxConcurrent,
+    maxRetries: opts.maxRetries
+  });
+}
+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((resolve) => {
+      const isWindows = process.platform === "win32";
+      const [shell, ...shellArgs] = isWindows ? ["cmd", "/d", "/c"] : ["sh", "-c"];
+      const child = spawn(shell, [...shellArgs, cmd], {
+        cwd: info.cwd,
+        shell: false,
+        windowsHide: true,
+        stdio: "ignore"
+      });
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill();
+        resolve({ ok: false, reason: `verification timed out: ${cmd}` });
+      }, timeoutMs);
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        if (timedOut) return;
+        resolve(
+          code === 0 ? { ok: true } : { ok: false, reason: `verification failed (exit ${code}): ${cmd}` }
+        );
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        if (timedOut) return;
+        resolve({ ok: false, reason: `verification spawn error: ${String(err)}` });
+      });
+    });
+  };
+}
+var TASK_TYPES2 = /* @__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 renderInstructionTemplate(readBundledInstructionText("sdd/decompose-task.md"), {
+    minSubtasks: String(min),
+    maxSubtasks: String(max),
+    title: task.title,
+    description: task.description,
+    error: error || "(none recorded)"
+  });
+}
+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_TYPES2.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 SEP = "=======";
+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 === SEP) {
+      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 === SEP || 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 !== SEP && 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 = renderInstructionTemplate(
+        readBundledInstructionText("sdd/merge-conflict-resolver.md"),
+        {
+          file: rel,
+          content
+        }
+      );
+      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;
+  };
+}
+
+export { AISpecBuilder, AutoExecutor, SPEC_TEMPLATES, SddBoardProjector, SddBoardStore, SddInterviewDriver, SddParallelRun, SddRunRegistry, SddSupervisor, SddTaskDecomposer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, TaskFlow, TaskGenerator, TaskGraphStore, analyzeCriticalPath, applySddLifecycle, buildBoardSnapshot, buildBoardTasks, cleanupSddWorktrees, cleanupStaleSddWorktrees, cleanupStaleWorktrees, createAutoExecutor, destroySddProject, extractVerificationCommand, getTemplate, hasConflictMarkers, isExplanatoryText, listTemplates, makeCommandVerifier, makeLlmConflictResolver, makeLlmSubtaskGenerator, makePreferSideConflictResolver, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, resolveConflictText, rollbackSddRunFromDisk, shortIdMap, startSddRun, templateToMarkdown };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map