@ikunin/sprintpilot 2.0.9 → 2.1.0

package/_Sprintpilot/lib/orchestrator/decision-log.js

@@ -0,0 +1,224 @@
+// decision-log.js — validate + append Decision[] entries to decision-log.yaml.
+//
+// Schema (from workflow.md:107–112 + the plan):
+//   - id: auto-generated DEC-<seq>
+//   - timestamp: ISO 8601, orchestrator-generated
+//   - story: required (current story key) — orchestrator-injected
+//   - phase: '<skill>:<sub_phase>'  e.g. 'dev-story:RED'
+//   - category: enum (8 values)
+//   - decision: non-empty string
+//   - rationale: non-empty string
+//   - impact: enum 'low' | 'medium' | 'high'
+//
+// LLM emits Decision via the optional decisions[] field on any signal.
+// Orchestrator validates each entry, auto-assigns id + timestamp + story,
+// then appends to decision-log.yaml.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const VALID_CATEGORIES = [
+  'architecture',
+  'test-strategy',
+  'dependency',
+  'review-triage',
+  'review-accept',
+  'halt-recovery',
+  'scope',
+  'workaround',
+];
+
+const VALID_IMPACTS = ['low', 'medium', 'high'];
+
+const PHASE_RE = /^[a-zA-Z][a-zA-Z0-9_-]*:[a-zA-Z][a-zA-Z0-9_-]*$/;
+
+function isPlainObject(v) {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+function nonEmptyString(v) {
+  return typeof v === 'string' && v.trim().length > 0;
+}
+
+// Validate a Decision object as emitted by the LLM. Returns
+//   { ok: true, decision } | { ok: false, errors: string[] }
+// `story` and `id` and `timestamp` are NOT required from the LLM — the
+// orchestrator stamps them at append time.
+function validateOne(d) {
+  const errors = [];
+  if (!isPlainObject(d)) return { ok: false, errors: ['decision is not an object'] };
+
+  if (!nonEmptyString(d.category)) errors.push('category required');
+  else if (!VALID_CATEGORIES.includes(d.category))
+    errors.push(`category must be one of: ${VALID_CATEGORIES.join(',')}`);
+
+  if (!nonEmptyString(d.impact)) errors.push('impact required');
+  else if (!VALID_IMPACTS.includes(d.impact))
+    errors.push(`impact must be one of: ${VALID_IMPACTS.join(',')}`);
+
+  if (!nonEmptyString(d.phase)) errors.push('phase required');
+  else if (!PHASE_RE.test(d.phase)) errors.push('phase must match <skill>:<sub_phase>');
+
+  if (!nonEmptyString(d.decision)) errors.push('decision required');
+  if (!nonEmptyString(d.rationale)) errors.push('rationale required');
+
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, decision: d };
+}
+
+function validateMany(decisions) {
+  const list = Array.isArray(decisions) ? decisions : [];
+  const valid = [];
+  const errors = [];
+  for (let i = 0; i < list.length; i += 1) {
+    const r = validateOne(list[i]);
+    if (r.ok) valid.push(r.decision);
+    else errors.push({ index: i, errors: r.errors });
+  }
+  if (errors.length > 0) return { ok: false, errors, valid };
+  return { ok: true, decisions: valid };
+}
+
+// Render one decision as YAML lines (matching workflow.md schema).
+function renderDecision(d) {
+  const yamlEscape = (s) => {
+    const str = String(s);
+    // Single-line, no embedded special chars → bare; else double-quote.
+    // YAML bare-scalar rules. Quote if any of:
+    //   - matches a reserved literal (true/false/null/~)
+    //   - looks like a number
+    //   - contains `: ` (key-value ambiguity)
+    //   - contains a YAML comment intro `#`
+    //   - contains chars outside the bare-safe set (allow `:` w/o space, `.`, `/`, `-`)
+    const reserved = /^(true|false|null|~)$/i.test(str);
+    const numeric = /^-?\d/.test(str);
+    const ambiguousColon = /:\s/.test(str);
+    const hasHash = /#/.test(str);
+    const bareSafe = /^[A-Za-z0-9_.:/\- ]+$/.test(str);
+    if (!reserved && !numeric && !ambiguousColon && !hasHash && bareSafe) return str;
+    return JSON.stringify(str);
+  };
+  return [
+    `  - id: ${d.id}`,
+    `    timestamp: ${yamlEscape(d.timestamp)}`,
+    `    story: ${yamlEscape(d.story)}`,
+    `    phase: ${yamlEscape(d.phase)}`,
+    `    category: ${d.category}`,
+    `    impact: ${d.impact}`,
+    `    decision: ${yamlEscape(d.decision)}`,
+    `    rationale: ${yamlEscape(d.rationale)}`,
+  ].join('\n');
+}
+
+// Read existing decision-log.yaml and return the next sequence number.
+// We deliberately parse with a regex rather than a full YAML parser so this
+// works in install-time contexts without js-yaml available.
+function nextSeq(existingText) {
+  if (!existingText) return 1;
+  let max = 0;
+  const re = /^\s*- id:\s*DEC-(\d+)\b/gm;
+  let m;
+  while ((m = re.exec(existingText))) {
+    const n = Number.parseInt(m[1], 10);
+    if (Number.isFinite(n) && n > max) max = n;
+  }
+  return max + 1;
+}
+
+// append(logPath, decisions, context, options?)
+//   logPath: absolute path to decision-log.yaml
+//   decisions: validated Decision[] from validateMany
+//   context: { story: string, now: () => Date }  — orchestrator-injected
+//   options: { fs? }                              — for testing
+// Returns { appended: number, ids: string[] }
+function append(logPath, decisions, context, options) {
+  const fsImpl = (options && options.fs) || fs;
+  const story = context && context.story ? String(context.story) : 'sprint';
+  const nowFn = (context && context.now) || (() => new Date());
+
+  let existing = '';
+  try {
+    existing = fsImpl.readFileSync(logPath, 'utf8');
+  } catch (_e) {
+    existing = '';
+  }
+
+  const isFresh = !existing.trim();
+  let seq = nextSeq(existing);
+  const ids = [];
+  const renderedBlocks = [];
+
+  for (const d of decisions) {
+    const stamped = {
+      id: `DEC-${String(seq).padStart(3, '0')}`,
+      timestamp: nowFn().toISOString(),
+      story,
+      phase: d.phase,
+      category: d.category,
+      impact: d.impact,
+      decision: d.decision,
+      rationale: d.rationale,
+    };
+    ids.push(stamped.id);
+    renderedBlocks.push(renderDecision(stamped));
+    seq += 1;
+  }
+
+  const header = isFresh
+    ? [
+        `generated: ${nowFn().toISOString().slice(0, 10)}`,
+        `last_updated: ${nowFn().toISOString()}`,
+        'decisions:',
+      ].join('\n')
+    : updateLastUpdated(existing, nowFn().toISOString());
+
+  const body = renderedBlocks.join('\n');
+  const finalText = isFresh ? `${header}\n${body}\n` : `${header}${body}\n`;
+
+  fsImpl.mkdirSync(path.dirname(logPath), { recursive: true });
+  fsImpl.writeFileSync(logPath, finalText, 'utf8');
+
+  return { appended: decisions.length, ids };
+}
+
+// Replace or insert the `last_updated:` line; leave everything else intact.
+// Returns a string ending with the existing content (no trailing newline
+// trim) so renderedBlocks can be appended directly.
+function updateLastUpdated(existing, isoNow) {
+  const lines = existing.split(/\r?\n/);
+  let touched = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    if (/^last_updated:/.test(lines[i])) {
+      lines[i] = `last_updated: ${isoNow}`;
+      touched = true;
+      break;
+    }
+  }
+  if (!touched) {
+    // Insert after `generated:` if present, else at top.
+    let insertAt = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+      if (/^generated:/.test(lines[i])) {
+        insertAt = i + 1;
+        break;
+      }
+    }
+    lines.splice(insertAt, 0, `last_updated: ${isoNow}`);
+  }
+  // Strip trailing empty lines so we can append the new block(s) directly.
+  while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop();
+  return `${lines.join('\n')}\n`;
+}
+
+module.exports = {
+  VALID_CATEGORIES,
+  VALID_IMPACTS,
+  validateOne,
+  validateMany,
+  append,
+  renderDecision,
+  // exported for tests
+  nextSeq,
+};

