@opengsd/gsd-core 1.2.0-rc.1

package/get-shit-done/bin/lib/workstream-inventory-builder.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+/**
+ * Workstream Inventory Builder — pure projection from pre-collected
+ * filesystem data to typed WorkstreamInventory. No I/O. No async.
+ */
+
+const path = require('path');
+const relative = path.relative;
+
+// Internal helpers
+function toPosixPath(p) {
+    return p.split('\\').join('/');
+}
+
+function isCompletedInventory(status) {
+    const s = String(status ?? '').trim().toLowerCase();
+    return /\bmilestone\s+complete\b/.test(s) || /\barchived\b/.test(s);
+}
+
+function buildWorkstreamInventory(inputs) {
+    const { name, projectDir, workstreamDir, phaseDirNames, activeWorkstreamName, phaseFilesCounts, roadmapPhaseCount, stateProjection, filesExist, } = inputs;
+    // Index counts by directory for O(1) lookup during sort/iteration
+    const countsMap = new Map();
+    for (const entry of phaseFilesCounts) {
+        countsMap.set(entry.directory, { planCount: entry.planCount, summaryCount: entry.summaryCount });
+    }
+    const phases = [];
+    let completedPhases = 0;
+    let totalPlans = 0;
+    let completedPlans = 0;
+    for (const dir of [...phaseDirNames].sort()) {
+        const counts = countsMap.get(dir) ?? { planCount: 0, summaryCount: 0 };
+        const status = counts.summaryCount >= counts.planCount && counts.planCount > 0
+            ? 'complete'
+            : counts.planCount > 0
+                ? 'in_progress'
+                : 'pending';
+        totalPlans += counts.planCount;
+        completedPlans += Math.min(counts.summaryCount, counts.planCount);
+        if (status === 'complete')
+            completedPhases++;
+        phases.push({
+            directory: dir,
+            status,
+            plan_count: counts.planCount,
+            summary_count: counts.summaryCount,
+        });
+    }
+    return {
+        name,
+        path: toPosixPath(relative(projectDir, workstreamDir)),
+        active: name === activeWorkstreamName,
+        files: {
+            roadmap: filesExist.roadmap,
+            state: filesExist.state,
+            requirements: filesExist.requirements,
+        },
+        status: stateProjection.status,
+        current_phase: stateProjection.current_phase,
+        last_activity: stateProjection.last_activity,
+        phases,
+        phase_count: phases.length,
+        completed_phases: completedPhases,
+        roadmap_phase_count: roadmapPhaseCount,
+        total_plans: totalPlans,
+        completed_plans: completedPlans,
+        progress_percent: roadmapPhaseCount > 0
+            ? Math.min(100, Math.round((completedPhases / roadmapPhaseCount) * 100))
+            : 0,
+    };
+}
+
+module.exports = { buildWorkstreamInventory, isCompletedInventory };

