@wrongstack/core 0.4.1 → 0.5.0

package/dist/sdd/index.js

@@ -1,3 +1,7 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { randomUUID, randomBytes } from 'crypto';
+
 // src/sdd/spec-parser.ts
 var SpecParser = class {
   parse(content) {
@@ -460,6 +464,27 @@ function computeTaskProgress(graph) {
     actualHours
   };
 }
+function topologicalSort(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const result = [];
+  function visit(id) {
+    if (inStack.has(id)) return;
+    if (visited.has(id)) return;
+    if (!graph.nodes.has(id)) return;
+    visited.add(id);
+    inStack.add(id);
+    for (const edge of graph.edges) {
+      if (edge.from === id) visit(edge.to);
+    }
+    inStack.delete(id);
+    result.push(id);
+  }
+  for (const rootId of graph.rootNodes) {
+    visit(rootId);
+  }
+  return result;
+}
 
 // src/sdd/task-tracker.ts
 var TaskTracker = class {
@@ -858,7 +883,1561 @@ var SpecDrivenDev = class {
     }));
   }
 };
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path.join(dir, `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fs.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fs.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat2 = await fs.stat(targetPath);
+      mode = stat2.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fs.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fs.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fs.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delays[i]));
+    }
+  }
+  throw lastErr;
+}
+
+// src/sdd/spec-store.ts
+var SpecStore = class {
+  baseDir;
+  indexPath;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.indexPath = path.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 fs.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 fs.unlink(this.filePath(id));
+      await this.removeFromIndex(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async exists(id) {
+    try {
+      await fs.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 path.join(this.baseDir, `${id}.json`);
+  }
+  async readIndex() {
+    try {
+      const raw = await fs.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 = path.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 fs.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 fs.unlink(this.filePath(id));
+      await this.removeFromIndex(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async exists(id) {
+    try {
+      await fs.access(this.filePath(id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  filePath(id) {
+    return path.join(this.baseDir, `${id}.json`);
+  }
+  async readIndex() {
+    try {
+      const raw = await fs.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 });
+  }
+};
+
+// src/sdd/spec-builder.ts
+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",
+    "",
+    `**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 = 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.",
+    "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",
+    "[",
+    "  {",
+    '    "title": "Create auth middleware",',
+    '    "description": "Implement JWT verification middleware for protected routes",',
+    '    "type": "feature",',
+    '    "priority": "critical",',
+    '    "estimateHours": 3,',
+    '    "tags": ["auth", "middleware"]',
+    "  },",
+    "  {",
+    '    "title": "Write auth tests",',
+    '    "description": "Unit and integration tests for authentication flow",',
+    '    "type": "test",',
+    '    "priority": "high",',
+    '    "estimateHours": 2,',
+    '    "tags": ["test", "auth"]',
+    "  }",
+    "]",
+    "```",
+    "",
+    "Rules:",
+    "- Each task must be independently executable",
+    "- Order tasks by dependency (things that block others come first)",
+    '- 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 fsp3 = await import('fs/promises');
+      const path4 = await import('path');
+      await fsp3.mkdir(path4.dirname(this.sessionPath), { recursive: true });
+      await fsp3.writeFile(this.sessionPath, JSON.stringify(this.session, null, 2), "utf8");
+    } catch {
+    }
+  }
+  /** Load session state from disk. Returns true if a session was loaded. */
+  async loadSession() {
+    if (!this.sessionPath) return false;
+    try {
+      const fsp3 = await import('fs/promises');
+      const raw = await fsp3.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 fsp3 = await import('fs/promises');
+      await fsp3.unlink(this.sessionPath);
+    } catch {
+    }
+  }
+  /** Auto-save helper — calls saveSession() but never throws. */
+  autoSave() {
+    this.saveSession().catch(() => {
+    });
+  }
+  // ── 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 Error("Cannot approve: no spec generated yet.");
+        }
+        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 Error("No spec to save.");
+    }
+    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 Error(`Invalid JSON for spec: ${e instanceof Error ? e.message : "parse error"}`);
+    }
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("Spec JSON must be an object.");
+    }
+    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 Error("Spec must have an overview.");
+    }
+    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;
+  }
+};
+
+// src/sdd/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");
+}
+
+// src/sdd/task-visualizer.ts
+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 truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+
+// src/sdd/critical-path.ts
+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 = 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 = 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;
+}
+
+// src/sdd/spec-versioning.ts
+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 "security":
+        return "feature";
+      case "performance":
+        return "feature";
+      case "ux":
+        return "feature";
+      default:
+        return "feature";
+    }
+  }
+};
+
+// src/sdd/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
+  });
+}
 
-export { DefaultTaskStore, SpecDrivenDev, SpecParser, TaskFlow, TaskGenerator, TaskTracker };
+export { AISpecBuilder, AutoExecutor, DefaultTaskStore, SPEC_TEMPLATES, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, analyzeCriticalPath, createAutoExecutor, getTemplate, listTemplates, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, templateToMarkdown };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map