edsger 0.50.0 → 0.52.0

package/dist/api/issues/get-issue.js

@@ -0,0 +1,21 @@
+import { logInfo } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * Get issue details by ID
+ */
+export async function getIssue(issueId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching issue details for: ${issueId}`);
+    }
+    const result = (await callMcpEndpoint('issues/get', {
+        issue_id: issueId,
+    }));
+    if (!result.issues || result.issues.length === 0) {
+        throw new Error(`Issue not found: ${issueId}`);
+    }
+    const issue = result.issues[0];
+    if (!issue || typeof issue !== 'object') {
+        throw new Error(`Invalid issue data returned for: ${issueId}`);
+    }
+    return issue;
+}

package/dist/api/issues/index.d.ts

@@ -0,0 +1,8 @@
+export * from './batch-operations.js';
+export * from './get-issue.js';
+export * from './issue-utils.js';
+export * from './status-updater.js';
+export * from './test-cases.js';
+export * from './update-issue.js';
+export * from './user-stories.js';
+export * from '../../types/issues.js';

package/dist/api/issues/index.js

@@ -0,0 +1,10 @@
+// Re-export all issue-related functions
+export * from './batch-operations.js';
+export * from './get-issue.js';
+export * from './issue-utils.js';
+export * from './status-updater.js';
+export * from './test-cases.js';
+export * from './update-issue.js';
+export * from './user-stories.js';
+// Re-export types
+export * from '../../types/issues.js';

package/dist/api/issues/issue-utils.d.ts

@@ -0,0 +1,23 @@
+import { type IssueInfo } from '../../types/issues.js';
+/**
+ * Claim the next available ready_for_ai issue for processing.
+ * Uses database-level locking (FOR UPDATE SKIP LOCKED) to prevent
+ * race conditions between multiple workers.
+ *
+ * @param productId - The product ID to claim an issue from
+ * @param verbose - Whether to log verbose output
+ * @returns The claimed issue or null if no issues available
+ */
+export declare function claimNextIssue(productId: string, verbose?: boolean): Promise<IssueInfo | null>;
+/**
+ * Filter issues by status
+ */
+export declare function filterIssuesByStatus(issues: IssueInfo[], status: string): IssueInfo[];
+/**
+ * Sort issues by updated_at (oldest first for processing)
+ */
+export declare function sortIssuesByUpdatedAt(issues: IssueInfo[]): IssueInfo[];
+/**
+ * Get issues with ready_for_ai status for a product
+ */
+export declare function getReadyForAIIssues(productId: string, verbose?: boolean): Promise<IssueInfo[]>;

package/dist/api/issues/issue-utils.js

@@ -0,0 +1,80 @@
+import { logError, logInfo } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * Claim the next available ready_for_ai issue for processing.
+ * Uses database-level locking (FOR UPDATE SKIP LOCKED) to prevent
+ * race conditions between multiple workers.
+ *
+ * @param productId - The product ID to claim an issue from
+ * @param verbose - Whether to log verbose output
+ * @returns The claimed issue or null if no issues available
+ */
+export async function claimNextIssue(productId, verbose) {
+    if (verbose) {
+        logInfo(`Attempting to claim next ready_for_ai issue for product: ${productId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('issues/claim', {
+            product_id: productId,
+        }));
+        if (result.issue) {
+            if (verbose) {
+                logInfo(`✅ Claimed issue: ${result.issue.name} (${result.issue.id})`);
+            }
+            return result.issue;
+        }
+        if (verbose) {
+            logInfo('No issues available for processing');
+        }
+        return null;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to claim issue: ${errorMessage}`);
+        throw error;
+    }
+}
+/**
+ * Filter issues by status
+ */
+export function filterIssuesByStatus(issues, status) {
+    return issues.filter((issue) => issue.status === status);
+}
+/**
+ * Sort issues by updated_at (oldest first for processing)
+ */
+export function sortIssuesByUpdatedAt(issues) {
+    return [...issues].sort((a, b) => {
+        const dateA = new Date(a.updated_at || 0).getTime();
+        const dateB = new Date(b.updated_at || 0).getTime();
+        return dateA - dateB;
+    });
+}
+/**
+ * Get issues with ready_for_ai status for a product
+ */
+export async function getReadyForAIIssues(productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching ready_for_ai issues for product: ${productId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('issues/list', {
+            product_id: productId,
+            status: 'ready_for_ai',
+        }));
+        const issues = result.issues || [];
+        const sortedIssues = sortIssuesByUpdatedAt(issues);
+        if (verbose) {
+            logInfo(`✅ Found ${sortedIssues.length} ready_for_ai issues (oldest first)`);
+            sortedIssues.forEach((issue, index) => {
+                logInfo(`   ${index + 1}. ${issue.name} (updated: ${issue.updated_at})`);
+            });
+        }
+        return sortedIssues;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch ready_for_ai issues: ${errorMessage}`);
+        throw error;
+    }
+}