package/get-shit-done/bin/lib/workstream-inventory.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+/**
+ * Workstream Inventory Module
+ *
+ * Owns discovery and read-only projection of .planning/workstreams/* state.
+ * Command handlers should render outputs from this inventory instead of
+ * rescanning workstream directories directly.
+ *
+ * Pure projection logic lives in workstream-inventory-builder.generated.cjs.
+ * This module handles I/O orchestration only.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { toPosixPath, readSubdirectories } = require('./core.cjs');
+const scanPhasePlans = require('./plan-scan.cjs');
+const { planningPaths, planningRoot, getActiveWorkstream } = require('./planning-workspace.cjs');
+const { stateExtractField } = require('./state-document.cjs');
+const { buildWorkstreamInventory, isCompletedInventory } = require('./workstream-inventory-builder.cjs');
+
+function workstreamsRoot(cwd) {
+  return path.join(planningRoot(cwd), 'workstreams');
+}
+
+function countRoadmapPhases(roadmapPath, fallbackCount) {
+  try {
+    const roadmapContent = fs.readFileSync(roadmapPath, 'utf-8');
+    const matches = roadmapContent.match(/^#{2,4}\s+Phase\s+[\w][\w.-]*/gm);
+    return matches ? matches.length : fallbackCount;
+  } catch {
+    return fallbackCount;
+  }
+}
+
+function countPhaseFiles(phaseDir) {
+  const scan = scanPhasePlans(phaseDir);
+  return { planCount: scan.planCount, summaryCount: scan.summaryCount };
+}
+
+function readStateProjection(statePath) {
+  try {
+    const stateContent = fs.readFileSync(statePath, 'utf-8');
+    return {
+      status: stateExtractField(stateContent, 'Status') || 'unknown',
+      current_phase: stateExtractField(stateContent, 'Current Phase'),
+      last_activity: stateExtractField(stateContent, 'Last Activity'),
+    };
+  } catch {
+    return {
+      status: 'unknown',
+      current_phase: null,
+      last_activity: null,
+    };
+  }
+}
+
+function sortWorkstreamInventories(inventories, activeWorkstreamName) {
+  return [...inventories].sort((a, b) => {
+    const aActive = a.name === activeWorkstreamName ? 1 : 0;
+    const bActive = b.name === activeWorkstreamName ? 1 : 0;
+    if (aActive !== bActive) {
+      return bActive - aActive;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+
+function inspectWorkstream(cwd, name, options = {}) {
+  const wsDir = path.join(workstreamsRoot(cwd), name);
+  if (!fs.existsSync(wsDir)) return null;
+
+  const activeWorkstreamName = options.active === undefined ? getActiveWorkstream(cwd) : options.active;
+  const p = planningPaths(cwd, name);
+  const phaseDirNames = readSubdirectories(p.phases);
+
+  // Collect per-phase file counts
+  const phaseFilesCounts = phaseDirNames.map(dir => {
+    const counts = countPhaseFiles(path.join(p.phases, dir));
+    return { directory: dir, planCount: counts.planCount, summaryCount: counts.summaryCount };
+  });
+
+  return buildWorkstreamInventory({
+    name,
+    projectDir: cwd,
+    workstreamDir: wsDir,
+    phaseDirNames,
+    activeWorkstreamName,
+    phaseFilesCounts,
+    roadmapPhaseCount: countRoadmapPhases(p.roadmap, phaseDirNames.length),
+    stateProjection: readStateProjection(p.state),
+    filesExist: {
+      roadmap: fs.existsSync(p.roadmap),
+      state: fs.existsSync(p.state),
+      requirements: fs.existsSync(p.requirements),
+    },
+  });
+}
+
+function listWorkstreamInventories(cwd) {
+  const wsRoot = workstreamsRoot(cwd);
+  if (!fs.existsSync(wsRoot)) {
+    return {
+      mode: 'flat',
+      active: null,
+      workstreams: [],
+      count: 0,
+      message: 'No workstreams — operating in flat mode',
+    };
+  }
+
+  const active = getActiveWorkstream(cwd);
+  const entries = fs.readdirSync(wsRoot, { withFileTypes: true });
+  const workstreams = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const inventory = inspectWorkstream(cwd, entry.name, { active });
+    if (inventory) workstreams.push(inventory);
+  }
+
+  const ordered = sortWorkstreamInventories(workstreams, active);
+
+  return {
+    mode: 'workstream',
+    active,
+    workstreams: ordered,
+    count: ordered.length,
+  };
+}
+
+function getOtherActiveWorkstreamInventories(cwd, excludeWs) {
+  return listWorkstreamInventories(cwd).workstreams
+    .filter(inventory => inventory.name !== excludeWs)
+    .filter(inventory => !isCompletedInventory(inventory.status));
+}
+
+module.exports = {
+  countPhaseFiles,
+  countRoadmapPhases,
+  getOtherActiveWorkstreamInventories,
+  inspectWorkstream,
+  isCompletedInventory,
+  listWorkstreamInventories,
+  sortWorkstreamInventories,
+  workstreamsRoot,
+};

package/get-shit-done/bin/lib/workstream-name-policy.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+/**
+ * Canonical workstream name validation and slug normalization.
+ * Used by active-workstream-store.cjs, planning-workspace.cjs, workstream.cjs.
+ */
+
+const ACTIVE_WORKSTREAM_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE = 'Invalid workstream name: must be alphanumeric, hyphens, underscores, or dots';
+
+function normalizeWorkstreamNameInput(name) {
+    const value = String(name || '').trim();
+    return value || null;
+}
+
+function validateActiveWorkstreamName(name) {
+    const value = normalizeWorkstreamNameInput(name);
+    if (!value) {
+        return {
+            ok: false,
+            reason: 'empty',
+            value: null,
+        };
+    }
+    if (hasInvalidPathSegment(value) || !ACTIVE_WORKSTREAM_RE.test(value)) {
+        return {
+            ok: false,
+            reason: 'invalid',
+            value,
+        };
+    }
+    return {
+        ok: true,
+        reason: null,
+        value,
+    };
+}
+/**
+ * Validate a workstream name.
+ * Allowed: alphanumeric, hyphens, underscores, dots.
+ * Disallowed: empty, spaces, slashes, special chars, path traversal.
+ *
+ * Alias for isValidActiveWorkstreamName; provided for SDK-layer callers.
+ */
+function validateWorkstreamName(name) {
+    return isValidActiveWorkstreamName(name);
+}
+/**
+ * Convert a display name to a URL/filesystem-safe workstream slug.
+ * Lowercases, collapses non-alphanumeric runs to hyphens, strips leading/trailing hyphens.
+ */
+function toWorkstreamSlug(name) {
+    return String(name || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Returns true when `name` contains a path separator, a bare dot, or a
+ * dot-dot sequence — any of which would make the name unsafe for use as a
+ * filesystem path segment.
+ */
+function hasInvalidPathSegment(name) {
+    const value = String(name || '');
+    return /[/\\]/.test(value) || value === '.' || value === '..' || value.includes('..');
+}
+/**
+ * Returns true when `name` is a valid active workstream name:
+ * - Must start with alphanumeric
+ * - May contain alphanumeric, dots, underscores, hyphens
+ * - Must not contain path traversal sequences (..)
+ */
+function isValidActiveWorkstreamName(name) {
+    return validateActiveWorkstreamName(name).ok;
+}
+
+function assertValidActiveWorkstreamName(name, errorMessage = INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE) {
+    const validation = validateActiveWorkstreamName(name);
+    if (!validation.ok) {
+        throw new Error(errorMessage);
+    }
+    return validation.value;
+}
+
+module.exports = {
+  INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE,
+  normalizeWorkstreamNameInput,
+  validateActiveWorkstreamName,
+  validateWorkstreamName,
+  toWorkstreamSlug,
+  hasInvalidPathSegment,
+  isValidActiveWorkstreamName,
+  assertValidActiveWorkstreamName,
+};

package/get-shit-done/bin/lib/workstream.cjs

@@ -0,0 +1,389 @@
+/**
+ * Workstream — CRUD operations for workstream namespacing
+ *
+ * Workstreams enable parallel milestones by scoping ROADMAP.md, STATE.md,
+ * REQUIREMENTS.md, and phases/ into .planning/workstreams/{name}/ directories.
+ *
+ * When no workstreams/ directory exists, GSD operates in "flat mode" with
+ * everything at .planning/ — backward compatible with pre-workstream installs.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { output, error, toPosixPath, getMilestoneInfo, generateSlugInternal } = require('./core.cjs');
+const { platformWriteSync, platformEnsureDir } = require('./shell-command-projection.cjs');
+const { planningRoot, setActiveWorkstream, getActiveWorkstream } = require('./planning-workspace.cjs');
+const {
+  toWorkstreamSlug,
+  assertValidActiveWorkstreamName,
+  isValidActiveWorkstreamName,
+  INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE,
+} = require('./workstream-name-policy.cjs');
+const { formatGsdSlash, resolveRuntime } = require('./runtime-slash.cjs');
+const {
+  getOtherActiveWorkstreamInventories,
+  inspectWorkstream,
+  listWorkstreamInventories,
+} = require('./workstream-inventory.cjs');
+
+// ─── Migration ──────────────────────────────────────────────────────────────
+
+/**
+ * Migrate flat .planning/ layout to workstream mode.
+ * Moves per-workstream files (ROADMAP.md, STATE.md, REQUIREMENTS.md, phases/)
+ * into .planning/workstreams/{name}/. Shared files (PROJECT.md, config.json,
+ * milestones/, research/, codebase/, todos/) stay in place.
+ */
+function migrateToWorkstreams(cwd, workstreamName) {
+  try {
+    assertValidActiveWorkstreamName(workstreamName, 'Invalid workstream name for migration');
+  } catch (err) {
+    throw new Error('Invalid workstream name for migration');
+  }
+
+  const baseDir = planningRoot(cwd);
+  const wsDir = path.join(baseDir, 'workstreams', workstreamName);
+
+  if (fs.existsSync(path.join(baseDir, 'workstreams'))) {
+    throw new Error('Already in workstream mode — .planning/workstreams/ exists');
+  }
+
+  const toMove = [
+    { name: 'ROADMAP.md', type: 'file' },
+    { name: 'STATE.md', type: 'file' },
+    { name: 'REQUIREMENTS.md', type: 'file' },
+    { name: 'phases', type: 'dir' },
+  ];
+
+  platformEnsureDir(wsDir);
+
+  const filesMoved = [];
+  try {
+    for (const item of toMove) {
+      const src = path.join(baseDir, item.name);
+      if (fs.existsSync(src)) {
+        const dest = path.join(wsDir, item.name);
+        fs.renameSync(src, dest);
+        filesMoved.push(item.name);
+      }
+    }
+  } catch (err) {
+    for (const name of filesMoved) {
+      try { fs.renameSync(path.join(wsDir, name), path.join(baseDir, name)); } catch {}
+    }
+    try { fs.rmSync(wsDir, { recursive: true }); } catch {}
+    try { fs.rmdirSync(path.join(baseDir, 'workstreams')); } catch {}
+    throw err;
+  }
+
+  return { migrated: true, workstream: workstreamName, files_moved: filesMoved };
+}
+
+// ─── CRUD Commands ──────────────────────────────────────────────────────────
+
+function cmdWorkstreamCreate(cwd, name, options, raw) {
+  if (!name) {
+    error('workstream name required. Usage: workstream create <name>');
+  }
+
+  const slug = toWorkstreamSlug(name);
+  if (!slug) {
+    error('Invalid workstream name — must contain at least one alphanumeric character');
+  }
+
+  const baseDir = planningRoot(cwd);
+  if (!fs.existsSync(baseDir)) {
+    error(`.planning/ directory not found — run ${formatGsdSlash('new-project', resolveRuntime(cwd))} first`);
+  }
+
+  const wsRoot = path.join(baseDir, 'workstreams');
+  const wsDir = path.join(wsRoot, slug);
+
+  if (fs.existsSync(wsDir) && fs.existsSync(path.join(wsDir, 'STATE.md'))) {
+    output({ created: false, error: 'already_exists', workstream: slug, path: toPosixPath(path.relative(cwd, wsDir)) }, raw);
+    return;
+  }
+
+  const isFlatMode = !fs.existsSync(wsRoot);
+  let migration = null;
+  if (isFlatMode && options.migrate !== false) {
+    const hasExistingWork = fs.existsSync(path.join(baseDir, 'ROADMAP.md')) ||
+                            fs.existsSync(path.join(baseDir, 'STATE.md')) ||
+                            fs.existsSync(path.join(baseDir, 'phases'));
+
+    if (hasExistingWork) {
+      const migrateName = options.migrateName || null;
+      let existingWsName;
+      if (migrateName) {
+        existingWsName = toWorkstreamSlug(migrateName);
+        if (!existingWsName) {
+          output({
+            created: false,
+            error: 'migration_failed',
+            message: 'Invalid migrate-name — must contain at least one alphanumeric character',
+          }, raw);
+          return;
+        }
+      } else {
+        try {
+          const milestone = getMilestoneInfo(cwd);
+          existingWsName = generateSlugInternal(milestone.name) || 'default';
+        } catch {
+          existingWsName = 'default';
+        }
+      }
+
+      try {
+        migration = migrateToWorkstreams(cwd, existingWsName);
+      } catch (e) {
+        output({ created: false, error: 'migration_failed', message: e.message }, raw);
+        return;
+      }
+    } else {
+      platformEnsureDir(wsRoot);
+    }
+  }
+
+  platformEnsureDir(wsDir);
+  platformEnsureDir(path.join(wsDir, 'phases'));
+
+  const today = new Date().toISOString().split('T')[0];
+  const stateContent = [
+    '---',
+    `workstream: ${slug}`,
+    `created: ${today}`,
+    '---',
+    '',
+    '# Project State',
+    '',
+    '## Current Position',
+    '**Status:** Not started',
+    '**Current Phase:** None',
+    `**Last Activity:** ${today}`,
+    '**Last Activity Description:** Workstream created',
+    '',
+    '## Progress',
+    '**Phases Complete:** 0',
+    '**Current Plan:** N/A',
+    '',
+    '## Session Continuity',
+    '**Stopped At:** N/A',
+    '**Resume File:** None',
+    '',
+  ].join('\n');
+
+  const statePath = path.join(wsDir, 'STATE.md');
+  if (!fs.existsSync(statePath)) {
+    platformWriteSync(statePath, stateContent);
+  }
+
+  setActiveWorkstream(cwd, slug);
+
+  const relPath = toPosixPath(path.relative(cwd, wsDir));
+  output({
+    created: true,
+    workstream: slug,
+    path: relPath,
+    state_path: relPath + '/STATE.md',
+    phases_path: relPath + '/phases',
+    migration: migration || null,
+    active: true,
+  }, raw);
+}
+
+function cmdWorkstreamList(cwd, raw) {
+  const inventory = listWorkstreamInventories(cwd);
+  if (inventory.mode === 'flat') {
+    output({ mode: 'flat', workstreams: [], message: inventory.message }, raw);
+    return;
+  }
+
+  const workstreams = inventory.workstreams.map(ws => ({
+    name: ws.name,
+    path: ws.path,
+    has_roadmap: ws.files.roadmap,
+    has_state: ws.files.state,
+    status: ws.status,
+    current_phase: ws.current_phase,
+    phase_count: ws.phase_count,
+    completed_phases: ws.completed_phases,
+  }));
+
+  output({ mode: 'workstream', workstreams, count: workstreams.length }, raw);
+}
+
+function cmdWorkstreamStatus(cwd, name, raw) {
+  if (!name) error('workstream name required. Usage: workstream status <name>');
+  try {
+    assertValidActiveWorkstreamName(name, INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+  } catch {
+    error(INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+  }
+
+  const wsDir = path.join(planningRoot(cwd), 'workstreams', name);
+  if (!fs.existsSync(wsDir)) {
+    output({ found: false, workstream: name }, raw);
+    return;
+  }
+
+  const inventory = inspectWorkstream(cwd, name);
+
+  output({
+    found: true,
+    workstream: name,
+    path: inventory.path,
+    files: inventory.files,
+    phases: inventory.phases,
+    phase_count: inventory.phase_count,
+    completed_phases: inventory.completed_phases,
+    status: inventory.status,
+    current_phase: inventory.current_phase,
+    last_activity: inventory.last_activity,
+  }, raw);
+}
+
+function cmdWorkstreamComplete(cwd, name, options, raw) {
+  if (!name) error('workstream name required. Usage: workstream complete <name>');
+  try {
+    assertValidActiveWorkstreamName(name, INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+  } catch {
+    error(INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+  }
+
+  const root = planningRoot(cwd);
+  const wsRoot = path.join(root, 'workstreams');
+  const wsDir = path.join(wsRoot, name);
+
+  if (!fs.existsSync(wsDir)) {
+    output({ completed: false, error: 'not_found', workstream: name }, raw);
+    return;
+  }
+
+  const active = getActiveWorkstream(cwd);
+  if (active === name) setActiveWorkstream(cwd, null);
+
+  const archiveDir = path.join(root, 'milestones');
+  const today = new Date().toISOString().split('T')[0];
+  let archivePath = path.join(archiveDir, `ws-${name}-${today}`);
+  let suffix = 1;
+  while (fs.existsSync(archivePath)) {
+    archivePath = path.join(archiveDir, `ws-${name}-${today}-${suffix++}`);
+  }
+
+  platformEnsureDir(archivePath);
+
+  const filesMoved = [];
+  try {
+    const entries = fs.readdirSync(wsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      fs.renameSync(path.join(wsDir, entry.name), path.join(archivePath, entry.name));
+      filesMoved.push(entry.name);
+    }
+  } catch (err) {
+    for (const fname of filesMoved) {
+      try { fs.renameSync(path.join(archivePath, fname), path.join(wsDir, fname)); } catch {}
+    }
+    try { fs.rmSync(archivePath, { recursive: true }); } catch {}
+    if (active === name) setActiveWorkstream(cwd, name);
+    output({ completed: false, error: 'archive_failed', message: err.message, workstream: name }, raw);
+    return;
+  }
+
+  try { fs.rmdirSync(wsDir); } catch {}
+
+  let remainingWs = 0;
+  try {
+    remainingWs = fs.readdirSync(wsRoot, { withFileTypes: true }).filter(e => e.isDirectory()).length;
+    if (remainingWs === 0) fs.rmdirSync(wsRoot);
+  } catch {}
+
+  output({
+    completed: true,
+    workstream: name,
+    archived_to: toPosixPath(path.relative(cwd, archivePath)),
+    remaining_workstreams: remainingWs,
+    reverted_to_flat: remainingWs === 0,
+  }, raw);
+}
+
+// ─── Active Workstream Commands ──────────────────────────────────────────────
+
+function cmdWorkstreamSet(cwd, name, raw) {
+  if (!name || name === '--clear') {
+    if (name !== '--clear') {
+      error('Workstream name required. Usage: workstream set <name> (or workstream set --clear to unset)');
+    }
+    const previous = getActiveWorkstream(cwd);
+    setActiveWorkstream(cwd, null);
+    output({ active: null, cleared: true, previous: previous || null }, raw);
+    return;
+  }
+
+  if (!isValidActiveWorkstreamName(name)) {
+    output({ active: null, error: 'invalid_name', message: 'Workstream name must be alphanumeric, hyphens, underscores, or dots' }, raw);
+    return;
+  }
+
+  const wsDir = path.join(planningRoot(cwd), 'workstreams', name);
+  if (!fs.existsSync(wsDir)) {
+    output({ active: null, error: 'not_found', workstream: name }, raw);
+    return;
+  }
+
+  setActiveWorkstream(cwd, name);
+  output({ active: name, set: true }, raw, name);
+}
+
+function cmdWorkstreamGet(cwd, raw) {
+  const active = getActiveWorkstream(cwd);
+  const wsRoot = path.join(planningRoot(cwd), 'workstreams');
+  output({ active, mode: fs.existsSync(wsRoot) ? 'workstream' : 'flat' }, raw, active || 'none');
+}
+
+function cmdWorkstreamProgress(cwd, raw) {
+  const inventory = listWorkstreamInventories(cwd);
+  if (inventory.mode === 'flat') {
+    output({ mode: 'flat', workstreams: [], message: inventory.message }, raw);
+    return;
+  }
+
+  const workstreams = inventory.workstreams.map(ws => ({
+    name: ws.name,
+    active: ws.active,
+    status: ws.status,
+    current_phase: ws.current_phase,
+    phases: `${ws.completed_phases}/${ws.roadmap_phase_count}`,
+    plans: `${ws.completed_plans}/${ws.total_plans}`,
+    progress_percent: ws.progress_percent,
+  }));
+
+  output({ mode: 'workstream', active: inventory.active, workstreams, count: workstreams.length }, raw);
+}
+
+// ─── Collision Detection ────────────────────────────────────────────────────
+
+/**
+ * Return other workstreams that are NOT complete.
+ * Used to detect whether the milestone has active parallel work
+ * when a workstream finishes its last phase.
+ */
+function getOtherActiveWorkstreams(cwd, excludeWs) {
+  return getOtherActiveWorkstreamInventories(cwd, excludeWs).map(ws => ({
+    name: ws.name,
+    status: ws.status,
+    current_phase: ws.current_phase,
+    phases: `${ws.completed_phases}/${ws.phase_count}`,
+  }));
+}
+
+module.exports = {
+  migrateToWorkstreams,
+  cmdWorkstreamCreate,
+  cmdWorkstreamList,
+  cmdWorkstreamStatus,
+  cmdWorkstreamComplete,
+  cmdWorkstreamSet,
+  cmdWorkstreamGet,
+  cmdWorkstreamProgress,
+  getOtherActiveWorkstreams,
+};