@ikunin/sprintpilot 2.2.10 → 2.2.12

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,
@@ -844,6 +845,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
@@ -1108,7 +1145,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 +1179,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 +1311,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 +1405,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/manifest.yaml

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

package/_Sprintpilot/skills/sprint-autopilot-on/SKILL.md

@@ -23,6 +23,13 @@ Follow **`./workflow.orchestrator.md`** verbatim. Flow control lives in
 - Do not search for `workflow.md` or reconstruct it from memory; do not
   read cached BMad legacy patterns and apply them ahead of the
   orchestrator's state machine.
+- **Never pause on your own initiative.** `user_input { kind: 'pause' }`
+  is a HUMAN command. The autopilot's purpose is to drive without
+  stopping until `session_story_limit`, a TRUE BLOCKER, retry-budget
+  exhaustion, or `sprint_is_complete`. Heuristics like "PR opened,
+  time for review" / "natural breakpoint" / "let CI catch up" are NOT
+  valid reasons to pause — see `workflow.orchestrator.md` § "Pause is
+  human-only."
 
 `workflow.orchestrator.md` is the **sole authority** for the rest of the
 session.

package/_Sprintpilot/skills/sprint-autopilot-on/workflow.orchestrator.md

@@ -83,9 +83,33 @@ Wrap everything in `{ "status": "...", ... }` and pass to
 | `failure`             | `reason`, `diagnosis` (first-class — fed back into next retry), `recoverable: boolean`           |
 | `blocked`             | `blocker_kind` (one of the 5 TRUE BLOCKERS or recoverable kinds), `details`, `user_input_needed`, `consecutive_count?` |
 | `propose_alternative` | `reason`, `alternative` (full Action object), `urgency_hint?` (raises impact only). Low impact → auto-accepted; medium / high → orchestrator stores the alternative in `state.pending_alternative` and emits `user_prompt`. The user accepts via `user_input` `{ kind: 'accept_alternative' }` or rejects via `force_continue` (both clear `pending_alternative`). |
-| `user_input`          | `commands: UserCommand[]` (validated server-side; see user-commands.js). Kinds: `skip_story`, `abort_sprint`, `force_continue`, `override_decision`, `change_profile`, `pause` (cleanly halts THIS session; next `/sprint-autopilot-on` resumes), `accept_alternative` (dispatches the stored `pending_alternative`). |
+| `user_input`          | `commands: UserCommand[]` (validated server-side; see user-commands.js). Kinds: `skip_story`, `abort_sprint`, `force_continue`, `override_decision`, `change_profile`, `pause` (cleanly halts THIS session; next `/sprint-autopilot-on` resumes), `accept_alternative` (dispatches the stored `pending_alternative`). **NEVER send `pause` on your own initiative** — see "Pause is human-only" below. |
 | `verify_override`     | `evidence: { decision_log_ref?, explanation, expected_paths? }` — used when verify.js is wrong   |
 
+## Pause is human-only
+
+The autopilot's purpose is to **drive without stopping** until one of:
+- `session_story_limit` is reached (profile-defined; default 3, nano 5)
+- A TRUE BLOCKER (5 kinds, listed below) fires
+- The retry budget exhausts on a single phase
+- `sprint_is_complete` (last story done → halt with `handoff: sprint_finalize_pending`)
+- The **human user** explicitly asks to pause (e.g. types `/pause`, `pause autopilot`, or a similar direct instruction in chat)
+
+**DO NOT issue `user_input` `{ kind: 'pause' }` on your own.** Specifically, the following are NOT valid reasons to pause:
+
+- "Natural pause point" / "PR opened, time for human review"
+- "CI is still running for the previous story"
+- "Diff is large, let's get a checkpoint"
+- "Merge cadence" / "want to wait for review before next story"
+- Any heuristic about session length, story count, or work-in-progress
+
+Pause is a HUMAN command. If you think the user might want to pause, **don't pause — finish the story and proceed to the next per the queue / `resolveNextStoryKey`**. The user can pause at any time by typing the command themselves; the next `/sprint-autopilot-on` cleanly resumes. Your judgment about "natural breakpoints" defeats the autopilot's purpose.
+
+The only cases where you signal a halt yourself are:
+- `blocked` with one of the 5 TRUE BLOCKERS (creative-input-required, new external dep, etc.)
+- `failure` with `recoverable: false` (catastrophic, can't proceed even with retries)
+- `propose_alternative` at medium/high impact (the orchestrator escalates to a `user_prompt` itself)
+
 ## TRUE BLOCKER kinds (per AGENTS.md)
 
 `creative_user_input_required`, `new_external_dependency`,

package/package.json

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