@ikunin/sprintpilot 2.2.11 → 2.2.13

package/_Sprintpilot/bin/autopilot.js

@@ -39,6 +39,7 @@ const userCommands = require('../lib/orchestrator/user-commands');
 const divergence = require('../lib/orchestrator/divergence');
 const reportRenderer = require('../lib/orchestrator/report');
 const gitPlan = require('../lib/orchestrator/git-plan');
+const land = require('../lib/orchestrator/land');
 const {
   parseStatuses: parseSprintStatuses,
   remainingFrom: remainingStoriesFrom,
@@ -694,6 +695,13 @@ function composeRuntimeState(persisted, profile, projectRoot) {
     // across halts so the next session re-emits the prompt rather than
     // silently dropping the LLM's proposal.
     pending_alternative: persisted.pending_alternative || null,
+    // session_story_limit counter: per-session count of stories completed.
+    // adapt.advanceState increments on STORY_DONE → EPIC_BOUNDARY_CHECK;
+    // state-machine.nextAction emits a halt when this hits profile.session_story_limit.
+    // cmdStart resets to 0 on each new session boot (the limit is per-session,
+    // not lifetime). Persisted across in-session resumes so a `pause` mid-flow
+    // doesn't reset progress against the limit.
+    session_stories_completed: persisted.session_stories_completed || 0,
     // halt_requested is intentionally NOT carried forward here: cmdStart
     // clears it on each new session (a `pause` cleanly halts THIS session
     // and the next /sprint-autopilot-on resumes normally).
@@ -722,6 +730,7 @@ function persistRuntimeState(runtime, profile, projectRoot) {
     story_queue: Array.isArray(runtime.story_queue) ? runtime.story_queue : [],
     land_pending: runtime.land_pending,
     pending_alternative: runtime.pending_alternative || null,
+    session_stories_completed: runtime.session_stories_completed || 0,
   };
   return persistState(updates, profile, projectRoot, runtime.story_key || 'sprint');
 }
@@ -844,6 +853,42 @@ function decorateGitOp(action, state, profile, projectRoot) {
   }
 }
 
+// run_script actions for op=land_story carry only metadata (helper,
+// land_when, squash_on_merge, ...) — the state machine's comment
+// promises "The CLI edge composes the actual argv via land.js#planLand"
+// but that wiring was missing pre-v2.2.12. Without it, LLMs driving
+// land_as_you_go got a metadata-only action and had to improvise.
+// Symmetric to decorateGitOp: call land.planLand(state, profile,
+// options), inline the resulting `steps[]` onto the action.
+function decorateRunScript(action, state, profile, projectRoot) {
+  if (!action || action.type !== 'run_script') return action;
+  if (action.op !== 'land_story') return action;
+  try {
+    const root = projectRoot || process.cwd();
+    const scriptsDir = path.join(root, '_Sprintpilot', 'scripts');
+    const snapshotPath = path.join(
+      root,
+      '_bmad-output',
+      'implementation-artifacts',
+      '.land-snapshots',
+      `${state.story_key || 'sprint'}.json`,
+    );
+    const branch = gitPlan.branchName(profile, state.story_key, state.current_epic, state);
+    const platform = profile.platform_provider || 'auto';
+    const planned = land.planLand(state, profile, {
+      scriptsDir,
+      snapshotPath,
+      branch,
+      platform,
+      projectRoot: root,
+    });
+    return { ...action, branch: planned.branch, steps: planned.steps };
+  } catch (e) {
+    log.warn(`land-plan failed for op=${action.op}: ${e.message}`);
+    return action;
+  }
+}
+
 // Detect whether a branch exists, locally OR on origin. Used by
 // decorateGitOp so the create_branch plan can degrade to a plain switch
 // when the branch is already known. Checking remote refs avoids the
