@pennyfarthing/core 7.5.0 → 7.6.1

package/packages/core/dist/workflow/workflow-executor.js

@@ -0,0 +1,197 @@
+/**
+ * Workflow Executor for MSSCI-12084
+ *
+ * Implements /workflow start, resume, and status commands for stepped workflows.
+ * Coordinates step loading, session state tracking, and progress reporting.
+ */
+import { initWorkflowState, updateWorkflowState, parseSessionState, updateSessionContent, } from './session-state.js';
+import { parseStepFromPath } from './step-parser.js';
+import { resolveStepVariables } from './variable-resolver.js';
+/**
+ * Start a new stepped workflow
+ *
+ * @param workflow - Workflow definition
+ * @param sessionContent - Current session file content (or empty for new)
+ * @param mode - Optional tri-modal mode (default: workflow default or 'create')
+ * @returns StartResult with state, first step, and updated session
+ */
+export async function startWorkflow(workflow, sessionContent, mode) {
+    // Determine mode: explicit > workflow default > 'create'
+    const effectiveMode = mode ?? workflow.modes?.default ?? 'create';
+    // Initialize workflow state
+    const state = initWorkflowState(workflow.name, workflow.type, effectiveMode);
+    // Update session content with workflow state
+    const updateResult = updateSessionContent(sessionContent, state);
+    if (!updateResult.success || !updateResult.content) {
+        return {
+            success: false,
+            error: updateResult.error ?? 'Failed to update session content',
+        };
+    }
+    // Try to load step 1 (may fail if step file doesn't exist)
+    const step = await loadStep(workflow, 1, workflow.variables);
+    return {
+        success: true,
+        state,
+        step: step ?? undefined,
+        sessionContent: updateResult.content,
+    };
+}
+/**
+ * Resume an existing stepped workflow from last completed step
+ *
+ * @param workflow - Workflow definition
+ * @param sessionContent - Current session file content with state
+ * @returns ResumeResult with state and next step
+ */
+export async function resumeWorkflow(workflow, sessionContent) {
+    // Parse existing state from session
+    const parseResult = parseSessionState(sessionContent);
+    if (!parseResult.success || !parseResult.state) {
+        return {
+            success: false,
+            error: 'No workflow state found in session',
+        };
+    }
+    const state = parseResult.state;
+    // Check if workflow is already complete
+    if (state.status === 'completed') {
+        return {
+            success: true,
+            state,
+            isComplete: true,
+        };
+    }
+    // Try to load the current step
+    const step = await loadStep(workflow, state.currentStep, workflow.variables);
+    return {
+        success: true,
+        state,
+        step: step ?? undefined,
+    };
+}
+/**
+ * Get current workflow status from session
+ *
+ * @param sessionContent - Session file content
+ * @param totalSteps - Total number of steps in workflow
+ * @returns StatusResult with progress information
+ */
+export function getWorkflowStatus(sessionContent, totalSteps) {
+    // Parse state from session
+    const parseResult = parseSessionState(sessionContent);
+    if (!parseResult.success || !parseResult.state) {
+        return {
+            success: false,
+            error: 'No workflow state found in session',
+        };
+    }
+    const state = parseResult.state;
+    // Calculate completion percentage
+    const completedCount = state.stepsCompleted.length;
+    const completionPercent = totalSteps > 0
+        ? Math.round((completedCount / totalSteps) * 100)
+        : 0;
+    const status = {
+        name: state.name,
+        type: state.type,
+        mode: state.mode,
+        currentStep: state.currentStep,
+        totalSteps,
+        stepsCompleted: state.stepsCompleted,
+        completionPercent,
+        status: state.status,
+        started: state.started,
+        lastUpdated: state.lastUpdated,
+    };
+    return {
+        success: true,
+        status,
+    };
+}
+/**
+ * Load step file for a specific step number
+ *
+ * @param workflow - Workflow definition
+ * @param stepNumber - Step number to load
+ * @param variables - Variables for content resolution
+ * @returns ParsedStep with resolved content
+ */
+export async function loadStep(workflow, stepNumber, variables) {
+    // Build step file path
+    const pattern = workflow.steps.pattern ?? 'step-*.md';
+    const paddedNum = String(stepNumber).padStart(2, '0');
+    // Replace * in pattern with padded step number
+    const filename = pattern.replace('*', paddedNum);
+    const stepPath = `${workflow.steps.path}/${filename}`;
+    try {
+        const parseResult = await parseStepFromPath(stepPath);
+        if (!parseResult.success || !parseResult.step) {
+            return null;
+        }
+        // Resolve variables in step content if provided
+        if (variables && Object.keys(variables).length > 0) {
+            const resolveResult = resolveStepVariables(parseResult.step.content, {
+                workflowVars: variables,
+            });
+            parseResult.step.content = resolveResult.content;
+        }
+        return parseResult.step;
+    }
+    catch {
+        // Step file doesn't exist or can't be read
+        return null;
+    }
+}
+/**
+ * Complete current step and advance workflow state
+ *
+ * @param sessionContent - Current session content
+ * @param stepNumber - Step number being completed
+ * @param nextStep - Optional specific next step (for skip scenarios)
+ * @returns Updated session content
+ */
+export function completeStep(sessionContent, stepNumber, nextStep) {
+    // Parse existing state
+    const parseResult = parseSessionState(sessionContent);
+    if (!parseResult.success || !parseResult.state) {
+        return sessionContent; // Return unchanged if no state
+    }
+    // Update state with completed step
+    const updatedState = updateWorkflowState(parseResult.state, stepNumber, nextStep);
+    // Update session content
+    const updateResult = updateSessionContent(sessionContent, updatedState);
+    return updateResult.content ?? sessionContent;
+}
+/**
+ * Check if workflow has an in-progress state in session
+ *
+ * @param sessionContent - Session file content
+ * @returns true if workflow is in progress
+ */
+export function hasActiveWorkflow(sessionContent) {
+    const parseResult = parseSessionState(sessionContent);
+    if (!parseResult.success || !parseResult.state) {
+        return false;
+    }
+    // Active means in_progress or paused (not completed)
+    return parseResult.state.status === 'in_progress' || parseResult.state.status === 'paused';
+}
+/**
+ * Detect incomplete workflow from session and return name
+ *
+ * @param sessionContent - Session file content
+ * @returns Workflow name if incomplete workflow found, undefined otherwise
+ */
+export function detectIncompleteWorkflow(sessionContent) {
+    const parseResult = parseSessionState(sessionContent);
+    if (!parseResult.success || !parseResult.state) {
+        return undefined;
+    }
+    // Only return name if workflow is not completed
+    if (parseResult.state.status === 'completed') {
+        return undefined;
+    }
+    return parseResult.state.name;
+}
+//# sourceMappingURL=workflow-executor.js.map

