@girardmedia/bootspring 2.5.9 → 2.5.11

package/dist/mcp-server.js

@@ -31156,6 +31156,13 @@ ${COLORS.bold}${msg}${COLORS.reset}`);
         console.log(`${indent}- ${formatListItem(item)}`);
       }
     };
+    printImpl.apiError = (prefix, err) => {
+      if (err && typeof err === "object" && err.authHandled) {
+        return;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`${COLORS.red}\u2717${COLORS.reset} ${prefix}: ${message}`);
+    };
     print = printImpl;
   }
 });
@@ -31370,7 +31377,7 @@ var init_release = __esm({
   "../../packages/shared/src/release.ts"() {
     "use strict";
     init_cjs_shims();
-    BOOTSPRING_VERSION = "2.5.7";
+    BOOTSPRING_VERSION = "2.5.11";
     BOOTSPRING_PACKAGE_NAME = "@girardmedia/bootspring";
   }
 });
@@ -48932,6 +48939,7 @@ var require_dist2 = __commonJS({
       presence: () => presence_exports,
       readNearestProjectConfig: () => readNearestProjectConfig,
       refreshSession: () => refreshSession,
+      registerMcpForAssistant: () => registerMcpForAssistant,
       remoteLogout: () => remoteLogout,
       request: () => request,
       resolvePolicyProfile: () => resolvePolicyProfile,
@@ -49151,6 +49159,7 @@ var require_dist2 = __commonJS({
           if (reauthOk) {
             return rawRequest(method, path10, data, { ...options, _authRetried: true, noCache: true });
           }
+          err.authHandled = true;
         }
         throw err;
       }
@@ -49380,6 +49389,7 @@ var require_dist2 = __commonJS({
     var self_heal_exports = {};
     __export2(self_heal_exports, {
       classifyError: () => classifyError,
+      registerMcpForAssistant: () => registerMcpForAssistant,
       runDiagnostics: () => runDiagnostics,
       tryHeal: () => tryHeal
     });
@@ -49627,6 +49637,30 @@ var require_dist2 = __commonJS({
       } else {
         results.push({ id: "deps", status: "ok", message: "Dependencies installed." });
       }
+      const lockPath = import_path3.default.join(cwd, "package-lock.json");
+      const pnpmLock = import_path3.default.join(cwd, "pnpm-lock.yaml");
+      const nmPath = import_path3.default.join(cwd, "node_modules");
+      const lockFile = import_fs3.default.existsSync(pnpmLock) ? pnpmLock : import_fs3.default.existsSync(lockPath) ? lockPath : null;
+      if (lockFile && import_fs3.default.existsSync(nmPath)) {
+        try {
+          const lockMtime = import_fs3.default.statSync(lockFile).mtimeMs;
+          const nmMtime = import_fs3.default.statSync(nmPath).mtimeMs;
+          if (lockMtime > nmMtime) {
+            const installCmd = lockFile.endsWith(".yaml") ? "pnpm install" : "npm install";
+            if (autoFix) {
+              try {
+                (0, import_child_process.execSync)(installCmd, { cwd, timeout: 12e4, stdio: "pipe" });
+                results.push({ id: "deps-stale", status: "healed", message: `Lockfile newer than node_modules \u2014 ran ${installCmd}.` });
+              } catch {
+                results.push({ id: "deps-stale", status: "action-needed", message: "Lockfile newer than node_modules.", fix: installCmd });
+              }
+            } else {
+              results.push({ id: "deps-stale", status: "action-needed", message: "Lockfile newer than node_modules \u2014 dependencies may be stale.", fix: `${installCmd}` });
+            }
+          }
+        } catch {
+        }
+      }
       const mcpTargets = {
         claude: import_path3.default.join(homeDir, ".claude.json"),
         codex: import_path3.default.join(homeDir, ".codex", "config.toml"),
@@ -49677,7 +49711,9 @@ var require_dist2 = __commonJS({
             if (autoFix) {
               const backup = buildStatePath + ".bak";
               import_fs3.default.copyFileSync(buildStatePath, backup);
-              results.push({ id: "build-state", status: "action-needed", message: "BUILD_STATE.json has invalid structure.", fix: "bootspring build start" });
+              state.implementationQueue = state.implementationQueue || [];
+              import_fs3.default.writeFileSync(buildStatePath, JSON.stringify(state, null, 2));
+              results.push({ id: "build-state", status: "healed", message: `BUILD_STATE.json repaired (backed up to ${import_path3.default.basename(backup)}).` });
             } else {
               results.push({ id: "build-state", status: "action-needed", message: "BUILD_STATE.json has invalid structure.", fix: "bootspring doctor --fix" });
             }
@@ -49773,6 +49809,29 @@ ${block}` : block;
         return false;
       }
     }