package/_Sprintpilot/lib/orchestrator/divergence.js

@@ -0,0 +1,201 @@
+// divergence.js — resume fingerprint diff.
+//
+// When the autopilot resumes (next session, after a halt, after the user
+// did stuff manually), we don't trust that the world still matches what
+// the ledger says. We fingerprint the relevant on-disk state, compare to
+// the fingerprint recorded at last halt, and report divergences.
+//
+// Returns a Divergence object the CLI edge can either:
+//   - accept (`{ identical: true }` → emit next planned action)
+//   - escalate to user_prompt (`{ identical: false, differences: ... }`)
+//
+// Fingerprint inputs (per the plan):
+//   - sprint-status.yaml: SHA-256 of canonical content (trailing-WS stripped)
+//   - per-story branch HEADs: SHA list from `git rev-parse refs/heads/...`
+//     (skipped if git not available / no git_enabled in profile)
+//   - _bmad-output tree: { relative-path → size }
+//   - active worktree paths: list of `.worktrees/<name>` dirs
+//
+// All inputs are computed via injected dependencies so tests can drive
+// without a real repo.
+
+'use strict';
+
+const crypto = require('node:crypto');
+const nodeFs = require('node:fs');
+const path = require('node:path');
+
+function sha256(text) {
+  return crypto.createHash('sha256').update(text).digest('hex');
+}
+
+function exists(fs, p) {
+  try {
+    fs.accessSync(p, fs.constants ? fs.constants.F_OK : 0);
+    return true;
+  } catch (_e) {
+    return false;
+  }
+}
+
+function readSafe(fs, p) {
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch (_e) {
+    return null;
+  }
+}
+
+// canonicalizeYaml — strip trailing whitespace per line; ensure final newline.
+// We don't try to canonicalize key ordering because users may legitimately
+// reorder fields; we just want to ignore whitespace-only churn.
+function canonicalizeYaml(text) {
+  if (!text) return '';
+  const lines = text.split(/\r?\n/).map((l) => l.replace(/[ \t]+$/g, ''));
+  while (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return `${lines.join('\n')}\n`;
+}
+
+function walkTree(fs, root, out, relBase) {
+  let entries;
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch (_e) {
+    return;
+  }
+  for (const ent of entries) {
+    const full = path.join(root, ent.name);
+    const rel = path.join(relBase, ent.name);
+    if (ent.isDirectory()) {
+      walkTree(fs, full, out, rel);
+    } else if (ent.isFile()) {
+      try {
+        const st = fs.statSync(full);
+        out[rel.split(path.sep).join('/')] = st.size;
+      } catch (_e) {
+        // ignore unreadable
+      }
+    }
+  }
+}
+
+// fingerprint(context) → { sprintStatusSha, bmadTree, branchHeads, worktreePaths }
+//
+// context = { projectRoot, fs?, gitHeadResolver?, worktreeScanner? }
+//   gitHeadResolver(branch): string | null  — return SHA or null
+//   worktreeScanner(): string[]             — return list of worktree paths
+//
+// Both git-side functions are injected so tests don't need a real repo.
+function fingerprint(context) {
+  if (!context || !context.projectRoot) throw new Error('fingerprint: projectRoot required');
+  const fs = context.fs || nodeFs;
+  const root = context.projectRoot;
+
+  const sprintStatusPath = path.join(
+    root,
+    '_bmad-output',
+    'implementation-artifacts',
+    'sprint-status.yaml',
+  );
+  const sprintStatus = readSafe(fs, sprintStatusPath);
+  const sprintStatusSha = sprintStatus ? sha256(canonicalizeYaml(sprintStatus)) : null;
+
+  const bmadTree = {};
+  const bmadRoot = path.join(root, '_bmad-output');
+  if (exists(fs, bmadRoot)) {
+    walkTree(fs, bmadRoot, bmadTree, '');
+  }
+
+  const branchHeads = {};
+  if (typeof context.gitHeadResolver === 'function' && Array.isArray(context.branches)) {
+    for (const b of context.branches) {
+      branchHeads[b] = context.gitHeadResolver(b);
+    }
+  }
+
+  const worktreePaths =
+    typeof context.worktreeScanner === 'function' ? context.worktreeScanner() : [];
+
+  return { sprintStatusSha, bmadTree, branchHeads, worktreePaths };
+}
+
+// diff(expected, actual) → Divergence
+//
+// Divergence shape:
+//   {
+//     identical: boolean,
+//     differences: {
+//       sprint_status?: { expected: sha, actual: sha },
+//       branch_heads?: { branch, expected, actual }[],
+//       bmad_tree?: { added: string[], removed: string[], changed: string[] },
+//       worktrees?: { added: string[], removed: string[] },
+//     }
+//   }
+function diff(expected, actual) {
+  if (!expected) return { identical: false, differences: { reason: 'no_baseline_fingerprint' } };
+  if (!actual) return { identical: false, differences: { reason: 'no_actual_fingerprint' } };
+
+  const differences = {};
+
+  if (expected.sprintStatusSha !== actual.sprintStatusSha) {
+    differences.sprint_status = {
+      expected: expected.sprintStatusSha,
+      actual: actual.sprintStatusSha,
+    };
+  }
+
+  const headDiffs = [];
+  const branches = new Set([
+    ...Object.keys(expected.branchHeads || {}),
+    ...Object.keys(actual.branchHeads || {}),
+  ]);
+  for (const b of branches) {
+    const e = expected.branchHeads ? expected.branchHeads[b] : undefined;
+    const a = actual.branchHeads ? actual.branchHeads[b] : undefined;
+    if (e !== a) headDiffs.push({ branch: b, expected: e ?? null, actual: a ?? null });
+  }
+  if (headDiffs.length > 0) differences.branch_heads = headDiffs;
+
+  const expTree = expected.bmadTree || {};
+  const actTree = actual.bmadTree || {};
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const p of Object.keys(actTree)) {
+    if (!(p in expTree)) added.push(p);
+    else if (expTree[p] !== actTree[p]) changed.push(p);
+  }
+  for (const p of Object.keys(expTree)) {
+    if (!(p in actTree)) removed.push(p);
+  }
+  if (added.length || removed.length || changed.length) {
+    differences.bmad_tree = { added: added.sort(), removed: removed.sort(), changed: changed.sort() };
+  }
+
+  const expWt = new Set(expected.worktreePaths || []);
+  const actWt = new Set(actual.worktreePaths || []);
+  const wtAdded = Array.from(actWt).filter((p) => !expWt.has(p)).sort();
+  const wtRemoved = Array.from(expWt).filter((p) => !actWt.has(p)).sort();
+  if (wtAdded.length || wtRemoved.length) {
+    differences.worktrees = { added: wtAdded, removed: wtRemoved };
+  }
+
+  return { identical: Object.keys(differences).length === 0, differences };
+}
+
+// detect(context) — convenience: read the last baseline fingerprint from the
+// ledger, compute current fingerprint, diff. The baseline is recorded as a
+// `state_transition` entry with `fingerprint` field when the orchestrator
+// halts. (The CLI edge wires this up; this module just composes.)
+function detect(context, baselineFingerprint) {
+  const actual = fingerprint(context);
+  return diff(baselineFingerprint, actual);
+}
+
+module.exports = {
+  sha256,
+  canonicalizeYaml,
+  fingerprint,
+  diff,
+  detect,
+};