package/dist/api/issues/status-updater.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Issue status updater for workflow pipeline
+ * Updates issue status at each phase of the development workflow
+ */
+import type { IssueStatus } from '../../types/index.js';
+interface StatusUpdateOptions {
+    readonly issueId: string;
+    readonly status: IssueStatus;
+    readonly verbose?: boolean;
+}
+/**
+ * Check if moving from currentStatus to newStatus is forward progression
+ *
+ * Special cases for archived status:
+ * - Any status → archived: Always allowed (archiving from any state)
+ * - Archived → backlog: Always allowed (unarchiving restores to backlog)
+ */
+export declare function isForwardProgression(currentStatus: IssueStatus, newStatus: IssueStatus): boolean;
+/**
+ * Update issue status via MCP endpoint
+ */
+export declare function updateIssueStatus({ issueId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
+/**
+ * Map pipeline phase to issue status
+ */
+export declare const getStatusForPhase: (phase: string) => IssueStatus | null;
+/**
+ * Update issue status based on pipeline phase
+ *
+ * @param issueId - The issue ID to update
+ * @param phase - The pipeline phase name
+ * @param verbose - Whether to log verbose output
+ * @returns Promise<boolean> - true if update succeeded, false if skipped or failed
+ *
+ * BREAKING CHANGE: This function was changed from synchronous to asynchronous in PR #87
+ * to support regression prevention checks. All callers must now use await/then to handle
+ * the Promise return type. The function now validates against status regression and will
+ * skip updates that would move an issue backward in the development workflow.
+ */
+export declare const updateIssueStatusForPhase: (issueId: string, phase: string, verbose?: boolean) => Promise<boolean>;
+export {};

package/dist/api/{features → issues}/status-updater.js

@@ -1,11 +1,11 @@
 /**
- * Feature status updater for workflow pipeline
- * Updates feature status at each phase of the development workflow
+ * Issue status updater for workflow pipeline
+ * Updates issue status at each phase of the development workflow
  */
-import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../../config/feature-status.js';
+import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../../config/issue-status.js';
 import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
-import { getFeature } from './get-feature.js';
+import { getIssue } from './get-issue.js';
 /**
  * Check if moving from currentStatus to newStatus is forward progression
  *
@@ -28,23 +28,23 @@ export function isForwardProgression(currentStatus, newStatus) {
     return newIndex >= currentIndex;
 }
 /**
- * Update feature status via MCP endpoint
+ * Update issue status via MCP endpoint
  */
-export async function updateFeatureStatus({ featureId, status, verbose = false, }) {
+export async function updateIssueStatus({ issueId, status, verbose = false, }) {
     try {
         if (verbose) {
-            logInfo(`Updating feature ${featureId} status to: ${status}`);
+            logInfo(`Updating issue ${issueId} status to: ${status}`);
         }
-        // Get current feature status to check for regression
-        let feature;
+        // Get current issue status to check for regression
+        let issue;
         let currentStatus;
         try {
-            feature = await getFeature(featureId, verbose);
-            currentStatus = feature.status;
+            issue = await getIssue(issueId, verbose);
+            currentStatus = issue.status;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            logError(`Failed to get current feature status for ${featureId}: ${errorMessage}`);
+            logError(`Failed to get current issue status for ${issueId}: ${errorMessage}`);
             // If we can't get the current status, we can't safely check for regression
             // so we'll skip the update to prevent potential regression
             if (verbose) {
@@ -68,34 +68,34 @@ export async function updateFeatureStatus({ featureId, status, verbose = false,
             return true;
         }
         // Update status
-        await callMcpEndpoint('features/update', {
-            feature_id: featureId,
+        await callMcpEndpoint('issues/update', {
+            issue_id: issueId,
             status,
         });
         if (verbose) {
-            logInfo(`✅ Feature status updated successfully from ${currentStatus} to: ${status}`);
+            logInfo(`✅ Issue status updated successfully from ${currentStatus} to: ${status}`);
         }
         return true;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (verbose) {
-            logError(`Failed to update feature status: ${errorMessage}`);
+            logError(`Failed to update issue status: ${errorMessage}`);
         }
         return false;
     }
 }
 /**
- * Map pipeline phase to feature status
+ * Map pipeline phase to issue status
  */
 export const getStatusForPhase = (phase) => {
     // Use the externalized phase-to-status mapping
     return PHASE_STATUS_MAP[phase] ?? null;
 };
 /**
- * Update feature status based on pipeline phase
+ * Update issue status based on pipeline phase
  *
- * @param featureId - The feature ID to update
+ * @param issueId - The issue ID to update
  * @param phase - The pipeline phase name
  * @param verbose - Whether to log verbose output
  * @returns Promise<boolean> - true if update succeeded, false if skipped or failed
@@ -103,9 +103,9 @@ export const getStatusForPhase = (phase) => {
  * BREAKING CHANGE: This function was changed from synchronous to asynchronous in PR #87
  * to support regression prevention checks. All callers must now use await/then to handle
  * the Promise return type. The function now validates against status regression and will
- * skip updates that would move a feature backward in the development workflow.
+ * skip updates that would move an issue backward in the development workflow.
  */
-export const updateFeatureStatusForPhase = async (featureId, phase, verbose) => {
+export const updateIssueStatusForPhase = async (issueId, phase, verbose) => {
     const status = getStatusForPhase(phase);
     if (!status) {
         const message = `⚠️ Unknown phase '${phase}' - skipping status update to prevent regression`;
@@ -114,8 +114,8 @@ export const updateFeatureStatusForPhase = async (featureId, phase, verbose) =>
         }
         return false;
     }
-    return updateFeatureStatus({
-        featureId,
+    return updateIssueStatus({
+        issueId,
         status,
         verbose,
     });

package/dist/api/{features → issues}/test-cases.d.ts

@@ -1,20 +1,20 @@
-import { type TestCase, type TestCaseStatus } from '../../types/features.js';
+import { type TestCase, type TestCaseStatus } from '../../types/issues.js';
 /**
- * Get test cases for a feature
+ * Get test cases for an issue
  */
-export declare function getTestCases(featureId: string, verbose?: boolean): Promise<TestCase[]>;
+export declare function getTestCases(issueId: string, verbose?: boolean): Promise<TestCase[]>;
 /**
- * Create a new test case for a feature
+ * Create a new test case for an issue
  */
-export declare function createTestCase(featureId: string, testCase: {
+export declare function createTestCase(issueId: string, testCase: {
     name: string;
     description: string;
     is_critical?: boolean;
 }, verbose?: boolean): Promise<boolean>;
 /**
- * Create multiple test cases for a feature
+ * Create multiple test cases for an issue
  */
-export declare function createTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, testCases: {
+export declare function createTestCases(mcpServerUrl: string, mcpToken: string, issueId: string, testCases: {
     name: string;
     description: string;
     is_critical?: boolean;

package/dist/api/{features → issues}/test-cases.js

@@ -1,27 +1,27 @@
 import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
- * Get test cases for a feature
+ * Get test cases for an issue
  */
-export async function getTestCases(featureId, verbose) {
+export async function getTestCases(issueId, verbose) {
     if (verbose) {
-        logInfo(`Fetching test cases for feature: ${featureId}`);
+        logInfo(`Fetching test cases for issue: ${issueId}`);
     }
     const result = (await callMcpEndpoint('test_cases/list', {
-        feature_id: featureId,
+        issue_id: issueId,
     }));
     return (result.test_cases || []);
 }
 /**
- * Create a new test case for a feature
+ * Create a new test case for an issue
  */
-export async function createTestCase(featureId, testCase, verbose) {
+export async function createTestCase(issueId, testCase, verbose) {
     try {
         if (verbose) {
-            logInfo(`Creating test case for feature: ${featureId}`);
+            logInfo(`Creating test case for issue: ${issueId}`);
         }
         await callMcpEndpoint('test_cases/create', {
-            feature_id: featureId,
+            issue_id: issueId,
             test_cases: [
                 {
                     name: testCase.name,
@@ -42,15 +42,15 @@ export async function createTestCase(featureId, testCase, verbose) {
     }
 }
 /**
- * Create multiple test cases for a feature
+ * Create multiple test cases for an issue
  */
-export async function createTestCases(mcpServerUrl, mcpToken, featureId, testCases, verbose) {
+export async function createTestCases(mcpServerUrl, mcpToken, issueId, testCases, verbose) {
     try {
         if (verbose) {
-            logInfo(`Creating ${testCases.length} test cases for feature: ${featureId}`);
+            logInfo(`Creating ${testCases.length} test cases for issue: ${issueId}`);
         }
         for (const testCase of testCases) {
-            await createTestCase(featureId, testCase, false);
+            await createTestCase(issueId, testCase, false);
         }
         if (verbose) {
             logInfo('✅ All test cases created successfully');

package/dist/api/issues/update-issue.d.ts

@@ -0,0 +1,20 @@
+import { type IssueWorkflow } from '../../types/pipeline.js';
+/**
+ * Update issue with new data
+ */
+export declare function updateIssue(issueId: string, updates: {
+    technical_design?: string;
+    status?: string;
+    execution_mode?: string;
+    workflow?: IssueWorkflow;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Update technical design for an issue
+ */
+export declare function updateTechnicalDesign(issueId: string, technicalDesign: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Mark a workflow phase as completed
+ * Fetches current workflow, updates the phase status, and saves back
+ * Accepts phase names in either format (hyphens or underscores)
+ */
+export declare function markWorkflowPhaseCompleted(issueId: string, phaseName: string, verbose?: boolean): Promise<boolean>;

package/dist/api/{features/update-feature.js → issues/update-issue.js}

@@ -1,37 +1,37 @@
 import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
- * Update feature with new data
+ * Update issue with new data
  */
-export async function updateFeature(featureId, updates, verbose) {
+export async function updateIssue(issueId, updates, verbose) {
     try {
         if (verbose) {
-            logInfo(`Updating feature: ${featureId}`);
+            logInfo(`Updating issue: ${issueId}`);
         }
-        await callMcpEndpoint('features/update', {
-            feature_id: featureId,
+        await callMcpEndpoint('issues/update', {
+            issue_id: issueId,
             ...updates,
         });
         if (verbose) {
-            logInfo('✅ Feature updated successfully');
+            logInfo('✅ Issue updated successfully');
         }
         return true;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to update feature: ${errorMessage}`);
+        logError(`Failed to update issue: ${errorMessage}`);
         return false;
     }
 }
 /**
- * Update technical design for a feature
+ * Update technical design for an issue
  */
-export async function updateTechnicalDesign(featureId, technicalDesign, verbose) {
-    return updateFeature(featureId, { technical_design: technicalDesign }, verbose);
+export async function updateTechnicalDesign(issueId, technicalDesign, verbose) {
+    return updateIssue(issueId, { technical_design: technicalDesign }, verbose);
 }
 /**
  * Normalize phase name from pipeline format (hyphens) to workflow format (underscores)
- * e.g., 'feature-analysis' -> 'feature_analysis'
+ * e.g., 'issue-analysis' -> 'issue_analysis'
  */
 function normalizePhaseNameForWorkflow(phaseName) {
     return phaseName.replace(/-/g, '_');
@@ -41,26 +41,26 @@ function normalizePhaseNameForWorkflow(phaseName) {
  * Fetches current workflow, updates the phase status, and saves back
  * Accepts phase names in either format (hyphens or underscores)
  */
-export async function markWorkflowPhaseCompleted(featureId, phaseName, verbose) {
+export async function markWorkflowPhaseCompleted(issueId, phaseName, verbose) {
     try {
         // Normalize phase name to workflow format (underscores)
         const normalizedPhaseName = normalizePhaseNameForWorkflow(phaseName);
         if (verbose) {
-            logInfo(`Marking workflow phase '${normalizedPhaseName}' as completed for feature: ${featureId}`);
+            logInfo(`Marking workflow phase '${normalizedPhaseName}' as completed for issue: ${issueId}`);
         }
-        // Fetch current feature to get workflow
-        const response = (await callMcpEndpoint('features/get', {
-            feature_id: featureId,
+        // Fetch current issue to get workflow
+        const response = (await callMcpEndpoint('issues/get', {
+            issue_id: issueId,
         }));
-        const feature = response?.features?.[0];
-        if (!feature) {
-            logError(`Feature not found: ${featureId}`);
+        const issue = response?.issues?.[0];
+        if (!issue) {
+            logError(`Issue not found: ${issueId}`);
             return false;
         }
-        const workflow = feature.workflow || [];
+        const workflow = issue.workflow || [];
         if (workflow.length === 0) {
             if (verbose) {
-                logInfo(`No workflow defined for feature, skipping phase completion`);
+                logInfo(`No workflow defined for issue, skipping phase completion`);
             }
             return true;
         }
@@ -73,7 +73,7 @@ export async function markWorkflowPhaseCompleted(featureId, phaseName, verbose)
             }
             : p);
         // Save updated workflow
-        return await updateFeature(featureId, { workflow: updatedWorkflow }, verbose);
+        return await updateIssue(issueId, { workflow: updatedWorkflow }, verbose);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/api/{features → issues}/user-stories.d.ts

@@ -1,12 +1,12 @@
-import { type UserStory, type UserStoryStatus } from '../../types/features.js';
+import { type UserStory, type UserStoryStatus } from '../../types/issues.js';
 /**
- * Get user stories for a feature
+ * Get user stories for an issue
  */
-export declare function getUserStories(featureId: string, verbose?: boolean): Promise<UserStory[]>;
+export declare function getUserStories(issueId: string, verbose?: boolean): Promise<UserStory[]>;
 /**
- * Create a new user story for a feature
+ * Create a new user story for an issue
  */
-export declare function createUserStory(featureId: string, userStory: {
+export declare function createUserStory(issueId: string, userStory: {
     title: string;
     description: string;
     status?: string;

package/dist/api/{features → issues}/user-stories.js

@@ -1,27 +1,27 @@
 import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
- * Get user stories for a feature
+ * Get user stories for an issue
  */
-export async function getUserStories(featureId, verbose) {
+export async function getUserStories(issueId, verbose) {
     if (verbose) {
-        logInfo(`Fetching user stories for feature: ${featureId}`);
+        logInfo(`Fetching user stories for issue: ${issueId}`);
     }
     const result = (await callMcpEndpoint('user_stories/list', {
-        feature_id: featureId,
+        issue_id: issueId,
     }));
     return (result.user_stories || []);
 }
 /**
- * Create a new user story for a feature
+ * Create a new user story for an issue
  */
-export async function createUserStory(featureId, userStory, verbose) {
+export async function createUserStory(issueId, userStory, verbose) {
     try {
         if (verbose) {
-            logInfo(`Creating user story for feature: ${featureId}`);
+            logInfo(`Creating user story for issue: ${issueId}`);
         }
         await callMcpEndpoint('user_stories/create', {
-            feature_id: featureId,
+            issue_id: issueId,
             user_stories: [
                 {
                     title: userStory.title,

package/dist/api/products.d.ts

@@ -2,7 +2,7 @@ export interface ProductInfo {
     id: string;
     name: string;
     description?: string;
-    features?: {
+    issues?: {
         name: string;
         description?: string;
         status?: string;

package/dist/api/tasks.d.ts

@@ -8,7 +8,7 @@ export interface TaskInfo {
     priority: number;
     executor: string;
     source: string;
-    feature_id: string | null;
+    issue_id: string | null;
     approval_id: string | null;
     action_url: string | null;
     assigned_to: string | null;

package/dist/api/test-reports.d.ts

@@ -1,7 +1,7 @@
 /**
- * Create test report for a feature
+ * Create test report for an issue
  */
-export declare function createTestReport(mcpServerUrl: string, mcpToken: string, featureId: string, reportData: {
+export declare function createTestReport(mcpServerUrl: string, mcpToken: string, issueId: string, reportData: {
     test_type: string;
     status: 'passed' | 'failed' | 'error';
     summary: string;

package/dist/api/test-reports.js

@@ -1,15 +1,15 @@
 import { logError, logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
- * Create test report for a feature
+ * Create test report for an issue
  */
-export async function createTestReport(mcpServerUrl, mcpToken, featureId, reportData, verbose) {
+export async function createTestReport(mcpServerUrl, mcpToken, issueId, reportData, verbose) {
     try {
         if (verbose) {
-            logInfo(`Creating test report for feature: ${featureId}`);
+            logInfo(`Creating test report for issue: ${issueId}`);
         }
         await callMcpEndpoint('test_reports/create', {
-            feature_id: featureId,
+            issue_id: issueId,
             ...reportData,
         });
         if (verbose) {

package/dist/auth/login.js

@@ -143,7 +143,7 @@ export async function runLogin() {
             });
         }
         logRaw('');
-        logInfo('You can now run `edsger` to start processing features.');
+        logInfo('You can now run `edsger` to start processing issues.');
     }
     catch (error) {
         logError(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);

package/dist/commands/agent-workflow/chat-worker.d.ts

@@ -1,16 +1,16 @@
 /**
  * Chat Worker — Child process entry point for processing chat messages.
  *
- * Spawned by AgentWorkflowProcessor as a parallel subprocess alongside feature workers.
- * Runs continuously, polling for unprocessed human messages across all active feature channels.
+ * Spawned by AgentWorkflowProcessor as a parallel subprocess alongside issue workers.
+ * Runs continuously, polling for unprocessed human messages across all active issue channels.
  *
  * Communication with parent via IPC:
  * - Parent sends: { type: 'init', config }
- * - Parent sends: { type: 'event:phase_completed', featureId, phase, summary, phaseOutput }
- * - Parent sends: { type: 'event:phase_failed', featureId, phase, error }
- * - Parent sends: { type: 'event:feature_done', featureId }
+ * - Parent sends: { type: 'event:phase_completed', issueId, phase, summary, phaseOutput }
+ * - Parent sends: { type: 'event:phase_failed', issueId, phase, error }
+ * - Parent sends: { type: 'event:issue_done', issueId }
  * - Worker sends: { type: 'log', level, message }
- * - Worker sends: { type: 'command:pause_feature', featureId }
- * - Worker sends: { type: 'command:resume_feature', featureId }
+ * - Worker sends: { type: 'command:pause_issue', issueId }
+ * - Worker sends: { type: 'command:resume_issue', issueId }
  */
 export {};