+    var MCP_PATHS = {
+      claude: () => import_path3.default.join(import_os2.default.homedir(), ".claude.json"),
+      cursor: () => import_path3.default.join(import_os2.default.homedir(), ".cursor", "mcp.json"),
+      codex: () => import_path3.default.join(import_os2.default.homedir(), ".codex", "config.toml"),
+      gemini: () => import_path3.default.join(import_os2.default.homedir(), ".gemini", "settings.json")
+    };
+    function registerMcpForAssistant(target) {
+      const configPath = MCP_PATHS[target]();
+      let success = false;
+      switch (target) {
+        case "claude":
+        case "cursor":
+          success = writeClaudeMcp(configPath);
+          break;
+        case "codex":
+          success = writeCodexMcp(configPath);
+          break;
+        case "gemini":
+          success = writeGeminiMcp(configPath);
+          break;
+      }
+      return { success, path: configPath };
+    }
     var presence_exports = {};
     __export2(presence_exports, {
       maybeAutoUploadTelemetry: () => maybeAutoUploadTelemetry,
@@ -52219,7 +52278,7 @@ var require_package = __commonJS({
   "../../../package.json"(exports2, module2) {
     module2.exports = {
       name: "bootspring-workspace",
-      version: "2.5.9",
+      version: "2.5.11",
       private: true,
       description: "Workspace tooling for the Bootspring monorepo",
       keywords: [
@@ -52249,7 +52308,9 @@ var require_package = __commonJS({
         mcp: "node monorepo/apps/cli/dist/mcp-server.js",
         "version:sync": "node scripts/sync-version-metadata.js",
         "verify:version-sync": "node scripts/sync-version-metadata.js --check",
-        "release:prepare": "npm run version:sync && npm run build && npm test && npm run lint --if-present && npm run verify:package && npm run verify:thin-client-contract && npm run verify:mcp-contract && npm run verify:monorepo-assets && npm run verify:release-gates",
+        "release:prepare": "npm run version:sync && npm run build && npm test && npm run lint --if-present && npm run verify:package && npm run verify:thin-client-contract && npm run verify:mcp-contract && npm run verify:monorepo-assets && npm run verify:release-gates && npm run smoke:publish",
+        "release:dry-run": "npm run version:sync && npm run build && npm test && npm run lint --if-present && npm run verify:package && npm run verify:thin-client-contract && npm run verify:mcp-contract && npm run verify:monorepo-assets && npm run verify:release-gates && npm run smoke:publish && echo '\\n--- DRY RUN COMPLETE (no publish) ---'",
+        "smoke:publish": "node scripts/smoke-publish.js",
         pretest: "npm run build",
         test: "vitest run",
         "test:launch-smoke": "vitest run __tests__/unit/cli-first-run-smoke.test.js __tests__/unit/health-fresh-start.test.ts __tests__/unit/session-project-scope.test.ts __tests__/unit/auth-cli-mixed-states.test.ts __tests__/unit/api-client-project-auth-fallback.test.js __tests__/unit/cli-help-surface.test.js __tests__/unit/cli-command-manifest.test.js",
@@ -52276,7 +52337,10 @@ var require_package = __commonJS({
         "server:bundle:configure-shared-billing-gh": "bash monorepo/apps/server/compat-runtime/scripts/configure-shared-billing-smoke-gh.sh",
         "build:cli": "npm --prefix monorepo/apps/cli run build",
         "build:watch": "npm --prefix monorepo/apps/cli run dev",
-        dev: "npm --prefix monorepo/apps/cli run dev",
+        dev: "cd monorepo && pnpm turbo dev --filter=@girardmedia/bootspring --filter=@bootspring/server --concurrency=10",
+        "dev:cli": "npm --prefix monorepo/apps/cli run dev",
+        "dev:server": "npm --prefix monorepo/apps/server run dev",
+        "dev:test": "vitest",
         "verify:lint-budget": "node scripts/check-lint-budgets.js",
         "verify:release-gates": "node scripts/release-gate-check.js",
         "verify:shared-contracts": "node scripts/verify-shared-contracts.js",
@@ -52345,6 +52409,577 @@ 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) }] };
+    }
+    case "scan": {
+      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 { execSync } = require("child_process");
+      const projectRoot = getProjectRoot();
+      let gitLog;
+      try {
+        const since = state.loopSession?.startedAt;
+        const sinceArg = since ? ` --since="${since}"` : " -100";
+        gitLog = execSync(`git log --oneline${sinceArg}`, { cwd: projectRoot, encoding: "utf-8", timeout: 1e4 }).trim();
+      } catch {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "Failed to read git log \u2014 not a git repo or git not available" }, null, 2) }] };
+      }
+      if (!gitLog) {
+        return { content: [{ type: "text", text: JSON.stringify({ scanned: 0, marked: 0, message: "No commits found to scan" }, null, 2) }] };
+      }
+      const lines = gitLog.split("\n").filter(Boolean);
+      const bsIdPattern = /\bbs-(\d+)\b/gi;
+      const foundIds = /* @__PURE__ */ new Set();
+      for (const line of lines) {
+        for (const match of line.matchAll(bsIdPattern)) {
+          foundIds.add(`bs-${match[1]}`);
+        }
+      }
+      const queue = state.implementationQueue || [];
+      const marked = [];
+      for (const id of foundIds) {
+        const task = queue.find((t) => t.id === id && (t.status === "pending" || t.status === "in_progress"));
+        if (task) {
+          task.status = "completed";
+          task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          task.completedBy = "commit-back-scan";
+          marked.push(id);
+        }
+      }
+      if (marked.length > 0) {
+        saveBuildState(state);
+      }
+      const stats = buildGetStats(state);
+      return { content: [{ type: "text", text: JSON.stringify({
+        scanned: lines.length,
+        bsIdsFound: foundIds.size,
+        marked: marked.length,
+        markedIds: marked,
+        progress: stats,
+        message: marked.length > 0 ? `Marked ${marked.length} task${marked.length === 1 ? "" : "s"} as completed from git history` : `Scanned ${lines.length} commits, found ${foundIds.size} bs-IDs, but none matched pending/in-progress tasks`
+      }, null, 2) }] };
+    }
+    default:
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown action: ${action}`, validActions: ["next", "current", "done", "skip", "status", "list", "init", "sync", "advance", "scan"] }, 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",
@@ -52422,7 +53057,7 @@ var FALLBACK_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        action: { type: "string", enum: ["next", "current", "done", "skip", "status", "list", "init", "sync", "advance"] },
+        action: { type: "string", enum: ["next", "current", "done", "skip", "status", "list", "init", "sync", "advance", "scan"] },
         reason: { type: "string" },
         autoDone: { type: "boolean" }
       },
@@ -52513,20 +53148,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 +53182,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 +53205,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 +53301,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"];