package/_Sprintpilot/lib/orchestrator/git-plan.js

@@ -0,0 +1,259 @@
+// git-plan.js — produce an argv sequence for a git_op action.
+//
+// Given (state, profile, action), return:
+//   { steps: [{ args, description, retry? }] }
+//
+// Pure. Argv-only — no shell strings. The CLI edge executes each step in
+// order, halting on first failure. Steps are deterministic: same inputs
+// always produce the same argv.
+
+'use strict';
+
+const { STATES } = require('./state-machine');
+
+const STORY_BRANCH_RE = /^[a-z0-9][a-z0-9._-]*$/i;
+
+function sanitizeStoryKey(key) {
+  if (typeof key !== 'string') return null;
+  // Per existing sanitize-branch.js: only allow [a-z0-9._-], lowercase.
+  const s = key.toLowerCase().replace(/[^a-z0-9._-]/g, '-');
+  if (!STORY_BRANCH_RE.test(s)) return null;
+  return s;
+}
+
+// branchName(profile, storyKey, epicKey, state?)
+//   When `state?.user_branch` is set (because git.reuse_user_branch=true and
+//   the user pre-created a working branch), every story commits to that
+//   single branch — per-story/per-epic branches are NOT created.
+//   Otherwise honor profile.granularity for story/epic per-unit branches.
+//
+// Format matches the legacy workflow (see git/config.yaml:12 + the legacy
+// workflow.md:685+716): `<branch_prefix>epic-<epic_id>` for epic granularity
+// and `<branch_prefix><story_key>` for story granularity. The default prefix
+// is "story/", so under nano you get `story/epic-1` (not `epic/1`) — that's
+// what the existing tooling and e2e tests expect.
+function branchName(profile, storyKey, epicKey, state) {
+  if (state && state.user_branch) return state.user_branch;
+  const prefix = profile.branch_prefix || 'story/';
+  // git.granularity: 'story' (default) or 'epic'. Nano + large can be epic.
+  if (profile.granularity === 'epic' && epicKey) {
+    return `${prefix}epic-${sanitizeStoryKey(epicKey) || 'unknown'}`;
+  }
+  const safe = sanitizeStoryKey(storyKey) || 'unknown';
+  return `${prefix}${safe}`;
+}
+
+// commit_and_push_story — full sequence for STORY_DONE.
+//   Phase 1 — commit + push the story branch (code lives here):
+//     1. git add (specific files only — never -A / .)
+//     2. git commit -m "<message>"
+//     3. git push -u origin <branch>  (retried 4x with exponential backoff)
+//   Phase 2 — sync `_bmad-output/` to <base_branch> (BMad artifacts live
+//   on main so `git log main` is the canonical sprint audit trail):
+//     4. git switch <base_branch>
+//     5. git checkout <branch> -- _bmad-output
+//     6. git add _bmad-output
+//     7. git commit --allow-empty -m "docs(<story>): BMad artifacts"
+//     8. git push origin <base_branch>  (retried 4x)
+//     9. git switch <branch>            (return to story for next phase)
+//   --allow-empty on step 7 covers multi-story sprints where _bmad-output/
+//   on main already matches the story-branch version (e.g. epics.md was
+//   authored during story 1, unchanged for story 2). The empty commit is
+//   audit-trail noise but cheap.
+function plan(state, profile, action) {
+  if (!action || !action.type || action.type !== 'git_op') {
+    throw new Error('git-plan.plan: action.type must be git_op');
+  }
+  const op = action.op;
+  const branch = branchName(profile, state.story_key, state.current_epic, state);
+
+  switch (op) {
+    case 'commit_and_push_story':
+      return planCommitAndPush(state, profile, action, branch);
+    case 'merge_epic':
+      return planMergeEpic(state, profile, action, branch);
+    case 'push':
+      return planPush(state, profile, action, branch);
+    case 'fetch':
+      return planFetch(state, profile);
+    case 'create_branch':
+      return planCreateBranch(state, profile, branch);
+    default:
+      throw new Error(`git-plan.plan: unknown op ${op}`);
+  }
+}
+
+function planCreateBranch(state, profile, branch) {
+  // Branch reuse: when the user pre-created the branch, do not create a
+  // new one. Just confirm HEAD is on the right branch (idempotent switch).
+  if (state && state.user_branch) {
+    return {
+      branch,
+      steps: [
+        {
+          args: ['git', 'switch', branch],
+          description: `switch to user branch ${branch} (reuse mode)`,
+        },
+      ],
+    };
+  }
+  const baseBranch = profile.base_branch || 'main';
+  return {
+    branch,
+    steps: [
+      // Create branch from base; -B is idempotent (creates or resets).
+      // But for new-story creation we want to fail if it already exists,
+      // so use -b instead. The CLI edge can downgrade to -B on retry.
+      {
+        args: ['git', 'switch', '-c', branch, baseBranch],
+        description: `create story branch ${branch} from ${baseBranch}`,
+      },
+    ],
+  };
+}
+
+function planCommitAndPush(state, profile, action, branch) {
+  const files = Array.isArray(action.files) && action.files.length > 0 ? action.files : null;
+  const message =
+    action.message ||
+    (state.story_key
+      ? `feat(${state.story_key}): ${state.ac_summary || 'story done'}`
+      : 'feat: story done');
+  const baseBranch = profile.base_branch || 'main';
+  const storyKey = state.story_key || 'sprint';
+  const hasOrigin = profile.has_origin !== false;
+
+  const steps = [];
+
+  // Phase 1 — commit + push the story branch (code lives here).
+  if (files) {
+    steps.push({
+      args: ['git', 'add', ...files],
+      description: `stage ${files.length} file(s) explicitly`,
+    });
+  } else {
+    // No explicit file list provided. Add all tracked changes only — the
+    // CLI edge should populate `files` from the LLM's success.output.
+    // Fall back to `-u` which stages tracked modifications without picking
+    // up untracked files (which might include secrets).
+    steps.push({
+      args: ['git', 'add', '-u'],
+      description: 'stage tracked modifications only (no -A / .)',
+    });
+  }
+  steps.push({
+    args: ['git', 'commit', '-m', message],
+    description: `commit on ${branch}`,
+  });
+  if (hasOrigin) {
+    steps.push({
+      args: ['git', 'push', '-u', 'origin', branch],
+      description: `push ${branch} (retry 4× exponential backoff on network)`,
+      retry: { attempts: 4, backoff_ms: [2000, 4000, 8000, 16000], on: 'network' },
+    });
+  }
+
+  // Phase 2 — sync `_bmad-output/` to `<base_branch>`. BMad planning +
+  // bookkeeping artifacts must land on main per story so `git log main`
+  // is the canonical sprint audit trail. Without this, planning
+  // artifacts, sprint-status, story files, and reviews exist only on
+  // the story branch.
+  steps.push({
+    args: ['git', 'switch', baseBranch],
+    description: `switch to ${baseBranch} to sync BMad artifacts`,
+  });
+  steps.push({
+    args: ['git', 'checkout', branch, '--', '_bmad-output'],
+    description: `bring _bmad-output/ from ${branch} into ${baseBranch}'s working tree`,
+  });
+  steps.push({
+    args: ['git', 'add', '_bmad-output'],
+    description: 'stage BMad artifacts',
+  });
+  steps.push({
+    args: ['git', 'commit', '--allow-empty', '-m', `docs(${storyKey}): BMad artifacts`],
+    description: `commit BMad artifacts to ${baseBranch} (--allow-empty for no-diff stories)`,
+  });
+  if (hasOrigin) {
+    steps.push({
+      args: ['git', 'push', 'origin', baseBranch],
+      description: `push ${baseBranch}`,
+      retry: { attempts: 4, backoff_ms: [2000, 4000, 8000, 16000], on: 'network' },
+    });
+  }
+  steps.push({
+    args: ['git', 'switch', branch],
+    description: `return to ${branch} for the next phase`,
+  });
+
+  return { branch, steps };
+}
+
+function planMergeEpic(state, profile, _action, branch) {
+  const baseBranch = profile.base_branch || 'main';
+  const squash = !!profile.squash_on_merge;
+  const steps = [];
+
+  if (profile.has_origin !== false) {
+    steps.push({ args: ['git', 'fetch', 'origin'], description: 'sync with remote' });
+  }
+  steps.push({ args: ['git', 'switch', baseBranch], description: `switch to ${baseBranch}` });
+  if (profile.has_origin !== false) {
+    steps.push({
+      args: ['git', 'merge', '--ff-only', `origin/${baseBranch}`],
+      description: 'fast-forward base to remote',
+    });
+  }
+  if (squash) {
+    steps.push({
+      args: ['git', 'merge', '--squash', branch],
+      description: `squash-merge ${branch}`,
+    });
+    steps.push({
+      args: ['git', 'commit', '-m', `feat(${state.current_epic || 'epic'}): squash merge`],
+      description: 'squash commit',
+    });
+  } else {
+    steps.push({
+      args: ['git', 'merge', '--no-ff', '-m', `Merge ${branch}`, branch],
+      description: `non-ff merge ${branch}`,
+    });
+  }
+  if (profile.has_origin !== false) {
+    steps.push({
+      args: ['git', 'push', 'origin', baseBranch],
+      description: `push ${baseBranch}`,
+      retry: { attempts: 4, backoff_ms: [2000, 4000, 8000, 16000], on: 'network' },
+    });
+  }
+  return { branch, steps };
+}
+
+function planPush(_state, profile, _action, branch) {
+  if (profile.has_origin === false) return { branch, steps: [] };
+  return {
+    branch,
+    steps: [
+      {
+        args: ['git', 'push', '-u', 'origin', branch],
+        description: `push ${branch}`,
+        retry: { attempts: 4, backoff_ms: [2000, 4000, 8000, 16000], on: 'network' },
+      },
+    ],
+  };
+}
+
+function planFetch(_state, profile) {
+  if (profile.has_origin === false) return { branch: null, steps: [] };
+  return {
+    branch: null,
+    steps: [{ args: ['git', 'fetch', 'origin'], description: 'fetch origin' }],
+  };
+}
+
+module.exports = {
+  plan,
+  branchName,
+  sanitizeStoryKey,
+  STATES,
+};