@girardmedia/bootspring 2.0.6 → 2.0.7

package/cli/build.js

@@ -56,9 +56,11 @@ async function run(args) {
       return showBuildStatus(projectRoot, parsedArgs);
 
     case 'pause':
-    case 'stop':
       return pauseBuildLoop(projectRoot);
 
+    case 'stop':
+      return gracefulStop(projectRoot);
+
     case 'resume':
     case 'continue':
       return resumeBuildLoop(projectRoot);
@@ -189,13 +191,14 @@ Some tasks may be blocked. Run ${c.cyan}bootspring build status${c.reset} for de
   console.log(`${c.bold}What would you like to do?${c.reset}
 
   ${c.cyan}1${c.reset}  Start this task (shows prompt for Claude Code)
-  ${c.cyan}2${c.reset}  View task details
-  ${c.cyan}3${c.reset}  Skip this task
-  ${c.cyan}4${c.reset}  View full plan
+  ${c.cyan}2${c.reset}  Loop all tasks (autonomous - runs Claude until complete)
+  ${c.cyan}3${c.reset}  View task details
+  ${c.cyan}4${c.reset}  Skip this task
+  ${c.cyan}5${c.reset}  View full plan
   ${c.cyan}q${c.reset}  Quit
 `);
 
-  const choice = await askQuestion('Choose [1-4, q]: ');
+  const choice = await askQuestion('Choose [1-5, q]: ');
 
   switch (choice.trim()) {
     case '1':
@@ -203,17 +206,20 @@ Some tasks may be blocked. Run ${c.cyan}bootspring build status${c.reset} for de
       return buildNextTask(projectRoot, args);
 
     case '2':
+      return buildAll(projectRoot, args);
+
+    case '3':
       showCurrentTask(projectRoot, { prompt: true });
       console.log('');
       return interactiveBuild(projectRoot, args);
 
-    case '3': {
+    case '4': {
       const reason = await askQuestion('Skip reason (optional): ');
       skipCurrentTask(projectRoot, { reason: reason || 'Skipped by user' });
       return interactiveBuild(projectRoot, args);
     }
 
-    case '4':
+    case '5':
       showPlan(projectRoot);
       return interactiveBuild(projectRoot, args);
 
@@ -547,6 +553,24 @@ Or start fresh:
 `);
 }
 
+/**
+ * Graceful stop - finish current task then pause
+ */
+function gracefulStop(projectRoot) {
+  const loop = require('./loop');
+
+  console.log(`
+${c.yellow}${c.bold}Graceful stop requested${c.reset}
+
+The loop will pause after the current task completes.
+This ensures no work is interrupted mid-task.
+
+${c.dim}Waiting for current task to finish...${c.reset}
+`);
+
+  loop.setStopSignal(projectRoot);
+}
+
 /**
  * Show current task
  */
@@ -745,6 +769,7 @@ ${c.bold}Commands:${c.reset}
   ${c.cyan}bootspring build next${c.reset}      Show next task prompt
   ${c.cyan}bootspring build done${c.reset}      Mark current task complete
   ${c.cyan}bootspring build skip${c.reset}      Skip current task
+  ${c.cyan}bootspring build stop${c.reset}      Graceful stop (finish current task, then pause)
   ${c.cyan}bootspring build status${c.reset}    View detailed progress
   ${c.cyan}bootspring build task${c.reset}      View current task details
   ${c.cyan}bootspring build plan${c.reset}      View the full master plan

package/cli/loop.js

@@ -457,17 +457,25 @@ ${task.acceptance ? `\n### Acceptance Criteria\n${task.acceptance.map(a => `- ${
 - No TypeScript/lint errors
 - No security vulnerabilities introduced
 
-## Exit Signals
-When you successfully complete the task, output exactly:
-<loop-status>TASK_COMPLETE</loop-status>
+## Status Reporting
+When you complete work, include a status block at the end of your response:
 
-If you cannot complete the task, output exactly:
-<loop-status>TASK_BLOCKED</loop-status>
-Reason: [explanation]
+\`\`\`
+BOOTSPRING_STATUS: COMPLETE
+\`\`\`
+
+If you cannot proceed (missing info, blocked, need human input):
+\`\`\`
+BOOTSPRING_STATUS: BLOCKED
+BOOTSPRING_REASON: [brief explanation]
+\`\`\`
 
-If all tasks are done, output exactly:
-<loop-status>ALL_COMPLETE</loop-status>
-EXIT_SIGNAL
+If ALL tasks in the build are finished:
+\`\`\`
+BOOTSPRING_STATUS: EXIT
+\`\`\`
+
+IMPORTANT: Always include one of these status blocks at the end of your work.
 
 ## Session Info
 - Session: ${session.state.sessionId}
@@ -543,7 +551,17 @@ async function runIteration(session, taskInfo, options = {}) {
 
     if (session.state.tool === 'claude') {
       aiCmd = 'claude';
-      aiArgs = ['--print'];
+      aiArgs = ['-p'];  // Print mode for non-interactive
+
+      // Continue session if not first iteration (maintains context)
+      if (session.state.iteration > 0) {
+        aiArgs.push('-c');  // Continue most recent conversation
+      }
+
+      // Use JSON output for structured parsing when not in live mode
+      if (!options.live) {
+        aiArgs.push('--output-format', 'json');
+      }
     } else if (session.state.tool === 'amp') {
       aiCmd = 'amp';
       aiArgs = [];
@@ -552,9 +570,12 @@ async function runIteration(session, taskInfo, options = {}) {
       return;
     }
 
+    // For live mode, inherit stdout/stderr so user sees Claude working
+    // For non-live mode, capture output for parsing
     const child = spawn(aiCmd, aiArgs, {
       cwd: session.projectRoot,
-      stdio: options.live ? ['pipe', 'inherit', 'inherit'] : ['pipe', 'pipe', 'pipe']
+      stdio: options.live ? ['pipe', 'inherit', 'inherit'] : ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env }
     });
 
     // Send prompt via stdin
@@ -577,6 +598,28 @@ async function runIteration(session, taskInfo, options = {}) {
     }
 
     child.on('close', (code) => {
+      // For live mode, we assume success if exit code is 0
+      // Claude will have output directly to terminal
+      if (options.live) {
+        if (code !== 0) {
+          session.recordTaskEnd('error', { exitCode: code });
+          resolve({ status: 'error', exitCode: code });
+        } else {
+          session.recordTaskEnd('complete');
+          resolve({ status: 'complete', output: '[live mode - output shown above]' });
+        }
+        return;
+      }
+
+      // Parse JSON output if available
+      let parsedOutput = null;
+      try {
+        parsedOutput = JSON.parse(output);
+        output = parsedOutput.result || parsedOutput.content || output;
+      } catch {
+        // Not JSON, use raw output
+      }
+
       // Check exit conditions
       const exitCheck = session.checkExitConditions(output);
 
@@ -586,7 +629,27 @@ async function runIteration(session, taskInfo, options = {}) {
         return;
       }
 
-      // Check for task status in output
+      // Check for BOOTSPRING_STATUS block (like Ralph's RALPH_STATUS)
+      const statusMatch = output.match(/BOOTSPRING_STATUS:\s*(\w+)/i);
+      if (statusMatch) {
+        const status = statusMatch[1].toUpperCase();
+        if (status === 'COMPLETE' || status === 'DONE') {
+          session.recordTaskEnd('complete');
+          resolve({ status: 'complete', output });
+          return;
+        } else if (status === 'BLOCKED' || status === 'STUCK') {
+          const reasonMatch = output.match(/BOOTSPRING_REASON:\s*(.+)/i);
+          session.recordTaskEnd('blocked', { reason: reasonMatch?.[1] || 'Unknown' });
+          resolve({ status: 'blocked', reason: reasonMatch?.[1], output });
+          return;
+        } else if (status === 'EXIT' || status === 'FINISHED') {
+          session.recordTaskEnd('complete', { exitReason: 'All tasks complete' });
+          resolve({ status: 'all_complete', reason: 'All tasks complete', output });
+          return;
+        }
+      }
+
+      // Legacy status tags
       if (output.includes('<loop-status>TASK_COMPLETE</loop-status>')) {
         session.recordTaskEnd('complete');
         resolve({ status: 'complete', output });
@@ -618,6 +681,37 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Check if graceful stop signal is set
+ */
+function checkStopSignal(projectRoot) {
+  const stopFile = path.join(projectRoot, '.bootspring', 'STOP_AFTER_TASK');
+  return fs.existsSync(stopFile);
+}
+
+/**
+ * Set graceful stop signal (stop after current task completes)
+ */
+function setStopSignal(projectRoot) {
+  const bootspringDir = path.join(projectRoot, '.bootspring');
+  if (!fs.existsSync(bootspringDir)) {
+    fs.mkdirSync(bootspringDir, { recursive: true });
+  }
+  const stopFile = path.join(bootspringDir, 'STOP_AFTER_TASK');
+  fs.writeFileSync(stopFile, new Date().toISOString());
+  return stopFile;
+}
+
+/**
+ * Clear graceful stop signal
+ */
+function clearStopSignal(projectRoot) {
+  const stopFile = path.join(projectRoot, '.bootspring', 'STOP_AFTER_TASK');
+  if (fs.existsSync(stopFile)) {
+    fs.unlinkSync(stopFile);
+  }
+}
+
 /**
  * Run the main loop
  */
@@ -729,6 +823,16 @@ ${c.bold}Configuration${c.reset}
       }
     }
 
+    // Check for graceful stop signal (stop after completing current task)
+    if (checkStopSignal(projectRoot)) {
+      console.log(`\n${c.yellow}${c.bold}⏸ Graceful stop requested. Pausing after this task.${c.reset}`);
+      session.state.status = 'paused';
+      session.save();
+      clearStopSignal(projectRoot);
+      console.log(`${c.dim}Resume with: bootspring build${c.reset}\n`);
+      break;
+    }
+
     // Delay between iterations
     await sleep(LOOP_CONFIG.minDelayBetweenCalls);
   }
@@ -1331,5 +1435,7 @@ module.exports = {
   showStatus,
   showPRDStatus,
   getTasks,
+  setStopSignal,
+  clearStopSignal,
   LOOP_CONFIG
 };

package/mcp/contracts/mcp-contract.v1.json

@@ -1,7 +1,7 @@
 {
   "contractVersion": "v1",
   "packageName": "@girardmedia/bootspring",
-  "packageVersion": "2.0.6",
+  "packageVersion": "2.0.7",
   "tools": [
     {
       "name": "bootspring_assist",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardmedia/bootspring",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Development scaffolding with intelligence - AI-powered context, agents, and workflows for any MCP-compatible assistant",
   "keywords": [
     "ai",