package/packages/core/dist/workflow/workflow-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-executor.js","sourceRoot":"","sources":["../../src/workflow/workflow-executor.ts"],"names":[],"mappings":"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"}

package/packages/core/dist/workflow/workflow-executor.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Workflow Executor Tests for MSSCI-12084
+ *
+ * Tests for /workflow start, resume, and status commands.
+ * Covers all 8 acceptance criteria plus edge cases.
+ */
+export {};
+//# sourceMappingURL=workflow-executor.test.d.ts.map

package/packages/core/dist/workflow/workflow-executor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-executor.test.d.ts","sourceRoot":"","sources":["../../src/workflow/workflow-executor.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/packages/core/dist/workflow/workflow-executor.test.js

@@ -0,0 +1,444 @@
+/**
+ * Workflow Executor Tests for MSSCI-12084
+ *
+ * Tests for /workflow start, resume, and status commands.
+ * Covers all 8 acceptance criteria plus edge cases.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { startWorkflow, resumeWorkflow, getWorkflowStatus, loadStep, completeStep, hasActiveWorkflow, detectIncompleteWorkflow, } from './workflow-executor.js';
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+const mockWorkflow = {
+    name: 'architecture',
+    type: 'stepped',
+    description: 'Architecture design workflow',
+    steps: {
+        path: '/workflows/architecture/steps',
+        pattern: 'step-*.md',
+    },
+    modes: {
+        default: 'create',
+        available: ['create', 'validate', 'edit'],
+    },
+    variables: {
+        project_name: 'Test Project',
+    },
+    gates: {
+        after_steps: [2, 5],
+    },
+    totalSteps: 7,
+};
+const emptySession = `# Story Test
+
+## Story Overview
+- **Epic:** Test Epic
+
+## Acceptance Criteria
+- [ ] AC1
+`;
+const sessionWithWorkflowState = `# Story Test
+
+## Story Overview
+- **Epic:** Test Epic
+
+## Workflow State
+- **Workflow Name:** architecture
+- **Type:** stepped
+- **Mode:** create
+- **Started:** 2026-01-20T10:00:00.000Z
+- **Last Updated:** 2026-01-20T11:30:00.000Z
+- **Current Step:** 3
+- **Steps Completed:** [1, 2]
+- **Status:** in_progress
+
+## Acceptance Criteria
+- [ ] AC1
+`;
+const sessionWithCompletedWorkflow = `# Story Test
+
+## Workflow State
+- **Workflow Name:** architecture
+- **Type:** stepped
+- **Mode:** create
+- **Started:** 2026-01-20T10:00:00.000Z
+- **Last Updated:** 2026-01-20T15:00:00.000Z
+- **Current Step:** 7
+- **Steps Completed:** [1, 2, 3, 4, 5, 6, 7]
+- **Status:** completed
+`;
+// =============================================================================
+// AC1: /workflow start <name> [--mode create|validate|edit] implemented
+// =============================================================================
+describe('MSSCI-12084: Workflow Executor', () => {
+    describe('AC1: /workflow start command', () => {
+        it('should start workflow with given name', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.state);
+            assert.strictEqual(result.state.name, 'architecture');
+            assert.strictEqual(result.state.type, 'stepped');
+        });
+        it('should accept --mode flag for tri-modal selection', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession, 'validate');
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.state?.mode, 'validate');
+        });
+        it('should accept create mode', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession, 'create');
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.state?.mode, 'create');
+        });
+        it('should accept validate mode', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession, 'validate');
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.state?.mode, 'validate');
+        });
+        it('should accept edit mode', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession, 'edit');
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.state?.mode, 'edit');
+        });
+        it('should return error for invalid workflow definition', async () => {
+            const invalidWorkflow = { ...mockWorkflow, name: '' };
+            const result = await startWorkflow(invalidWorkflow, emptySession);
+            // Should handle invalid workflow gracefully
+            assert.ok(result);
+        });
+    });
+    // =============================================================================
+    // AC2: /workflow start creates session and loads step 1
+    // =============================================================================
+    describe('AC2: Start creates session and loads step 1', () => {
+        it('should initialize workflow state at step 1', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.state?.currentStep, 1);
+            assert.deepStrictEqual(result.state?.stepsCompleted, []);
+        });
+        it('should set status to in_progress', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.strictEqual(result.state?.status, 'in_progress');
+        });
+        it('should include step 1 content in result', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            // Step content should be loaded (or null if file not found)
+            assert.ok(result.step !== undefined || result.success === true);
+        });
+        it('should return updated session content with workflow state', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.ok(result.sessionContent);
+            assert.ok(result.sessionContent.includes('## Workflow State'));
+            assert.ok(result.sessionContent.includes('**Workflow Name:** architecture'));
+        });
+        it('should set started timestamp', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.ok(result.state?.started);
+            // Should be ISO timestamp
+            assert.ok(result.state.started.match(/^\d{4}-\d{2}-\d{2}T/));
+        });
+        it('should set lastUpdated timestamp', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.ok(result.state?.lastUpdated);
+            assert.ok(result.state.lastUpdated.match(/^\d{4}-\d{2}-\d{2}T/));
+        });
+    });
+    // =============================================================================
+    // AC3: --mode flag selects tri-modal path (default: create)
+    // =============================================================================
+    describe('AC3: Tri-modal mode selection', () => {
+        it('should use create as default mode when not specified', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.strictEqual(result.state?.mode, 'create');
+        });
+        it('should use workflow default mode if specified in definition', async () => {
+            const workflowWithValidateDefault = {
+                ...mockWorkflow,
+                modes: {
+                    default: 'validate',
+                    available: ['create', 'validate', 'edit'],
+                },
+            };
+            const result = await startWorkflow(workflowWithValidateDefault, emptySession);
+            assert.strictEqual(result.state?.mode, 'validate');
+        });
+        it('should override workflow default with explicit mode', async () => {
+            const workflowWithValidateDefault = {
+                ...mockWorkflow,
+                modes: {
+                    default: 'validate',
+                    available: ['create', 'validate', 'edit'],
+                },
+            };
+            const result = await startWorkflow(workflowWithValidateDefault, emptySession, 'edit');
+            assert.strictEqual(result.state?.mode, 'edit');
+        });
+        it('should not set mode for workflows without modes config', async () => {
+            const workflowWithoutModes = {
+                ...mockWorkflow,
+                modes: undefined,
+            };
+            const result = await startWorkflow(workflowWithoutModes, emptySession);
+            // Mode should be undefined or default to create
+            assert.ok(result.state?.mode === undefined || result.state?.mode === 'create');
+        });
+        it('should include mode in session content when set', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession, 'validate');
+            assert.ok(result.sessionContent?.includes('**Mode:** validate'));
+        });
+    });
+    // =============================================================================
+    // AC4: /workflow resume [name] implemented
+    // =============================================================================
+    describe('AC4: /workflow resume command', () => {
+        it('should resume workflow from existing session state', async () => {
+            const result = await resumeWorkflow(mockWorkflow, sessionWithWorkflowState);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.state);
+        });
+        it('should return current state from session', async () => {
+            const result = await resumeWorkflow(mockWorkflow, sessionWithWorkflowState);
+            assert.strictEqual(result.state?.name, 'architecture');
+            assert.strictEqual(result.state?.currentStep, 3);
+            assert.deepStrictEqual(result.state?.stepsCompleted, [1, 2]);
+        });
+        it('should return error when no workflow state in session', async () => {
+            const result = await resumeWorkflow(mockWorkflow, emptySession);
+            // Should fail or return isComplete with no active workflow
+            assert.ok(result.error || result.state === undefined);
+        });
+        it('should preserve mode from existing state', async () => {
+            const result = await resumeWorkflow(mockWorkflow, sessionWithWorkflowState);
+            assert.strictEqual(result.state?.mode, 'create');
+        });
+    });
+    // =============================================================================
+    // AC5: /workflow resume detects incomplete workflow and continues
+    // =============================================================================
+    describe('AC5: Resume detects incomplete workflow', () => {
+        it('should detect incomplete workflow from session', () => {
+            const workflowName = detectIncompleteWorkflow(sessionWithWorkflowState);
+            assert.strictEqual(workflowName, 'architecture');
+        });
+        it('should return undefined when no workflow in session', () => {
+            const workflowName = detectIncompleteWorkflow(emptySession);
+            assert.strictEqual(workflowName, undefined);
+        });
+        it('should return undefined when workflow is completed', () => {
+            const workflowName = detectIncompleteWorkflow(sessionWithCompletedWorkflow);
+            // Completed workflows should not be detected as incomplete
+            assert.strictEqual(workflowName, undefined);
+        });
+        it('should continue from last completed step', async () => {
+            const result = await resumeWorkflow(mockWorkflow, sessionWithWorkflowState);
+            // Current step should be 3 (next after completed steps [1, 2])
+            assert.strictEqual(result.state?.currentStep, 3);
+        });
+        it('should load next step content on resume', async () => {
+            const result = await resumeWorkflow(mockWorkflow, sessionWithWorkflowState);
+            // Step should be loaded (number should match current step)
+            assert.ok(result.step === undefined || result.step?.number === 3);
+        });
+        it('should mark as complete when all steps done', async () => {
+            const result = await resumeWorkflow(mockWorkflow, sessionWithCompletedWorkflow);
+            assert.strictEqual(result.isComplete, true);
+        });
+    });
+    // =============================================================================
+    // AC6: /workflow status shows step progress and completion %
+    // =============================================================================
+    describe('AC6: /workflow status command', () => {
+        it('should return workflow status from session', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.status);
+        });
+        it('should show current step number', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.strictEqual(result.status?.currentStep, 3);
+        });
+        it('should show total steps', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.strictEqual(result.status?.totalSteps, 7);
+        });
+        it('should show completed steps array', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.deepStrictEqual(result.status?.stepsCompleted, [1, 2]);
+        });
+        it('should calculate completion percentage', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            // 2 of 7 steps completed = ~28.57%
+            assert.ok(result.status?.completionPercent);
+            assert.ok(result.status.completionPercent >= 28 && result.status.completionPercent <= 29);
+        });
+        it('should show 0% for new workflow', () => {
+            const newWorkflowSession = `## Workflow State
+- **Workflow Name:** test
+- **Type:** stepped
+- **Started:** 2026-01-20T10:00:00.000Z
+- **Last Updated:** 2026-01-20T10:00:00.000Z
+- **Current Step:** 1
+- **Steps Completed:** []
+- **Status:** in_progress
+`;
+            const result = getWorkflowStatus(newWorkflowSession, 5);
+            assert.strictEqual(result.status?.completionPercent, 0);
+        });
+        it('should show 100% for completed workflow', () => {
+            const result = getWorkflowStatus(sessionWithCompletedWorkflow, 7);
+            assert.strictEqual(result.status?.completionPercent, 100);
+        });
+        it('should show workflow name', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.strictEqual(result.status?.name, 'architecture');
+        });
+        it('should show workflow type', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.strictEqual(result.status?.type, 'stepped');
+        });
+        it('should show mode if set', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.strictEqual(result.status?.mode, 'create');
+        });
+        it('should show workflow status', () => {
+            const result = getWorkflowStatus(sessionWithWorkflowState, 7);
+            assert.strictEqual(result.status?.status, 'in_progress');
+        });
+        it('should return error when no workflow state', () => {
+            const result = getWorkflowStatus(emptySession, 7);
+            // Should indicate no active workflow
+            assert.ok(!result.status || result.error);
+        });
+    });
+    // =============================================================================
+    // AC7: Session file state tracked via Workflow State section
+    // =============================================================================
+    describe('AC7: Session state integration', () => {
+        it('should write workflow state to session on start', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.ok(result.sessionContent?.includes('## Workflow State'));
+        });
+        it('should update session state on step completion', () => {
+            const updated = completeStep(sessionWithWorkflowState, 3);
+            assert.ok(updated.includes('**Steps Completed:**'));
+            // Should now include step 3
+            assert.ok(updated.includes('[1, 2, 3]'));
+        });
+        it('should advance current step on completion', () => {
+            const updated = completeStep(sessionWithWorkflowState, 3);
+            assert.ok(updated.includes('**Current Step:** 4'));
+        });
+        it('should update lastUpdated timestamp on completion', () => {
+            const updated = completeStep(sessionWithWorkflowState, 3);
+            // lastUpdated should be different from original
+            assert.ok(updated.includes('**Last Updated:**'));
+        });
+        it('should detect active workflow in session', () => {
+            const hasActive = hasActiveWorkflow(sessionWithWorkflowState);
+            assert.strictEqual(hasActive, true);
+        });
+        it('should detect no active workflow in empty session', () => {
+            const hasActive = hasActiveWorkflow(emptySession);
+            assert.strictEqual(hasActive, false);
+        });
+        it('should preserve other session content when updating state', async () => {
+            const result = await startWorkflow(mockWorkflow, emptySession);
+            assert.ok(result.sessionContent?.includes('## Story Overview'));
+            assert.ok(result.sessionContent?.includes('## Acceptance Criteria'));
+        });
+    });
+    // =============================================================================
+    // AC8: Commands available in CLI with help documentation
+    // This AC is about CLI integration - tested via bash script existence
+    // =============================================================================
+    describe('AC8: CLI availability', () => {
+        it('should export startWorkflow function', () => {
+            assert.strictEqual(typeof startWorkflow, 'function');
+        });
+        it('should export resumeWorkflow function', () => {
+            assert.strictEqual(typeof resumeWorkflow, 'function');
+        });
+        it('should export getWorkflowStatus function', () => {
+            assert.strictEqual(typeof getWorkflowStatus, 'function');
+        });
+        it('should export loadStep function', () => {
+            assert.strictEqual(typeof loadStep, 'function');
+        });
+        it('should export completeStep function', () => {
+            assert.strictEqual(typeof completeStep, 'function');
+        });
+        it('should export hasActiveWorkflow function', () => {
+            assert.strictEqual(typeof hasActiveWorkflow, 'function');
+        });
+        it('should export detectIncompleteWorkflow function', () => {
+            assert.strictEqual(typeof detectIncompleteWorkflow, 'function');
+        });
+    });
+    // =============================================================================
+    // Edge Cases
+    // =============================================================================
+    describe('Edge Cases', () => {
+        it('should handle workflow with no steps gracefully', async () => {
+            const emptyWorkflow = {
+                ...mockWorkflow,
+                totalSteps: 0,
+            };
+            const result = await startWorkflow(emptyWorkflow, emptySession);
+            // Should handle gracefully
+            assert.ok(result);
+        });
+        it('should handle single-step workflow', async () => {
+            const singleStepWorkflow = {
+                ...mockWorkflow,
+                totalSteps: 1,
+            };
+            const result = await startWorkflow(singleStepWorkflow, emptySession);
+            assert.ok(result.state?.currentStep === 1);
+        });
+        it('should handle phased workflow type', async () => {
+            const phasedWorkflow = {
+                ...mockWorkflow,
+                type: 'phased',
+            };
+            const result = await startWorkflow(phasedWorkflow, emptySession);
+            assert.strictEqual(result.state?.type, 'phased');
+        });
+        it('should handle step completion with explicit next step', () => {
+            // Skip from step 3 to step 5
+            const updated = completeStep(sessionWithWorkflowState, 3, 5);
+            assert.ok(updated.includes('**Current Step:** 5'));
+        });
+        it('should handle resume on paused workflow', async () => {
+            const pausedSession = sessionWithWorkflowState.replace('in_progress', 'paused');
+            const result = await resumeWorkflow(mockWorkflow, pausedSession);
+            // Should be able to resume paused workflow
+            assert.ok(result);
+        });
+        it('should calculate correct percentage for mid-workflow', () => {
+            // 3 of 5 steps = 60%
+            const sessionWith3of5 = `## Workflow State
+- **Workflow Name:** test
+- **Type:** stepped
+- **Started:** 2026-01-20T10:00:00.000Z
+- **Last Updated:** 2026-01-20T10:00:00.000Z
+- **Current Step:** 4
+- **Steps Completed:** [1, 2, 3]
+- **Status:** in_progress
+`;
+            const result = getWorkflowStatus(sessionWith3of5, 5);
+            assert.strictEqual(result.status?.completionPercent, 60);
+        });
+        it('should handle loadStep for non-existent step', async () => {
+            const result = await loadStep(mockWorkflow, 999);
+            // Should return null or handle gracefully
+            assert.ok(result === null || result !== undefined);
+        });
+        it('should handle workflow variables in step loading', async () => {
+            const result = await loadStep(mockWorkflow, 1, { project_name: 'Custom Project' });
+            // Should handle variables (even if step doesn't exist)
+            assert.ok(result === null || result !== undefined);
+        });
+    });
+});
+//# sourceMappingURL=workflow-executor.test.js.map