@girardmedia/bootspring 2.4.0 → 2.5.0

package/dist/cli/index.cjs

@@ -3214,13 +3214,15 @@ function isMCPContext() {
 function deepClone(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
-var import_fs, import_path, REDACTED, SENSITIVE_KEY_PATTERN, COLORS, print;
+var import_fs, import_path, BOOTSPRING_VERSION, BOOTSPRING_PACKAGE_NAME, REDACTED, SENSITIVE_KEY_PATTERN, COLORS, print;
 var init_dist = __esm({
   "../../packages/shared/dist/index.mjs"() {
     "use strict";
     init_cjs_shims();
     import_fs = __toESM(require("fs"), 1);
     import_path = __toESM(require("path"), 1);
+    BOOTSPRING_VERSION = "2.5.0";
+    BOOTSPRING_PACKAGE_NAME = "@girardmedia/bootspring";
     REDACTED = "[REDACTED]";
     SENSITIVE_KEY_PATTERN = /(?:^|[_-])(api[_-]?key|token|refresh[_-]?token|authorization|x[_-]?api[_-]?key|project[_-]?id)$/i;
     COLORS = {
@@ -3269,6 +3271,8 @@ __export(dist_exports, {
   API_BASE: () => API_BASE,
   API_VERSION: () => API_VERSION,
   BOOTSPRING_DIR: () => BOOTSPRING_DIR,
+  BOOTSPRING_PACKAGE_NAME: () => BOOTSPRING_PACKAGE_NAME,
+  BOOTSPRING_VERSION: () => BOOTSPRING_VERSION,
   COLORS: () => COLORS,
   CONFIG_FILE: () => CONFIG_FILE,
   CREDENTIALS_FILE: () => CREDENTIALS_FILE,
@@ -4681,6 +4685,7 @@ var {
 
 // src/index.ts
 init_dist2();
+init_dist();
 
 // src/middleware.ts
 init_cjs_shims();
@@ -7698,6 +7703,367 @@ init_cjs_shims();
 var fs8 = __toESM(require("fs"), 1);
 var path9 = __toESM(require("path"), 1);
 init_dist();
+function getPlanningSurfaceStatus() {
+  const planningDir = path9.join(process.cwd(), "planning");
+  return {
+    hasTodo: fs8.existsSync(path9.join(planningDir, "TODO.md")),
+    hasQueue: fs8.existsSync(path9.join(planningDir, "TASK_QUEUE.md"))
+  };
+}
+function printLegacyQueueWarningIfNeeded() {
+  const { hasTodo, hasQueue } = getPlanningSurfaceStatus();
+  if (hasTodo && hasQueue) {
+    print.warning("Legacy planning conflict detected: planning/TODO.md is canonical, but planning/TASK_QUEUE.md is still present.");
+    print.info("Run `bootspring build migrate-todo` to archive the lingering queue file.");
+  }
+}
+function formatPlanningSourceLabel(source) {
+  if (source === "TODO.md") return "planning/TODO.md";
+  if (source === "TASK_QUEUE.md") return "planning/TASK_QUEUE.md (legacy fallback)";
+  if (source === "BUILD_STATE.json") return "planning/BUILD_STATE.json";
+  return "not detected";
+}
+function normalizeStatus(value) {
+  const normalized = String(value || "pending").trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (normalized === "done" || normalized === "complete" || normalized === "completed") {
+    return "completed";
+  }
+  if (normalized === "inprogress" || normalized === "in_progress") {
+    return "in_progress";
+  }
+  if (normalized === "blocked" || normalized === "skipped") {
+    return normalized;
+  }
+  return normalized === "pending" ? "pending" : "pending";
+}
+function normalizePhase(value) {
+  const normalized = String(value || "mvp").trim().toLowerCase().replace(/[\s-]+/g, "_");
+  return ["foundation", "mvp", "launch"].includes(normalized) ? normalized : "mvp";
+}
+function formatPhaseName(phase) {
+  if (!phase) return "Unknown";
+  if (phase.toLowerCase() === "mvp") return "MVP";
+  const normalized = normalizePhase(phase);
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+function parseDependencyIds(rawText) {
+  const matches = rawText.match(/[a-z0-9][a-z0-9_-]*/gi) || [];
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    const token = match.trim();
+    if (!token.includes("-") || !/\d/.test(token) || seen.has(token)) continue;
+    seen.add(token);
+    ids.push(token);
+  }
+  return ids;
+}
+function parseSourceMetadata(rawSource) {
+  const trimmed = rawSource.trim();
+  const match = trimmed.match(/^(.+?)\s+\((.+)\)$/);
+  if (match?.[1] && match?.[2]) {
+    return {
+      source: match[1].trim(),
+      sourceSection: match[2].trim()
+    };
+  }
+  return { source: trimmed };
+}
+function parseTodoTasks(content) {
+  const tasks = [];
+  const lines = content.split("\n");
+  let currentPhase = "mvp";
+  let currentTask = null;
+  const pushTask = () => {
+    if (!currentTask) return;
+    tasks.push(currentTask);
+    currentTask = null;
+  };
+  for (const line of lines) {
+    const phaseMatch = line.match(/^##\s+(Foundation|MVP|Launch)\b/i);
+    if (phaseMatch?.[1]) {
+      pushTask();
+      currentPhase = normalizePhase(phaseMatch[1]);
+      continue;
+    }
+    const taskMatch = line.match(/^-\s+\[([ xX])\]\s+`([^`]+)`\s+(.+?)(?:\s+\(`?([\w-]+)`?\))?\s*$/);
+    if (taskMatch?.[2] && taskMatch?.[3]) {
+      pushTask();
+      const checked = taskMatch[1]?.toLowerCase() === "x";
+      currentTask = {
+        id: taskMatch[2].trim(),
+        title: taskMatch[3].trim(),
+        phase: currentPhase,
+        status: normalizeStatus(taskMatch[4] || (checked ? "completed" : "pending")),
+        acceptanceCriteria: [],
+        dependencies: []
+      };
+      continue;
+    }
+    if (!currentTask) {
+      continue;
+    }
+    const sourceMatch = line.match(/^\s{2,}-\s+\*\*Source:\*\*\s+(.+)\s*$/);
+    if (sourceMatch?.[1]) {
+      const sourceMetadata = parseSourceMetadata(sourceMatch[1]);
+      currentTask.source = sourceMetadata.source;
+      currentTask.sourceSection = sourceMetadata.sourceSection;
+      continue;
+    }
+    const descriptionMatch = line.match(/^\s{2,}-\s+\*\*Description:\*\*\s+(.+)\s*$/);
+    if (descriptionMatch?.[1]) {
+      currentTask.description = descriptionMatch[1].trim();
+      continue;
+    }
+    const complexityMatch = line.match(/^\s{2,}-\s+\*\*Complexity:\*\*\s+(.+)\s*$/);
+    if (complexityMatch?.[1]) {
+      currentTask.complexity = complexityMatch[1].trim().toLowerCase();
+      continue;
+    }
+    const dependenciesMatch = line.match(/^\s{2,}-\s+\*\*Dependencies:\*\*\s+(.+)\s*$/);
+    if (dependenciesMatch?.[1]) {
+      currentTask.dependencies = parseDependencyIds(dependenciesMatch[1]);
+      continue;
+    }
+    const criteriaMatch = line.match(/^\s{2,}-\s+\[[ xX]\]\s+(.+)\s*$/);
+    if (criteriaMatch?.[1]) {
+      currentTask.acceptanceCriteria?.push(criteriaMatch[1].trim());
+    }
+  }
+  pushTask();
+  return tasks;
+}
+function parseQueueTasks(content) {
+  const tasks = [];
+  const tableMatches = content.matchAll(/^\|\s*([^|]+)\s*\|\s*([a-z0-9][a-z0-9_-]*)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|$/gmi);
+  for (const match of tableMatches) {
+    const id = match[2]?.trim() ?? "";
+    const title = match[3]?.trim() ?? "";
+    if (id.toLowerCase() === "id" || title.toLowerCase() === "task" || id.includes("---") || title.includes("---")) {
+      continue;
+    }
+    tasks.push({
+      id,
+      title,
+      phase: normalizePhase(match[4]?.trim()),
+      complexity: String(match[5] || "medium").trim().toLowerCase(),
+      status: normalizeStatus(match[6]?.trim()),
+      acceptanceCriteria: [],
+      dependencies: []
+    });
+  }
+  const detailMatches = content.matchAll(/^###\s+([a-z0-9][a-z0-9_-]*):\s*(.+)$/gmi);
+  for (const match of detailMatches) {
+    const id = match[1]?.trim() ?? "";
+    const sectionStart = (match.index ?? 0) + match[0].length;
+    const nextSectionOffset = content.slice(sectionStart).search(/^###\s+/m);
+    const sectionContent = nextSectionOffset === -1 ? content.slice(sectionStart) : content.slice(sectionStart, sectionStart + nextSectionOffset);
+    const existing = tasks.find((task) => task.id === id);
+    const acceptanceCriteria = [];
+    const criteriaBlock = sectionContent.match(/\*{0,2}Acceptance\s+Criteria:\*{0,2}\s*([\s\S]*?)(?=\n\*{0,2}[A-Z]|\n---|\n###|$)/i);
+    if (criteriaBlock?.[1]) {
+      for (const criteriaMatch of criteriaBlock[1].matchAll(/^\s*[-*]\s+(?:\[[ xX]\]\s*)?(.+)$/gm)) {
+        if (criteriaMatch[1]) {
+          acceptanceCriteria.push(criteriaMatch[1].trim());
+        }
+      }
+    }
+    const dependencies = (() => {
+      const dependencyMatch = sectionContent.match(/\*{0,2}(?:Dependencies|Depends on):\*{0,2}\s*([\s\S]*?)(?=\n\*{0,2}[A-Z]|\n---|\n###|$)/i);
+      return dependencyMatch?.[1] ? parseDependencyIds(dependencyMatch[1]) : [];
+    })();
+    if (existing) {
+      existing.acceptanceCriteria = acceptanceCriteria;
+      existing.dependencies = dependencies;
+    }
+  }
+  return tasks;
+}
+function loadPlanningTasks() {
+  const todoFile = path9.join(process.cwd(), "planning", "TODO.md");
+  const queueFile = path9.join(process.cwd(), "planning", "TASK_QUEUE.md");
+  if (fs8.existsSync(todoFile)) {
+    try {
+      const tasks = parseTodoTasks(fs8.readFileSync(todoFile, "utf-8"));
+      if (tasks.length > 0) {
+        return { tasks, source: "TODO.md" };
+      }
+    } catch {
+    }
+  }
+  if (fs8.existsSync(queueFile)) {
+    try {
+      const tasks = parseQueueTasks(fs8.readFileSync(queueFile, "utf-8"));
+      if (tasks.length > 0) {
+        return { tasks, source: "TASK_QUEUE.md" };
+      }
+    } catch {
+    }
+  }
+  return { tasks: [], source: null };
+}
+function renderTodo(tasks, projectName) {
+  const byPhase = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const phase = normalizePhase(task.phase);
+    const phaseTasks = byPhase.get(phase) ?? [];
+    phaseTasks.push({ ...task, phase });
+    byPhase.set(phase, phaseTasks);
+  }
+  const orderedPhases = ["foundation", "mvp", "launch", ...Array.from(byPhase.keys()).filter((phase) => !["foundation", "mvp", "launch"].includes(phase))];
+  const total = tasks.length;
+  const completed = tasks.filter((task) => normalizeStatus(task.status) === "completed").length;
+  const pending = tasks.filter((task) => normalizeStatus(task.status) === "pending").length;
+  const inProgress = tasks.filter((task) => normalizeStatus(task.status) === "in_progress").length;
+  let content = `# ${projectName} - Build Todo
+
+> Single source of truth for autonomous build execution
+> Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+
+---
+
+## Program Status
+
+| Metric | Value |
+|---|---:|
+| Total Tasks | ${total} |
+| Completed | ${completed} |
+| Remaining | ${pending} |
+| In Progress | ${inProgress} |
+
+---
+
+`;
+  for (const phase of orderedPhases) {
+    const phaseTasks = byPhase.get(phase);
+    if (!phaseTasks || phaseTasks.length === 0) continue;
+    const phaseCompleted = phaseTasks.filter((task) => normalizeStatus(task.status) === "completed").length;
+    const percent = phaseTasks.length > 0 ? Math.round(phaseCompleted / phaseTasks.length * 100) : 0;
+    content += `## ${formatPhaseName(phase)} (${phaseCompleted}/${phaseTasks.length} \u2014 ${percent}%)
+
+`;
+    for (const task of phaseTasks) {
+      const status = normalizeStatus(task.status);
+      const checkbox = status === "completed" ? "[x]" : "[ ]";
+      const statusTag = status === "pending" ? "" : ` (\`${status}\`)`;
+      content += `- ${checkbox} \`${task.id}\` ${task.title}${statusTag}
+`;
+      if (task.source) {
+        const sourceLabel = task.sourceSection ? `${task.source} (${task.sourceSection})` : task.source;
+        content += `  - **Source:** ${sourceLabel}
+`;
+      }
+      if (task.description) {
+        content += `  - **Description:** ${task.description}
+`;
+      }
+      if (task.complexity && task.complexity !== "medium") {
+        content += `  - **Complexity:** ${task.complexity}
+`;
+      }
+      if (task.dependencies && task.dependencies.length > 0) {
+        content += `  - **Dependencies:** ${task.dependencies.join(", ")}
+`;
+      }
+      if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+        const criteriaCheckbox = status === "completed" ? "[x]" : "[ ]";
+        for (const criterion of task.acceptanceCriteria) {
+          content += `  - ${criteriaCheckbox} ${criterion}
+`;
+        }
+      }
+    }
+    content += "\n---\n\n";
+  }
+  content += `*Updated: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`;
+  return content;
+}
+function getCurrentPhase(queue) {
+  const active = queue?.find((task) => normalizeStatus(task.status) === "in_progress") ?? queue?.find((task) => normalizeStatus(task.status) === "pending");
+  return active?.phase ? formatPhaseName(active.phase) : "N/A";
+}
+function getTaskEntriesFromState(state) {
+  return (state?.implementationQueue ?? []).map((task) => ({
+    id: task.id,
+    title: task.title,
+    phase: task.phase,
+    complexity: task.estimatedComplexity,
+    status: normalizeStatus(task.status),
+    description: task.description,
+    source: task.source,
+    sourceSection: task.sourceSection,
+    acceptanceCriteria: task.acceptanceCriteria ?? [],
+    dependencies: task.dependencies ?? []
+  }));
+}
+function extractSupplementaryContent(queueContent) {
+  const lines = queueContent.split("\n");
+  const sections = [];
+  let currentSection = null;
+  let inTaskTable = false;
+  let inTaskDetail = false;
+  for (const rawLine of lines) {
+    const line = rawLine ?? "";
+    if (/^\|\s*(Priority|Position|#)\s*\|/i.test(line)) {
+      inTaskTable = true;
+      continue;
+    }
+    if (inTaskTable && /^\|/.test(line)) continue;
+    if (inTaskTable && !/^\|/.test(line)) inTaskTable = false;
+    if (/^###\s+([a-z0-9][a-z0-9_-]*)\s*:/.test(line)) {
+      inTaskDetail = true;
+      continue;
+    }
+    if (inTaskDetail && /^#{2,3}\s+/.test(line) && !/^###\s+([a-z0-9][a-z0-9_-]*)\s*:/.test(line)) {
+      inTaskDetail = false;
+    }
+    if (inTaskDetail) continue;
+    if (/^#\s+.*(?:Implementation Queue|Task Queue)\b/i.test(line)) continue;
+    if (/^>\s*(Ordered task queue|Last Updated|Current Version)/i.test(line)) continue;
+    if (/^##\s+(Queue Status|Task Details)\b/i.test(line)) {
+      if (/^##\s+Queue Status\b/i.test(line)) inTaskTable = true;
+      if (/^##\s+Task Details\b/i.test(line)) inTaskDetail = true;
+      continue;
+    }
+    if (/^\*Generated by/i.test(line)) continue;
+    if (/^---$/.test(line.trim())) continue;
+    if (/^##\s+/.test(line)) {
+      if (currentSection) sections.push(currentSection);
+      currentSection = { heading: line, lines: [] };
+      continue;
+    }
+    if (currentSection) {
+      currentSection.lines.push(line);
+    }
+  }
+  if (currentSection) {
+    sections.push(currentSection);
+  }
+  return sections.filter((section) => section.lines.some((line) => line.trim().length > 0)).map((section) => `${section.heading}
+
+${section.lines.join("\n").trim()}`).join("\n\n---\n\n").trim();
+}
+function getAvailableArchivePath(filePath) {
+  const baseArchivePath = `${filePath}.bak`;
+  if (!fs8.existsSync(baseArchivePath)) {
+    return baseArchivePath;
+  }
+  let counter = 1;
+  while (fs8.existsSync(`${baseArchivePath}.${counter}`)) {
+    counter += 1;
+  }
+  return `${baseArchivePath}.${counter}`;
+}
+function syncTodoFromState(state) {
+  const queue = state.implementationQueue ?? [];
+  if (queue.length === 0) return;
+  const dir = path9.join(process.cwd(), "planning");
+  if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+  const todoPath = path9.join(dir, "TODO.md");
+  const tasks = getTaskEntriesFromState(state);
+  fs8.writeFileSync(todoPath, renderTodo(tasks, state.projectName ?? path9.basename(process.cwd())));
+}
 function loadBuildState() {
   const stateFile = path9.join(process.cwd(), "planning", "BUILD_STATE.json");
   if (!fs8.existsSync(stateFile)) return null;
@@ -7710,67 +8076,21 @@ function loadBuildState() {
 function saveBuildState(state) {
   const dir = path9.join(process.cwd(), "planning");
   if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+  if (state.implementationQueue?.length) {
+    state.currentPhase = getCurrentPhase(state.implementationQueue);
+  }
   if (state.metadata) state.metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   fs8.writeFileSync(path9.join(dir, "BUILD_STATE.json"), JSON.stringify(state, null, 2));
+  syncTodoFromState(state);
 }
 function loadTasks() {
-  const todoFile = path9.join(process.cwd(), "planning", "TODO.md");
-  const queueFile = path9.join(process.cwd(), "planning", "TASK_QUEUE.md");
-  const files = [];
-  if (fs8.existsSync(todoFile)) files.push(todoFile);
-  if (fs8.existsSync(queueFile)) files.push(queueFile);
-  for (const file of files) {
-    try {
-      const content = fs8.readFileSync(file, "utf-8");
-      const tasks = [];
-      if (file.endsWith("TODO.md")) {
-        let currentPhase = "Unknown";
-        for (const line of content.split("\n")) {
-          const phaseMatch = line.match(/^##\s+(Foundation|MVP|Launch)\b/i);
-          if (phaseMatch) {
-            currentPhase = phaseMatch[1];
-            continue;
-          }
-          const todoMatch = line.match(/^-\s+\[([ xX])\]\s+`(bs-\d+)`\s+(.+?)(?:\s+\(`?(\w+)`?\))?$/);
-          if (todoMatch) {
-            const checked = todoMatch[1].toLowerCase() === "x";
-            const explicitStatus = todoMatch[4]?.toLowerCase();
-            tasks.push({
-              id: todoMatch[2],
-              title: todoMatch[3].trim(),
-              phase: currentPhase,
-              status: explicitStatus || (checked ? "completed" : "pending")
-            });
-          }
-        }
-        if (tasks.length > 0) return tasks;
-      }
-      for (const line of content.split("\n")) {
-        const match = line.match(/\|\s*\d+\s*\|\s*(bs-\d+)\s*\|\s*(.+?)\s*\|\s*(\w+)\s*\|\s*(\w+)\s*\|\s*(\w+)\s*\|/);
-        if (match) {
-          tasks.push({
-            id: match[1],
-            title: match[2].trim(),
-            phase: match[3],
-            complexity: match[4],
-            status: match[5]
-          });
-        }
-      }
-      if (tasks.length > 0) return tasks;
-    } catch {
-      continue;
-    }
+  const planningTasks = loadPlanningTasks();
+  if (planningTasks.tasks.length > 0) {
+    return planningTasks.tasks;
   }
   const state = loadBuildState();
   if (state?.implementationQueue?.length) {
-    return state.implementationQueue.map((t) => ({
-      id: t.id,
-      title: t.title,
-      phase: t.phase,
-      complexity: t.estimatedComplexity,
-      status: t.status
-    }));
+    return getTaskEntriesFromState(state);
   }
   return [];
 }
@@ -7778,8 +8098,10 @@ function registerBuildCommand(program3) {
   const build = program3.command("build").description("Manage the build loop");
   build.command("status").description("Check build progress").action(() => {
     const state = loadBuildState();
-    const tasks = loadTasks();
+    const planningTasks = loadPlanningTasks();
+    const tasks = planningTasks.tasks.length > 0 ? planningTasks.tasks : getTaskEntriesFromState(state);
     print.header("Build Status");
+    printLegacyQueueWarningIfNeeded();
     if (!state) {
       print.warning("No build state found. Run `bootspring build start` to begin.");
       return;
@@ -7797,11 +8119,16 @@ function registerBuildCommand(program3) {
     const sessionId = state.loopSession?.sessionId ?? "N/A";
     print.info(`Project: ${state.projectName ?? "Unknown"}`);
     print.info(`Status: ${state.status}`);
-    print.info(`Phase: ${state.currentPhase ?? "N/A"}`);
+    print.info(`Phase: ${formatPhaseName(state.currentPhase ?? getCurrentPhase(state.implementationQueue))}`);
+    print.info(`Planning Source: ${formatPlanningSourceLabel(planningTasks.source ?? (state ? "BUILD_STATE.json" : null))}`);
     print.info(`Progress: ${completed}/${total} (${pct}%)`);
     print.info(`Pending: ${pending}`);
     if (inProgress > 0) print.info(`In Progress: ${inProgress}`);
-    print.info(`Iteration: ${iteration}/${maxIter}`);
+    if (iteration > maxIter) {
+      print.info(`Iteration: ${iteration} (session max ${maxIter})`);
+    } else {
+      print.info(`Iteration: ${iteration}/${maxIter}`);
+    }
     print.info(`Session: ${sessionId}`);
     const currentTask = tasks.find((t) => t.status.toLowerCase() === "in_progress");
     if (currentTask) {
@@ -7813,6 +8140,7 @@ function registerBuildCommand(program3) {
     console.log(`  [${bar}] ${pct}%`);
   });
   build.command("task").description("Show the current task").action(() => {
+    printLegacyQueueWarningIfNeeded();
     const tasks = loadTasks();
     const current = tasks.find((t) => t.status.toLowerCase() === "in_progress");
     const next = current ?? tasks.find((t) => t.status.toLowerCase() === "pending");
@@ -7857,6 +8185,7 @@ function registerBuildCommand(program3) {
     }
   });
   build.command("plan").description("View the full build plan").action(() => {
+    printLegacyQueueWarningIfNeeded();
     const tasks = loadTasks();
     if (tasks.length === 0) {
       print.warning("No tasks found in planning/TODO.md or planning/TASK_QUEUE.md");
@@ -7956,10 +8285,11 @@ function registerBuildCommand(program3) {
     saveBuildState(state);
     print.info("Build resumed");
   });
-  build.command("sync").description("Sync tasks from TASK_QUEUE.md to BUILD_STATE.json").action(() => {
-    const queueFile = path9.join(process.cwd(), "planning", "TASK_QUEUE.md");
-    if (!fs8.existsSync(queueFile)) {
-      print.warning("No planning/TASK_QUEUE.md found");
+  build.command("sync").description("Sync planning tasks from TODO.md into BUILD_STATE.json").option("--replace", "Replace runtime queue instead of merging").action((opts) => {
+    printLegacyQueueWarningIfNeeded();
+    const planningTasks = loadPlanningTasks();
+    if (planningTasks.tasks.length === 0) {
+      print.warning("No planning/TODO.md found (legacy fallback: planning/TASK_QUEUE.md)");
       return;
     }
     const state = loadBuildState();
@@ -7967,24 +8297,62 @@ function registerBuildCommand(program3) {
       print.error("No build state found");
       return;
     }
-    const tasks = loadTasks();
-    const existingIds = new Set((state.implementationQueue ?? []).map((t) => t.id));
+    const replace = Boolean(opts.replace);
+    const planningIds = new Set(planningTasks.tasks.map((task) => task.id));
+    const existingQueue = replace ? [] : state.implementationQueue ?? [];
+    const existingIds = new Set(existingQueue.map((t) => t.id));
     let added = 0;
-    for (const task of tasks) {
+    let updated = 0;
+    for (const task of planningTasks.tasks) {
       if (!existingIds.has(task.id)) {
-        state.implementationQueue = state.implementationQueue ?? [];
-        state.implementationQueue.push({
+        existingQueue.push({
           id: task.id,
           title: task.title,
           phase: task.phase,
           status: task.status,
-          estimatedComplexity: task.complexity
+          estimatedComplexity: task.complexity,
+          description: task.description,
+          source: task.source,
+          sourceSection: task.sourceSection,
+          acceptanceCriteria: task.acceptanceCriteria,
+          dependencies: task.dependencies
         });
         added++;
+        continue;
       }
+      const index = existingQueue.findIndex((existing) => existing.id === task.id);
+      if (index >= 0) {
+        const previous = existingQueue[index];
+        const nextTask = {
+          ...previous,
+          id: task.id,
+          title: task.title,
+          phase: task.phase,
+          status: task.status,
+          estimatedComplexity: task.complexity,
+          description: task.description,
+          source: task.source,
+          sourceSection: task.sourceSection,
+          acceptanceCriteria: task.acceptanceCriteria,
+          dependencies: task.dependencies
+        };
+        if (JSON.stringify(previous) !== JSON.stringify(nextTask)) {
+          existingQueue[index] = nextTask;
+          updated++;
+        }
+      }
+    }
+    const orderedQueue = [
+      ...planningTasks.tasks.map((task) => existingQueue.find((existing) => existing.id === task.id)).filter(Boolean),
+      ...existingQueue.filter((task) => !planningIds.has(task.id))
+    ];
+    state.implementationQueue = orderedQueue;
+    if (!state.metadata) {
+      state.metadata = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
     }
     saveBuildState(state);
-    print.success(`Synced ${added} new tasks (${state.implementationQueue?.length ?? 0} total)`);
+    print.success(`Synced ${added} new tasks and updated ${updated} tasks (${state.implementationQueue?.length ?? 0} total)`);
+    print.info(`Planning source: ${planningTasks.source ?? "unknown"}`);
   });
   build.command("stop").description("Graceful stop the build loop").action(() => {
     const state = loadBuildState();
@@ -8040,6 +8408,7 @@ function registerBuildCommand(program3) {
     print.success(`Started: ${first.id} \u2014 ${first.title}`);
   });
   build.command("start").description("Initialize build from seed/planning documents").action(() => {
+    printLegacyQueueWarningIfNeeded();
     const state = loadBuildState();
     if (state) {
       print.warning("Build already initialized. Use `bootspring build status` to check progress.");
@@ -8047,7 +8416,7 @@ function registerBuildCommand(program3) {
     }
     const tasks = loadTasks();
     if (tasks.length === 0) {
-      print.warning("No tasks found in planning/TODO.md or planning/TASK_QUEUE.md");
+      print.warning("No tasks found in planning/TODO.md (legacy fallback: planning/TASK_QUEUE.md)");
       print.info("Run `bootspring preseed` or `bootspring prd create` first to generate tasks.");
       return;
     }
@@ -8075,54 +8444,56 @@ function registerBuildCommand(program3) {
     print.success(`Build initialized with ${tasks.length} tasks`);
     print.info("Run `bootspring build next` to start the first task");
   });
-  build.command("migrate-todo").alias("migrate").description("Convert TASK_QUEUE.md to enriched TODO.md format").action(() => {
+  build.command("migrate-todo").alias("migrate").description("Convert legacy TASK_QUEUE.md into canonical TODO.md format and archive the queue by default").option("--keep-queue", "Keep legacy planning/TASK_QUEUE.md instead of archiving it").action((options) => {
     const queueFile = path9.join(process.cwd(), "planning", "TASK_QUEUE.md");
     const todoFile = path9.join(process.cwd(), "planning", "TODO.md");
-    if (!fs8.existsSync(queueFile)) {
-      print.warning("No planning/TASK_QUEUE.md found to migrate");
-      return;
-    }
-    if (fs8.existsSync(todoFile)) {
-      print.warning("planning/TODO.md already exists. Delete it first to re-migrate.");
-      return;
-    }
+    const state = loadBuildState();
+    const keepQueue = Boolean(options.keepQueue);
+    const hasTodo = fs8.existsSync(todoFile);
+    const hasQueue = fs8.existsSync(queueFile);
     try {
-      const content = fs8.readFileSync(queueFile, "utf-8");
-      const tasks = [];
-      for (const line of content.split("\n")) {
-        const match = line.match(/\|\s*\d+\s*\|\s*(bs-\d+)\s*\|\s*(.+?)\s*\|\s*(\w+)\s*\|\s*(\w+)\s*\|\s*(\w+)\s*\|/);
-        if (match) {
-          tasks.push({
-            id: match[1],
-            title: match[2].trim(),
-            phase: match[3],
-            complexity: match[4],
-            status: match[5]
-          });
-        }
+      const planningTasks = loadPlanningTasks();
+      let tasks = planningTasks.tasks;
+      let source = planningTasks.source;
+      if (tasks.length === 0) {
+        tasks = getTaskEntriesFromState(state);
+        source = tasks.length > 0 ? "BUILD_STATE.json" : null;
       }
       if (tasks.length === 0) {
-        print.warning("No tasks found in TASK_QUEUE.md");
+        print.warning("No tasks found in planning/TODO.md, planning/TASK_QUEUE.md, or planning/BUILD_STATE.json");
         return;
       }
-      const phases = [...new Set(tasks.map((t) => t.phase))];
-      let todoContent = "# Build TODO\n\n";
-      for (const phase of phases) {
-        todoContent += `## ${phase}
+      const dir = path9.dirname(todoFile);
+      if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+      const projectName = state?.projectName ?? path9.basename(process.cwd());
+      if (!hasTodo || source !== "TODO.md") {
+        let todoContent = renderTodo(tasks, projectName);
+        if (hasQueue && source === "TASK_QUEUE.md") {
+          const supplementaryContent = extractSupplementaryContent(fs8.readFileSync(queueFile, "utf-8"));
+          if (supplementaryContent) {
+            todoContent += `
+---
 
+## Reference (from TASK_QUEUE.md)
+
+${supplementaryContent}
 `;
-        const phaseTasks = tasks.filter((t) => t.phase === phase);
-        for (const task of phaseTasks) {
-          const checked = task.status.toLowerCase() === "completed" || task.status.toLowerCase() === "done";
-          todoContent += `- [${checked ? "x" : " "}] \`${task.id}\` ${task.title}
-`;
+          }
         }
-        todoContent += "\n";
+        fs8.writeFileSync(todoFile, todoContent);
+        print.success(`Wrote planning/TODO.md from ${source ?? "planning data"} (${tasks.length} tasks)`);
+      } else {
+        print.info("Retained existing planning/TODO.md as the canonical task file");
+      }
+      if (hasQueue && !keepQueue) {
+        const archivePath = getAvailableArchivePath(queueFile);
+        fs8.renameSync(queueFile, archivePath);
+        print.success(`Archived legacy TASK_QUEUE.md to planning/${path9.basename(archivePath)}`);
+      } else if (hasQueue && keepQueue) {
+        print.info("Retained legacy TASK_QUEUE.md for compatibility (--keep-queue)");
+      } else {
+        print.info("No planning/TASK_QUEUE.md present; nothing to archive");
       }
-      const dir = path9.dirname(todoFile);
-      if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
-      fs8.writeFileSync(todoFile, todoContent);
-      print.success(`Migrated ${tasks.length} tasks to planning/TODO.md`);
     } catch (err) {
       print.error(`Migration failed: ${err.message}`);
     }
@@ -8130,6 +8501,7 @@ function registerBuildCommand(program3) {
   build.command("backfill").aliases(["recover", "hydrate", "bootstrap"]).description("Recover build artifacts from existing codebase").action(() => {
     const planningDir = path9.join(process.cwd(), "planning");
     print.header("Build Artifact Recovery");
+    printLegacyQueueWarningIfNeeded();
     const hasState = fs8.existsSync(path9.join(planningDir, "BUILD_STATE.json"));
     const hasTodo = fs8.existsSync(path9.join(planningDir, "TODO.md"));
     const hasQueue = fs8.existsSync(path9.join(planningDir, "TASK_QUEUE.md"));
@@ -8420,7 +8792,7 @@ function registerGenerateCommand(program3) {
     const sections = [
       `# ${projectName} - AI Context`,
       "",
-      "**Generated by**: Bootspring v2.0.0",
+      `**Generated by**: Bootspring v${BOOTSPRING_VERSION}`,
       `**Last Updated**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
       "",
       "---",
@@ -9325,7 +9697,7 @@ function registerLoopCommand(program3) {
     }
     const tasks = loadTasks2();
     if (tasks.length === 0) {
-      print.warning("No tasks found in planning/TODO.md or planning/TASK_QUEUE.md");
+      print.warning("No tasks found in planning/TODO.md (legacy fallback: planning/TASK_QUEUE.md)");
       return;
     }
     const pending = tasks.filter((t) => t.status.toLowerCase() === "pending");
@@ -13666,9 +14038,227 @@ init_cjs_shims();
 var fs30 = __toESM(require("fs"), 1);
 var path31 = __toESM(require("path"), 1);
 init_dist();
-var OUTPUT_DIR = "planning";
-function getTemplates(projectName, date) {
+
+// src/commands/business-templates.ts
+init_cjs_shims();
+
+// src/commands/business-strategy-modules.ts
+init_cjs_shims();
+var STRATEGY_MODULES = [
+  {
+    title: "Precision ICP Builder",
+    useWhen: "You need a buyer definition that changes product, sales, and messaging decisions immediately.",
+    prompt: ["You are a market research strategist for early-stage software and services.", "Build a decision-ready ideal customer profile for the project."],
+    returns: ["buyer filters that materially affect purchase behavior", "identity, professional self-image, status fears, and desired reputation", "urgent pains versus tolerable pains", "active buying triggers and decision style", "exact customer language, reachable communities, objections, first-buyer profile, and one opening sentence"],
+    inputs: ["Offer: <describe what you sell>", "Current customer guess: <who you think buys today>"]
+  },
+  {
+    title: "Distinctive Positioning Builder",
+    useWhen: "You need messaging that sounds like you, not a generic competitor.",
+    prompt: ["You are a positioning strategist.", "Write positioning for the project that survives a specificity test."],
+    returns: ["one sharp positioning statement", "a rewrite pass that removes vague phrases", "a competitor difference matrix on the 4 factors buyers actually care about", "variations for cold outreach, homepage copy, and spoken pitch", "a short validation question to ask live prospects"],
+    inputs: ["Product: <what you do>", "Target customer: <who buys this>", "Main alternative: <what buyers do instead>", "Real differentiator: <what is true and hard to copy>"]
+  },
+  {
+    title: "Pricing Architecture Builder",
+    useWhen: "You want pricing to steer buyers toward the right plan instead of just listing options.",
+    prompt: ["You are a monetization strategist.", "Design a 3-tier pricing system for the project with strong anchoring."],
+    returns: ["entry, core, and premium tier structure", "why each tier exists and what should stay out of it", "recommended monthly and annual price points", "upgrade triggers between tiers", "page-ordering, trial logic, and the pricing mistake most likely to hurt us"],
+    inputs: ["Offer: <describe what you sell>", "Pricing instinct: <what you were planning to charge>", "Target customer: <who buys>"]
+  },
+  {
+    title: "90-Day GTM Sprint Planner",
+    useWhen: "You need a week-by-week launch plan with zero fluff and no paid ads.",
+    prompt: ["You are a zero-to-one go-to-market operator.", "Create a 90-day GTM plan for the project."],
+    returns: ["one-line ICP restatement", "top 3 launch channels ranked by likely first-90-day ROI", "week-by-week actions for validation, first closes, system building, and momentum", "measurable weekly targets", "2 daily non-negotiables for month 1", "one signal that proves the market is responding"],
+    inputs: ["Product: <describe the product or service>", "Ideal buyer: <specific role and context>", "Available channels: <email, LinkedIn, communities, network, etc.>"]
+  },
+  {
+    title: "Partnership Lever Scanner",
+    useWhen: "You want distribution through other people\u2019s audiences instead of only direct outreach.",
+    prompt: ["You are a partnership strategist.", "Find partnership and co-marketing opportunities for the project."],
+    returns: ["complementary product partners", "audience owners and the co-marketing format that fits each", "referral partners and incentive logic", "integration partners that place us near the moment of need", "first outreach message and top 3 fastest opportunities"],
+    inputs: ["Product: <what you sell>", "ICP: <who you want to reach>", "Category: <your niche or market>"]
+  },
+  {
+    title: "Competitive Gap and Threat Review",
+    useWhen: "You need actionable white space, not a generic list of rivals.",
+    prompt: ["You are a competitive intelligence analyst.", "Map the competitive field for the project and show where we can win."],
+    returns: ["the 5 most relevant competitors ranked by directness", "each rival\u2019s model, strengths, recurring weaknesses, and ignored segment", "the open category gap buyers would pay for", "the competitor most likely to copy us and how to raise the bar before they do", "3 quick wins to take buyers from a named rival this month"],
+    inputs: ["Product: <what you sell>", "Known competitors: <names or descriptions>"]
+  },
+  {
+    title: "Moat and Defensibility Planner",
+    useWhen: "You need a credible path to defensibility before scale makes copying easier.",
+    prompt: ["You are a startup strategy advisor.", "Evaluate defensibility for the project."],
+    returns: ["current moat score across network effects, switching costs, cost advantage, intangible assets, and efficient scale", "the 1 or 2 moat types most realistic right now", "90-day actions that start compounding defensibility", "an incumbent attack scenario and how to reduce vulnerability", "a 2-sentence investor explanation of the moat"],
+    inputs: ["Business model: <describe product and monetization>", "Current unfair advantage: <what is hard to copy today>"]
+  },
+  {
+    title: "Revenue Model Stress Test",
+    useWhen: "Your model looks fine on paper but you need to find the weak assumptions early.",
+    prompt: ["You are a financial model reviewer.", "Pressure-test the revenue model for the project."],
+    returns: ["unit economics summary", "break-even math and runway implications", "churn and concentration risks", "pricing-pressure scenario analysis", "customer growth math to reach key revenue milestones", "the single assumption that could break the model", "the one improvement lever with the highest 90-day impact"],
+    inputs: ["Revenue model: <how money is made>", "Current pricing: <what you charge>", "Cost structure: <rough CAC and cost to serve>"]
+  },
+  {
+    title: "Investor One-Pager Draft Builder",
+    useWhen: "You need a fundraising artifact that is short, specific, and credible.",
+    prompt: ["You are a fundraising narrative advisor.", "Write a one-page investor brief for the project."],
+    returns: ["clear problem, solution, market framing, model, traction, team, and ask", "a competition section that differentiates without posturing", "a one-page layout with suggested word count per section", "the closing line that makes a meeting feel like the next obvious step"],
+    inputs: ["Product: <what is being built>", "Traction: <revenue, pilots, waitlist, design partners, etc.>", "Team: <who is building it>"]
+  },
+  {
+    title: "Startup Launch Brief",
+    useWhen: "You want one document that turns strategy into immediate execution.",
+    prompt: ["You are a founding-team operator.", "Synthesize the current plan for the project into a one-page execution brief."],
+    returns: ["business in one line", "ICP in one line", "positioning in one line", "pricing summary", "30-day action plan", "first 5 customers with outreach angle", "top 3 risks and the mitigation for each", "the single highest-leverage action for the next 7 days", "the measurable 90-day success definition"],
+    inputs: ["Idea context: <product, market, stage, founder context>", "Biggest uncertainty: <what feels most risky>", "90-day goal: <what success looks like>"]
+  },
+  {
+    title: "Customer Interview Guide",
+    useWhen: "You want interviews that produce decisions, not polite anecdotes.",
+    prompt: ["You are a customer interview coach.", "Create a buyer interview guide for the project."],
+    returns: ["12 interview questions in the right order", "follow-up probes for pain, urgency, alternatives, and budget", "signals that indicate real buying intent", "the 3 mistakes that bias the conversation"],
+    inputs: ["Who you want to interview: <specific buyer type>", "Hypothesis to test: <belief you want validated or disproved>"]
+  },
+  {
+    title: "Offer Packaging Designer",
+    useWhen: "Your product is clear but the way it is sold still feels muddy.",
+    prompt: ["You are an offer designer.", "Turn the project into a clear, high-conversion offer."],
+    returns: ["core deliverable and boundary definition", "what is included, excluded, guaranteed, and time-bound", "add-ons, bonuses, urgency devices, and risk reversal", "the offer version best suited for first customers"],
+    inputs: ["Product: <what you sell>", "Buyer: <who buys>", "Delivery model: <software, service, hybrid, one-time, recurring>"]
+  },
+  {
+    title: "Homepage Messaging Brief",
+    useWhen: "The product is real but the homepage does not yet explain why anyone should care.",
+    prompt: ["You are a conversion copy strategist.", "Draft the messaging architecture for the homepage."],
+    returns: ["hero headline and subhead", "proof strip, problem framing, value explanation, objection handling, and CTA logic", "section order for a high-intent homepage", "copy notes for designers and implementers"],
+    inputs: ["ICP: <who lands on the page>", "Offer: <what you sell>", "Proof available: <logos, results, founder story, testimonials>"]
+  },
+  {
+    title: "Outbound Sequence Builder",
+    useWhen: "You need a repeatable outbound message system rooted in real buyer pain.",
+    prompt: ["You are an outbound operator.", "Write a short outbound sequence for the project."],
+    returns: ["first-touch email or DM", "3 follow-ups with different angles", "subject lines or hooks", "reply handling for curiosity, no timing, wrong fit, and no response"],
+    inputs: ["Target role: <who you are contacting>", "Trigger event: <what happened that makes them timely>", "Offer angle: <why they should care now>"]
+  },
+  {
+    title: "Sales Discovery Blueprint",
+    useWhen: "You need a better structure for live calls and demos.",
+    prompt: ["You are a sales discovery coach.", "Design a discovery and demo flow for the project."],
+    returns: ["call agenda", "key diagnostic questions", "what to show in the product and in what order", "deal qualification criteria", "close question and next-step framing"],
+    inputs: ["Buyer type: <role and company>", "Typical use case: <what they want done>", "Common objection: <what usually stalls the sale>"]
+  },
+  {
+    title: "Activation Friction Audit",
+    useWhen: "People sign up or book demos but stall before reaching value.",
+    prompt: ["You are a product activation strategist.", "Audit the first-use journey for the project."],
+    returns: ["the first-value milestone", "the top friction points before that milestone", "manual assists, product changes, and lifecycle messaging fixes", "one metric that best measures activation progress"],
+    inputs: ["Onboarding flow: <how new users start>", "Desired outcome: <what first value looks like>", "Current drop-off: <where people stall today>"]
+  },
+  {
+    title: "Referral Engine Designer",
+    useWhen: "You have some happy users but no deliberate referral motion.",
+    prompt: ["You are a referral growth strategist.", "Design a referral loop for the project."],
+    returns: ["the ideal moment to ask for a referral", "what the referrer and referred person each get", "the message and CTA to use", "how to track quality, not just volume"],
+    inputs: ["Best-fit customer: <who is happiest today>", "Product outcome: <what result they got>", "Incentive limits: <what you can realistically offer>"]
+  },
+  {
+    title: "Case Study Capture Kit",
+    useWhen: "You are getting wins but not turning them into reusable proof.",
+    prompt: ["You are a case-study editor.", "Create a case-study capture system for the project."],
+    returns: ["interview questions for customers", "the before/during/after story arc", "proof formats for website, outbound, investor updates, and sales calls", "release and approval checklist"],
+    inputs: ["Customer win: <what changed for them>", "Available evidence: <quotes, screenshots, metrics, call notes>"]
+  },
+  {
+    title: "Founder Narrative Builder",
+    useWhen: "You need a tighter founder story for customers, hires, and investors.",
+    prompt: ["You are a founder narrative strategist.", "Shape the founder story for the project."],
+    returns: ["short founder story for homepage and deck", "longer origin story for meetings and recruiting", "why-now logic", "credibility anchors that feel earned rather than inflated"],
+    inputs: ["Founder background: <relevant experience>", "Why this matters: <personal reason or market insight>", "What gives credibility: <evidence you can execute>"]
+  },
+  {
+    title: "Channel Experiment Scorecard",
+    useWhen: "You have too many growth ideas and need to prioritize the next 30 days.",
+    prompt: ["You are a growth experiment lead.", "Build a channel experiment scorecard for the project."],
+    returns: ["10 experiments scored by impact, speed, confidence, and cost", "one experiment to run this week", "kill criteria, success metric, and owner for each", "the reporting cadence for a 30-day sprint"],
+    inputs: ["Current channels: <where you can reach buyers today>", "Team capacity: <how much time or headcount you have>", "Revenue goal: <what outcome matters most next>"]
+  }
+];
+
+// src/commands/business-templates.ts
+function renderList(items) {
+  return items.map((item) => `- ${item}`).join("\n");
+}
+function renderStrategyModule(module2, index) {
+  return `### ${index}. ${module2.title}
+
+**Use when**: ${module2.useWhen}
+
+**Prompt**
+${module2.prompt.join("\n")}
+
+Return:
+${renderList(module2.returns)}
+
+Inputs:
+${renderList(module2.inputs)}`;
+}
+function buildFounderStrategyPack(projectName, date) {
+  const coreModules = STRATEGY_MODULES.slice(0, 10).map((module2, index) => renderStrategyModule(module2, index + 1)).join("\n\n");
+  const expansionModules = STRATEGY_MODULES.slice(10).map((module2, index) => renderStrategyModule(module2, index + 11)).join("\n\n");
+  return `# Founder Strategy Pack: ${projectName}
+
+> **Version**: 1.0 | **Created**: ${date} | **Purpose**: Founder strategy prompts for customer research, positioning, pricing, GTM, fundraising, and growth
+
+---
+
+## How to Use This Pack
+
+- Start with modules 1 through 10 to sharpen customer, market, and business fundamentals.
+- Use modules 11 through 20 to tighten execution, messaging, activation, and growth loops.
+- Feed the outputs back into \`AUDIENCE.md\`, \`BUSINESS_MODEL.md\`, \`COMPETITORS.md\`, \`ROADMAP.md\`, and your launch docs.
+- Replace the angle-bracket inputs before pasting a prompt into your preferred assistant or Bootspring workflow.
+
+---
+
+## Core Strategy Modules
+
+${coreModules}
+
+---
+
+## Execution Expansion Modules
+
+${expansionModules}
+
+---
+
+## Recommended Order
+
+1. Precision ICP Builder
+2. Distinctive Positioning Builder
+3. Pricing Architecture Builder
+4. 90-Day GTM Sprint Planner
+5. Competitive Gap and Threat Review
+6. Startup Launch Brief
+
+Then use the expansion modules based on the bottleneck you hit first.
+
+---
+
+*Generated with Bootspring*
+`;
+}
+function getBusinessTemplates(projectName, date) {
   return {
+    strategy: {
+      name: "Founder Strategy Pack",
+      output: "FOUNDER_STRATEGY_PACK.md",
+      description: "20 founder strategy prompts for ICP, pricing, GTM, fundraising, and growth",
+      content: buildFounderStrategyPack(projectName, date)
+    },
     plan: {
       name: "Business Plan",
       output: "BUSINESS_PLAN.md",
@@ -13841,6 +14431,9 @@ For [target customer] who [need], [product] is a [category] that [key benefit].
     }
   };
 }
+
+// src/commands/business.ts
+var OUTPUT_DIR = "planning";
 function registerBusinessCommand(program3) {
   const business = program3.command("business").description("Business planning and strategy tools");
   business.command("init").description("Initialize all business planning documents").action(async () => {
@@ -13853,7 +14446,7 @@ function registerBusinessCommand(program3) {
     if (!fs30.existsSync(outputDir)) {
       fs30.mkdirSync(outputDir, { recursive: true });
     }
-    const templates = getTemplates(projectName, date);
+    const templates = getBusinessTemplates(projectName, date);
     const created = [];
     const skipped = [];
     const spinner = createSpinner("Creating business documents...").start();
@@ -13880,15 +14473,37 @@ function registerBusinessCommand(program3) {
       }
     }
     console.log("\nNext Steps:");
-    console.log(`  1. Edit ${OUTPUT_DIR}/BUSINESS_PLAN.md`);
-    console.log("  2. Run `bootspring agent invoke business-strategy-expert`");
-    console.log("  3. Run `bootspring business status` to check progress");
+    console.log(`  1. Edit ${OUTPUT_DIR}/FOUNDER_STRATEGY_PACK.md`);
+    console.log(`  2. Edit ${OUTPUT_DIR}/BUSINESS_PLAN.md`);
+    console.log("  3. Run `bootspring agent invoke business-strategy-expert`");
+    console.log("  4. Run `bootspring business status` to check progress");
+  });
+  business.command("strategy").description("Create founder strategy pack").action(async () => {
+    const projectRoot = process.cwd();
+    const projectName = path31.basename(projectRoot);
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const templates = getBusinessTemplates(projectName, date);
+    const template = templates.strategy;
+    print.header(template.name);
+    const outputDir = path31.join(projectRoot, OUTPUT_DIR);
+    const outputPath = path31.join(outputDir, template.output);
+    if (fs30.existsSync(outputPath)) {
+      print.warning(`File already exists: ${OUTPUT_DIR}/${template.output}`);
+      return;
+    }
+    if (!fs30.existsSync(outputDir)) {
+      fs30.mkdirSync(outputDir, { recursive: true });
+    }
+    fs30.writeFileSync(outputPath, template.content);
+    print.success(`Created ${template.name}`);
+    console.log(`
+File: ${OUTPUT_DIR}/${template.output}`);
   });
   business.command("plan").description("Create business plan").action(async () => {
     const projectRoot = process.cwd();
     const projectName = path31.basename(projectRoot);
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const templates = getTemplates(projectName, date);
+    const templates = getBusinessTemplates(projectName, date);
     const template = templates.plan;
     print.header(template.name);
     const outputDir = path31.join(projectRoot, OUTPUT_DIR);
@@ -13909,7 +14524,7 @@ File: ${OUTPUT_DIR}/${template.output}`);
     const projectRoot = process.cwd();
     const projectName = path31.basename(projectRoot);
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const templates = getTemplates(projectName, date);
+    const templates = getBusinessTemplates(projectName, date);
     const template = templates.model;
     print.header(template.name);
     const outputDir = path31.join(projectRoot, OUTPUT_DIR);
@@ -13930,7 +14545,7 @@ File: ${OUTPUT_DIR}/${template.output}`);
     const projectRoot = process.cwd();
     const projectName = path31.basename(projectRoot);
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const templates = getTemplates(projectName, date);
+    const templates = getBusinessTemplates(projectName, date);
     const template = templates.competitors;
     print.header(template.name);
     const outputDir = path31.join(projectRoot, OUTPUT_DIR);
@@ -13953,7 +14568,7 @@ File: ${OUTPUT_DIR}/${template.output}`);
     const projectName = path31.basename(projectRoot);
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const outputDir = path31.join(projectRoot, OUTPUT_DIR);
-    const templates = getTemplates(projectName, date);
+    const templates = getBusinessTemplates(projectName, date);
     let found = 0;
     const total = Object.keys(templates).length;
     for (const [key, template] of Object.entries(templates)) {
@@ -13978,11 +14593,11 @@ Progress: ${found}/${total} documents created`);
       console.log("  bootspring business init - Create all documents");
     }
   });
-  business.command("show").description("Preview a business document").argument("<type>", "Document type (plan, model, competitors)").action((type) => {
+  business.command("show").description("Preview a business document").argument("<type>", "Document type (strategy, plan, model, competitors)").action((type) => {
     const projectRoot = process.cwd();
     const projectName = path31.basename(projectRoot);
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const templates = getTemplates(projectName, date);
+    const templates = getBusinessTemplates(projectName, date);
     const template = templates[type];
     if (!template) {
       print.error(`Unknown template: ${type}`);
@@ -20083,7 +20698,7 @@ ${COLORS.green}Done.${COLORS.reset} Restart assistant clients to load new MCP se
 
 // src/index.ts
 var program2 = new Command();
-program2.name("bootspring").description("Development scaffolding with intelligence - CLI for AI-assisted workflows").version("2.0.0");
+program2.name("bootspring").description("Development scaffolding with intelligence - CLI for AI-assisted workflows").version(BOOTSPRING_VERSION);
 registerAuthCommand(program2);
 registerProjectCommand(program2);
 registerSwitchCommand(program2);