@ktpartners/dgs-platform 3.3.0 → 3.4.1

package/deliver-great-systems/bin/lib/milestone.cjs

@@ -4,12 +4,16 @@
 
 const fs = require('fs');
 const path = require('path');
+const { execSync } = require('child_process');
 const { escapeRegex, getMilestonePhaseFilter, getProjectRoot, output, error, loadConfig } = require('./core.cjs');
-const { extractFrontmatter } = require('./frontmatter.cjs');
+const { extractFrontmatter, spliceFrontmatter } = require('./frontmatter.cjs');
 const { getPlanningRoot } = require('./paths.cjs');
-const { writeStateMd } = require('./state.cjs');
+const { writeStateMd, stateReadAdhoc } = require('./state.cjs');
+const { parseReposMd } = require('./repos.cjs');
 const { getContributors, checkFourEyes } = require('./governance.cjs');
 const { requireGitIdentity, formatAuthorString } = require('./identity.cjs');
+const { composeMilestoneSlug } = require('./worktrees.cjs');
+const { listProjectsReadonly } = require('./projects.cjs');
 
 /**
  * Internal helper: marks requirement IDs complete in REQUIREMENTS.md.
@@ -359,8 +363,472 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
   output(result, raw);
 }
 
+// ─── Ad-hoc Milestone Creation (Phase 159) ───────────────────────────────────
+
+/**
+ * Sanitize a name into a slug (mirrors worktrees.cjs::_sanitizeSlug).
+ */
+function _adhocSanitizeSlug(input) {
+  if (!input) return '';
+  return String(input)
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 50)
+    .replace(/-+$/, '');
+}
+
+/** Resolve a repo's absolute path from its REPOS.md relative path. */
+function _adhocRepoAbsPath(cwd, repoRelPath) {
+  return path.resolve(getPlanningRoot(cwd), repoRelPath);
+}
+
+/** Run a git command in a repo, returning { ok, stdout, stderr }. */
+function _adhocGit(repoDir, gitArgs) {
+  try {
+    const stdout = execSync('git ' + gitArgs.map(a => JSON.stringify(a)).join(' '), {
+      cwd: repoDir, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8',
+    });
+    return { ok: true, stdout: stdout.trim(), stderr: '' };
+  } catch (err) {
+    return { ok: false, stdout: (err.stdout || '').toString().trim(), stderr: (err.stderr || err.message || '').toString().trim() };
+  }
+}
+
+/**
+ * True if a working tree has uncommitted changes.
+ *
+ * `config.local.json` is machine-local DGS state (normally gitignored) and is
+ * mutated as a side effect of routine commands, so it is excluded from the
+ * precondition — only source-tracked changes block ad-hoc creation.
+ */
+function _adhocIsDirty(repoDir) {
+  const r = _adhocGit(repoDir, ['status', '--porcelain']);
+  if (!r.ok) return false;
+  const lines = r.stdout.split('\n').map(l => l.trim()).filter(Boolean);
+  const meaningful = lines.filter(l => {
+    const file = l.replace(/^\S+\s+/, '');
+    return file !== 'config.local.json';
+  });
+  return meaningful.length > 0;
+}
+
+/** Resolve the dgs-tools.cjs entrypoint path (this file lives in bin/lib/). */
+function _adhocToolsPath() {
+  return path.resolve(__dirname, '..', 'dgs-tools.cjs');
+}
+
+/** Run a dgs-tools subcommand from the planning root. Returns { ok, stdout, stderr }. */
+function _adhocTools(cwd, argStr) {
+  try {
+    const stdout = execSync('node ' + JSON.stringify(_adhocToolsPath()) + ' ' + argStr, {
+      cwd, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8',
+    });
+    return { ok: true, stdout: stdout.trim(), stderr: '' };
+  } catch (err) {
+    return { ok: false, stdout: (err.stdout || '').toString().trim(), stderr: (err.stderr || err.message || '').toString().trim() };
+  }
+}
+
+/**
+ * Create an ad-hoc milestone container atomically (Phase 159).
+ *
+ * Canonical 6-step ordered creation with full rollback (RESEARCH.md):
+ *   1. assert preconditions (clean trees + no active_context)   [ADH-19]
+ *   2. capture planning base ref refs/dgs/adhoc/{slug}/base      [ADH-06]
+ *   3. create code worktrees --type milestone --adhoc --base-ref [ADH-02]
+ *   4. confirm adhoc marker on the worktree entry                [ADH-04 mirror]
+ *   5. commit STATE.md with adhoc:true + milestone vX.Y          [ADH-04 primary]
+ *   6. set execution.active_context LAST                         [ADH-03, no leak]
+ * On any failure, rolls back in reverse leaving NO residue (no ref, no entry,
+ * no marker, active_context unset). Prints the ADH-22 abandon advisory on
+ * success. detectQuickMode is never touched.
+ *
+ * @param {string} cwd - Planning root
+ * @param {string[]} args - [name..., --version vX.Y]
+ * @param {boolean} raw
+ */
+function cmdMilestoneCreateAdhoc(cwd, args, raw) {
+  // ── Parse args: collect name tokens until a flag; parse --version. ──
+  const versionIdx = args.indexOf('--version');
+  let explicitVersion = versionIdx !== -1 ? args[versionIdx + 1] : null;
+  const nameTokens = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) { if (args[i] === '--version') i++; continue; }
+    nameTokens.push(args[i]);
+  }
+  const name = nameTokens.join(' ').trim();
+  if (!name) error('Usage: milestone create-adhoc <name> [--version vX.Y]');
+
+  // Step 0 — version: default recommendation is MINOR (vX.Y two-component).
+  // Provisional only; nothing product-global is written at creation.
+  let version = explicitVersion || 'v0.1';
+  if (!/^v?\d+\.\d+$/.test(version)) error('--version must be two-component vX.Y');
+  if (!version.startsWith('v')) version = 'v' + version;
+
+  const config = loadConfig(cwd);
+  const project = config.current_project;
+  if (!project) error('No current project set.');
+  const baseBranch = config.base_branch || 'main';
+  const planningRoot = getPlanningRoot(cwd);
+
+  // Structural slug consistency: ad-hoc milestones use the SAME composition as
+  // spec/phase-driven ones ([<project>-]<version>-<name-slug>), so their branch
+  // never collapses to a bare name and never collides. Computed AFTER version
+  // and project are resolved (both feed the composition) and BEFORE the base-ref
+  // / active_context derivations below that consume `slug`.
+  const multiProject = listProjectsReadonly(cwd).projects.length > 1;
+  const slug = composeMilestoneSlug({ version, name, project, multiProject });
+  if (!slug) error('Could not derive a slug from name: ' + name);
+
+  // ── Step 1 — assert preconditions (ADH-19). No mutation before this. ──
+  // 1a. active_context already set?
+  const acRes = _adhocTools(cwd, 'config-get execution.active_context');
+  const activeContext = acRes.ok ? acRes.stdout.replace(/^"|"$/g, '').trim() : '';
+  if (activeContext && activeContext !== 'null' && activeContext !== '') {
+    error('An active context is already set (' + activeContext + '). Complete or abandon it first (e.g. /dgs:abandon-milestone), then retry.');
+  }
+
+  // 1b. dirty working trees (planning + every registered code repo)?
+  const parsed = parseReposMd(cwd);
+  const repos = (parsed && parsed.repos) ? parsed.repos : [];
+  if (_adhocIsDirty(planningRoot)) {
+    error('Planning working tree is dirty. Commit or stash changes first, then retry.');
+  }
+  for (const repo of repos) {
+    const repoAbs = _adhocRepoAbsPath(cwd, repo.path);
+    if (fs.existsSync(repoAbs) && _adhocIsDirty(repoAbs)) {
+      error('Code repo "' + repo.name + '" working tree is dirty. Commit or stash changes first, then retry.');
+    }
+  }
+
+  // Rollback bookkeeping — only undo what THIS invocation created.
+  const baseRef = 'refs/dgs/adhoc/' + slug + '/base';
+  let refCreated = false;
+  let worktreesCreated = false;
+  let stateCommitHash = null;
+  const statePath = path.join(planningRoot, getProjectRoot(cwd), 'STATE.md');
+
+  const rollback = (reasonMsg) => {
+    // Reverse order. active_context is set LAST so a pre-step-6 failure never set it.
+    if (stateCommitHash) {
+      // Reset the just-made STATE commit (not yet pushed at this point).
+      _adhocGit(planningRoot, ['reset', '--hard', stateCommitHash + '^']);
+    }
+    if (worktreesCreated) {
+      _adhocTools(cwd, 'worktrees remove ' + JSON.stringify(slug) + ' --force');
+    }
+    if (refCreated) {
+      _adhocGit(planningRoot, ['update-ref', '-d', baseRef]);
+    }
+    error(reasonMsg + ' — rolled back (no worktree, no base ref, no STATE marker, active_context unset).');
+  };
+
+  // ── Step 2 — capture planning base ref (ADH-06). ──
+  const refRes = _adhocGit(planningRoot, ['update-ref', baseRef, 'HEAD']);
+  if (!refRes.ok) error('Failed to capture base ref: ' + refRes.stderr);
+  refCreated = true;
+
+  // ── Step 3 — create code worktrees (ADH-02). ──
+  const wtRes = _adhocTools(cwd, 'worktrees create ' + JSON.stringify(slug) +
+    ' --type milestone --adhoc --base-ref ' + JSON.stringify(baseRef));
+  if (!wtRes.ok) {
+    worktreesCreated = true; // partial entry may exist — let rollback clean it.
+    rollback('Worktree creation failed: ' + (wtRes.stderr || wtRes.stdout));
+  }
+  worktreesCreated = true;
+
+  // ── Step 4 — confirm marker on the worktree entry (ADH-04 mirror). ──
+  let entryOk = false;
+  try {
+    const localCfg = JSON.parse(fs.readFileSync(path.join(planningRoot, 'config.local.json'), 'utf-8'));
+    const entry = localCfg.projects && localCfg.projects[project]
+      && localCfg.projects[project].worktrees && localCfg.projects[project].worktrees[slug];
+    entryOk = !!(entry && entry.adhoc === true && entry.adhoc_base_ref);
+  } catch { entryOk = false; }
+  if (!entryOk) rollback('Worktree entry missing adhoc marker / base-ref');
+
+  // ── Step 5 — commit STATE.md with adhoc:true + milestone vX.Y (ADH-04 primary). ──
+  if (!fs.existsSync(statePath)) rollback('STATE.md not found at ' + statePath);
+  try {
+    const content = fs.readFileSync(statePath, 'utf-8');
+    const fm = extractFrontmatter(content);
+    fm.milestone = version;
+    fm.milestone_name = name;
+    fm.status = 'executing';
+    fm.adhoc = true;
+    const newContent = spliceFrontmatter(content, fm);
+    fs.writeFileSync(statePath, newContent, 'utf-8');
+  } catch (e) {
+    rollback('Failed to write STATE.md adhoc marker: ' + e.message);
+  }
+  const stateRel = path.relative(planningRoot, statePath);
+  const addRes = _adhocGit(planningRoot, ['add', stateRel]);
+  if (!addRes.ok) rollback('Failed to stage STATE.md: ' + addRes.stderr);
+  const commitRes = _adhocGit(planningRoot, ['commit', '-m',
+    'feat(milestone): establish ad-hoc container ' + slug + ' (' + version + ')']);
+  if (!commitRes.ok) rollback('Failed to commit STATE.md: ' + commitRes.stderr);
+  const hashRes = _adhocGit(planningRoot, ['rev-parse', 'HEAD']);
+  stateCommitHash = hashRes.ok ? hashRes.stdout : null;
+
+  // ── Step 6 — set active_context LAST (ADH-03, no leak window). ──
+  const setRes = _adhocTools(cwd, 'config-local-set execution.active_context ' + JSON.stringify(slug));
+  if (!setRes.ok) rollback('Failed to set active_context: ' + setRes.stderr);
+
+  // ── Success — ADH-22 advisory. ──
+  process.stderr.write(
+    'Advisory: while ad-hoc milestone "' + slug + '" is active, any product-level ' +
+    '(--main) quick that commits to ' + baseBranch + ' (base_branch) will have its ' +
+    'STATE.md row reverted if you later run /dgs:abandon-milestone.\n'
+  );
+
+  output({
+    created: true,
+    adhoc: true,
+    slug,
+    version,
+    name,
+    base_ref: baseRef,
+    active_context: slug,
+    state_commit: stateCommitHash,
+  }, raw);
+}
+
+/**
+ * Abandon an active ad-hoc milestone (Phase 160) — the mirror of
+ * cmdMilestoneCreateAdhoc.
+ *
+ * Guard-then-mutate order (NO mutation until every guard passes):
+ *   1. require --confirmed (ADH-12; loss message lives here)            [guard]
+ *   2. resolve project + active ad-hoc slug from active_context          [guard]
+ *   3. assert ad-hoc marker on STATE.md + worktree entry (ADH-08)        [guard]
+ *   4. doc-scoped dirty check on the 5 restored docs (ADH-20a)           [guard]
+ *   5. detect pushed milestone branches (warn-only, ADH-20)             [collect]
+ *   6. teardown with reverse-order partial-failure bookkeeping:
+ *        a. worktrees remove {slug} (subprocess; drops branches, nulls
+ *           active_context — ADH-07)
+ *        b. path-scoped git restore --source <baseRef> -- <present docs>
+ *           (ADH-09; never a whole-tree reset)
+ *        c. attributed reversion commit (ADH-20)
+ *   7. emit pushed-branch warnings, then output the result JSON.
+ *
+ * Forward-only and intentionally destructive: on mid-op failure it REPORTS
+ * precisely what was/was not reverted (remainder recoverable) rather than
+ * rolling back. Local worktrees/branches only; remote refs are never deleted.
+ * detectQuickMode is never touched.
+ *
+ * @param {string} cwd - Planning root
+ * @param {string[]} args - [--confirmed]
+ * @param {boolean} raw
+ */
+function cmdAbandonMilestone(cwd, args, raw) {
+  // ── Guard 1 — confirmation (ADH-12). The CLI flag is the second guard
+  //    behind the workflow's AskUserQuestion gate. ──
+  const confirmed = args.includes('--confirmed');
+  if (!confirmed) {
+    error('Refusing to abandon: --confirmed required. WARNING: all uncommitted and committed milestone changes will be lost.');
+  }
+
+  // ── Resolve project + planning root. ──
+  const config = loadConfig(cwd);
+  const project = config.current_project;
+  if (!project) error('No current project set.');
+  const planningRoot = getPlanningRoot(cwd);
+
+  // ── Guard 2 — resolve the ACTIVE ad-hoc slug from active_context, so
+  //    worktrees-remove nulls context (Pitfall 3). ──
+  const acRes = _adhocTools(cwd, 'config-get execution.active_context');
+  const slug = acRes.ok ? acRes.stdout.replace(/^"|"$/g, '').trim() : '';
+  if (!slug || slug === 'null') error('No active milestone to abandon.');
+
+  // ── Guard 3 — ad-hoc-only (ADH-08). Cross-check STATE.md marker AND the
+  //    worktree entry's adhoc flag + base ref. No mutation on failure. ──
+  let localCfg;
+  try {
+    localCfg = JSON.parse(fs.readFileSync(path.join(planningRoot, 'config.local.json'), 'utf-8'));
+  } catch {
+    localCfg = {};
+  }
+  const entry = localCfg.projects && localCfg.projects[project]
+    && localCfg.projects[project].worktrees && localCfg.projects[project].worktrees[slug];
+  if (!entry || entry.adhoc !== true || !entry.adhoc_base_ref || !stateReadAdhoc(cwd)) {
+    error('milestone abandon only discards ad-hoc milestones. "' + slug + '" is spec/phase-driven — complete it with /dgs:complete-milestone. No changes made.');
+  }
+  const baseRef = entry.adhoc_base_ref; // refs/dgs/adhoc/{slug}/base
+
+  // ── Compute the canonical 5-doc list, filtered to those present at the
+  //    base ref (Pitfall 1 — git restore aborts on a missing pathspec). ──
+  const projRel = getProjectRoot(cwd);
+  const allDocs = ['PROJECT.md', 'STATE.md', 'ROADMAP.md', 'REQUIREMENTS.md']
+    .map(d => path.join(projRel, d))
+    .concat(['config.json']);
+  const present = allDocs.filter(d => _adhocGit(planningRoot, ['cat-file', '-e', baseRef + ':' + d]).ok);
+
+  // ── Guard 4 — doc-scoped dirty check (ADH-20a, Pitfall 5: NOT whole-tree). ──
+  const dirty = _adhocGit(planningRoot, ['status', '--porcelain', '--'].concat(present));
+  if (dirty.ok && dirty.stdout.trim()) {
+    error('Planning docs have uncommitted/staged edits (' + dirty.stdout.trim() + '). Commit or discard them first, then retry /dgs:abandon-milestone. No changes made.');
+  }
+
+  // ── Step 5 — delete the OWNED pushed milestone branch on origin (ADH-20).
+  //    For each repo whose remote-tracking ref exists, run a NON-FATAL
+  //    `git push origin --delete milestone/<slug>` so the milestone name is
+  //    reclaimed (prevents branch-name collisions). A delete failure is
+  //    collected as a warning and never aborts the abandon. ──
+  const warnings = [];
+  const parsed = parseReposMd(cwd);
+  const repos = (parsed && parsed.repos) ? parsed.repos : [];
+  for (const repo of repos) {
+    const repoAbs = _adhocRepoAbsPath(cwd, repo.path);
+    if (!fs.existsSync(repoAbs)) continue;
+    const r = _adhocGit(repoAbs, ['rev-parse', '--verify', '--quiet', 'refs/remotes/origin/milestone/' + slug]);
+    if (r.ok && r.stdout) {
+      const del = _adhocGit(repoAbs, ['push', 'origin', '--delete', 'milestone/' + slug]);
+      if (!del.ok) {
+        warnings.push('Warning: failed to delete remote milestone/' + slug + ' on origin in ' +
+          repo.name + ' (non-fatal): ' + (del.stderr || del.stdout) +
+          '. Delete it manually if needed: git push origin --delete milestone/' + slug);
+      }
+    }
+  }
+
+  // ── Step 6 — teardown with reverse-order partial-failure bookkeeping. ──
+  const reverted = { worktrees: false, docs: false, committed: false };
+
+  // 6a. Remove code worktrees + local branches via SUBPROCESS (Pitfall 4 —
+  //     cmdWorktreesRemove process-exits). This also nulls active_context.
+  const rmRes = _adhocTools(cwd, 'worktrees remove ' + JSON.stringify(slug));
+  reverted.worktrees = rmRes.ok;
+  if (!rmRes.ok) {
+    error('Failed to remove worktrees for "' + slug + '": ' + (rmRes.stderr || rmRes.stdout) +
+      '. Reverted so far: ' + JSON.stringify(reverted) + '. Docs NOT restored; nothing committed. ' +
+      'Re-run /dgs:abandon-milestone after resolving, or remove the worktree manually.');
+  }
+
+  // 6b. Path-scoped restore of exactly the present docs (ADH-09). NEVER a
+  //     whole-tree reset / checkout <ref> .
+  if (present.length > 0) {
+    const restoreRes = _adhocGit(planningRoot, ['restore', '--source', baseRef, '--'].concat(present));
+    reverted.docs = restoreRes.ok;
+    if (!restoreRes.ok) {
+      error('Worktrees removed, but failed to restore planning docs from ' + baseRef + ': ' + restoreRes.stderr +
+        '. Reverted so far: ' + JSON.stringify(reverted) + '. Recoverable — re-run: ' +
+        'git restore --source ' + baseRef + ' -- ' + present.join(' '));
+    }
+  } else {
+    reverted.docs = true; // nothing to restore
+  }
+
+  // 6c. Attributed reversion commit (ADH-20). Skip gracefully if the restore
+  //     produced no staged change (base === current for these docs).
+  if (present.length > 0) {
+    const addRes = _adhocGit(planningRoot, ['add', '--'].concat(present));
+    if (!addRes.ok) {
+      error('Docs restored but failed to stage them: ' + addRes.stderr +
+        '. Reverted so far: ' + JSON.stringify(reverted) + '. Recoverable — stage and commit the restored docs manually.');
+    }
+    const hasStaged = !_adhocGit(planningRoot, ['diff', '--cached', '--quiet']).ok;
+    if (hasStaged) {
+      const author = formatAuthorString(requireGitIdentity(cwd));
+      const commitRes = _adhocGit(planningRoot, ['commit', '--author', author, '-m',
+        'revert(milestone): abandon ad-hoc ' + slug + ' — restore project docs to pre-milestone state']);
+      reverted.committed = commitRes.ok;
+      if (!commitRes.ok) {
+        error('Docs restored + staged but commit failed: ' + commitRes.stderr +
+          '. Reverted so far: ' + JSON.stringify(reverted) + '. Recoverable — commit the staged docs manually.');
+      }
+    } else {
+      // No diff to commit — restore was a no-op (base == current). Treated as success.
+      reverted.committed = true;
+    }
+  } else {
+    reverted.committed = true;
+  }
+
+  // ── Step 6d — ADH-21 lifecycle cleanup: drop the base ref + any stale entry.
+  //    Called LAST so the doc restore above (which reads entry.adhoc_base_ref) ran first.
+  const cleanup = cleanupAdhoc(cwd, slug);
+
+  // ── Step 7 — surface pushed-branch warnings, then report. ──
+  for (const w of warnings) {
+    process.stderr.write(w + '\n');
+  }
+
+  output({
+    abandoned: true,
+    slug,
+    base_ref: baseRef,
+    restored: present,
+    reverted,
+    base_ref_deleted: cleanup.ref_deleted,
+    warnings,
+  }, raw);
+}
+
+/**
+ * ADH-21 — Idempotent teardown of ad-hoc lifecycle bookkeeping. Called from
+ * BOTH complete-milestone (after worktrees remove) and abandon (after the
+ * doc restore). Safe no-op for non-ad-hoc / already-clean slugs.
+ *
+ * 1. delete the snapshot base ref refs/dgs/adhoc/{slug}/base (no-op if absent)
+ * 2. defensively remove a lingering worktrees[slug] entry that still carries
+ *    adhoc keys (the normal path already removed it via `worktrees remove`)
+ * 3. clear execution.active_context if it still points at this slug
+ *
+ * @param {string} cwd - planning root
+ * @param {string} slug
+ * @returns {{ slug: string, ref_deleted: boolean, entry_removed: boolean }}
+ */
+function cleanupAdhoc(cwd, slug) {
+  const planningRoot = getPlanningRoot(cwd);
+  const config = loadConfig(cwd);
+  const project = config.current_project;
+  const baseRef = 'refs/dgs/adhoc/' + slug + '/base';
+
+  // 1. base ref — delete only if present (mirror rollback update-ref -d at create-adhoc).
+  const refExisted = _adhocGit(planningRoot, ['rev-parse', '--verify', '--quiet', baseRef]).ok;
+  if (refExisted) {
+    _adhocGit(planningRoot, ['update-ref', '-d', baseRef]);
+  }
+
+  // 2/3. defensive config cleanup — only the lingering-entry case.
+  let entryRemoved = false;
+  const cfgPath = path.join(planningRoot, 'config.local.json');
+  if (fs.existsSync(cfgPath)) {
+    let cfg;
+    try { cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8')); } catch { cfg = null; }
+    if (cfg) {
+      const wt = cfg.projects && cfg.projects[project] && cfg.projects[project].worktrees;
+      const entry = wt && wt[slug];
+      if (entry && (entry.adhoc === true || entry.adhoc_base_ref)) {
+        delete wt[slug];
+        entryRemoved = true;
+        if (cfg.execution && cfg.execution.active_context === slug) {
+          cfg.execution.active_context = null;
+        }
+        fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+      }
+    }
+  }
+
+  return { slug, ref_deleted: refExisted, entry_removed: entryRemoved };
+}
+
+/**
+ * CLI wrapper for ADH-21 cleanup. `dgs-tools milestone cleanup-adhoc <slug> [--raw]`.
+ */
+function cmdMilestoneCleanupAdhoc(cwd, slug, raw) {
+  if (!slug) error('Usage: milestone cleanup-adhoc <slug>');
+  output(cleanupAdhoc(cwd, slug), raw);
+}
+
 module.exports = {
   cmdRequirementsMarkComplete,
   requirementsMarkCompleteInternal,
   cmdMilestoneComplete,
+  cmdMilestoneCreateAdhoc,
+  cmdAbandonMilestone,
+  cleanupAdhoc,
+  cmdMilestoneCleanupAdhoc,
 };