@@ -1096,6 +1141,12 @@ function cmdStart(opts) {
   // profile-aware initial phase when persisted state is empty.
   const runtime = composeRuntimeState(persisted, profile, projectRoot);
 
+  // session_story_limit is per-session — a fresh `autopilot start`
+  // resets the counter so the next batch of N stories can run before
+  // the next halt. (state-machine.nextAction enforces the cap; adapt.js
+  // increments on STORY_DONE → EPIC_BOUNDARY_CHECK.)
+  runtime.session_stories_completed = 0;
+
   const lockResult = lockUserBranchIfNeeded(runtime, profile, projectRoot);
   if (lockResult && lockResult.halt) {
     ledger.append(
@@ -1108,7 +1159,12 @@ function cmdStart(opts) {
     return 0;
   }
 
-  const action = decorateGitOp(stateMachine.nextAction(runtime, profile), runtime, profile, projectRoot);
+  const action = decorateRunScript(
+    decorateGitOp(stateMachine.nextAction(runtime, profile), runtime, profile, projectRoot),
+    runtime,
+    profile,
+    projectRoot,
+  );
   ledger.append({ kind: 'action_emitted', phase: runtime.phase, action }, { projectRoot });
   persistRuntimeState(runtime, profile, projectRoot);
   if (profile.coalesce_state_writes) stateStore.flush(profile, { projectRoot, story: runtime.story_key });
@@ -1137,7 +1193,12 @@ function cmdNext(opts) {
     return 0;
   }
 
-  const action = decorateGitOp(stateMachine.nextAction(runtime, profile), runtime, profile, projectRoot);
+  const action = decorateRunScript(
+    decorateGitOp(stateMachine.nextAction(runtime, profile), runtime, profile, projectRoot),
+    runtime,
+    profile,
+    projectRoot,
+  );
   ledger.append({ kind: 'action_emitted', phase: runtime.phase, action }, { projectRoot });
   // Persist any mutations done by lockUserBranchIfNeeded — without this
   // every cmdNext under reuse_user_branch=true re-detects the branch and
@@ -1264,7 +1325,12 @@ function cmdRecord(opts) {
   }
 
   const payload = {
-    action: decorateGitOp(result.nextAction, result.newState, result.newProfile, projectRoot),
+    action: decorateRunScript(
+      decorateGitOp(result.nextAction, result.newState, result.newProfile, projectRoot),
+      result.newState,
+      result.newProfile,
+      projectRoot,
+    ),
     verdict: result.verdict,
     phase: result.newState.phase,
     profile: result.newProfile.name,
@@ -1353,4 +1419,4 @@ if (require.main === module) {
   process.exit(main(process.argv.slice(2)));
 }
 
-module.exports = { main, SUBCOMMANDS, decorateGitOp, composeRuntimeState };
+module.exports = { main, SUBCOMMANDS, decorateGitOp, decorateRunScript, composeRuntimeState };

package/_Sprintpilot/lib/orchestrator/adapt.js

@@ -592,6 +592,10 @@ function advanceState(state, profile, newPhase, signal) {
     next.story_key = null;
     next.story_file_path = null;
     next.ac_summary = null;
+    // session_story_limit: increment per-session completion counter so
+    // state-machine.js#nextAction can emit the halt at the next
+    // emission. The counter resets on cmdStart (new session boundary).
+    next.session_stories_completed = (state.session_stories_completed || 0) + 1;
   }
 
   return next;

package/_Sprintpilot/lib/orchestrator/state-machine.js

@@ -170,6 +170,37 @@ function nextAction(state, profile) {
       handoff: 'sprint_finalize_pending',
     };
   }
+  // session_story_limit: when this session has completed >= limit
+  // stories, halt cleanly. The next /sprint-autopilot-on resets the
+  // counter and continues. Skipped when limit === 0 (unlimited per
+  // Sprintpilot.md) or limit is unset.
+  const sessionLimit = profile && profile.session_story_limit;
+  const sessionDone = state.session_stories_completed || 0;
+  if (
+    typeof sessionLimit === 'number' &&
+    sessionLimit > 0 &&
+    sessionDone >= sessionLimit &&
+    // Don't halt when we're at a story-start phase — that would
+    // create an infinite halt loop on resume. The limit check should
+    // fire at the boundary between stories (epic_boundary_check or
+    // before the next story is picked). Most natural is to halt
+    // before emitting the next story-start action.
+    (state.phase === STATES.EPIC_BOUNDARY_CHECK ||
+      state.phase === STATES.RETROSPECTIVE ||
+      state.phase === STATES.PREPARE_STORY_BRANCH ||
+      state.phase === STATES.CREATE_STORY ||
+      state.phase === STATES.NANO_QUICK_DEV)
+  ) {
+    return {
+      type: 'halt',
+      reason: 'session_story_limit_reached',
+      prompt:
+        `Session story limit reached (${sessionDone}/${sessionLimit}). ` +
+        `Run /sprint-autopilot-on to start a new session and continue with the next pending story.`,
+      session_stories_completed: sessionDone,
+      session_story_limit: sessionLimit,
+    };
+  }
 
   switch (state.phase) {
     case STATES.PREPARE_STORY_BRANCH: {

package/_Sprintpilot/manifest.yaml

@@ -1,6 +1,6 @@
 addon:
   name: sprintpilot
-  version: 2.2.11
+  version: 2.2.13
   description: Sprintpilot — autopilot and multi-agent addon for BMad Method (git workflow, parallel agents, autonomous story execution)
   bmad_compatibility: ">=6.2.0"
   modules:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikunin/sprintpilot",
-  "version": "2.2.11",
+  "version": "2.2.13",
   "description": "Sprintpilot — autopilot and multi-agent addon for BMad Method v6: git workflow, parallel agents, autonomous story execution",
   "license": "Apache-2.0",
   "repository": {