@girardmedia/bootspring 2.5.8 → 2.5.10

package/dist/cli/index.js

@@ -3378,7 +3378,7 @@ var init_release = __esm({
   "../../packages/shared/src/release.ts"() {
     "use strict";
     init_cjs_shims();
-    BOOTSPRING_VERSION = "2.5.7";
+    BOOTSPRING_VERSION = "2.5.10";
     BOOTSPRING_PACKAGE_NAME = "@girardmedia/bootspring";
   }
 });
@@ -48530,19 +48530,62 @@ init_src();
 // src/middleware.ts
 init_cjs_shims();
 init_src2();
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i2 = 0; i2 <= m; i2++) dp[i2][0] = i2;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i2 = 1; i2 <= m; i2++)
+    for (let j = 1; j <= n; j++)
+      dp[i2][j] = Math.min(
+        dp[i2 - 1][j] + 1,
+        dp[i2][j - 1] + 1,
+        dp[i2 - 1][j - 1] + (a[i2 - 1] !== b[j - 1] ? 1 : 0)
+      );
+  return dp[m][n];
+}
+function suggestSubcommand(typed, cmd) {
+  const names = cmd.commands.flatMap((c) => [c.name(), ...c.aliases()]);
+  let best = "";
+  let bestDist = Infinity;
+  for (const name of names) {
+    const d = levenshtein(typed.toLowerCase(), name.toLowerCase());
+    if (d < bestDist) {
+      bestDist = d;
+      best = name;
+    }
+  }
+  const threshold = Math.ceil(Math.max(typed.length, best.length) * 0.4);
+  return bestDist <= threshold ? best : null;
+}
 function applyHealingMiddleware(program3) {
   wrapCommand(program3);
 }
 function wrapCommand(cmd) {
+  if (!cmd._actionHandler && cmd.commands.length > 0 && cmd.parent) {
+    cmd.action(() => {
+      cmd.outputHelp();
+    });
+  }
   const listeners = cmd._actionHandler;
   if (listeners) {
     const originalAction = listeners;
     const hasSubcommands = cmd.commands.length > 0;
     cmd._actionHandler = async (...args) => {
-      if (hasSubcommands && args.length > 0 && typeof args[0] === "string") {
-        console.error(`error: unknown command '${args[0]}'. See 'bootspring ${cmd.name()} --help'.`);
-        process.exitCode = 1;
-        return;
+      if (hasSubcommands && cmd.args?.length > 0) {
+        const unknownArg = cmd.args[0];
+        if (typeof unknownArg === "string") {
+          if (unknownArg === "help") {
+            cmd.outputHelp();
+            return;
+          }
+          const suggestion = suggestSubcommand(unknownArg, cmd);
+          const hint = suggestion ? `
+(Did you mean ${suggestion}?)` : "";
+          console.error(`error: unknown command '${unknownArg}'${hint}`);
+          process.exitCode = 1;
+          return;
+        }
       }
       const commandName = cmd.name();
       presence_exports.sendHeartbeat({ activity: `bootspring ${commandName}` });
@@ -49553,6 +49596,10 @@ ${COLORS.cyan}${COLORS.bold}MCP Connectors${COLORS.reset}
     }
   });
   mcpCmd.action(async () => {
+    if (process.stdin.isTTY) {
+      mcpCmd.outputHelp();
+      return;
+    }
     console.error("Starting MCP Proxy Server...");
     try {
       const mcpServer = await Promise.resolve().then(() => (init_src3(), src_exports3));

package/dist/core/index.d.ts

@@ -470,7 +470,7 @@ interface InstallContext {
     scriptPath: string;
 }
 declare const PACKAGE_NAME = "@girardmedia/bootspring";
-declare const CURRENT_VERSION = "2.5.7";
+declare const CURRENT_VERSION = "2.5.10";
 declare const DEFAULT_INTERVAL_MS: number;
 declare const STATE_PATH: string;
 declare function compareVersions(a: string, b: string): number;

package/dist/core.js

@@ -372,7 +372,7 @@ var init_release = __esm({
   "../../packages/shared/src/release.ts"() {
     "use strict";
     init_cjs_shims();
-    BOOTSPRING_VERSION = "2.5.7";
+    BOOTSPRING_VERSION = "2.5.10";
     BOOTSPRING_PACKAGE_NAME = "@girardmedia/bootspring";
   }
 });
@@ -21577,7 +21577,7 @@ ${COLORS2.dim}Run "bootspring mcp" for server options${COLORS2.reset}
       console.log(`${COLORS2.dim}Run "bootspring mcp" for setup instructions.${COLORS2.reset}
 `);
     }
-    var BOOTSPRING_VERSION2 = "2.5.7";
+    var BOOTSPRING_VERSION2 = "2.5.10";
     var BOOTSPRING_PACKAGE_NAME2 = "@girardmedia/bootspring";
     var REDACTED2 = "[REDACTED]";
     var SENSITIVE_KEY_PATTERN2 = /(?:^|[_-])(api[_-]?key|token|refresh[_-]?token|authorization|x[_-]?api[_-]?key|project[_-]?id)$/i;
@@ -21625,7 +21625,7 @@ var require_package = __commonJS({
   "../../../package.json"(exports2, module2) {
     module2.exports = {
       name: "bootspring-workspace",
-      version: "2.5.8",
+      version: "2.5.10",
       private: true,
       description: "Workspace tooling for the Bootspring monorepo",
       keywords: [

package/dist/mcp-server.js

@@ -31370,7 +31370,7 @@ var init_release = __esm({
   "../../packages/shared/src/release.ts"() {
     "use strict";
     init_cjs_shims();
-    BOOTSPRING_VERSION = "2.5.7";
+    BOOTSPRING_VERSION = "2.5.10";
     BOOTSPRING_PACKAGE_NAME = "@girardmedia/bootspring";
   }
 });
@@ -52219,7 +52219,7 @@ var require_package = __commonJS({
   "../../../package.json"(exports2, module2) {
     module2.exports = {
       name: "bootspring-workspace",
-      version: "2.5.8",
+      version: "2.5.10",
       private: true,
       description: "Workspace tooling for the Bootspring monorepo",
       keywords: [
@@ -52345,6 +52345,527 @@ var core = require_dist2();
 var api2 = core.api;
 var auth2 = core.auth;
 var VERSION = require_package().version;
+function getProjectRoot() {
+  return process.cwd();
+}
+function loadBuildState() {
+  const fs3 = require("fs");
+  const path3 = require("path");
+  const stateFile = path3.join(getProjectRoot(), "planning", "BUILD_STATE.json");
+  if (!fs3.existsSync(stateFile)) return null;
+  try {
+    return JSON.parse(fs3.readFileSync(stateFile, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveBuildState(state) {
+  const fs3 = require("fs");
+  const path3 = require("path");
+  const planDir = path3.join(getProjectRoot(), "planning");
+  if (!fs3.existsSync(planDir)) fs3.mkdirSync(planDir, { recursive: true });
+  state.metadata = state.metadata || {};
+  state.metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (state.loopSession) state.loopSession.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  fs3.writeFileSync(path3.join(planDir, "BUILD_STATE.json"), JSON.stringify(state, null, 2));
+}
+function buildGetStats(state) {
+  if (!state) return null;
+  const q = state.implementationQueue || [];
+  const completed = q.filter((t) => t.status === "completed").length;
+  const pending = q.filter((t) => t.status === "pending").length;
+  const inProgress = q.filter((t) => t.status === "in_progress").length;
+  const blocked = q.filter((t) => t.status === "blocked").length;
+  const skipped = q.filter((t) => t.status === "skipped").length;
+  const total = q.length;
+  const percent = total > 0 ? Math.round(completed / total * 100) : 0;
+  return { total, completed, pending, inProgress, blocked, skipped, percent };
+}
+function buildGetNextTask(state) {
+  if (!state) return null;
+  const q = state.implementationQueue || [];
+  const ip = q.find((t) => t.status === "in_progress");
+  if (ip) return ip;
+  for (const task of q.filter((t) => t.status === "pending")) {
+    if (!task.dependencies || task.dependencies.length === 0) return task;
+    const allDone = task.dependencies.every((depId) => {
+      const dep = q.find((t) => t.id === depId);
+      return dep && dep.status === "completed";
+    });
+    if (allDone) return task;
+  }
+  return null;
+}
+function buildUpdateTaskStatus(state, taskId, status) {
+  const task = (state.implementationQueue || []).find((t) => t.id === taskId);
+  if (!task) return false;
+  task.status = status;
+  task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (status === "completed") task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (status === "completed" || status === "skipped") {
+    state.loopSession = state.loopSession || {};
+    state.loopSession.currentIteration = (state.loopSession.currentIteration || 0) + 1;
+  }
+  return true;
+}
+function formatBuildTask(task) {
+  if (!task) return null;
+  return {
+    id: task.id,
+    title: task.title,
+    description: task.description,
+    phase: task.phase,
+    source: task.source,
+    sourceSection: task.sourceSection,
+    acceptanceCriteria: task.acceptanceCriteria || []
+  };
+}
+async function executeLocalBuild(args) {
+  const action = args?.action || "status";
+  const state = loadBuildState();
+  switch (action) {
+    case "status": {
+      if (!state) {
+        return { content: [{ type: "text", text: JSON.stringify({ initialized: false, message: "No build state found. Create planning/TODO.md and run action=sync, or use action=init.", hint: "Run: bootspring seed go" }, null, 2) }] };
+      }
+      const stats = buildGetStats(state);
+      const currentTask = (state.implementationQueue || []).find((t) => t.status === "in_progress");
+      return { content: [{ type: "text", text: JSON.stringify({
+        project: state.projectName,
+        phase: state.currentPhase,
+        status: state.status,
+        progress: { completed: stats.completed, pending: stats.pending, inProgress: stats.inProgress, total: stats.total, percent: stats.percent },
+        currentTask: currentTask ? { id: currentTask.id, title: currentTask.title } : null,
+        nextAction: currentTask ? "Complete the current task, then use action=done" : "Use action=next to get the next task"
+      }, null, 2) }] };
+    }
+    case "next": {
+      if (!state) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No build state found", hint: "Use action=init to initialize" }, null, 2) }] };
+      }
+      const inProgress = (state.implementationQueue || []).find((t) => t.status === "in_progress");
+      if (inProgress) {
+        return { content: [{ type: "text", text: JSON.stringify({
+          message: "Task already in progress",
+          state: "in_progress",
+          task: formatBuildTask(inProgress),
+          hint: "Complete this task with action=done, or use action=skip to skip it"
+        }, null, 2) }] };
+      }
+      const nextTask = buildGetNextTask(state);
+      if (!nextTask) {
+        const stats2 = buildGetStats(state);
+        return { content: [{ type: "text", text: JSON.stringify({ message: "All tasks complete!", progress: { completed: stats2.completed, total: stats2.total }, celebration: "Build finished!" }, null, 2) }] };
+      }
+      buildUpdateTaskStatus(state, nextTask.id, "in_progress");
+      saveBuildState(state);
+      const stats = buildGetStats(state);
+      return { content: [{ type: "text", text: JSON.stringify({
+        task: formatBuildTask(nextTask),
+        state: "task_ready",
+        file: "planning/TODO.md",
+        progress: { completed: stats.completed, total: stats.total, percent: stats.percent },
+        instructions: [
+          `Find ${nextTask.id} in planning/TODO.md for full details`,
+          "Implement the task in the codebase",
+          "Ensure acceptance criteria are met",
+          "Run quality checks (lint, test)",
+          "Commit changes with descriptive message",
+          "Use action=done when complete"
+        ]
+      }, null, 2) }] };
+    }
+    case "current": {
+      if (!state) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No build state found" }, null, 2) }] };
+      }
+      const currentTask = (state.implementationQueue || []).find((t) => t.status === "in_progress");
+      if (!currentTask) {
+        return { content: [{ type: "text", text: JSON.stringify({ message: "No task currently in progress", hint: "Use action=next to get the next task" }, null, 2) }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify({
+        task: formatBuildTask(currentTask),
+        instructions: ["Implement this task in the codebase", "Run quality checks (lint, test)", "Commit your changes", "Use action=done to mark complete"]
+      }, null, 2) }] };
+    }
+    case "done": {
+      if (!state) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No build state found" }, null, 2) }] };
+      }
+      const inProgress = (state.implementationQueue || []).find((t) => t.status === "in_progress");
+      if (!inProgress) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No task currently in progress", hint: "Use action=next to get a task first" }, null, 2) }] };
+      }
+      buildUpdateTaskStatus(state, inProgress.id, "completed");
+      const nextTask = buildGetNextTask(state);
+      if (nextTask) {
+        buildUpdateTaskStatus(state, nextTask.id, "in_progress");
+      }
+      saveBuildState(state);
+      const stats = buildGetStats(state);
+      return { content: [{ type: "text", text: JSON.stringify({
+        completed: { id: inProgress.id, title: inProgress.title },
+        progress: { completed: stats.completed, total: stats.total, percent: stats.percent },
+        nextTask: nextTask ? { ...formatBuildTask(nextTask), file: "planning/TODO.md" } : null,
+        allComplete: !nextTask,
+        message: nextTask ? `Complete! Next: implement ${nextTask.id} \u2014 ${nextTask.title}` : "Build complete! All tasks finished."
+      }, null, 2) }] };
+    }
+    case "skip": {
+      if (!state) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No build state found" }, null, 2) }] };
+      }
+      const inProgress = (state.implementationQueue || []).find((t) => t.status === "in_progress");
+      if (!inProgress) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No task to skip", hint: "Use action=next to get a task first" }, null, 2) }] };
+      }
+      buildUpdateTaskStatus(state, inProgress.id, "skipped");
+      const nextTask = buildGetNextTask(state);
+      if (nextTask) {
+        buildUpdateTaskStatus(state, nextTask.id, "in_progress");
+      }
+      saveBuildState(state);
+      return { content: [{ type: "text", text: JSON.stringify({
+        skipped: { id: inProgress.id, title: inProgress.title, reason: args?.reason || "Skipped" },
+        nextTask: nextTask ? formatBuildTask(nextTask) : null,
+        message: nextTask ? `Skipped. Next: ${nextTask.title}` : "No more tasks available"
+      }, null, 2) }] };
+    }
+    case "list": {
+      if (!state) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No build state found" }, null, 2) }] };
+      }
+      const tasks = (state.implementationQueue || []).map((t) => ({ id: t.id, title: t.title, status: t.status, phase: t.phase }));
+      return { content: [{ type: "text", text: JSON.stringify({ project: state.projectName, tasks }, null, 2) }] };
+    }
+    case "advance": {
+      if (!state) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No build state found", hint: "Use action=init or action=sync first" }, null, 2) }] };
+      }
+      const activeTask = (state.implementationQueue || []).find((t) => t.status === "in_progress");
+      if (activeTask) {
+        if (args?.autoDone) {
+          try {
+            const { execSync } = require("child_process");
+            const gitStatus = execSync("git status --porcelain", { cwd: getProjectRoot(), encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+            if (gitStatus.trim().length === 0) {
+              buildUpdateTaskStatus(state, activeTask.id, "completed");
+              const nextTask2 = buildGetNextTask(state);
+              if (nextTask2) buildUpdateTaskStatus(state, nextTask2.id, "in_progress");
+              saveBuildState(state);
+              const stats = buildGetStats(state);
+              return { content: [{ type: "text", text: JSON.stringify({
+                state: nextTask2 ? "advanced" : "all_complete",
+                autoCompleted: true,
+                completed: { id: activeTask.id, title: activeTask.title },
+                nextTask: nextTask2 ? formatBuildTask(nextTask2) : null,
+                progress: { completed: stats.completed, total: stats.total, percent: stats.percent }
+              }, null, 2) }] };
+            }
+          } catch {
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify({
+          state: "in_progress",
+          task: formatBuildTask(activeTask),
+          hint: "Finish implementation and use action=done, or call action=advance with autoDone=true after commit"
+        }, null, 2) }] };
+      }
+      const nextTask = buildGetNextTask(state);
+      if (!nextTask) {
+        const stats = buildGetStats(state);
+        return { content: [{ type: "text", text: JSON.stringify({ state: "all_complete", message: "All tasks complete!", progress: { completed: stats.completed, total: stats.total, percent: stats.percent } }, null, 2) }] };
+      }
+      buildUpdateTaskStatus(state, nextTask.id, "in_progress");
+      saveBuildState(state);
+      return { content: [{ type: "text", text: JSON.stringify({
+        state: "task_ready",
+        task: formatBuildTask(nextTask),
+        file: "planning/TODO.md",
+        hint: "Implement task, then call action=advance (or action=done) to continue loop"
+      }, null, 2) }] };
+    }
+    case "sync": {
+      const fs3 = require("fs");
+      const pathMod = require("path");
+      const projectRoot = getProjectRoot();
+      const todoPath = pathMod.join(projectRoot, "planning", "TODO.md");
+      if (!fs3.existsSync(todoPath)) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "planning/TODO.md not found", hint: "Create planning/TODO.md with tasks first" }, null, 2) }] };
+      }
+      const todoContent = fs3.readFileSync(todoPath, "utf-8");
+      const taskRegex = /^-\s*\[([ xX])\]\s*(?:\*\*)?([a-zA-Z]+-\d+)(?:\*\*)?[:\s]+(.+?)$/gm;
+      const tasks = [];
+      let match;
+      while ((match = taskRegex.exec(todoContent)) !== null) {
+        const checked = match[1].toLowerCase() === "x";
+        tasks.push({
+          id: match[2],
+          title: match[3].trim().replace(/\*\*/g, ""),
+          status: checked ? "completed" : "pending",
+          phase: "mvp",
+          source: "TODO.md"
+        });
+      }
+      if (tasks.length === 0) {
+        const simpleLine = /(?:bs|task)-\d+[:\s]+(.+)/gi;
+        let lineMatch;
+        while ((lineMatch = simpleLine.exec(todoContent)) !== null) {
+          tasks.push({
+            id: lineMatch[0].split(/[:\s]/)[0],
+            title: lineMatch[1]?.trim() || lineMatch[0],
+            status: "pending",
+            phase: "mvp",
+            source: "TODO.md"
+          });
+        }
+      }
+      const currentState = state || {
+        version: "1.0.0",
+        projectName: "Project",
+        status: "pending",
+        currentPhase: "mvp",
+        phases: {},
+        implementationQueue: [],
+        mvpCriteria: { features: [], completionPercentage: 0, allCriteriaMet: false },
+        loopSession: { sessionId: `build-${Date.now()}`, currentIteration: 0, maxIterations: 500, startedAt: (/* @__PURE__ */ new Date()).toISOString(), lastUpdated: null, pausedAt: null },
+        metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString(), updatedAt: (/* @__PURE__ */ new Date()).toISOString(), seedSource: "TODO.md", preseedDocs: [] }
+      };
+      if (args?.replace) {
+        currentState.implementationQueue = tasks;
+      } else {
+        const existingIds = new Set((currentState.implementationQueue || []).map((t) => t.id));
+        for (const task of tasks) {
+          if (!existingIds.has(task.id)) {
+            currentState.implementationQueue = currentState.implementationQueue || [];
+            currentState.implementationQueue.push(task);
+          }
+        }
+      }
+      saveBuildState(currentState);
+      const stats = buildGetStats(currentState);
+      return { content: [{ type: "text", text: JSON.stringify({
+        success: true,
+        source: "TODO.md",
+        tasksFound: tasks.length,
+        mode: args?.replace ? "replace" : "merge",
+        progress: { total: stats.total, completed: stats.completed, pending: stats.pending },
+        nextStep: "Use action=next to get the first task"
+      }, null, 2) }] };
+    }
+    case "init": {
+      const fs3 = require("fs");
+      const pathMod = require("path");
+      const projectRoot = getProjectRoot();
+      const todoPath = pathMod.join(projectRoot, "planning", "TODO.md");
+      if (fs3.existsSync(todoPath)) {
+        return executeLocalBuild({ ...args, action: "sync", replace: true });
+      }
+      const newState = {
+        version: "1.0.0",
+        projectName: pathMod.basename(projectRoot),
+        status: "pending",
+        currentPhase: null,
+        phases: { foundation: { status: "pending", tasks: [] }, mvp: { status: "pending", tasks: [] }, launch: { status: "pending", tasks: [] } },
+        implementationQueue: [],
+        mvpCriteria: { features: [], completionPercentage: 0, allCriteriaMet: false },
+        loopSession: { sessionId: `build-${Date.now()}`, currentIteration: 0, maxIterations: 500, startedAt: (/* @__PURE__ */ new Date()).toISOString(), lastUpdated: null, pausedAt: null },
+        metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString(), updatedAt: (/* @__PURE__ */ new Date()).toISOString(), seedSource: null, preseedDocs: [] }
+      };
+      saveBuildState(newState);
+      return { content: [{ type: "text", text: JSON.stringify({
+        success: true,
+        message: "Build state initialized",
+        project: newState.projectName,
+        hint: "Create planning/TODO.md with tasks, then use action=sync to load them"
+      }, null, 2) }] };
+    }
+    default:
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown action: ${action}`, validActions: ["next", "current", "done", "skip", "status", "list", "init", "sync", "advance"] }, null, 2) }] };
+  }
+}
+async function executeLocalSeed(args) {
+  const fs3 = require("fs");
+  const pathMod = require("path");
+  const action = args?.action || "status";
+  const projectRoot = getProjectRoot();
+  const CONTEXT_DIR = ".bootspring/context";
+  const contextDir = pathMod.join(projectRoot, CONTEXT_DIR);
+  const CONTEXT_DOCS = {
+    vision: { name: "VISION.md", title: "Vision", description: "Problem, solution, core values", required: true },
+    audience: { name: "AUDIENCE.md", title: "Audience", description: "Target audience, personas, ICP", required: true },
+    market: { name: "MARKET.md", title: "Market", description: "TAM/SAM/SOM, market opportunity", required: false },
+    competitors: { name: "COMPETITORS.md", title: "Competitors", description: "Competitive landscape, differentiation", required: false },
+    "business-model": { name: "BUSINESS_MODEL.md", title: "Business Model", description: "Revenue, pricing, unit economics", required: true },
+    prd: { name: "PRD.md", title: "PRD", description: "Product requirements, user stories", required: true },
+    "technical-spec": { name: "TECHNICAL_SPEC.md", title: "Technical Spec", description: "Architecture, tech stack, data model", required: false },
+    roadmap: { name: "ROADMAP.md", title: "Roadmap", description: "Phases, milestones, timeline", required: false }
+  };
+  const PRESETS = {
+    essential: ["vision", "audience", "business-model", "prd"],
+    startup: ["vision", "audience", "market", "competitors", "business-model", "prd", "roadmap"],
+    full: Object.keys(CONTEXT_DOCS),
+    technical: ["vision", "prd", "technical-spec", "roadmap"],
+    investor: ["vision", "audience", "market", "competitors", "business-model", "roadmap"]
+  };
+  switch (action) {
+    case "setup":
+    case "init": {
+      const preset = args?.preset || "startup";
+      if (!fs3.existsSync(contextDir)) fs3.mkdirSync(contextDir, { recursive: true });
+      let projectName = pathMod.basename(projectRoot);
+      try {
+        const pkg = JSON.parse(fs3.readFileSync(pathMod.join(projectRoot, "package.json"), "utf-8"));
+        projectName = pkg.name || projectName;
+      } catch {
+      }
+      const docs = PRESETS[preset] || PRESETS.startup;
+      let generated = 0;
+      for (const docType of docs) {
+        const meta = CONTEXT_DOCS[docType];
+        if (!meta) continue;
+        const filePath = pathMod.join(contextDir, meta.name);
+        if (!fs3.existsSync(filePath)) {
+          const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          fs3.writeFileSync(filePath, `# ${projectName} \u2014 ${meta.title}
+
+**Generated:** ${date}
+**Status:** Draft
+
+## ${meta.title}
+
+*${meta.description}*
+
+---
+
+*Edit this file with your project details.*
+`);
+          generated++;
+        }
+      }
+      return { content: [{ type: "text", text: JSON.stringify({
+        success: true,
+        action: "init",
+        preset,
+        generated,
+        contextDir: CONTEXT_DIR,
+        docs: docs.map((d) => CONTEXT_DOCS[d]?.name).filter(Boolean),
+        nextSteps: ["Edit the .md files in .bootspring/context/", 'Run bootspring_seed with action: "generate" or run bootspring seed merge']
+      }, null, 2) }] };
+    }
+    case "status": {
+      const seedPath = pathMod.join(projectRoot, "planning", "SEED.md");
+      const hasSeed = fs3.existsSync(seedPath);
+      let docs = [];
+      if (fs3.existsSync(contextDir)) {
+        docs = fs3.readdirSync(contextDir).filter((f) => f.endsWith(".md") && f !== "README.md");
+      }
+      return { content: [{ type: "text", text: JSON.stringify({
+        contextDocs: docs,
+        total: docs.length,
+        contextDir: CONTEXT_DIR,
+        seedMd: hasSeed,
+        seedPath: hasSeed ? "planning/SEED.md" : null,
+        nextStep: docs.length === 0 ? 'Run bootspring_seed with action: "init"' : !hasSeed ? "Edit docs, then merge" : "Ready to build"
+      }, null, 2) }] };
+    }
+    case "generate": {
+      if (!fs3.existsSync(contextDir)) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No context docs found", hint: 'Run bootspring_seed with action: "init" first' }, null, 2) }] };
+      }
+      const validDocs = Object.values(CONTEXT_DOCS).map((d) => d.name);
+      const files = fs3.readdirSync(contextDir).filter((f) => f.endsWith(".md") && f !== "README.md").sort((a, b) => {
+        const ai = validDocs.indexOf(a);
+        const bi = validDocs.indexOf(b);
+        return (ai === -1 ? 999 : ai) - (bi === -1 ? 999 : bi);
+      });
+      if (files.length === 0) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No .md files in context folder" }, null, 2) }] };
+      }
+      const sections = files.map((f) => fs3.readFileSync(pathMod.join(contextDir, f), "utf-8"));
+      const planDir = pathMod.join(projectRoot, "planning");
+      if (!fs3.existsSync(planDir)) fs3.mkdirSync(planDir, { recursive: true });
+      fs3.writeFileSync(pathMod.join(planDir, "SEED.md"), sections.join("\n\n---\n\n"));
+      return { content: [{ type: "text", text: JSON.stringify({
+        success: true,
+        action: "generate",
+        merged: files.length,
+        output: "planning/SEED.md",
+        files,
+        nextStep: 'Create planning/TODO.md with tasks, then use bootspring_build action: "sync"'
+      }, null, 2) }] };
+    }
+    case "export": {
+      if (!fs3.existsSync(contextDir)) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "No context docs found" }, null, 2) }] };
+      }
+      const docs = {};
+      const files = fs3.readdirSync(contextDir).filter((f) => f.endsWith(".md") && f !== "README.md");
+      for (const file of files) {
+        docs[file.replace(".md", "")] = fs3.readFileSync(pathMod.join(contextDir, file), "utf-8");
+      }
+      return { content: [{ type: "text", text: JSON.stringify({ context: docs, exportedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) }] };
+    }
+    default:
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown action: ${action}`, validActions: ["setup", "init", "generate", "status", "export"] }, null, 2) }] };
+  }
+}
+async function executeLocalTodo(args) {
+  const fs3 = require("fs");
+  const pathMod = require("path");
+  const action = args?.action || "list";
+  const projectRoot = getProjectRoot();
+  const todoFile = pathMod.join(projectRoot, ".bootspring", "todos.json");
+  function loadTodos() {
+    if (!fs3.existsSync(todoFile)) return [];
+    try {
+      return JSON.parse(fs3.readFileSync(todoFile, "utf-8"));
+    } catch {
+      return [];
+    }
+  }
+  function saveTodos(todos) {
+    const dir = pathMod.dirname(todoFile);
+    if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
+    fs3.writeFileSync(todoFile, JSON.stringify(todos, null, 2));
+  }
+  switch (action) {
+    case "list": {
+      const todos = loadTodos();
+      return { content: [{ type: "text", text: JSON.stringify({ todos, total: todos.length }, null, 2) }] };
+    }
+    case "add": {
+      const todos = loadTodos();
+      const newTodo = { id: `todo-${Date.now()}`, text: args?.text || "Untitled", completed: false, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+      todos.push(newTodo);
+      saveTodos(todos);
+      return { content: [{ type: "text", text: JSON.stringify({ success: true, todo: newTodo }, null, 2) }] };
+    }
+    case "complete": {
+      const todos = loadTodos();
+      const todo = todos.find((t) => t.id === args?.id);
+      if (!todo) return { content: [{ type: "text", text: JSON.stringify({ error: "Todo not found" }, null, 2) }] };
+      todo.completed = true;
+      todo.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveTodos(todos);
+      return { content: [{ type: "text", text: JSON.stringify({ success: true, todo }, null, 2) }] };
+    }
+    case "delete": {
+      let todos = loadTodos();
+      const before = todos.length;
+      todos = todos.filter((t) => t.id !== args?.id);
+      saveTodos(todos);
+      return { content: [{ type: "text", text: JSON.stringify({ success: todos.length < before, remaining: todos.length }, null, 2) }] };
+    }
+    default:
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown action: ${action}` }, null, 2) }] };
+  }
+}
+var LOCAL_TOOL_EXECUTORS = {
+  bootspring_build: executeLocalBuild,
+  bootspring_seed: executeLocalSeed,
+  bootspring_todo: executeLocalTodo
+};
 var FALLBACK_TOOLS = [
   {
     name: "bootspring_agent",
@@ -52513,20 +53034,7 @@ function formatProxyError(error) {
   }
   return error?.message || "Unknown error from Bootspring API.";
 }
-var LOCAL_TOOLS = /* @__PURE__ */ new Set(["bootspring_build", "bootspring_seed", "bootspring_todo"]);
-function formatLocalToolGuidance(name, args) {
-  const action = args && typeof args.action === "string" ? args.action : "";
-  const base = name.replace(/^bootspring_/, "bootspring ");
-  const cmd = action ? `${base} ${action}` : base;
-  return [
-    `\`${name}\` is a local-state tool \u2014 it reads and writes files in your project (.bootspring/state, planning/, etc.) and therefore cannot be executed from the hosted MCP API.`,
-    ``,
-    `Run this in your project terminal:`,
-    `  ${cmd}`,
-    ``,
-    `Everything else in this conversation will still work \u2014 only local-state tools need to run from your shell.`
-  ].join("\n");
-}
+var LOCAL_TOOLS = new Set(Object.keys(LOCAL_TOOL_EXECUTORS));
 async function resolveTools() {
   if (!auth2.isAuthenticated()) {
     return FALLBACK_TOOLS;
@@ -52560,9 +53068,14 @@ async function resolveResources() {
 }
 async function proxyToolCall(name, args) {
   if (LOCAL_TOOLS.has(name)) {
-    return {
-      content: [{ type: "text", text: formatLocalToolGuidance(name, args) }]
-    };
+    try {
+      return await LOCAL_TOOL_EXECUTORS[name](args || {});
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Error executing ${name}: ${error?.message || error}` }],
+        isError: true
+      };
+    }
   }
   if (!auth2.isAuthenticated()) {
     return createAuthError("Authentication required. Run `bootspring auth login` first.");
@@ -52578,7 +53091,7 @@ async function proxyToolCall(name, args) {
     const response = await api2.callMcpTool(name, args || {});
     if (response && response.result && response.result.status === "local_execution_required") {
       return {
-        content: [{ type: "text", text: response.result.message || formatLocalToolGuidance(name, args) }]
+        content: [{ type: "text", text: response.result.message || `${name} requires local execution. Run: bootspring ${name.replace("bootspring_", "")} ${args?.action || ""}`.trim() }]
       };
     }
     return {
@@ -52674,11 +53187,11 @@ module.exports = {
   FALLBACK_TOOLS,
   FALLBACK_RESOURCES,
   main,
-  // Exposed for tests — lock in the stale-install regression guard
+  // Exposed for tests
   _diagnoseApiSurface: diagnoseApiSurface,
   _formatProxyError: formatProxyError,
   _LOCAL_TOOLS: LOCAL_TOOLS,
-  _formatLocalToolGuidance: formatLocalToolGuidance,
+  _LOCAL_TOOL_EXECUTORS: LOCAL_TOOL_EXECUTORS,
   _proxyToolCall: proxyToolCall,
   _diagnoseFromApi: function diagnoseFromApi(apiShim, version) {
     const required = ["callMcpTool", "listMcpTools", "listMcpResources", "getMcpResource"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardmedia/bootspring",
-  "version": "2.5.8",
+  "version": "2.5.10",
   "description": "Thin client for Bootspring cloud MCP, hosted agents, and paywalled workflow intelligence",
   "keywords": [
     "ai",