@opengsd/gsd-core 1.2.0 → 1.3.0

package/{get-shit-done → gsd-core}/bin/lib/workstream-inventory-builder.cjs

@@ -1,23 +1,32 @@
-'use strict';
-
+"use strict";
 /**
  * Workstream Inventory Builder — pure projection from pre-collected
  * filesystem data to typed WorkstreamInventory. No I/O. No async.
+ *
+ * ADR-457 build-at-publish: the hand-written
+ * bin/lib/workstream-inventory-builder.cjs collapsed to a TypeScript source
+ * of truth. Behaviour is preserved byte-for-behaviour from the prior
+ * hand-written .cjs; only types are added.
  */
-
-const path = require('path');
-const relative = path.relative;
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompletedInventory = isCompletedInventory;
+exports.buildWorkstreamInventory = buildWorkstreamInventory;
+const node_path_1 = __importDefault(require("node:path"));
 // Internal helpers
 function toPosixPath(p) {
     return p.split('\\').join('/');
 }
-
 function isCompletedInventory(status) {
-    const s = String(status ?? '').trim().toLowerCase();
+    const s = (typeof status === 'string'
+        ? status
+        : typeof status === 'number' || typeof status === 'boolean'
+            ? 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
@@ -49,7 +58,7 @@ function buildWorkstreamInventory(inputs) {
     }
     return {
         name,
-        path: toPosixPath(relative(projectDir, workstreamDir)),
+        path: toPosixPath(node_path_1.default.relative(projectDir, workstreamDir)),
         active: name === activeWorkstreamName,
         files: {
             roadmap: filesExist.roadmap,
@@ -70,5 +79,3 @@ function buildWorkstreamInventory(inputs) {
             : 0,
     };
 }
-
-module.exports = { buildWorkstreamInventory, isCompletedInventory };

package/gsd-core/bin/lib/workstream-inventory.cjs

@@ -0,0 +1,147 @@
+"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.cts.
+ * This module handles I/O orchestration only.
+ *
+ * ADR-457 build-at-publish: the hand-written bin/lib/workstream-inventory.cjs
+ * collapsed to a TypeScript source of truth. Behaviour is preserved byte-for-behaviour
+ * from the prior hand-written .cjs; only types are added.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const core = require("./core.cjs");
+const { toPosixPath, readSubdirectories } = core;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const planScan = require("./plan-scan.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const planningWorkspace = require("./planning-workspace.cjs");
+const { planningPaths, planningRoot, getActiveWorkstream } = planningWorkspace;
+const state_document_cjs_1 = require("./state-document.cjs");
+const workstream_inventory_builder_cjs_1 = require("./workstream-inventory-builder.cjs");
+// ─── Implementation ───────────────────────────────────────────────────────────
+function workstreamsRoot(cwd) {
+    return node_path_1.default.join(planningRoot(cwd), 'workstreams');
+}
+function countRoadmapPhases(roadmapPath, fallbackCount) {
+    try {
+        const roadmapContent = node_fs_1.default.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 = planScan(phaseDir);
+    return { planCount: scan.planCount, summaryCount: scan.summaryCount };
+}
+function readStateProjection(statePath) {
+    try {
+        const stateContent = node_fs_1.default.readFileSync(statePath, 'utf-8');
+        return {
+            status: (0, state_document_cjs_1.stateExtractField)(stateContent, 'Status') || 'unknown',
+            current_phase: (0, state_document_cjs_1.stateExtractField)(stateContent, 'Current Phase'),
+            last_activity: (0, state_document_cjs_1.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 = node_path_1.default.join(workstreamsRoot(cwd), name);
+    if (!node_fs_1.default.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(node_path_1.default.join(p.phases, dir));
+        return { directory: dir, planCount: counts.planCount, summaryCount: counts.summaryCount };
+    });
+    return (0, workstream_inventory_builder_cjs_1.buildWorkstreamInventory)({
+        name,
+        projectDir: cwd,
+        workstreamDir: wsDir,
+        phaseDirNames,
+        activeWorkstreamName: activeWorkstreamName ?? '',
+        phaseFilesCounts,
+        roadmapPhaseCount: countRoadmapPhases(p.roadmap, phaseDirNames.length),
+        stateProjection: readStateProjection(p.state),
+        filesExist: {
+            roadmap: node_fs_1.default.existsSync(p.roadmap),
+            state: node_fs_1.default.existsSync(p.state),
+            requirements: node_fs_1.default.existsSync(p.requirements),
+        },
+    });
+}
+function listWorkstreamInventories(cwd) {
+    const wsRoot = workstreamsRoot(cwd);
+    if (!node_fs_1.default.existsSync(wsRoot)) {
+        return {
+            mode: 'flat',
+            active: null,
+            workstreams: [],
+            count: 0,
+            message: 'No workstreams — operating in flat mode',
+        };
+    }
+    const active = getActiveWorkstream(cwd);
+    const entries = node_fs_1.default.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 => !(0, workstream_inventory_builder_cjs_1.isCompletedInventory)(inventory.status));
+}
+module.exports = {
+    countPhaseFiles,
+    countRoadmapPhases,
+    getOtherActiveWorkstreamInventories,
+    inspectWorkstream,
+    isCompletedInventory: workstream_inventory_builder_cjs_1.isCompletedInventory,
+    listWorkstreamInventories,
+    sortWorkstreamInventories,
+    workstreamsRoot,
+};

package/{get-shit-done → gsd-core}/bin/lib/workstream-name-policy.cjs

@@ -1,18 +1,36 @@
-'use strict';
-
+"use strict";
 /**
- * Canonical workstream name validation and slug normalization.
+ * Canonical workstream name validation and slug normalization
+ * (ADR-457 build-at-publish: the hand-written bin/lib/workstream-name-policy.cjs
+ * collapsed to a TypeScript source of truth). Behaviour is preserved
+ * byte-for-behaviour from the prior hand-written .cjs; only types are added.
+ *
  * Used by active-workstream-store.cjs, planning-workspace.cjs, workstream.cjs.
  */
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE = void 0;
+exports.normalizeWorkstreamNameInput = normalizeWorkstreamNameInput;
+exports.hasInvalidPathSegment = hasInvalidPathSegment;
+exports.validateActiveWorkstreamName = validateActiveWorkstreamName;
+exports.validateWorkstreamName = validateWorkstreamName;
+exports.toWorkstreamSlug = toWorkstreamSlug;
+exports.isValidActiveWorkstreamName = isValidActiveWorkstreamName;
+exports.assertValidActiveWorkstreamName = assertValidActiveWorkstreamName;
+exports.INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE = 'Invalid workstream name: must be alphanumeric, hyphens, underscores, or dots';
 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();
+    const value = String(name ?? '').trim();
     return value || null;
 }
-
+/**
+ * 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('..');
+}
 function validateActiveWorkstreamName(name) {
     const value = normalizeWorkstreamNameInput(name);
     if (!value) {
@@ -50,20 +68,11 @@ function validateWorkstreamName(name) {
  * Lowercases, collapses non-alphanumeric runs to hyphens, strips leading/trailing hyphens.
  */
 function toWorkstreamSlug(name) {
-    return String(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
@@ -73,22 +82,10 @@ function hasInvalidPathSegment(name) {
 function isValidActiveWorkstreamName(name) {
     return validateActiveWorkstreamName(name).ok;
 }
-
-function assertValidActiveWorkstreamName(name, errorMessage = INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE) {
+function assertValidActiveWorkstreamName(name, errorMessage = exports.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/gsd-core/bin/lib/workstream.cjs

@@ -0,0 +1,380 @@
+"use strict";
+/**
+ * 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.
+ *
+ * ADR-457 build-at-publish: the hand-written bin/lib/workstream.cjs collapsed
+ * to a TypeScript source of truth. Behaviour is preserved byte-for-behaviour
+ * from the prior hand-written .cjs; only strict types are added.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const core = require("./core.cjs");
+const { output, error, toPosixPath, getMilestoneInfo, generateSlugInternal } = core;
+const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const planningWorkspace = require("./planning-workspace.cjs");
+const { planningRoot, setActiveWorkstream, getActiveWorkstream } = planningWorkspace;
+const workstream_name_policy_cjs_1 = require("./workstream-name-policy.cjs");
+const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const workstreamInventory = require("./workstream-inventory.cjs");
+const { getOtherActiveWorkstreamInventories, inspectWorkstream, listWorkstreamInventories, } = workstreamInventory;
+// ─── 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 {
+        (0, workstream_name_policy_cjs_1.assertValidActiveWorkstreamName)(workstreamName, 'Invalid workstream name for migration');
+    }
+    catch {
+        throw new Error('Invalid workstream name for migration');
+    }
+    const baseDir = planningRoot(cwd);
+    const wsDir = node_path_1.default.join(baseDir, 'workstreams', workstreamName);
+    if (node_fs_1.default.existsSync(node_path_1.default.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' },
+    ];
+    (0, shell_command_projection_cjs_1.platformEnsureDir)(wsDir);
+    const filesMoved = [];
+    try {
+        for (const item of toMove) {
+            const src = node_path_1.default.join(baseDir, item.name);
+            if (node_fs_1.default.existsSync(src)) {
+                const dest = node_path_1.default.join(wsDir, item.name);
+                node_fs_1.default.renameSync(src, dest);
+                filesMoved.push(item.name);
+            }
+        }
+    }
+    catch (err) {
+        for (const name of filesMoved) {
+            try {
+                node_fs_1.default.renameSync(node_path_1.default.join(wsDir, name), node_path_1.default.join(baseDir, name));
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            node_fs_1.default.rmSync(wsDir, { recursive: true });
+        }
+        catch { /* ignore */ }
+        try {
+            node_fs_1.default.rmdirSync(node_path_1.default.join(baseDir, 'workstreams'));
+        }
+        catch { /* ignore */ }
+        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 = (0, workstream_name_policy_cjs_1.toWorkstreamSlug)(name);
+    if (!slug) {
+        error('Invalid workstream name — must contain at least one alphanumeric character');
+    }
+    const baseDir = planningRoot(cwd);
+    if (!node_fs_1.default.existsSync(baseDir)) {
+        error(`.planning/ directory not found — run ${(0, runtime_slash_cjs_1.formatGsdSlash)('new-project', (0, runtime_slash_cjs_1.resolveRuntime)(cwd))} first`);
+    }
+    const wsRoot = node_path_1.default.join(baseDir, 'workstreams');
+    const wsDir = node_path_1.default.join(wsRoot, slug);
+    if (node_fs_1.default.existsSync(wsDir) && node_fs_1.default.existsSync(node_path_1.default.join(wsDir, 'STATE.md'))) {
+        output({ created: false, error: 'already_exists', workstream: slug, path: toPosixPath(node_path_1.default.relative(cwd, wsDir)) }, raw, undefined);
+        return;
+    }
+    const isFlatMode = !node_fs_1.default.existsSync(wsRoot);
+    let migration = null;
+    if (isFlatMode && options.migrate !== false) {
+        const hasExistingWork = node_fs_1.default.existsSync(node_path_1.default.join(baseDir, 'ROADMAP.md')) ||
+            node_fs_1.default.existsSync(node_path_1.default.join(baseDir, 'STATE.md')) ||
+            node_fs_1.default.existsSync(node_path_1.default.join(baseDir, 'phases'));
+        if (hasExistingWork) {
+            const migrateName = options.migrateName || null;
+            let existingWsName;
+            if (migrateName) {
+                const slugged = (0, workstream_name_policy_cjs_1.toWorkstreamSlug)(migrateName);
+                if (!slugged) {
+                    output({
+                        created: false,
+                        error: 'migration_failed',
+                        message: 'Invalid migrate-name — must contain at least one alphanumeric character',
+                    }, raw, undefined);
+                    return;
+                }
+                existingWsName = slugged;
+            }
+            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, undefined);
+                return;
+            }
+        }
+        else {
+            (0, shell_command_projection_cjs_1.platformEnsureDir)(wsRoot);
+        }
+    }
+    (0, shell_command_projection_cjs_1.platformEnsureDir)(wsDir);
+    (0, shell_command_projection_cjs_1.platformEnsureDir)(node_path_1.default.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 = node_path_1.default.join(wsDir, 'STATE.md');
+    if (!node_fs_1.default.existsSync(statePath)) {
+        (0, shell_command_projection_cjs_1.platformWriteSync)(statePath, stateContent);
+    }
+    setActiveWorkstream(cwd, slug);
+    const relPath = toPosixPath(node_path_1.default.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, undefined);
+}
+function cmdWorkstreamList(cwd, raw) {
+    const inventory = listWorkstreamInventories(cwd);
+    if (inventory.mode === 'flat') {
+        output({ mode: 'flat', workstreams: [], message: inventory.message }, raw, undefined);
+        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, undefined);
+}
+function cmdWorkstreamStatus(cwd, name, raw) {
+    if (!name)
+        error('workstream name required. Usage: workstream status <name>');
+    try {
+        (0, workstream_name_policy_cjs_1.assertValidActiveWorkstreamName)(name, workstream_name_policy_cjs_1.INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+    }
+    catch {
+        error(workstream_name_policy_cjs_1.INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+    }
+    const wsDir = node_path_1.default.join(planningRoot(cwd), 'workstreams', name);
+    if (!node_fs_1.default.existsSync(wsDir)) {
+        output({ found: false, workstream: name }, raw, undefined);
+        return;
+    }
+    const inv = inspectWorkstream(cwd, name);
+    if (!inv) {
+        output({ found: false, workstream: name }, raw, undefined);
+        return;
+    }
+    output({
+        found: true,
+        workstream: name,
+        path: inv.path,
+        files: inv.files,
+        phases: inv.phases,
+        phase_count: inv.phase_count,
+        completed_phases: inv.completed_phases,
+        status: inv.status,
+        current_phase: inv.current_phase,
+        last_activity: inv.last_activity,
+    }, raw, undefined);
+}
+function cmdWorkstreamComplete(cwd, name, options, raw) {
+    if (!name)
+        error('workstream name required. Usage: workstream complete <name>');
+    try {
+        (0, workstream_name_policy_cjs_1.assertValidActiveWorkstreamName)(name, workstream_name_policy_cjs_1.INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+    }
+    catch {
+        error(workstream_name_policy_cjs_1.INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
+    }
+    const root = planningRoot(cwd);
+    const wsRoot = node_path_1.default.join(root, 'workstreams');
+    const wsDir = node_path_1.default.join(wsRoot, name);
+    if (!node_fs_1.default.existsSync(wsDir)) {
+        output({ completed: false, error: 'not_found', workstream: name }, raw, undefined);
+        return;
+    }
+    const active = getActiveWorkstream(cwd);
+    if (active === name)
+        setActiveWorkstream(cwd, null);
+    const archiveDir = node_path_1.default.join(root, 'milestones');
+    const today = new Date().toISOString().split('T')[0];
+    let archivePath = node_path_1.default.join(archiveDir, `ws-${name}-${today}`);
+    let suffix = 1;
+    while (node_fs_1.default.existsSync(archivePath)) {
+        archivePath = node_path_1.default.join(archiveDir, `ws-${name}-${today}-${suffix++}`);
+    }
+    (0, shell_command_projection_cjs_1.platformEnsureDir)(archivePath);
+    const filesMoved = [];
+    try {
+        const entries = node_fs_1.default.readdirSync(wsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            node_fs_1.default.renameSync(node_path_1.default.join(wsDir, entry.name), node_path_1.default.join(archivePath, entry.name));
+            filesMoved.push(entry.name);
+        }
+    }
+    catch (err) {
+        for (const fname of filesMoved) {
+            try {
+                node_fs_1.default.renameSync(node_path_1.default.join(archivePath, fname), node_path_1.default.join(wsDir, fname));
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            node_fs_1.default.rmSync(archivePath, { recursive: true });
+        }
+        catch { /* ignore */ }
+        if (active === name)
+            setActiveWorkstream(cwd, name);
+        output({ completed: false, error: 'archive_failed', message: err.message, workstream: name }, raw, undefined);
+        return;
+    }
+    try {
+        node_fs_1.default.rmdirSync(wsDir);
+    }
+    catch { /* ignore */ }
+    let remainingWs = 0;
+    try {
+        remainingWs = node_fs_1.default.readdirSync(wsRoot, { withFileTypes: true }).filter(e => e.isDirectory()).length;
+        if (remainingWs === 0)
+            node_fs_1.default.rmdirSync(wsRoot);
+    }
+    catch { /* ignore */ }
+    output({
+        completed: true,
+        workstream: name,
+        archived_to: toPosixPath(node_path_1.default.relative(cwd, archivePath)),
+        remaining_workstreams: remainingWs,
+        reverted_to_flat: remainingWs === 0,
+    }, raw, undefined);
+}
+// ─── 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, undefined);
+        return;
+    }
+    if (!(0, workstream_name_policy_cjs_1.isValidActiveWorkstreamName)(name)) {
+        output({ active: null, error: 'invalid_name', message: 'Workstream name must be alphanumeric, hyphens, underscores, or dots' }, raw, undefined);
+        return;
+    }
+    const wsDir = node_path_1.default.join(planningRoot(cwd), 'workstreams', name);
+    if (!node_fs_1.default.existsSync(wsDir)) {
+        output({ active: null, error: 'not_found', workstream: name }, raw, undefined);
+        return;
+    }
+    setActiveWorkstream(cwd, name);
+    output({ active: name, set: true }, raw, name);
+}
+function cmdWorkstreamGet(cwd, raw) {
+    const active = getActiveWorkstream(cwd);
+    const wsRoot = node_path_1.default.join(planningRoot(cwd), 'workstreams');
+    output({ active, mode: node_fs_1.default.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, undefined);
+        return;
+    }
+    const workstreams = inventory.workstreams.map(ws => ({
+        name: ws.name,
+        active: ws.active,
+        status: ws.status,
+        current_phase: ws.current_phase ?? null,
+        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, undefined);
+}
+// ─── 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 ?? null,
+        phases: `${ws.completed_phases}/${ws.phase_count}`,
+    }));
+}
+module.exports = {
+    migrateToWorkstreams,
+    cmdWorkstreamCreate,
+    cmdWorkstreamList,
+    cmdWorkstreamStatus,
+    cmdWorkstreamComplete,
+    cmdWorkstreamSet,
+    cmdWorkstreamGet,
+    cmdWorkstreamProgress,
+    getOtherActiveWorkstreams,
+};