@riotprompt/riotplan 1.0.4 → 1.0.5

package/dist/mcp-server.js

@@ -0,0 +1,3553 @@
+#!/usr/bin/env node
+import { McpServer as Se } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport as ve } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as c } from "zod";
+import { resolve as T, join as u, basename as J, dirname as be } from "node:path";
+import { writeFile as w, mkdir as $, stat as j, readFile as y, readdir as b, rename as ke, access as I, appendFile as _e } from "node:fs/promises";
+import { existsSync as $e, readFileSync as Y } from "node:fs";
+import { fileURLToPath as Pe } from "node:url";
+function S() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function A(e, n) {
+  return e.path ? T(e.path) : n.workingDirectory ? n.workingDirectory : process.cwd();
+}
+function x(e) {
+  return {
+    success: !1,
+    error: e instanceof Error ? e.message : String(e)
+  };
+}
+function C(e, n) {
+  return {
+    success: !0,
+    data: e,
+    message: n
+  };
+}
+const h = {
+  /** Meta-prompt file patterns */
+  metaPromptPatterns: [
+    "{code}-prompt.md",
+    "prompt-of-prompts.md",
+    "{code}.md"
+  ],
+  /** Step file pattern (e.g., "01-step-name.md") */
+  stepPattern: /^(\d{2})-(.+)\.md$/,
+  /** Feedback file pattern (e.g., "001-initial-review.md") */
+  feedbackPattern: /^(\d{3})-(.+)\.md$/,
+  /** Evidence file patterns */
+  evidencePatterns: [
+    /^what-happened-in-(.+)\.md$/,
+    /^research-(.+)\.md$/,
+    /^analysis-(.+)\.md$/,
+    /^example-(.+)\.md$/
+  ],
+  /** Standard files */
+  standardFiles: {
+    summary: "SUMMARY.md",
+    status: "STATUS.md",
+    executionPlan: "EXECUTION_PLAN.md",
+    readme: "README.md",
+    changelog: "CHANGELOG.md"
+  },
+  /** Standard directories */
+  standardDirs: {
+    plan: "plan",
+    analysis: "analysis",
+    architecture: "architecture",
+    implementation: "implementation",
+    testing: "testing",
+    feedback: "feedback",
+    evidence: "evidence",
+    history: ".history"
+  },
+  /** Status emoji mapping */
+  statusEmoji: {
+    pending: "⬜",
+    in_progress: "🔄",
+    completed: "✅",
+    failed: "❌",
+    blocked: "⏸️",
+    skipped: "⏭️"
+  },
+  /** Emoji to status mapping (reverse lookup) */
+  emojiToStatus: {
+    "⬜": "pending",
+    "🔄": "in_progress",
+    "✅": "completed",
+    "❌": "failed",
+    "⏸️": "blocked",
+    "⏭️": "skipped"
+  }
+};
+async function xe(e) {
+  if (!/^[a-z0-9-]+$/.test(e.code))
+    throw new Error(
+      `Invalid plan code: "${e.code}". Use lowercase letters, numbers, and hyphens only.`
+    );
+  const n = T(u(e.basePath, e.code)), t = [], s = e.createFeedbackDir ?? !0, r = e.createEvidenceDir ?? !0;
+  await Ce(n, {
+    feedback: s,
+    evidence: r
+  });
+  const a = u(n, h.standardFiles.summary);
+  await w(a, Ae(e)), t.push(a);
+  const i = u(
+    n,
+    h.standardFiles.executionPlan
+  );
+  await w(i, Ee(e)), t.push(i);
+  const o = u(n, h.standardFiles.status);
+  await w(o, De(e)), t.push(o);
+  const p = M(), d = [];
+  for (let m = 0; m < p.length; m++) {
+    const g = p[m], v = m + 1, k = Ne(g.title), E = `${String(v).padStart(2, "0")}-${k}.md`, D = u(
+      n,
+      h.standardDirs.plan,
+      E
+    );
+    await w(
+      D,
+      Ie(v, g.title, g.description)
+    ), t.push(D), d.push({
+      number: v,
+      code: k,
+      filename: E,
+      title: g.title,
+      description: g.description,
+      status: "pending",
+      filePath: D
+    });
+  }
+  const l = [h.standardDirs.plan];
+  return s && l.push(h.standardDirs.feedback), r && l.push(h.standardDirs.evidence), { plan: {
+    metadata: {
+      code: e.code,
+      name: e.name,
+      description: e.description,
+      author: e.author,
+      path: n,
+      createdAt: /* @__PURE__ */ new Date()
+    },
+    files: {
+      summary: h.standardFiles.summary,
+      status: h.standardFiles.status,
+      executionPlan: h.standardFiles.executionPlan,
+      steps: d.map((m) => m.filename),
+      subdirectories: l,
+      feedbackDir: s ? h.standardDirs.feedback : void 0,
+      evidenceDir: r ? h.standardDirs.evidence : void 0
+    },
+    steps: d,
+    state: {
+      status: "pending",
+      lastUpdatedAt: /* @__PURE__ */ new Date(),
+      blockers: [],
+      issues: [],
+      progress: 0
+    },
+    context: e.context
+  }, path: n, filesCreated: t };
+}
+async function Ce(e, n) {
+  await $(e, { recursive: !0 });
+  const t = u(e, h.standardDirs.plan);
+  if (await $(t, { recursive: !0 }), n.feedback) {
+    const s = u(
+      e,
+      h.standardDirs.feedback
+    );
+    await $(s, { recursive: !0 });
+  }
+  if (n.evidence) {
+    const s = u(
+      e,
+      h.standardDirs.evidence
+    );
+    await $(s, { recursive: !0 });
+  }
+}
+function Ae(e) {
+  const n = (/* @__PURE__ */ new Date()).toISOString().split("T")[0], t = e.author ? `
+*Author: ${e.author}*` : "";
+  return `# ${e.name}
+
+## Overview
+
+${e.description || "Description of this plan."}
+
+## Goals
+
+1. Goal 1
+2. Goal 2
+3. Goal 3
+
+## Scope
+
+### In Scope
+
+- Item 1
+- Item 2
+
+### Out of Scope
+
+- Item 1
+
+## Success Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+---
+
+*Plan created: ${n}*${t}
+`;
+}
+function Ee(e) {
+  const n = (/* @__PURE__ */ new Date()).toISOString().split("T")[0], t = M();
+  let s = "";
+  return t.forEach((r, a) => {
+    const i = String(a + 1).padStart(2, "0");
+    s += `| ${i} | ${r.title} | ${r.description || ""} |
+`;
+  }), `# Execution Plan: ${e.name}
+
+## Strategy
+
+Describe the overall approach and strategy for this plan.
+
+## Prerequisites
+
+- [ ] Prerequisite 1
+- [ ] Prerequisite 2
+
+## Steps
+
+| Step | Name | Description |
+|------|------|-------------|
+${s}
+## Quality Gates
+
+After each step:
+- [ ] Tests pass
+- [ ] Lint passes
+- [ ] Code review complete
+
+## Notes
+
+Additional notes about the execution approach.
+
+---
+
+*Last updated: ${n}*
+`;
+}
+function De(e) {
+  const n = (/* @__PURE__ */ new Date()).toISOString().split("T")[0], t = M();
+  let s = "";
+  return t.forEach((r, a) => {
+    const i = String(a + 1).padStart(2, "0");
+    s += `| ${i} | ${r.title} | ⬜ | - | - | |
+`;
+  }), `# ${e.name} Status
+
+## Current State
+
+| Field | Value |
+|-------|-------|
+| **Status** | ⬜ PLANNING |
+| **Current Step** | - |
+| **Last Completed** | - |
+| **Started** | - |
+| **Last Updated** | ${n} |
+| **Progress** | 0% (0/${t.length} steps) |
+
+## Step Progress
+
+| Step | Name | Status | Started | Completed | Notes |
+|------|------|--------|---------|-----------|-------|
+${s}
+## Blockers
+
+None currently.
+
+## Issues
+
+None currently.
+
+## Notes
+
+---
+
+*Last updated: ${n}*
+`;
+}
+function Ie(e, n, t) {
+  return `# Step ${String(e).padStart(2, "0")}: ${n}
+
+## Objective
+
+${t || "Describe the objective of this step."}
+
+## Background
+
+Provide context and rationale for this step.
+
+## Tasks
+
+### 1. Task 1
+
+Description of task 1.
+
+### 2. Task 2
+
+Description of task 2.
+
+## Acceptance Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+## Testing
+
+Describe how to verify this step is complete.
+
+## Files Changed
+
+- File 1
+- File 2
+
+## Notes
+
+Additional notes for this step.
+`;
+}
+function M() {
+  return [
+    { title: "Setup", description: "Initial setup and prerequisites" },
+    { title: "Implementation", description: "Core implementation work" },
+    { title: "Testing", description: "Verify everything works" }
+  ];
+}
+function Ne(e) {
+  return e.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function Te(e, n) {
+  try {
+    const t = e.directory ? e.directory : A(e, n), r = {
+      code: e.code,
+      name: e.name || e.code,
+      basePath: t,
+      description: e.description,
+      steps: void 0
+    }, a = await xe(r);
+    return C(
+      {
+        planPath: a.path,
+        code: e.code,
+        stepsCreated: a.plan.steps?.length || 0,
+        filesCreated: a.filesCreated || []
+      },
+      `Plan "${e.code}" created successfully at ${a.path}`
+    );
+  } catch (t) {
+    return x(t);
+  }
+}
+function Fe(e) {
+  const n = /* @__PURE__ */ new Set(), t = e.indexOf("---", 4);
+  if (e.startsWith(`---
+`) && t > 0) {
+    const d = e.substring(4, t).match(/depends-on:\s*([^\n]+)/);
+    if (d) {
+      const l = d[1].match(/\d+/g);
+      l && l.forEach((f) => n.add(parseInt(f)));
+    }
+  }
+  const s = e.split(`
+`), r = [];
+  let a = !1;
+  for (const p of s) {
+    if (/^##\s+Dependencies$/i.test(p)) {
+      a = !0;
+      continue;
+    }
+    if (a && /^#/.test(p))
+      break;
+    a && r.push(p);
+  }
+  if (r.length > 0) {
+    const p = r.join(`
+`), d = p.matchAll(
+      /[-*]\s*(?:Step\s*)?(\d+)/gi
+    );
+    for (const f of d)
+      n.add(parseInt(f[1]));
+    const l = p.matchAll(/Step\s+(\d+)/gi);
+    for (const f of l)
+      n.add(parseInt(f[1]));
+  }
+  const i = e.matchAll(
+    /\(depends\s+on\s+(?:Step\s*)?(\d+(?:\s*,\s*\d+)*)\)/gi
+  );
+  for (const p of i) {
+    const d = p[1].match(/\d+/g);
+    d && d.forEach((l) => n.add(parseInt(l)));
+  }
+  const o = e.matchAll(
+    /Requires:\s*(.+?)(?:\n|$)/gi
+  );
+  for (const p of o) {
+    const l = p[1].match(/\d+/g);
+    l && l.forEach((f) => n.add(parseInt(f)));
+  }
+  return Array.from(n).sort((p, d) => p - d);
+}
+async function P(e, n = {}) {
+  const {
+    includeFeedback: t = !0,
+    includeEvidence: s = !0,
+    parseStatus: r = !0
+  } = n, a = T(e);
+  let i;
+  try {
+    i = await j(a);
+  } catch {
+    throw new Error(`Plan path does not exist: ${a}`);
+  }
+  if (!i.isDirectory())
+    throw new Error(`Plan path is not a directory: ${a}`);
+  const o = await Oe(a), p = await qe(a, o), d = o.steps.length > 0 ? await Me(a, o) : [];
+  let l = {
+    status: "pending",
+    lastUpdatedAt: /* @__PURE__ */ new Date(),
+    blockers: [],
+    issues: [],
+    progress: 0
+  };
+  if (r && o.status) {
+    const g = await y(
+      u(a, o.status),
+      "utf-8"
+    );
+    l = We(g, d);
+  }
+  const f = t && o.feedbackDir ? await Be(u(a, o.feedbackDir)) : void 0, m = s && o.evidenceDir ? await Je(u(a, o.evidenceDir)) : void 0;
+  return {
+    metadata: p,
+    files: o,
+    steps: d,
+    state: l,
+    feedback: f,
+    evidence: m
+  };
+}
+async function Oe(e) {
+  const n = {
+    steps: [],
+    subdirectories: []
+  }, t = await b(e, { withFileTypes: !0 });
+  for (const s of t)
+    if (s.isDirectory())
+      n.subdirectories.push(s.name), s.name === h.standardDirs.plan ? n.steps = await B(
+        u(e, s.name)
+      ) : s.name === h.standardDirs.feedback ? (n.feedbackDir = s.name, n.feedbackFiles = await Re(
+        u(e, s.name)
+      )) : s.name === h.standardDirs.evidence ? (n.evidenceDir = s.name, n.evidenceFiles = await Le(
+        u(e, s.name)
+      )) : s.name === h.standardDirs.analysis ? n.analysisDir = s.name : s.name === h.standardDirs.history && (n.historyDir = s.name);
+    else if (s.isFile()) {
+      const r = s.name;
+      r === h.standardFiles.summary ? n.summary = r : r === h.standardFiles.status ? n.status = r : r === h.standardFiles.executionPlan ? n.executionPlan = r : r === h.standardFiles.readme ? n.readme = r : r === h.standardFiles.changelog ? n.changelog = r : je(r, J(e)) && (n.metaPrompt = r);
+    }
+  if (n.steps.length === 0) {
+    const s = await B(e);
+    s.length > 0 && (n.steps = s);
+  }
+  return n;
+}
+function je(e, n) {
+  for (const t of h.metaPromptPatterns) {
+    const s = t.replace("{code}", n);
+    if (e === s)
+      return !0;
+  }
+  return !1;
+}
+async function B(e) {
+  let n;
+  try {
+    n = await b(e);
+  } catch {
+    return [];
+  }
+  const t = [];
+  for (const s of n)
+    h.stepPattern.test(s) && t.push(s);
+  return t.sort((s, r) => {
+    const a = s.match(h.stepPattern), i = r.match(h.stepPattern);
+    if (!a || !i) return 0;
+    const o = parseInt(a[1]), p = parseInt(i[1]);
+    return o - p;
+  });
+}
+async function Re(e) {
+  let n;
+  try {
+    n = await b(e);
+  } catch {
+    return [];
+  }
+  const t = [];
+  for (const s of n)
+    h.feedbackPattern.test(s) && t.push(s);
+  return t.sort((s, r) => {
+    const a = s.match(h.feedbackPattern), i = r.match(h.feedbackPattern);
+    return !a || !i ? 0 : a[1].localeCompare(i[1]);
+  });
+}
+async function Le(e) {
+  let n;
+  try {
+    n = await b(e);
+  } catch {
+    return [];
+  }
+  const t = [];
+  for (const s of n)
+    for (const r of h.evidencePatterns)
+      if (r.test(s)) {
+        t.push(s);
+        break;
+      }
+  return t.sort();
+}
+async function Me(e, n) {
+  const t = [], s = n.subdirectories.includes(
+    h.standardDirs.plan
+  ) ? u(e, h.standardDirs.plan) : e;
+  for (const r of n.steps) {
+    const a = r.match(h.stepPattern);
+    if (!a) continue;
+    const [, i, o] = a, p = parseInt(i), d = u(s, r);
+    let l;
+    try {
+      l = await y(d, "utf-8");
+    } catch {
+      continue;
+    }
+    const f = Fe(l);
+    t.push({
+      number: p,
+      code: o,
+      filename: r,
+      title: q(l) || R(o),
+      description: Ue(l),
+      status: "pending",
+      // Default, may be overridden by STATUS.md
+      dependencies: f.length > 0 ? f : void 0,
+      filePath: d
+    });
+  }
+  return t;
+}
+async function qe(e, n) {
+  const t = J(e);
+  let s = R(t), r;
+  if (n.summary)
+    try {
+      const a = await y(
+        u(e, n.summary),
+        "utf-8"
+      ), i = q(a);
+      i && (s = i), r = U(a);
+    } catch {
+    }
+  return {
+    code: t,
+    name: s,
+    description: r,
+    path: e
+  };
+}
+function q(e) {
+  const n = e.match(/^#\s+(.+)$/m);
+  return n ? n[1].trim() : null;
+}
+function Ue(e) {
+  return U(e);
+}
+function U(e) {
+  const n = e.split(`
+`);
+  let t = !1, s = "";
+  for (const a of n) {
+    if (a.startsWith("#")) {
+      if (t && s)
+        break;
+      t = !0;
+      continue;
+    }
+    if (t && a.trim()) {
+      if (a.startsWith("-") || a.startsWith("|") || a.startsWith(">") || a.startsWith("```")) {
+        if (s) break;
+        continue;
+      }
+      s += a.trim() + " ";
+    } else if (t && s && !a.trim())
+      break;
+  }
+  return s.trim() || void 0;
+}
+function R(e) {
+  return e.replace(/-/g, " ").replace(/_/g, " ").replace(/\b\w/g, (n) => n.toUpperCase());
+}
+const Ge = ["⬜", "🔄", "✅", "❌", "⏸️", "⏭️"];
+function H(e) {
+  for (const n of Ge)
+    if (e.includes(n))
+      return n;
+  return null;
+}
+function We(e, n) {
+  const t = {
+    status: "pending",
+    lastUpdatedAt: /* @__PURE__ */ new Date(),
+    blockers: [],
+    issues: [],
+    progress: 0
+  }, s = e.match(/\*\*Status\*\*\s*\|\s*([^|]+)/i);
+  if (s) {
+    const p = H(s[1]);
+    if (p) {
+      const d = h.emojiToStatus[p];
+      d && (t.status = d);
+    }
+  }
+  const r = e.split(`
+`);
+  for (const p of r) {
+    const d = p.match(/^\|\s*(\d{2})\s*\|[^|]+\|([^|]+)\|/);
+    if (d) {
+      const l = parseInt(d[1]), f = d[2], m = H(f);
+      if (m) {
+        const g = h.emojiToStatus[m];
+        if (g) {
+          const v = n.find((k) => k.number === l);
+          v && (v.status = g);
+        }
+      }
+    }
+  }
+  const a = n.filter((p) => p.status === "completed").length;
+  t.progress = n.length > 0 ? Math.round(a / n.length * 100) : 0;
+  const i = n.find((p) => p.status === "in_progress");
+  i && (t.currentStep = i.number);
+  const o = n.filter((p) => p.status === "completed").map((p) => p.number);
+  return o.length > 0 && (t.lastCompletedStep = Math.max(...o)), t;
+}
+async function Be(e) {
+  let n;
+  try {
+    n = await b(e);
+  } catch {
+    return [];
+  }
+  const t = [];
+  for (const s of n)
+    if (h.feedbackPattern.test(s))
+      try {
+        const r = await y(u(e, s), "utf-8"), a = He(s, r);
+        a && t.push(a);
+      } catch {
+      }
+  return t.sort((s, r) => s.id.localeCompare(r.id));
+}
+function He(e, n) {
+  const t = e.match(h.feedbackPattern);
+  if (!t) return null;
+  const [, s, r] = t, { frontmatter: a, body: i } = K(n), o = [];
+  if (Array.isArray(a.participants)) {
+    for (const d of a.participants)
+      if (typeof d == "string")
+        o.push({ name: d, type: "human" });
+      else if (d && typeof d == "object") {
+        const l = d;
+        o.push({
+          name: (typeof l.name == "string" ? l.name : void 0) || "Unknown",
+          type: l.type === "human" || l.type === "ai" ? l.type : "human",
+          model: typeof l.model == "string" ? l.model : void 0
+        });
+      }
+  }
+  let p = "other";
+  return typeof a.platform == "string" && [
+    "cursor",
+    "chatgpt",
+    "slack",
+    "email",
+    "meeting",
+    "voice",
+    "document",
+    "other"
+  ].includes(a.platform) && (p = a.platform), {
+    id: s,
+    title: (typeof a.title == "string" ? a.title : void 0) || R(r),
+    createdAt: typeof a.date == "string" || typeof a.date == "number" ? new Date(a.date) : /* @__PURE__ */ new Date(),
+    participants: o.length > 0 ? o : [{ name: "Unknown", type: "human" }],
+    platform: p,
+    planVersion: typeof a.planVersion == "string" ? a.planVersion : void 0,
+    feedback: i.trim(),
+    resolution: typeof a.resolution == "string" ? a.resolution : void 0,
+    changes: Array.isArray(a.changes) ? a.changes.filter((d) => typeof d == "string") : void 0,
+    openQuestions: Array.isArray(a.openQuestions) ? a.openQuestions.filter((d) => typeof d == "string") : void 0,
+    filename: e
+  };
+}
+async function Je(e) {
+  let n;
+  try {
+    n = await b(e);
+  } catch {
+    return [];
+  }
+  const t = [];
+  for (const s of n) {
+    let r = !1;
+    for (const a of h.evidencePatterns)
+      if (a.test(s)) {
+        r = !0;
+        break;
+      }
+    if (r)
+      try {
+        const a = await y(u(e, s), "utf-8"), i = Ye(s, a);
+        i && t.push(i);
+      } catch {
+      }
+  }
+  return t.sort((s, r) => s.id.localeCompare(r.id));
+}
+function Ye(e, n) {
+  let t = "reference", s = null;
+  for (let p = 0; p < h.evidencePatterns.length; p++) {
+    const d = h.evidencePatterns[p], l = e.match(d);
+    if (l) {
+      s = l, t = [
+        "case-study",
+        "research",
+        "analysis",
+        "example"
+      ][p] || "reference";
+      break;
+    }
+  }
+  if (!s) return null;
+  const { frontmatter: r, body: a } = K(n), i = r.title || q(a) || R(s[1] || e);
+  return {
+    id: e.replace(/\.md$/, ""),
+    type: t,
+    title: typeof i == "string" ? i : "",
+    createdAt: typeof r.date == "string" || typeof r.date == "number" ? new Date(r.date) : /* @__PURE__ */ new Date(),
+    source: typeof r.source == "string" ? r.source : void 0,
+    filename: e,
+    summary: (typeof r.summary == "string" ? r.summary : void 0) || U(a),
+    tags: Array.isArray(r.tags) ? r.tags.filter((p) => typeof p == "string") : void 0
+  };
+}
+function K(e) {
+  if (!e.startsWith(`---
+`))
+    return { frontmatter: {}, body: e };
+  const n = e.indexOf(`
+---
+`, 4);
+  if (n === -1)
+    return { frontmatter: {}, body: e };
+  const t = e.substring(4, n), s = e.substring(n + 5), r = {}, a = t.split(`
+`);
+  let i = null, o = null;
+  for (const p of a) {
+    const d = p.trim();
+    if (d.startsWith("- ") && i) {
+      o || (o = [], r[i] = o);
+      const f = d.slice(2).trim();
+      if (f.includes(":")) {
+        const m = {}, g = f.split(",").map((v) => v.trim());
+        for (const v of g) {
+          const [k, E] = v.split(":").map((D) => D.trim());
+          k && E && (m[k] = E.replace(/^["']|["']$/g, ""));
+        }
+        o.push(m);
+      } else
+        o.push(f.replace(/^["']|["']$/g, ""));
+      continue;
+    }
+    const l = p.match(/^(\w+):\s*(.*)$/);
+    if (l) {
+      const [, f, m] = l;
+      i = f, o = null, m.trim() && (r[f] = m.trim().replace(/^["']|["']$/g, ""));
+    }
+  }
+  return { frontmatter: r, body: s };
+}
+const Ke = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  loadPlan: P
+}, Symbol.toStringTag, { value: "Module" }));
+async function Ve(e, n) {
+  try {
+    const t = e.path ? e.path : A(e, n), s = await P(t), r = s.steps.filter((p) => p.status === "completed").length, a = s.steps.length, i = a > 0 ? Math.round(r / a * 100) : 0, o = {
+      planPath: s.metadata.path,
+      code: s.metadata.code,
+      name: s.metadata.name,
+      status: s.state.status,
+      currentStep: s.state.currentStep,
+      lastCompleted: s.state.lastCompletedStep,
+      progress: {
+        completed: r,
+        total: a,
+        percentage: i
+      },
+      blockers: s.state.blockers || [],
+      issues: s.state.issues || [],
+      startedAt: s.state.startedAt,
+      lastUpdated: s.state.lastUpdatedAt
+    };
+    return e.verbose && (o.steps = s.steps.map((p) => ({
+      number: p.number,
+      title: p.title,
+      status: p.status,
+      startedAt: p.startedAt,
+      completedAt: p.completedAt
+    }))), C(o);
+  } catch (t) {
+    return x(t);
+  }
+}
+async function Qe(e) {
+  let n = u(e, h.standardDirs.plan), t;
+  try {
+    t = await b(n);
+  } catch {
+    n = e, t = await b(n);
+  }
+  const s = [];
+  for (const r of t) {
+    const a = r.match(h.stepPattern);
+    a && s.push({
+      number: parseInt(a[1]),
+      code: a[2],
+      filename: r,
+      path: u(n, r)
+    });
+  }
+  return s.sort((r, a) => r.number - a.number);
+}
+async function V(e) {
+  const n = u(e, h.standardDirs.plan);
+  try {
+    return await b(n), n;
+  } catch {
+    return e;
+  }
+}
+function Q(e, n) {
+  return `${String(e).padStart(2, "0")}-${n}.md`;
+}
+function ze(e) {
+  return e.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+async function Xe(e, n, t) {
+  const s = await V(e), r = await Qe(e), a = [], i = r.filter((o) => o.number >= n).reverse();
+  for (const o of i) {
+    const p = o.number + t, d = Q(p, o.code), l = u(s, d);
+    if (o.filename !== d) {
+      await ke(o.path, l), a.push({ from: o.filename, to: d });
+      const f = await y(l, "utf-8"), m = f.replace(
+        /^#\s+Step\s+\d+:/m,
+        `# Step ${String(p).padStart(2, "0")}:`
+      );
+      m !== f && await w(l, m);
+    }
+  }
+  return a;
+}
+function Ze(e, n, t) {
+  return `# Step ${String(e).padStart(2, "0")}: ${n}
+
+## Objective
+
+${t || "Describe the objective of this step."}
+
+## Background
+
+Provide context and rationale for this step.
+
+## Tasks
+
+### 1. Task 1
+
+Description of task 1.
+
+## Acceptance Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+## Testing
+
+Describe how to verify this step is complete.
+
+## Files Changed
+
+- File 1
+
+## Notes
+
+`;
+}
+async function et(e, n) {
+  const t = await V(e.metadata.path);
+  let s;
+  if (n.position !== void 0 ? s = n.position : n.after !== void 0 ? s = n.after + 1 : s = e.steps.length + 1, s < 1 || s > e.steps.length + 1)
+    throw new Error(
+      `Invalid position ${s}. Must be between 1 and ${e.steps.length + 1}`
+    );
+  let r = [];
+  s <= e.steps.length && (r = await Xe(e.metadata.path, s, 1));
+  const a = ze(n.title), i = Q(s, a), o = u(t, i), p = Ze(
+    s,
+    n.title,
+    n.description
+  );
+  return await w(o, p), {
+    step: {
+      number: s,
+      code: a,
+      filename: i,
+      title: n.title,
+      description: n.description,
+      status: n.status || "pending",
+      filePath: o
+    },
+    renamedFiles: r,
+    createdFile: o
+  };
+}
+function tt(e, n, t) {
+  const s = e.steps.find((r) => r.number === n);
+  if (!s)
+    throw new Error(`Step ${n} not found`);
+  return {
+    ...s,
+    status: "completed",
+    completedAt: /* @__PURE__ */ new Date(),
+    notes: t
+  };
+}
+function nt(e, n) {
+  const t = e.steps.find((s) => s.number === n);
+  if (!t)
+    throw new Error(`Step ${n} not found`);
+  return {
+    ...t,
+    status: "in_progress",
+    startedAt: /* @__PURE__ */ new Date()
+  };
+}
+function N(e, n) {
+  if (!e) return "-";
+  switch (n) {
+    case "iso":
+      return e.toISOString().split("T")[0];
+    case "long":
+      return e.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    default:
+      return e.toISOString().split("T")[0];
+  }
+}
+function G(e) {
+  return h.statusEmoji[e] || "⬜";
+}
+function st(e) {
+  const n = G(e), t = e.toUpperCase().replace("_", " ");
+  return `${n} ${t}`;
+}
+function at(e, n) {
+  const { state: t, steps: s } = e, r = s.filter((l) => l.status === "completed").length, a = s.length > 0 ? Math.round(r / s.length * 100) : 0, i = t.currentStep ? s.find((l) => l.number === t.currentStep) : void 0, o = t.lastCompletedStep ? s.find((l) => l.number === t.lastCompletedStep) : void 0, p = i ? `${String(i.number).padStart(2, "0")} - ${i.title}` : "-", d = o ? `${String(o.number).padStart(2, "0")} - ${o.title}` : "-";
+  return `## Current State
+
+| Field | Value |
+|-------|-------|
+| **Status** | ${st(t.status)} |
+| **Current Step** | ${p} |
+| **Last Completed** | ${d} |
+| **Started** | ${N(t.startedAt, n)} |
+| **Last Updated** | ${N(t.lastUpdatedAt, n)} |
+| **Progress** | ${a}% (${r}/${s.length} steps) |
+`;
+}
+function rt(e) {
+  if (!e.phases || e.phases.length === 0) return "";
+  let n = `## Phase Progress
+
+| Phase | Steps | Status | Progress |
+|-------|-------|--------|----------|
+`;
+  for (const t of e.phases) {
+    const s = e.steps.filter(
+      (p) => t.steps.includes(p.number)
+    ), a = `${s.filter(
+      (p) => p.status === "completed"
+    ).length}/${s.length}`, i = `${String(t.steps[0]).padStart(2, "0")}-${String(t.steps[t.steps.length - 1]).padStart(2, "0")}`, o = t.status.charAt(0).toUpperCase() + t.status.slice(1).replace("_", " ");
+    n += `| **${t.name}** | ${i} | ${G(t.status)} ${o} | ${a} |
+`;
+  }
+  return n + `
+`;
+}
+function it(e, n) {
+  let t = `## Step Progress
+
+| Step | Name | Status | Started | Completed | Notes |
+|------|------|--------|---------|-----------|-------|
+`;
+  for (const s of e) {
+    const r = String(s.number).padStart(2, "0"), a = N(s.startedAt, n), i = N(s.completedAt, n), o = s.notes || "";
+    t += `| ${r} | ${s.title} | ${G(s.status)} | ${a} | ${i} | ${o} |
+`;
+  }
+  return t + `
+`;
+}
+function ot(e) {
+  if (e.length === 0)
+    return `## Blockers
+
+None currently.
+
+`;
+  let n = `## Blockers
+
+`;
+  for (const t of e)
+    n += `- ${t.description}`, t.affectedSteps && t.affectedSteps.length > 0 && (n += ` (affects steps: ${t.affectedSteps.join(", ")})`), n += `
+`;
+  return n + `
+`;
+}
+function ct(e) {
+  if (e.length === 0)
+    return `## Issues
+
+None currently.
+
+`;
+  let n = `## Issues
+
+`;
+  for (const t of e)
+    n += `- **${t.title}**: ${t.description}
+`;
+  return n + `
+`;
+}
+function pt(e) {
+  return `## Notes
+
+${e || ""}
+
+`;
+}
+function dt(e) {
+  return `---
+
+**Status Legend**:
+- ${h.statusEmoji.pending} Pending
+- ${h.statusEmoji.in_progress} In Progress
+- ${h.statusEmoji.completed} Completed
+- ${h.statusEmoji.failed} Failed
+- ${h.statusEmoji.blocked} Blocked
+- ${h.statusEmoji.skipped} Skipped
+
+*Last updated: ${N(/* @__PURE__ */ new Date(), e)}*
+`;
+}
+function z(e, n = {}) {
+  const {
+    preserveNotes: t = !0,
+    existingContent: s,
+    includePhases: r = !0,
+    dateFormat: a = "short"
+  } = n;
+  let i;
+  if (t && s) {
+    const p = s.split(`
+`), d = [];
+    let l = !1;
+    for (const f of p) {
+      if (/^## Notes$/i.test(f)) {
+        l = !0;
+        continue;
+      }
+      if (l && (/^##/.test(f) || /^---/.test(f)))
+        break;
+      l && d.push(f);
+    }
+    d.length > 0 && (i = d.join(`
+`).trim());
+  }
+  let o = `# ${e.metadata.name} Status
+
+`;
+  return o += at(e, a), o += `
+`, r && e.phases && e.phases.length > 0 && (o += rt(e)), o += it(e.steps, a), o += ot(e.state.blockers), o += ct(e.state.issues), o += pt(i), o += dt(a), o;
+}
+async function lt(e, n) {
+  try {
+    const t = e.path ? e.path : A(e, n), s = await P(t);
+    let r = s.steps;
+    return e.pending ? r = r.filter((a) => a.status === "pending") : e.all || (r = r.filter((a) => a.status !== "completed")), C({
+      planPath: s.metadata.path,
+      steps: r.map((a) => ({
+        number: a.number,
+        title: a.title,
+        status: a.status,
+        file: a.filename,
+        startedAt: a.startedAt,
+        completedAt: a.completedAt
+      }))
+    });
+  } catch (t) {
+    return x(t);
+  }
+}
+async function ut(e, n) {
+  try {
+    const t = e.path ? e.path : A(e, n), s = await P(t), r = nt(s, e.step), a = s.steps.findIndex((o) => o.number === e.step);
+    a >= 0 && (s.steps[a] = r), s.state.currentStep = e.step, s.state.status = "in_progress", s.state.lastUpdatedAt = /* @__PURE__ */ new Date();
+    const i = z(s);
+    return await w(u(t, "STATUS.md"), i, "utf-8"), C(
+      { planPath: t, step: e.step },
+      `Step ${e.step} marked as started`
+    );
+  } catch (t) {
+    return x(t);
+  }
+}
+async function ht(e, n) {
+  try {
+    const t = e.path ? e.path : A(e, n), s = await P(t), r = tt(s, e.step), a = s.steps.findIndex((p) => p.number === e.step);
+    a >= 0 && (s.steps[a] = r), s.state.lastCompletedStep = e.step, s.state.lastUpdatedAt = /* @__PURE__ */ new Date();
+    const i = s.steps.find((p) => p.status === "pending");
+    i ? (s.state.currentStep = i.number, s.state.status = "in_progress") : (s.state.status = "completed", s.state.currentStep = void 0);
+    const o = z(s);
+    return await w(u(t, "STATUS.md"), o, "utf-8"), C(
+      { planPath: t, step: e.step },
+      `Step ${e.step} marked as completed`
+    );
+  } catch (t) {
+    return x(t);
+  }
+}
+async function mt(e, n) {
+  try {
+    const t = e.path ? e.path : A(e, n), s = await P(t), r = await et(s, {
+      title: e.title,
+      position: e.number,
+      after: e.after,
+      status: "pending"
+    });
+    return C(
+      {
+        planPath: t,
+        step: r.step.number,
+        file: r.createdFile,
+        renamedFiles: r.renamedFiles
+      },
+      `Step "${e.title}" added as step ${r.step.number}`
+    );
+  } catch (t) {
+    return x(t);
+  }
+}
+async function ft(e) {
+  const n = [], t = [];
+  try {
+    await I(e);
+  } catch {
+    return n.push({
+      code: "DIR_NOT_FOUND",
+      message: `Plan directory not found: ${e}`,
+      path: e
+    }), { errors: n, warnings: t };
+  }
+  const s = u(e, h.standardFiles.summary);
+  try {
+    await I(s);
+  } catch {
+    t.push({
+      code: "MISSING_SUMMARY",
+      message: "SUMMARY.md not found",
+      path: s
+    });
+  }
+  const r = u(e, h.standardFiles.status);
+  try {
+    await I(r);
+  } catch {
+    t.push({
+      code: "MISSING_STATUS",
+      message: "STATUS.md not found",
+      path: r
+    });
+  }
+  const a = u(
+    e,
+    h.standardFiles.executionPlan
+  );
+  try {
+    await I(a);
+  } catch {
+    t.push({
+      code: "MISSING_EXEC_PLAN",
+      message: "EXECUTION_PLAN.md not found",
+      path: a
+    });
+  }
+  const i = u(e, h.standardDirs.plan);
+  try {
+    await I(i), (await b(i)).filter(
+      (d) => h.stepPattern.test(d)
+    ).length === 0 && t.push({
+      code: "NO_STEPS",
+      message: "No step files found in plan/ directory"
+    });
+  } catch {
+    try {
+      (await b(e)).filter(
+        (d) => h.stepPattern.test(d)
+      ).length === 0 && t.push({
+        code: "NO_STEPS",
+        message: "No step files found"
+      });
+    } catch {
+      t.push({
+        code: "NO_STEPS",
+        message: "Unable to read plan directory for step files"
+      });
+    }
+  }
+  return { errors: n, warnings: t };
+}
+async function gt(e) {
+  const n = [], t = [], s = [], r = u(e, h.standardDirs.plan);
+  let a = [], i = r;
+  try {
+    a = (await b(r)).filter((l) => h.stepPattern.test(l));
+  } catch {
+    try {
+      a = (await b(e)).filter(
+        (l) => h.stepPattern.test(l)
+      ), i = e;
+    } catch {
+      return { errors: n, warnings: t, fixable: s };
+    }
+  }
+  if (a.length === 0) return { errors: n, warnings: t, fixable: s };
+  const o = [];
+  for (const d of a) {
+    const l = d.match(h.stepPattern);
+    l && o.push(parseInt(l[1]));
+  }
+  o.sort((d, l) => d - l);
+  for (let d = 0; d < o.length; d++) {
+    const l = d + 1;
+    if (o[d] !== l && o[d] > l) {
+      t.push({
+        code: "STEP_GAP",
+        message: `Gap in step numbering: expected ${l}, found ${o[d]}`,
+        step: o[d]
+      });
+      const f = l;
+      s.push({
+        code: "FIX_STEP_GAP",
+        description: `Renumber steps to close gap at ${f}`,
+        fix: async () => {
+        }
+      });
+    }
+  }
+  const p = /* @__PURE__ */ new Set();
+  for (const d of o)
+    p.has(d) && n.push({
+      code: "DUPLICATE_STEP",
+      message: `Duplicate step number: ${d}`,
+      step: d
+    }), p.add(d);
+  return o[0] === 0 && t.push({
+    code: "STEP_ZERO",
+    message: "Step numbering should start at 01, not 00"
+  }), { errors: n, warnings: t, fixable: s };
+}
+async function yt(e) {
+  const n = [], t = [];
+  try {
+    const s = await y(e.filePath, "utf-8");
+    s.match(/^#\s+/m) || t.push({
+      code: "MISSING_TITLE",
+      message: `Step ${e.number} missing title heading`,
+      step: e.number,
+      path: e.filePath
+    }), s.match(/##\s+Objective/i) || t.push({
+      code: "MISSING_OBJECTIVE",
+      message: `Step ${e.number} missing Objective section`,
+      step: e.number
+    }), s.match(/##\s+Acceptance Criteria/i) || t.push({
+      code: "MISSING_ACCEPTANCE",
+      message: `Step ${e.number} missing Acceptance Criteria section`,
+      step: e.number
+    });
+    const r = s.match(/^#\s+Step\s+(\d+)/m);
+    if (r) {
+      const a = parseInt(r[1]);
+      a !== e.number && n.push({
+        code: "STEP_NUMBER_MISMATCH",
+        message: `Step ${e.number} has title "Step ${a}" - mismatch`,
+        step: e.number
+      });
+    }
+  } catch {
+    n.push({
+      code: "STEP_UNREADABLE",
+      message: `Cannot read step file: ${e.filePath}`,
+      step: e.number
+    });
+  }
+  return { errors: n, warnings: t };
+}
+function wt(e) {
+  const n = [], t = [], s = new Set(e.map((a) => a.number));
+  for (const a of e)
+    if (a.dependencies)
+      for (const i of a.dependencies)
+        s.has(i) || n.push({
+          code: "INVALID_DEPENDENCY",
+          message: `Step ${a.number} depends on non-existent step ${i}`,
+          step: a.number
+        }), i === a.number && n.push({
+          code: "SELF_DEPENDENCY",
+          message: `Step ${a.number} depends on itself`,
+          step: a.number
+        }), i > a.number && t.push({
+          code: "FORWARD_DEPENDENCY",
+          message: `Step ${a.number} depends on later step ${i}`,
+          step: a.number
+        });
+  const r = St(e);
+  for (const a of r)
+    n.push({
+      code: "CIRCULAR_DEPENDENCY",
+      message: `Circular dependency detected: ${a.join(" → ")}`
+    });
+  return { errors: n, warnings: t };
+}
+function St(e) {
+  const n = [], t = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), r = [], a = new Map(e.map((o) => [o.number, o]));
+  function i(o) {
+    if (s.has(o)) {
+      const d = r.indexOf(o);
+      n.push([...r.slice(d), o]);
+      return;
+    }
+    if (t.has(o)) return;
+    t.add(o), s.add(o), r.push(o);
+    const p = a.get(o);
+    if (p?.dependencies)
+      for (const d of p.dependencies)
+        i(d);
+    r.pop(), s.delete(o);
+  }
+  for (const o of e)
+    i(o.number);
+  return n;
+}
+async function vt(e, n = {}) {
+  const {
+    validateContent: t = !0,
+    validateDependencies: s = !0,
+    validateStatus: r = !0,
+    strict: a = !1
+  } = n, i = {
+    valid: !0,
+    errors: [],
+    warnings: [],
+    info: [],
+    fixable: []
+  }, o = await ft(e);
+  if (i.errors.push(...o.errors), i.warnings.push(...o.warnings), o.errors.some((d) => d.code === "DIR_NOT_FOUND"))
+    return i.valid = !1, i;
+  const p = await gt(e);
+  i.errors.push(...p.errors), i.warnings.push(...p.warnings), i.fixable.push(...p.fixable);
+  try {
+    const { loadPlan: d } = await Promise.resolve().then(() => Ke), l = await d(e, {
+      parseStatus: r
+    });
+    if (t)
+      for (const f of l.steps) {
+        const m = await yt(f);
+        i.errors.push(...m.errors), i.warnings.push(...m.warnings);
+      }
+    if (s) {
+      const f = wt(l.steps);
+      i.errors.push(...f.errors), i.warnings.push(...f.warnings);
+    }
+    i.info.push({
+      code: "PLAN_LOADED",
+      message: `Plan "${l.metadata.name}" loaded with ${l.steps.length} steps`
+    });
+  } catch (d) {
+    i.errors.push({
+      code: "LOAD_FAILED",
+      message: `Failed to load plan: ${d.message}`
+    });
+  }
+  return a ? i.valid = i.errors.length === 0 && i.warnings.length === 0 : i.valid = i.errors.length === 0, i;
+}
+async function bt(e, n) {
+  try {
+    const t = e.path ? e.path : A(e, n), s = await vt(t);
+    return C(
+      {
+        planPath: t,
+        valid: s.valid,
+        errors: s.errors || [],
+        warnings: s.warnings || [],
+        fixable: s.fixable || []
+      },
+      s.valid ? "Plan validation passed" : `Plan validation failed with ${s.errors.length} error(s)`
+    );
+  } catch (t) {
+    return x(t);
+  }
+}
+async function kt(e, n, t = {}) {
+  const s = $t(e), r = {
+    model: t.model || "claude-sonnet-4-5",
+    messages: [
+      {
+        role: "system",
+        content: _t
+      },
+      {
+        role: "user",
+        content: s
+      }
+    ],
+    responseFormat: {
+      type: "json_schema",
+      json_schema: {
+        name: "plan_generation",
+        description: "Generate a detailed execution plan",
+        schema: {
+          type: "object",
+          properties: {
+            summary: { type: "string" },
+            approach: { type: "string" },
+            successCriteria: { type: "string" },
+            steps: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  number: { type: "number" },
+                  title: { type: "string" },
+                  objective: { type: "string" },
+                  background: { type: "string" },
+                  tasks: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      properties: {
+                        id: { type: "string" },
+                        description: { type: "string" }
+                      },
+                      required: ["id", "description"]
+                    }
+                  },
+                  acceptanceCriteria: {
+                    type: "array",
+                    items: { type: "string" }
+                  },
+                  testing: { type: "string" },
+                  filesChanged: {
+                    type: "array",
+                    items: { type: "string" }
+                  },
+                  notes: { type: "string" }
+                },
+                required: ["number", "title", "objective", "background", "tasks", "acceptanceCriteria", "testing", "filesChanged", "notes"]
+              }
+            }
+          },
+          required: ["summary", "approach", "successCriteria", "steps"]
+        }
+      }
+    },
+    addMessage: function(i) {
+      this.messages.push(i);
+    }
+  }, a = await n.execute(r, t);
+  return Pt(a.content);
+}
+const _t = `You are an expert project planner and software architect. Your role is to analyze project requirements and create detailed, actionable execution plans.
+
+When creating a plan:
+1. Break down the work into clear, sequential steps
+2. Provide specific, actionable tasks for each step
+3. Define measurable acceptance criteria
+4. Consider dependencies and ordering
+5. Be concrete and specific, not vague or generic
+6. Think about testing and verification at each stage
+
+CRITICAL: You must output ONLY valid JSON. Do not include any text before or after the JSON object. Ensure all strings are properly escaped.`;
+function $t(e) {
+  let n = `Create a detailed execution plan for the following project:
+
+**Project Name**: ${e.planName}
+
+**Description**:
+${e.description}
+`;
+  return e.elaborations && e.elaborations.length > 0 && (n += `
+**Additional Context**:
+`, e.elaborations.forEach((t, s) => {
+    n += `
+${s + 1}. ${t}
+`;
+  })), n += `
+**Requirements**:
+- Generate ${e.stepCount || 5} steps
+- Each step should be focused and achievable
+- Provide specific tasks, not generic placeholders
+- Include concrete acceptance criteria
+- Consider what files or components will be affected
+
+Please provide:
+1. Executive Summary (2-3 paragraphs explaining what this plan accomplishes)
+2. Approach (how you'll tackle this work, key decisions)
+3. Success Criteria (how we'll know the project is complete)
+4. Detailed steps with:
+   - Step title
+   - Objective (what this step accomplishes)
+   - Background (context needed)
+   - Tasks (specific actions to take)
+   - Acceptance criteria (how to verify completion)
+   - Testing approach
+   - Files that will be changed
+   - Any notes or considerations
+
+IMPORTANT: Output ONLY the JSON object below, with no markdown formatting, no code blocks, no additional text. Ensure all strings use proper JSON escaping for quotes and newlines.
+
+JSON structure:
+{
+  "summary": "executive summary text",
+  "approach": "approach description",
+  "successCriteria": "success criteria description",
+  "steps": [
+    {
+      "number": 1,
+      "title": "Step Title",
+      "objective": "what this step accomplishes",
+      "background": "context and prerequisites",
+      "tasks": [
+        {"id": "01.1", "description": "specific task"},
+        {"id": "01.2", "description": "another task"}
+      ],
+      "acceptanceCriteria": ["criterion 1", "criterion 2"],
+      "testing": "how to verify this step",
+      "filesChanged": ["file1.ts", "file2.ts"],
+      "notes": "additional notes"
+    }
+  ]
+}`, n;
+}
+function Pt(e, n) {
+  try {
+    let t = e.trim();
+    const s = t.indexOf("```");
+    if (s !== -1) {
+      const o = t.indexOf("```", s + 3);
+      o !== -1 && (t = t.substring(s + 3, o).trim(), t.startsWith("json") && (t = t.substring(4).trim()));
+    }
+    const r = t.indexOf("{"), a = t.lastIndexOf("}");
+    r !== -1 && a !== -1 && a > r && (t = t.substring(r, a + 1));
+    let i;
+    try {
+      i = JSON.parse(t);
+    } catch {
+      t = t.replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r"), i = JSON.parse(t);
+    }
+    if (!i.summary || !i.approach || !i.successCriteria || !i.steps)
+      throw new Error("Invalid plan structure: missing required fields");
+    return i;
+  } catch (t) {
+    throw new Error(`Failed to parse plan response: ${t instanceof Error ? t.message : "Unknown error"}`);
+  }
+}
+async function xt(e) {
+  const { name: n, apiKey: t } = e;
+  try {
+    switch (n.toLowerCase()) {
+      case "anthropic":
+      case "claude":
+        return await Ct(t);
+      case "openai":
+      case "gpt":
+        return await At(t);
+      case "gemini":
+      case "google":
+        return await Et(t);
+      default:
+        throw new Error(`Unknown provider: ${n}`);
+    }
+  } catch (s) {
+    throw s instanceof Error && s.message.includes("Cannot find package") ? new Error(
+      `Provider '${n}' is not installed. Install it with:
+  npm install @riotprompt/execution-${n}`
+    ) : s;
+  }
+}
+async function Ct(e) {
+  const { createAnthropicProvider: n } = await import("@riotprompt/execution-anthropic");
+  return n();
+}
+async function At(e) {
+  const { createOpenAIProvider: n } = await import("@riotprompt/execution-openai");
+  return n();
+}
+async function Et(e) {
+  const { createGeminiProvider: n } = await import("@riotprompt/execution-gemini");
+  return n();
+}
+async function Dt(e, n) {
+  try {
+    const t = e.provider || "anthropic", s = await xt({
+      name: t,
+      apiKey: process.env[`${t.toUpperCase()}_API_KEY`]
+    }), r = {
+      planName: "Generated Plan",
+      description: e.description,
+      stepCount: e.steps
+    }, a = await kt(r, s, {
+      model: e.model
+    });
+    return C(
+      {
+        summary: a.summary,
+        approach: a.approach,
+        stepsGenerated: a.steps.length,
+        steps: a.steps.map((i) => ({
+          number: i.number,
+          title: i.title,
+          objective: i.objective
+        }))
+      },
+      `Plan generated successfully with ${a.steps.length} steps`
+    );
+  } catch (t) {
+    return x(t);
+  }
+}
+const X = c.object({
+  path: c.string().optional().describe("Path to plan directory"),
+  name: c.string().describe("Checkpoint name (kebab-case)"),
+  message: c.string().describe("Description of why checkpoint created"),
+  capturePrompt: c.boolean().optional().default(!0).describe("Capture conversation context")
+}), Z = c.object({
+  path: c.string().optional().describe("Path to plan directory")
+}), ee = c.object({
+  path: c.string().optional().describe("Path to plan directory"),
+  checkpoint: c.string().describe("Checkpoint name")
+}), te = c.object({
+  path: c.string().optional().describe("Path to plan directory"),
+  checkpoint: c.string().describe("Checkpoint name")
+}), ne = c.object({
+  path: c.string().optional().describe("Path to plan directory"),
+  since: c.string().optional().describe("Show events since this ISO timestamp"),
+  eventType: c.string().optional().describe("Filter by event type"),
+  limit: c.number().optional().describe("Maximum number of events to show")
+});
+async function _(e, n) {
+  const t = u(e, ".history");
+  await $(t, { recursive: !0 });
+  const s = u(t, "timeline.jsonl"), r = JSON.stringify(n) + `
+`;
+  await _e(s, r);
+}
+async function W(e) {
+  const n = u(e, ".history", "timeline.jsonl");
+  try {
+    return (await y(n, "utf-8")).split(`
+`).filter((s) => s.trim()).map((s) => JSON.parse(s));
+  } catch (t) {
+    if (t.code === "ENOENT")
+      return [];
+    throw t;
+  }
+}
+async function It(e) {
+  const n = {
+    timestamp: S(),
+    stage: "unknown",
+    idea: void 0,
+    shaping: void 0,
+    lifecycle: void 0
+  };
+  try {
+    const t = await y(u(e, "IDEA.md"), "utf-8");
+    n.idea = {
+      content: t,
+      exists: !0
+    };
+  } catch {
+    n.idea = { exists: !1 };
+  }
+  try {
+    const t = await y(u(e, "SHAPING.md"), "utf-8");
+    n.shaping = {
+      content: t,
+      exists: !0
+    };
+  } catch {
+    n.shaping = { exists: !1 };
+  }
+  try {
+    const t = await y(u(e, "LIFECYCLE.md"), "utf-8");
+    n.lifecycle = {
+      content: t,
+      exists: !0
+    };
+    const s = t.match(/\*\*Stage\*\*:\s*`(\w+)`/);
+    s && (n.stage = s[1]);
+  } catch {
+    n.lifecycle = { exists: !1 };
+  }
+  return n;
+}
+async function Nt(e) {
+  const n = await W(e);
+  let t = -1;
+  for (let s = n.length - 1; s >= 0; s--)
+    if (n[s].type === "checkpoint_created") {
+      t = s;
+      break;
+    }
+  return t === -1 ? n.length : n.length - t - 1;
+}
+async function se(e) {
+  try {
+    return (await b(e)).filter((t) => t.endsWith(".md"));
+  } catch {
+    return [];
+  }
+}
+async function Tt(e, n) {
+  return (await W(e)).slice(-10).map((r) => `- ${new Date(r.timestamp).toLocaleString()}: ${r.type} - ${JSON.stringify(r.data)}`).join(`
+`);
+}
+function ae(e) {
+  let n = "";
+  return e.stage && (n += `**Current Stage**: ${e.stage}
+
+`), e.idea?.exists && (n += `### IDEA.md
+
+${e.idea.content}
+
+`), e.shaping?.exists && (n += `### SHAPING.md
+
+${e.shaping.content}
+
+`), n;
+}
+async function Ft(e, n, t, s) {
+  const r = u(e, ".history", "prompts");
+  await $(r, { recursive: !0 });
+  const a = `# Checkpoint: ${n}
+
+**Timestamp**: ${t.timestamp}
+**Stage**: ${t.stage || "unknown"}
+**Message**: ${s}
+
+## Current State
+
+${ae(t)}
+
+## Files at This Point
+
+${(await se(e)).map((i) => `- ${i}`).join(`
+`)}
+
+## Recent Timeline
+
+${await Tt(e)}
+
+---
+
+This checkpoint captures the state of the plan at this moment in time.
+You can restore to this checkpoint using: \`riotplan_checkpoint_restore({ checkpoint: "${n}" })\`
+`;
+  await w(
+    u(r, `${n}.md`),
+    a
+  );
+}
+async function Ot(e) {
+  const n = e.path || process.cwd(), { name: t, message: s, capturePrompt: r } = e, a = u(n, ".history", "checkpoints");
+  await $(a, { recursive: !0 });
+  const i = await It(n), o = {
+    name: t,
+    timestamp: i.timestamp,
+    message: s,
+    stage: i.stage,
+    snapshot: {
+      timestamp: i.timestamp,
+      idea: i.idea,
+      shaping: i.shaping,
+      lifecycle: i.lifecycle
+    },
+    context: {
+      filesChanged: await se(n),
+      eventsSinceLastCheckpoint: await Nt(n)
+    }
+  };
+  await w(
+    u(a, `${t}.json`),
+    JSON.stringify(o, null, 2)
+  ), r && await Ft(n, t, i, s);
+  const p = {
+    timestamp: i.timestamp,
+    type: "checkpoint_created",
+    data: {
+      name: t,
+      message: s,
+      snapshotPath: `.history/checkpoints/${t}.json`,
+      promptPath: `.history/prompts/${t}.md`
+    }
+  };
+  return await _(n, p), `✅ Checkpoint created: ${t}
+
+Location: ${n}/.history/checkpoints/${t}.json
+Prompt: ${n}/.history/prompts/${t}.md
+
+You can restore this checkpoint later with:
+  riotplan_checkpoint_restore({ checkpoint: "${t}" })`;
+}
+async function jt(e) {
+  const n = e.path || process.cwd(), t = u(n, ".history", "checkpoints");
+  try {
+    const r = (await b(t)).filter((i) => i.endsWith(".json"));
+    if (r.length === 0)
+      return "No checkpoints found.";
+    let a = `Found ${r.length} checkpoint(s):
+
+`;
+    for (const i of r) {
+      const o = await y(u(t, i), "utf-8"), p = JSON.parse(o), d = new Date(p.timestamp).toLocaleString();
+      a += `- **${p.name}** (${d})
+`, a += `  Stage: ${p.stage}
+`, a += `  Message: ${p.message}
+`, a += `  Events since last: ${p.context.eventsSinceLastCheckpoint}
+
+`;
+    }
+    return a;
+  } catch (s) {
+    if (s.code === "ENOENT")
+      return "No checkpoints found.";
+    throw s;
+  }
+}
+async function Rt(e) {
+  const n = e.path || process.cwd(), t = u(n, ".history", "checkpoints", `${e.checkpoint}.json`), s = await y(t, "utf-8"), r = JSON.parse(s), a = new Date(r.timestamp).toLocaleString();
+  let i = `# Checkpoint: ${r.name}
+
+`;
+  return i += `**Created**: ${a}
+`, i += `**Stage**: ${r.stage}
+`, i += `**Message**: ${r.message}
+
+`, i += `## Context
+
+`, i += `- Files changed: ${r.context.filesChanged.join(", ")}
+`, i += `- Events since last checkpoint: ${r.context.eventsSinceLastCheckpoint}
+
+`, i += `## Snapshot
+
+`, i += `${ae(r.snapshot)}
+`, i += `
+---
+
+`, i += `View full prompt context: ${n}/.history/prompts/${e.checkpoint}.md
+`, i += `Restore: riotplan_checkpoint_restore({ checkpoint: "${e.checkpoint}" })`, i;
+}
+async function Lt(e) {
+  const n = e.path || process.cwd(), t = u(n, ".history", "checkpoints", `${e.checkpoint}.json`), s = await y(t, "utf-8"), r = JSON.parse(s);
+  r.snapshot.idea?.exists && r.snapshot.idea.content && await w(u(n, "IDEA.md"), r.snapshot.idea.content), r.snapshot.shaping?.exists && r.snapshot.shaping.content && await w(u(n, "SHAPING.md"), r.snapshot.shaping.content), r.snapshot.lifecycle?.exists && r.snapshot.lifecycle.content && await w(u(n, "LIFECYCLE.md"), r.snapshot.lifecycle.content);
+  const a = {
+    timestamp: S(),
+    type: "checkpoint_restored",
+    data: {
+      checkpoint: e.checkpoint,
+      restoredFrom: r.timestamp
+    }
+  };
+  return await _(n, a), `✅ Restored to checkpoint: ${e.checkpoint}
+
+Restored from: ${r.timestamp}
+Stage: ${r.stage}
+
+Files restored:
+${r.context.filesChanged.map((i) => `  - ${i}`).join(`
+`)}`;
+}
+async function Mt(e) {
+  const n = e.path || process.cwd();
+  let t = await W(n);
+  if (t.length === 0)
+    return "No history events found.";
+  if (e.since) {
+    const r = new Date(e.since).getTime();
+    t = t.filter((a) => new Date(a.timestamp).getTime() >= r);
+  }
+  e.eventType && (t = t.filter((r) => r.type === e.eventType)), e.limit && (t = t.slice(-e.limit));
+  let s = `# Ideation History
+
+`;
+  s += `Total events: ${t.length}
+
+`;
+  for (const r of t) {
+    const a = new Date(r.timestamp).toLocaleString();
+    s += `## ${a} - ${r.type}
+
+`, s += `\`\`\`json
+${JSON.stringify(r.data, null, 2)}
+\`\`\`
+
+`;
+  }
+  return s;
+}
+async function qt(e, n) {
+  try {
+    const t = X.parse(e);
+    return { success: !0, data: { message: await Ot(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function Ut(e, n) {
+  try {
+    const t = Z.parse(e);
+    return { success: !0, data: { message: await jt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function Gt(e, n) {
+  try {
+    const t = ee.parse(e);
+    return { success: !0, data: { message: await Rt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function Wt(e, n) {
+  try {
+    const t = te.parse(e);
+    return { success: !0, data: { message: await Lt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function Bt(e, n) {
+  try {
+    const t = ne.parse(e);
+    return { success: !0, data: { message: await Mt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+X.shape;
+Z.shape;
+ee.shape;
+te.shape;
+ne.shape;
+const re = c.object({
+  code: c.string().describe("Plan identifier (kebab-case)"),
+  description: c.string().describe("Initial idea description"),
+  directory: c.string().optional().describe("Parent directory for the idea")
+}), ie = c.object({
+  path: c.string().optional().describe("Path to idea directory"),
+  note: c.string().describe("Note to add to the idea")
+}), oe = c.object({
+  path: c.string().optional().describe("Path to idea directory"),
+  constraint: c.string().describe("Constraint to add")
+}), ce = c.object({
+  path: c.string().optional().describe("Path to idea directory"),
+  question: c.string().describe("Question to add")
+}), pe = c.object({
+  path: c.string().optional().describe("Path to idea directory"),
+  evidencePath: c.string().optional().describe("Path to evidence file, or 'inline' for pasted text"),
+  description: c.string().describe("Description of the evidence and its relevance"),
+  content: c.string().optional().describe("Inline content if evidencePath is 'inline' (for pasted text/transcripts)"),
+  source: c.string().optional().describe("Where evidence came from (e.g., 'web search', 'user paste', 'file analysis')"),
+  gatheringMethod: c.enum(["manual", "model-assisted"]).optional().describe("How evidence was gathered"),
+  relevanceScore: c.number().min(0).max(1).optional().describe("Relevance score (0-1) from model if model-assisted"),
+  summary: c.string().optional().describe("Model-generated summary of the evidence")
+}), de = c.object({
+  path: c.string().optional().describe("Path to idea directory"),
+  content: c.string().describe("Raw narrative content (thoughts, observations, context)"),
+  source: c.enum(["typing", "voice", "paste", "import"]).optional().describe("Source of the narrative"),
+  context: c.string().optional().describe("Context about what prompted this narrative"),
+  speaker: c.string().optional().describe("Who is speaking (user, assistant, or name)")
+}), le = c.object({
+  path: c.string().optional().describe("Path to idea directory"),
+  reason: c.string().describe("Reason for killing the idea")
+});
+async function Ht(e) {
+  const { code: n, description: t, directory: s } = e, r = s || process.cwd(), a = u(r, n);
+  await $(a, { recursive: !0 });
+  const i = `# Idea: ${n}
+
+## Core Concept
+
+${t}
+
+## Why This Matters
+
+_Why pursue this idea?_
+
+## Initial Thoughts
+
+- _Add your thoughts..._
+
+## Constraints
+
+- _Add constraints..._
+
+## Questions
+
+- _Add questions..._
+
+## Evidence
+
+_Attach relevant documents, images, or files_
+
+## Related Ideas
+
+- _Link to related ideas..._
+
+## Status
+
+**Stage**: idea
+**Created**: ${S()}
+**Next**: Decide if worth shaping
+
+## Notes
+
+_Add notes as you think about this..._
+`;
+  await w(u(a, "IDEA.md"), i, "utf-8");
+  const o = `# Lifecycle
+
+## Current Stage
+
+**Stage**: \`idea\`
+**Since**: ${S()}
+
+## State History
+
+| From | To | When | Reason |
+|------|-----|------|--------|
+| - | idea | ${S()} | Initial creation |
+
+## Stage-Specific Data
+
+### Idea
+- Core concept: ${t}
+- Notes: []
+- Constraints: []
+- Questions: []
+- Evidence: []
+`;
+  return await w(u(a, "LIFECYCLE.md"), o, "utf-8"), await _(a, {
+    timestamp: S(),
+    type: "idea_created",
+    data: { code: n, description: t }
+  }), `✅ Idea created: ${a}
+
+Next steps:
+- Add notes: riotplan_idea_add_note
+- Add constraints: riotplan_idea_add_constraint
+- Add questions: riotplan_idea_add_question
+- Add evidence: riotplan_idea_add_evidence
+- When ready: riotplan_transition to 'shaping'`;
+}
+async function Jt(e) {
+  const n = e.path || process.cwd(), t = u(n, "IDEA.md");
+  let s = await y(t, "utf-8");
+  const r = "## Initial Thoughts", a = s.indexOf(r);
+  if (a === -1)
+    throw new Error("Could not find Initial Thoughts section in IDEA.md");
+  const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i, p = `- ${e.note}
+`;
+  return s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "note_added",
+    data: { note: e.note }
+  }), "✅ Note added to idea";
+}
+async function Yt(e) {
+  const n = e.path || process.cwd(), t = u(n, "IDEA.md");
+  let s = await y(t, "utf-8");
+  const r = "## Constraints", a = s.indexOf(r);
+  if (a === -1)
+    throw new Error("Could not find Constraints section in IDEA.md");
+  const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i, p = `- ${e.constraint}
+`;
+  return s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "constraint_added",
+    data: { constraint: e.constraint }
+  }), "✅ Constraint added to idea";
+}
+async function Kt(e) {
+  const n = e.path || process.cwd(), t = u(n, "IDEA.md");
+  let s = await y(t, "utf-8");
+  const r = "## Questions", a = s.indexOf(r);
+  if (a === -1)
+    throw new Error("Could not find Questions section in IDEA.md");
+  const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i, p = `- ${e.question}
+`;
+  return s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "question_added",
+    data: { question: e.question }
+  }), "✅ Question added to idea";
+}
+async function Vt(e) {
+  const n = e.path || process.cwd(), t = u(n, "IDEA.md");
+  let s = e.evidencePath, r;
+  if (s === "inline" || e.content) {
+    if (!e.content)
+      throw new Error("Content is required when evidencePath is 'inline'");
+    const f = u(n, "evidence");
+    await $(f, { recursive: !0 }), r = `evidence-${Date.now()}`;
+    const m = u(f, `${r}.md`), g = `# Evidence: ${e.description}
+
+**Source**: ${e.source || "user paste"}
+**Added**: ${S()}
+` + (e.gatheringMethod ? `**Gathering Method**: ${e.gatheringMethod}
+` : "") + (e.relevanceScore !== void 0 ? `**Relevance Score**: ${e.relevanceScore}
+` : "") + `
+---
+
+${e.content}`;
+    await w(m, g), s = `evidence/${r}.md`;
+  }
+  let a = await y(t, "utf-8");
+  const i = "## Evidence", o = a.indexOf(i);
+  if (o === -1)
+    throw new Error("Could not find Evidence section in IDEA.md");
+  const p = a.indexOf(`
+## `, o + i.length), d = p === -1 ? a.length : p, l = `- [${e.description}](${s})${e.source ? ` (${e.source})` : ""}
+`;
+  return a = a.slice(0, d) + l + a.slice(d), await w(t, a, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "evidence_added",
+    data: {
+      evidencePath: s,
+      description: e.description,
+      source: e.source,
+      gatheringMethod: e.gatheringMethod,
+      relevanceScore: e.relevanceScore,
+      summary: e.summary,
+      evidenceId: r
+    }
+  }), `✅ Evidence added: ${e.description}${r ? ` (ID: ${r})` : ""}`;
+}
+async function Qt(e) {
+  const n = e.path || process.cwd(), t = S();
+  await _(n, {
+    timestamp: t,
+    type: "narrative_chunk",
+    data: {
+      content: e.content,
+      source: e.source,
+      context: e.context,
+      speaker: e.speaker || "user"
+    }
+  });
+  const s = u(n, ".history"), r = u(s, "prompts");
+  await $(r, { recursive: !0 });
+  let a = [];
+  try {
+    a = await b(r);
+  } catch {
+    a = [];
+  }
+  const i = a.filter((m) => /^\d{3}-.*\.md$/.test(m)).sort(), o = i.length > 0 ? parseInt(i[i.length - 1].substring(0, 3)) + 1 : 1, p = e.context ? e.context.toLowerCase().replace(/[^a-z0-9]+/g, "-").substring(0, 50) : "narrative", d = `${String(o).padStart(3, "0")}-${p}.md`, l = u(r, d), f = `# Narrative: ${e.context || "User Input"}
+
+**Date**: ${t}
+**Source**: ${e.source || "unknown"}
+**Speaker**: ${e.speaker || "user"}
+
+---
+
+${e.content}
+`;
+  return await w(l, f, "utf-8"), `✅ Narrative saved to timeline and ${d} (${e.content.length} characters)`;
+}
+async function zt(e) {
+  const n = e.path || process.cwd(), t = u(n, "IDEA.md");
+  let s = await y(t, "utf-8");
+  const r = "## Status", a = s.indexOf(r);
+  if (a !== -1) {
+    const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i, p = `
+**Killed**: ${S()}
+**Reason**: ${e.reason}
+`;
+    s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8");
+  }
+  return await _(n, {
+    timestamp: S(),
+    type: "idea_killed",
+    data: { reason: e.reason }
+  }), `✅ Idea killed: ${e.reason}`;
+}
+async function Xt(e, n) {
+  try {
+    const t = re.parse(e);
+    return { success: !0, data: { message: await Ht(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function Zt(e, n) {
+  try {
+    const t = ie.parse(e);
+    return { success: !0, data: { message: await Jt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function en(e, n) {
+  try {
+    const t = oe.parse(e);
+    return { success: !0, data: { message: await Yt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function tn(e, n) {
+  try {
+    const t = ce.parse(e);
+    return { success: !0, data: { message: await Kt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function nn(e, n) {
+  try {
+    const t = pe.parse(e);
+    return { success: !0, data: { message: await Vt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function sn(e, n) {
+  try {
+    const t = de.parse(e);
+    return { success: !0, data: { message: await Qt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function an(e, n) {
+  try {
+    const t = le.parse(e);
+    return { success: !0, data: { message: await zt(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+re.shape;
+ie.shape;
+oe.shape;
+ce.shape;
+pe.shape;
+de.shape;
+le.shape;
+const ue = c.object({
+  path: c.string().optional().describe("Path to idea directory")
+}), he = c.object({
+  path: c.string().optional().describe("Path to shaping directory"),
+  name: c.string().describe("Name of the approach"),
+  description: c.string().describe("Description of the approach"),
+  tradeoffs: c.array(c.string()).optional().describe("List of tradeoffs (pros/cons)"),
+  assumptions: c.array(c.string()).optional().describe("Key assumptions")
+}), me = c.object({
+  path: c.string().optional().describe("Path to shaping directory"),
+  feedback: c.string().describe("Feedback about the current shaping")
+}), fe = c.object({
+  path: c.string().optional().describe("Path to shaping directory"),
+  evidencePath: c.string().describe("Path to evidence file"),
+  description: c.string().optional().describe("Description of the evidence"),
+  relatedTo: c.string().optional().describe("Which approach this evidence relates to")
+}), ge = c.object({
+  path: c.string().optional().describe("Path to shaping directory")
+}), ye = c.object({
+  path: c.string().optional().describe("Path to shaping directory"),
+  approach: c.string().describe("Name of the selected approach"),
+  reason: c.string().describe("Reason for selecting this approach")
+});
+async function rn(e) {
+  const n = e.path || process.cwd(), t = `# Shaping: [Name]
+
+## Problem Statement
+
+_What problem are we solving? What are we trying to achieve?_
+
+## Approaches Considered
+
+_Add approaches using riotplan_shaping_add_approach_
+
+## Feedback
+
+_Feedback will be added here as you provide it_
+
+## Evidence
+
+_Evidence will be added here to support decision-making_
+
+## Key Decisions
+
+_Decisions will be tracked here_
+
+## Open Questions
+
+- _What questions need answering?_
+
+## Status
+
+**Stage**: shaping
+**Started**: ${S()}
+**Next**: Select an approach and transition to 'built'
+`;
+  await w(u(n, "SHAPING.md"), t, "utf-8");
+  const s = u(n, "LIFECYCLE.md");
+  let r = await y(s, "utf-8");
+  r = r.replace(
+    /\*\*Stage\*\*: `\w+`/,
+    "**Stage**: `shaping`"
+  ), r = r.replace(
+    /\*\*Since\*\*: .+/,
+    `**Since**: ${S()}`
+  );
+  const a = r.indexOf("| From | To | When | Reason |");
+  if (a !== -1) {
+    const i = r.indexOf(`
+`, a + 50), o = `| idea | shaping | ${S()} | Ready to explore approaches |
+`;
+    r = r.slice(0, i + 1) + o + r.slice(i + 1);
+  }
+  return await w(s, r, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "shaping_started",
+    data: {}
+  }), `✅ Shaping started
+
+Next steps:
+- Add approaches: riotplan_shaping_add_approach
+- Provide feedback: riotplan_shaping_add_feedback
+- Add evidence: riotplan_shaping_add_evidence
+- Compare approaches: riotplan_shaping_compare
+- When ready: riotplan_shaping_select`;
+}
+async function on(e) {
+  const n = e.path || process.cwd(), t = u(n, "SHAPING.md");
+  let s = await y(t, "utf-8");
+  const r = "## Approaches Considered", a = s.indexOf(r);
+  if (a === -1)
+    throw new Error("Could not find Approaches Considered section in SHAPING.md");
+  const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i;
+  let p = `
+### Approach: ${e.name}
+
+`;
+  return p += `**Description**: ${e.description}
+
+`, e.tradeoffs && e.tradeoffs.length > 0 && (p += `**Tradeoffs**:
+`, e.tradeoffs.forEach((d) => {
+    p += `- ${d}
+`;
+  }), p += `
+`), e.assumptions && e.assumptions.length > 0 && (p += `**Assumptions**:
+`, e.assumptions.forEach((d) => {
+    p += `- ${d}
+`;
+  }), p += `
+`), s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "approach_added",
+    data: {
+      name: e.name,
+      description: e.description,
+      tradeoffs: e.tradeoffs,
+      assumptions: e.assumptions
+    }
+  }), `✅ Approach added: ${e.name}`;
+}
+async function cn(e) {
+  const n = e.path || process.cwd(), t = u(n, "SHAPING.md");
+  let s = await y(t, "utf-8");
+  const r = "## Feedback", a = s.indexOf(r);
+  if (a === -1)
+    throw new Error("Could not find Feedback section in SHAPING.md");
+  const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i, p = `
+### ${S()}
+
+${e.feedback}
+`;
+  return s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "feedback_added",
+    data: { feedback: e.feedback }
+  }), "✅ Feedback added";
+}
+async function pn(e) {
+  const n = e.path || process.cwd(), t = u(n, "SHAPING.md");
+  let s = await y(t, "utf-8");
+  const r = "## Evidence", a = s.indexOf(r);
+  if (a === -1)
+    throw new Error("Could not find Evidence section in SHAPING.md");
+  const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i;
+  let p = `
+- [${e.evidencePath}](${e.evidencePath})`;
+  return e.description && (p += ` - ${e.description}`), e.relatedTo && (p += ` (relates to: ${e.relatedTo})`), p += `
+`, s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8"), await _(n, {
+    timestamp: S(),
+    type: "evidence_added",
+    data: {
+      evidencePath: e.evidencePath,
+      description: e.description,
+      relatedTo: e.relatedTo
+    }
+  }), "✅ Evidence added";
+}
+async function dn(e) {
+  const n = e.path || process.cwd(), t = u(n, "SHAPING.md"), s = await y(t, "utf-8"), r = s.indexOf("## Approaches Considered"), a = s.indexOf(`
+## `, r + 25), i = s.slice(r, a !== -1 ? a : void 0), o = i.match(/### Approach: (.+)/g) || [];
+  if (o.length === 0)
+    return "No approaches found. Add approaches first using riotplan_shaping_add_approach";
+  let p = `## Approach Comparison
+
+`;
+  return o.forEach((d) => {
+    const l = d.replace("### Approach: ", "");
+    p += `**${l}**
+`;
+    const f = i.indexOf(d), m = i.indexOf("### Approach:", f + 1), v = i.slice(
+      f,
+      m !== -1 ? m : void 0
+    ).match(/\*\*Tradeoffs\*\*:\n((?:- .+\n)+)/);
+    v && (p += v[1]), p += `
+`;
+  }), await _(n, {
+    timestamp: S(),
+    type: "approach_compared",
+    data: { approachCount: o.length }
+  }), p;
+}
+async function ln(e) {
+  const n = e.path || process.cwd(), t = u(n, "SHAPING.md");
+  let s = await y(t, "utf-8");
+  const r = "## Key Decisions", a = s.indexOf(r);
+  if (a !== -1) {
+    const i = s.indexOf(`
+## `, a + r.length), o = i === -1 ? s.length : i, p = `
+**Selected Approach**: ${e.approach}
+
+**Reasoning**: ${e.reason}
+
+**Selected At**: ${S()}
+`;
+    s = s.slice(0, o) + p + s.slice(o), await w(t, s, "utf-8");
+  }
+  return await _(n, {
+    timestamp: S(),
+    type: "approach_selected",
+    data: {
+      approach: e.approach,
+      reason: e.reason
+    }
+  }), `✅ Approach selected: ${e.approach}
+
+Next: Transition to 'built' stage to generate detailed plan:
+  riotplan_transition({ stage: "built", reason: "Approach selected: ${e.approach}" })`;
+}
+async function un(e, n) {
+  try {
+    const t = ue.parse(e);
+    return { success: !0, data: { message: await rn(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function hn(e, n) {
+  try {
+    const t = he.parse(e);
+    return { success: !0, data: { message: await on(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function mn(e, n) {
+  try {
+    const t = me.parse(e);
+    return { success: !0, data: { message: await cn(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function fn(e, n) {
+  try {
+    const t = fe.parse(e);
+    return { success: !0, data: { message: await pn(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function gn(e, n) {
+  try {
+    const t = ge.parse(e);
+    return { success: !0, data: { message: await dn(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+async function yn(e, n) {
+  try {
+    const t = ye.parse(e);
+    return { success: !0, data: { message: await ln(t) } };
+  } catch (t) {
+    return { success: !1, error: t.message };
+  }
+}
+ue.shape;
+he.shape;
+me.shape;
+fe.shape;
+ge.shape;
+ye.shape;
+async function wn(e, n, t) {
+  try {
+    switch (e) {
+      case "riotplan_create":
+        return await Te(n, t);
+      case "riotplan_status":
+        return await Ve(n, t);
+      case "riotplan_step_list":
+        return await lt(n, t);
+      case "riotplan_step_start":
+        return await ut(n, t);
+      case "riotplan_step_complete":
+        return await ht(n, t);
+      case "riotplan_step_add":
+        return await mt(n, t);
+      case "riotplan_validate":
+        return await bt(n, t);
+      case "riotplan_generate":
+        return await Dt(n, t);
+      // Idea tools
+      case "riotplan_idea_create":
+        return await Xt(n, t);
+      case "riotplan_idea_add_note":
+        return await Zt(n, t);
+      case "riotplan_idea_add_constraint":
+        return await en(n, t);
+      case "riotplan_idea_add_question":
+        return await tn(n, t);
+      case "riotplan_idea_add_evidence":
+        return await nn(n, t);
+      case "riotplan_idea_add_narrative":
+        return await sn(n, t);
+      case "riotplan_idea_kill":
+        return await an(n, t);
+      // Shaping tools
+      case "riotplan_shaping_start":
+        return await un(n, t);
+      case "riotplan_shaping_add_approach":
+        return await hn(n, t);
+      case "riotplan_shaping_add_feedback":
+        return await mn(n, t);
+      case "riotplan_shaping_add_evidence":
+        return await fn(n, t);
+      case "riotplan_shaping_compare":
+        return await gn(n, t);
+      case "riotplan_shaping_select":
+        return await yn(n, t);
+      // History and checkpoint tools
+      case "riotplan_checkpoint_create":
+        return await qt(n, t);
+      case "riotplan_checkpoint_list":
+        return await Ut(n, t);
+      case "riotplan_checkpoint_show":
+        return await Gt(n, t);
+      case "riotplan_checkpoint_restore":
+        return await Wt(n, t);
+      case "riotplan_history_show":
+        return await Bt(n, t);
+      default:
+        return {
+          success: !1,
+          error: `Unknown tool: ${e}`
+        };
+    }
+  } catch (s) {
+    return {
+      success: !1,
+      error: s instanceof Error ? s.message : String(s),
+      context: {
+        errorType: s?.constructor?.name || "Error"
+      }
+    };
+  }
+}
+async function Sn(e) {
+  if (!$e(e))
+    return {
+      path: e,
+      code: "",
+      name: "",
+      exists: !1
+    };
+  try {
+    const t = await P(e);
+    return {
+      path: t.metadata.path,
+      code: t.metadata.code,
+      name: t.metadata.name,
+      exists: !0,
+      metadata: {
+        code: t.metadata.code,
+        name: t.metadata.name,
+        description: t.metadata.description,
+        created: t.metadata.createdAt
+      },
+      state: {
+        status: t.state.status,
+        currentStep: t.state.currentStep,
+        lastCompleted: t.state.lastCompletedStep,
+        startedAt: t.state.startedAt,
+        lastUpdated: t.state.lastUpdatedAt
+      }
+    };
+  } catch (t) {
+    throw new Error(`Failed to read plan at ${e}: ${t}`);
+  }
+}
+async function vn(e) {
+  try {
+    const n = await P(e), t = n.steps.filter((a) => a.status === "completed").length, s = n.steps.length, r = s > 0 ? Math.round(t / s * 100) : 0;
+    return {
+      planPath: n.metadata.path,
+      status: n.state.status,
+      currentStep: n.state.currentStep,
+      lastCompleted: n.state.lastCompletedStep,
+      progress: {
+        completed: t,
+        total: s,
+        percentage: r
+      },
+      blockers: (n.state.blockers || []).map(
+        (a) => typeof a == "string" ? a : `${a.severity}: ${a.description}`
+      ),
+      issues: (n.state.issues || []).map(
+        (a) => typeof a == "string" ? a : `${a.severity}: ${a.description}`
+      )
+    };
+  } catch (n) {
+    throw new Error(`Failed to read status at ${e}: ${n}`);
+  }
+}
+async function bn(e) {
+  try {
+    const n = await P(e);
+    return {
+      planPath: n.metadata.path,
+      steps: n.steps.map((t) => ({
+        number: t.number,
+        title: t.title,
+        status: t.status,
+        file: t.filename
+      }))
+    };
+  } catch (n) {
+    throw new Error(`Failed to read steps at ${e}: ${n}`);
+  }
+}
+async function kn(e, n) {
+  try {
+    const t = await P(e), s = t.steps.find((i) => i.number === n);
+    if (!s)
+      throw new Error(`Step ${n} not found in plan`);
+    const r = u(t.metadata.path, "plan", s.filename), a = Y(r, "utf-8");
+    return {
+      planPath: t.metadata.path,
+      number: s.number,
+      title: s.title,
+      status: s.status,
+      file: s.filename,
+      content: a
+    };
+  } catch (t) {
+    throw new Error(`Failed to read step ${n} at ${e}: ${t}`);
+  }
+}
+async function _n(e) {
+  const n = u(e, "IDEA.md");
+  try {
+    const t = await y(n, "utf-8");
+    return {
+      path: n,
+      content: t,
+      type: "idea"
+    };
+  } catch (t) {
+    throw t.code === "ENOENT" ? new Error(`IDEA.md not found at ${n}. This may not be an idea/plan directory.`) : t;
+  }
+}
+async function $n(e) {
+  const n = u(e, ".history", "timeline.jsonl");
+  try {
+    const s = (await y(n, "utf-8")).trim().split(`
+`).filter((r) => r.trim()).map((r) => JSON.parse(r));
+    return {
+      path: n,
+      events: s,
+      count: s.length,
+      type: "timeline"
+    };
+  } catch (t) {
+    throw t.code === "ENOENT" ? new Error(`Timeline not found at ${n}. This may not have history tracking enabled.`) : t;
+  }
+}
+async function Pn(e) {
+  const n = u(e, ".history", "prompts");
+  try {
+    const s = (await b(n)).filter((r) => r.endsWith(".md")).sort();
+    return {
+      path: n,
+      prompts: s,
+      count: s.length,
+      type: "prompts_list"
+    };
+  } catch (t) {
+    if (t.code === "ENOENT")
+      return {
+        path: n,
+        prompts: [],
+        count: 0,
+        type: "prompts_list",
+        note: "No prompts directory found"
+      };
+    throw t;
+  }
+}
+async function xn(e, n) {
+  const t = u(e, ".history", "prompts", n);
+  try {
+    const s = await y(t, "utf-8");
+    return {
+      path: t,
+      file: n,
+      content: s,
+      type: "prompt"
+    };
+  } catch (s) {
+    throw s.code === "ENOENT" ? new Error(`Prompt file not found: ${n}`) : s;
+  }
+}
+async function Cn(e) {
+  const n = u(e, "evidence");
+  try {
+    const t = await b(n), s = await Promise.all(
+      t.map(async (r) => {
+        const a = u(n, r), i = await j(a);
+        return {
+          name: r,
+          size: i.size,
+          modified: i.mtime
+        };
+      })
+    );
+    return {
+      path: n,
+      evidence: s,
+      count: s.length,
+      type: "evidence_list"
+    };
+  } catch (t) {
+    if (t.code === "ENOENT")
+      return {
+        path: n,
+        evidence: [],
+        count: 0,
+        type: "evidence_list",
+        note: "No evidence directory found"
+      };
+    throw t;
+  }
+}
+async function An(e, n) {
+  const t = u(e, "evidence", n);
+  try {
+    const s = await y(t, "utf-8"), r = await j(t);
+    return {
+      path: t,
+      file: n,
+      content: s,
+      size: r.size,
+      modified: r.mtime,
+      type: "evidence"
+    };
+  } catch (s) {
+    throw s.code === "ENOENT" ? new Error(`Evidence file not found: ${n}`) : s;
+  }
+}
+async function En(e) {
+  const n = u(e, "SHAPING.md");
+  try {
+    const t = await y(n, "utf-8");
+    return {
+      path: n,
+      content: t,
+      type: "shaping"
+    };
+  } catch (t) {
+    if (t.code === "ENOENT")
+      return {
+        path: n,
+        content: null,
+        type: "shaping",
+        note: "No shaping file found - idea may not have been shaped yet"
+      };
+    throw t;
+  }
+}
+async function Dn(e) {
+  const n = u(e, ".history", "checkpoints");
+  try {
+    const t = await b(n), s = await Promise.all(
+      t.filter((r) => r.endsWith(".json")).map(async (r) => {
+        const a = u(n, r), i = await j(a);
+        return {
+          name: r.replace(".json", ""),
+          file: r,
+          created: i.mtime
+        };
+      })
+    );
+    return s.sort((r, a) => a.created.getTime() - r.created.getTime()), {
+      path: n,
+      checkpoints: s,
+      count: s.length,
+      type: "checkpoints_list"
+    };
+  } catch (t) {
+    if (t.code === "ENOENT")
+      return {
+        path: n,
+        checkpoints: [],
+        count: 0,
+        type: "checkpoints_list",
+        note: "No checkpoints directory found"
+      };
+    throw t;
+  }
+}
+async function In(e, n) {
+  const t = u(e, ".history", "checkpoints", `${n}.json`), s = u(e, ".history", "prompts", `${n}.md`);
+  try {
+    const r = await y(t, "utf-8"), a = JSON.parse(r);
+    let i = null;
+    try {
+      i = await y(s, "utf-8");
+    } catch {
+    }
+    return {
+      path: t,
+      name: n,
+      checkpoint: a,
+      prompt: i,
+      type: "checkpoint"
+    };
+  } catch (r) {
+    throw r.code === "ENOENT" ? new Error(`Checkpoint not found: ${n}`) : r;
+  }
+}
+function Nn(e) {
+  if (!e.startsWith("riotplan://"))
+    throw new Error(`Invalid riotplan URI: ${e}`);
+  const n = e.slice(11), [t, s] = n.split("?"), r = t.split("/"), a = r[0], i = r.slice(1).join("/") || void 0, o = {};
+  if (s) {
+    const p = new URLSearchParams(s);
+    for (const [d, l] of p.entries())
+      o[d] = l;
+  }
+  return {
+    scheme: "riotplan",
+    type: a,
+    path: i,
+    query: Object.keys(o).length > 0 ? o : void 0
+  };
+}
+function Tn() {
+  return [
+    // Plan execution resources
+    {
+      uri: "riotplan://plan/{path}",
+      name: "Plan",
+      description: "Read plan metadata and structure",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://status/{path}",
+      name: "Status",
+      description: "Read plan status and progress",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://steps/{path}",
+      name: "Steps",
+      description: "List all steps in a plan",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://step/{path}/{number}",
+      name: "Step",
+      description: "Read a specific step with full content",
+      mimeType: "application/json"
+    },
+    // Ideation context resources
+    {
+      uri: "riotplan://idea/{path}",
+      name: "Idea",
+      description: "Read IDEA.md file with core concept, constraints, questions, and evidence",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://timeline/{path}",
+      name: "Timeline",
+      description: "Read .history/timeline.jsonl with full evolution of thinking (notes, narratives, decisions)",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://prompts/{path}",
+      name: "Prompts List",
+      description: "List all prompt files in .history/prompts/ directory",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://prompt/{path}/{file}",
+      name: "Prompt",
+      description: "Read a specific prompt file with conversational context",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://evidence/{path}",
+      name: "Evidence List",
+      description: "List all evidence files in evidence/ directory",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://evidence-file/{path}/{file}",
+      name: "Evidence File",
+      description: "Read a specific evidence file",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://shaping/{path}",
+      name: "Shaping",
+      description: "Read SHAPING.md with approaches, tradeoffs, and selected approach",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://checkpoints/{path}",
+      name: "Checkpoints List",
+      description: "List all checkpoints in .history/checkpoints/ directory",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotplan://checkpoint/{path}/{name}",
+      name: "Checkpoint",
+      description: "Read a specific checkpoint with snapshot and prompt context",
+      mimeType: "application/json"
+    }
+  ];
+}
+async function Fn(e) {
+  const n = Nn(e);
+  switch (n.type) {
+    // Plan execution resources
+    case "plan":
+      return await Sn(n.path || ".");
+    case "status":
+      return await vn(n.path || ".");
+    case "steps":
+      return await bn(n.path || ".");
+    case "step": {
+      const t = n.query?.number ? parseInt(n.query.number) : void 0;
+      if (!t)
+        throw new Error("Step number is required for step resource");
+      return await kn(n.path || ".", t);
+    }
+    // Ideation context resources
+    case "idea":
+      return await _n(n.path || ".");
+    case "timeline":
+      return await $n(n.path || ".");
+    case "prompts":
+      return await Pn(n.path || ".");
+    case "prompt": {
+      const t = n.query?.file;
+      if (!t)
+        throw new Error("File name is required for prompt resource");
+      return await xn(n.path || ".", t);
+    }
+    case "evidence":
+      return await Cn(n.path || ".");
+    case "evidence-file": {
+      const t = n.query?.file;
+      if (!t)
+        throw new Error("File name is required for evidence resource");
+      return await An(n.path || ".", t);
+    }
+    case "shaping":
+      return await En(n.path || ".");
+    case "checkpoints":
+      return await Dn(n.path || ".");
+    case "checkpoint": {
+      const t = n.query?.name;
+      if (!t)
+        throw new Error("Checkpoint name is required for checkpoint resource");
+      return await In(n.path || ".", t);
+    }
+    default:
+      throw new Error(`Unknown resource type: ${n.type}`);
+  }
+}
+const L = Pe(import.meta.url), F = be(L);
+function On() {
+  return F.includes("/dist") || F.endsWith("dist") || L.includes("dist/mcp-server.js") || L.includes("dist\\mcp-server.js") ? T(F, "mcp/prompts") : F;
+}
+function jn(e) {
+  const n = On(), t = T(n, `${e}.md`);
+  try {
+    return Y(t, "utf-8").trim();
+  } catch (s) {
+    throw new Error(`Failed to load prompt template "${e}" from ${t}: ${s}`);
+  }
+}
+function Rn(e, n) {
+  return e.replace(/\${(\w+)}/g, (t, s) => n[s] || `[${s}]`);
+}
+function we() {
+  return [
+    {
+      name: "explore_idea",
+      description: "Explore a new idea collaboratively without premature commitment. Capture thoughts, constraints, questions, and evidence.",
+      arguments: [
+        {
+          name: "code",
+          description: 'Idea identifier (kebab-case, e.g., "real-time-notifications")',
+          required: !1
+        },
+        {
+          name: "description",
+          description: "Initial concept description",
+          required: !1
+        }
+      ]
+    },
+    {
+      name: "shape_approach",
+      description: "Compare different approaches and make decisions before building detailed plans. Surface tradeoffs and gather evidence.",
+      arguments: [
+        {
+          name: "path",
+          description: "Path to idea or shaping directory",
+          required: !1
+        }
+      ]
+    },
+    {
+      name: "create_plan",
+      description: "Create a new plan with AI-generated steps for a complex task (use after shaping)",
+      arguments: [
+        {
+          name: "code",
+          description: 'Plan code/identifier (e.g., "auth-system", "dark-mode")',
+          required: !1
+        },
+        {
+          name: "description",
+          description: "Detailed description of what you want to accomplish",
+          required: !1
+        },
+        {
+          name: "directory",
+          description: 'Parent directory where the plan should be created (e.g., "./plans")',
+          required: !1
+        },
+        {
+          name: "steps",
+          description: "Number of steps to generate (optional, AI will determine if not specified)",
+          required: !1
+        }
+      ]
+    },
+    {
+      name: "develop_plan",
+      description: "Refine a generated plan through conversational feedback. Captures full narrative of plan evolution with checkpoints.",
+      arguments: [
+        {
+          name: "path",
+          description: "Path to the plan directory to develop",
+          required: !1
+        }
+      ]
+    },
+    {
+      name: "execute_plan",
+      description: "Execute a plan with intelligent state management. Automatically determines next step, guides through tasks, and manages execution state.",
+      arguments: [
+        {
+          name: "path",
+          description: "Path to the plan directory to execute",
+          required: !1
+        }
+      ]
+    },
+    {
+      name: "execute_step",
+      description: "Execute a single step from a plan with proper status tracking",
+      arguments: [
+        {
+          name: "path",
+          description: "Plan directory path",
+          required: !1
+        }
+      ]
+    },
+    {
+      name: "track_progress",
+      description: "Monitor plan progress and maintain status tracking",
+      arguments: [
+        {
+          name: "path",
+          description: "Plan directory path",
+          required: !1
+        }
+      ]
+    }
+  ];
+}
+async function Ln(e, n) {
+  if (!we().find((o) => o.name === e))
+    throw new Error(`Unknown prompt: ${e}`);
+  const r = jn(e), a = { ...n };
+  return e === "explore_idea" && (a.code || (a.code = "[idea-code]"), a.description || (a.description = "[initial concept]")), e === "create_plan" && (a.code || (a.code = "[code]"), a.description || (a.description = "[description]"), a.directory || (a.directory = "[directory]"), a.steps || (a.steps = "[steps]")), a.path || (a.path = "current directory"), [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: Rn(r, a)
+      }
+    }
+  ];
+}
+function O(e) {
+  if (e !== void 0) {
+    if (e === null)
+      return null;
+    if (Array.isArray(e))
+      return e.map(O).filter((n) => n !== void 0);
+    if (typeof e == "object") {
+      const n = {};
+      for (const [t, s] of Object.entries(e)) {
+        const r = O(s);
+        r !== void 0 && (n[t] = r);
+      }
+      return n;
+    }
+    return e;
+  }
+}
+async function Mn() {
+  process.env.RIOTPLAN_MCP_SERVER = "true";
+  const e = new Se(
+    {
+      name: "riotplan",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {
+          subscribe: !1,
+          listChanged: !1
+        },
+        prompts: {
+          listChanged: !1
+        }
+      }
+    }
+  );
+  function n(a, i, o) {
+    e.tool(
+      a,
+      i,
+      o,
+      async (p, { sendNotification: d, _meta: l }) => {
+        const f = {
+          workingDirectory: process.cwd(),
+          config: void 0,
+          logger: void 0,
+          sendNotification: async (g) => {
+            if (g.method === "notifications/progress" && l?.progressToken) {
+              const v = {
+                progressToken: l.progressToken,
+                progress: g.params.progress
+              };
+              g.params.total !== void 0 && (v.total = g.params.total), g.params.message !== void 0 && (v.message = g.params.message), await d({
+                method: "notifications/progress",
+                params: O(v)
+              });
+            }
+          },
+          progressToken: l?.progressToken
+        }, m = await wn(a, p, f);
+        if (m.success) {
+          const g = [];
+          m.logs && m.logs.length > 0 && g.push({
+            type: "text",
+            text: `=== Command Output ===
+` + m.logs.join(`
+`) + `
+
+=== Result ===`
+          });
+          const v = O(m.data), k = v !== void 0 ? JSON.stringify(v, null, 2) : m.message || "Success";
+          return g.push({
+            type: "text",
+            text: k
+          }), { content: g };
+        } else {
+          const g = [];
+          if (m.logs && m.logs.length > 0 && (g.push("=== Command Output ==="), g.push(m.logs.join(`
+`)), g.push(`
+=== Error ===`)), g.push(m.error || "Unknown error"), m.context && typeof m.context == "object") {
+            g.push(`
+=== Context ===`);
+            for (const [v, k] of Object.entries(m.context))
+              k != null && g.push(`${v}: ${String(k)}`);
+          }
+          return m.details && (m.details.stderr && m.details.stderr.trim() && (g.push(`
+=== STDERR ===`), g.push(m.details.stderr)), m.details.stdout && m.details.stdout.trim() && (g.push(`
+=== STDOUT ===`), g.push(m.details.stdout))), m.recovery && m.recovery.length > 0 && (g.push(`
+=== Recovery Steps ===`), g.push(...m.recovery.map((v, k) => `${k + 1}. ${v}`))), {
+            content: [{
+              type: "text",
+              text: g.join(`
+`)
+            }],
+            isError: !0
+          };
+        }
+      }
+    );
+  }
+  n(
+    "riotplan_create",
+    "Create a new plan with AI generation. Generates detailed, actionable plans from descriptions.",
+    {
+      code: c.string(),
+      name: c.string().optional(),
+      description: c.string(),
+      directory: c.string().optional(),
+      steps: c.number().optional(),
+      direct: c.boolean().optional(),
+      provider: c.string().optional(),
+      model: c.string().optional(),
+      noAi: c.boolean().optional()
+    }
+  ), n(
+    "riotplan_status",
+    "Show current plan status including progress, current step, blockers, and issues.",
+    {
+      path: c.string().optional(),
+      verbose: c.boolean().optional()
+    }
+  ), n(
+    "riotplan_step_list",
+    "List all steps in a plan with their status. Can filter to show only pending or all steps.",
+    {
+      path: c.string().optional(),
+      pending: c.boolean().optional(),
+      all: c.boolean().optional()
+    }
+  ), n(
+    "riotplan_step_start",
+    "Mark a step as started. Updates STATUS.md to reflect the step is in progress.",
+    {
+      path: c.string().optional(),
+      step: c.number()
+    }
+  ), n(
+    "riotplan_step_complete",
+    "Mark a step as completed. Updates STATUS.md to reflect the step is done.",
+    {
+      path: c.string().optional(),
+      step: c.number()
+    }
+  ), n(
+    "riotplan_step_add",
+    "Add a new step to the plan. Can specify position or add after a specific step.",
+    {
+      path: c.string().optional(),
+      title: c.string(),
+      number: c.number().optional(),
+      after: c.number().optional()
+    }
+  ), n(
+    "riotplan_validate",
+    "Validate plan structure and files. Checks for required files, valid STATUS.md, step numbering, and dependencies.",
+    {
+      path: c.string().optional(),
+      fix: c.boolean().optional()
+    }
+  ), n(
+    "riotplan_generate",
+    "Generate plan content from an existing prompt file. Useful for regenerating plan files.",
+    {
+      path: c.string().optional(),
+      steps: c.number().optional(),
+      provider: c.string().optional(),
+      model: c.string().optional()
+    }
+  ), n(
+    "riotplan_idea_create",
+    "Create a new idea without commitment. Start exploring a concept in the Idea stage.",
+    {
+      code: c.string(),
+      description: c.string(),
+      directory: c.string().optional()
+    }
+  ), n(
+    "riotplan_idea_add_note",
+    "Add a note to an idea. Capture thoughts and observations during exploration.",
+    {
+      note: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_idea_add_constraint",
+    "Add a constraint to an idea. Document limitations and requirements.",
+    {
+      constraint: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_idea_add_question",
+    "Add a question to an idea. Raise uncertainties that need resolution.",
+    {
+      question: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_idea_add_evidence",
+    "Add evidence to an idea. Attach supporting materials like diagrams, documents, or examples.",
+    {
+      evidencePath: c.string(),
+      description: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_idea_add_narrative",
+    "Add raw narrative content to the timeline. Use this to capture conversational context, thinking-out-loud, or any free-form input that doesn't fit structured categories. Narrative chunks preserve full-fidelity context.",
+    {
+      content: c.string(),
+      path: c.string().optional(),
+      source: c.enum(["typing", "voice", "paste", "import"]).optional(),
+      context: c.string().optional(),
+      speaker: c.string().optional()
+    }
+  ), n(
+    "riotplan_idea_kill",
+    "Kill an idea. Abandon the idea with a reason, preserving the learning.",
+    {
+      reason: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_shaping_start",
+    "Start shaping an idea. Move from Idea to Shaping stage to explore approaches.",
+    {
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_shaping_add_approach",
+    "Add an approach to consider. Propose a way to solve the problem with explicit tradeoffs.",
+    {
+      name: c.string(),
+      description: c.string(),
+      tradeoffs: c.array(c.string()),
+      assumptions: c.array(c.string()).optional(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_shaping_add_feedback",
+    "Add feedback on an approach. Provide observations, concerns, or suggestions.",
+    {
+      approach: c.string(),
+      feedback: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_shaping_add_evidence",
+    "Add evidence for an approach. Attach supporting materials that inform the decision.",
+    {
+      approach: c.string(),
+      evidencePath: c.string(),
+      description: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_shaping_compare",
+    "Compare all approaches. Generate a side-by-side comparison of tradeoffs.",
+    {
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_shaping_select",
+    "Select an approach. Choose the best approach and move to Built stage.",
+    {
+      approach: c.string(),
+      reason: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_checkpoint_create",
+    "Create a checkpoint. Save a snapshot of the current state with prompt context.",
+    {
+      name: c.string(),
+      message: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_checkpoint_list",
+    "List all checkpoints. Show all saved checkpoints with timestamps.",
+    {
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_checkpoint_show",
+    "Show checkpoint details. Display the full checkpoint snapshot and prompt context.",
+    {
+      checkpoint: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_checkpoint_restore",
+    "Restore a checkpoint. Revert to a previous state.",
+    {
+      checkpoint: c.string(),
+      path: c.string().optional()
+    }
+  ), n(
+    "riotplan_history_show",
+    "Show ideation history. Display the complete timeline of events.",
+    {
+      path: c.string().optional(),
+      limit: c.number().optional(),
+      sinceCheckpoint: c.string().optional()
+    }
+  );
+  const t = Tn();
+  for (const a of t)
+    e.resource(
+      a.name,
+      a.uri,
+      {
+        description: a.description || ""
+      },
+      async () => {
+        const i = await Fn(a.uri);
+        return {
+          contents: [{
+            uri: a.uri,
+            mimeType: a.mimeType || "application/json",
+            text: JSON.stringify(i, null, 2)
+          }]
+        };
+      }
+    );
+  const s = we();
+  for (const a of s) {
+    const i = {};
+    if (a.arguments)
+      for (const o of a.arguments)
+        i[o.name] = o.required ? c.string() : c.string().optional();
+    e.prompt(
+      a.name,
+      a.description,
+      i,
+      async (o, p) => {
+        const d = {};
+        for (const [f, m] of Object.entries(o))
+          typeof m == "string" && (d[f] = m);
+        return {
+          messages: (await Ln(a.name, d)).map((f) => f.content.type === "text" ? {
+            role: f.role,
+            content: {
+              type: "text",
+              text: f.content.text || ""
+            }
+          } : f)
+        };
+      }
+    );
+  }
+  const r = new ve();
+  await e.connect(r);
+}
+Mn().catch((e) => {
+  process.exit(1);
+});