edsger 0.54.0 → 0.55.0

package/README.md

@@ -229,6 +229,26 @@ npx edsger --review --staged
 - MCP server for advanced issue operations (analysis, design, implementation, testing)
 - Playwright for functional testing (when using `--test` flag)
 
+## Releasing
+
+Published from this directory using
+[semantic-release](https://github.com/semantic-release/semantic-release),
+driven by [Conventional Commit](https://www.conventionalcommits.org/)
+messages on `main` (`fix:` → patch, `feat:` → minor, `feat!:` /
+`BREAKING CHANGE:` → major).
+
+```bash
+cd packages/edsger
+npm run release:preview   # dry-run, see the next version + notes
+npm run release           # publish to npm + push the git tag
+```
+
+> **Important:** the `edsger-contract` and `edsger-tools` versions
+> referenced in `package.json` must already be on the npm registry
+> before this CLI can be installed. Always run the Changesets flow for
+> those two packages first — see [`RELEASING.md`](../../RELEASING.md)
+> in the repo root for the full sequence.
+
 ## License
 
 ISC

package/dist/api/financing.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Thin MCP wrappers for the Financing tab. Mirror the shape of the
+ * `growth.ts` and `intelligence.ts` siblings.
+ */
+export type FinancingStage = 'pre_seed' | 'seed' | 'series_a' | 'series_b' | 'series_c' | 'growth';
+export interface FinancingDeckSlide {
+    slide_id: string;
+    title: string;
+    body: string;
+    ai_rationale?: string;
+}
+export interface FinancingRedFlag {
+    metric: string;
+    severity: 'low' | 'medium' | 'high';
+    explanation: string;
+    fix: string;
+}
+export interface FinancingContext {
+    product: {
+        id: string;
+        name: string;
+        description: string | null;
+        created_at: string | null;
+    } | null;
+    profile: Record<string, unknown> | null;
+    metrics: Record<string, unknown> | null;
+    target_stage: FinancingStage | null;
+}
+/**
+ * Fetch the founder-supplied financing profile + metrics. The agent is
+ * expected to WebSearch current industry benchmarks itself rather than
+ * relying on a stale server-side table.
+ */
+export declare function getFinancingContext(productId: string, targetStage: FinancingStage, verbose?: boolean): Promise<FinancingContext>;
+/**
+ * Persist a generated pitch deck draft to financing_ai_analyses.
+ */
+export declare function saveFinancingAnalysis(payload: {
+    product_id: string;
+    target_stage: FinancingStage;
+    deck_slides: FinancingDeckSlide[];
+    stage_reasoning?: string;
+    red_flags?: FinancingRedFlag[];
+    source_summary?: Record<string, unknown>;
+}, verbose?: boolean): Promise<{
+    analysis_id: string;
+}>;

package/dist/api/financing.js

@@ -0,0 +1,37 @@
+import { logError, logInfo } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+/**
+ * Fetch the founder-supplied financing profile + metrics. The agent is
+ * expected to WebSearch current industry benchmarks itself rather than
+ * relying on a stale server-side table.
+ */
+export async function getFinancingContext(productId, targetStage, verbose) {
+    if (verbose) {
+        logInfo(`Fetching financing context for product=${productId} stage=${targetStage}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('financing/get_context', {
+            product_id: productId,
+            target_stage: targetStage,
+        }));
+        const text = result.content?.[0]?.text || '{}';
+        return JSON.parse(text);
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch financing context: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Persist a generated pitch deck draft to financing_ai_analyses.
+ */
+export async function saveFinancingAnalysis(payload, verbose) {
+    if (verbose) {
+        logInfo(`Saving financing analysis: ${payload.deck_slides.length} slides, ${(payload.red_flags ?? []).length} red flags`);
+    }
+    const result = (await callMcpEndpoint('financing/save_analysis', payload));
+    const text = result.content?.[0]?.text || '{}';
+    return JSON.parse(text);
+}

package/dist/api/issues/approval-checker.d.ts

@@ -1,6 +1,11 @@
 /**
- * Approval workflow integration for issue phases
- * Checks if current issue status has been approved before executing next phase
+ * Approval workflow integration for issue phases.
+ *
+ * Under the 2D model, approvals are gated on the PHASE the worker is
+ * about to enter (e.g. "approve before technical_design runs"), not on
+ * the issue's lifecycle status. The phase-executor passes the target
+ * phase name; we look up the approval config for that phase and block
+ * execution if pending approval is required.
  */
 interface ApprovalCheckResult {
     canProceed: boolean;
@@ -9,12 +14,9 @@ interface ApprovalCheckResult {
     message?: string;
 }
 /**
- * Check if current issue status has been approved before executing next phase
- * This should be called BEFORE executing a phase, not after
- *
- * @param issueId - Issue ID
- * @param verbose - Verbose logging
- * @returns Promise<ApprovalCheckResult> - Whether the phase can proceed
+ * Check if a phase requires approval before the worker enters it.
+ * Called by phase-executor with the snake_case phase name (e.g.
+ * 'technical_design').
  */
-export declare function checkApprovalBeforePhaseExecution(issueId: string, verbose?: boolean): Promise<ApprovalCheckResult>;
+export declare function checkApprovalBeforePhaseExecution(issueId: string, phase: string, verbose?: boolean): Promise<ApprovalCheckResult>;
 export {};

package/dist/api/issues/approval-checker.js

@@ -1,32 +1,31 @@
 /**
- * Approval workflow integration for issue phases
- * Checks if current issue status has been approved before executing next phase
+ * Approval workflow integration for issue phases.
+ *
+ * Under the 2D model, approvals are gated on the PHASE the worker is
+ * about to enter (e.g. "approve before technical_design runs"), not on
+ * the issue's lifecycle status. The phase-executor passes the target
+ * phase name; we look up the approval config for that phase and block
+ * execution if pending approval is required.
  */
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 import { getIssue } from './get-issue.js';
 /**
- * Check if current issue status has been approved before executing next phase
- * This should be called BEFORE executing a phase, not after
- *
- * @param issueId - Issue ID
- * @param verbose - Verbose logging
- * @returns Promise<ApprovalCheckResult> - Whether the phase can proceed
+ * Check if a phase requires approval before the worker enters it.
+ * Called by phase-executor with the snake_case phase name (e.g.
+ * 'technical_design').
  */
-export async function checkApprovalBeforePhaseExecution(issueId, verbose = false) {
+export async function checkApprovalBeforePhaseExecution(issueId, phase, verbose = false) {
     try {
-        // 1. Get current issue to check its status and product_id
         const issue = await getIssue(issueId, verbose);
-        const currentStatus = issue.status;
         const productId = issue.product_id;
         if (verbose) {
-            logInfo(`🔍 Checking approval for current status: ${currentStatus}`);
+            logInfo(`🔍 Checking approval for phase: ${phase}`);
             logInfo(`📦 Product ID: ${productId}`);
         }
-        // 2. Check if current status requires approval
         const requiresApprovalResult = (await callMcpEndpoint('approvals/requires_approval', {
             product_id: productId,
-            issue_status: currentStatus,
+            issue_status: phase,
         }));
         if (verbose) {
             logInfo(`📋 MCP requires_approval response: ${JSON.stringify(requiresApprovalResult)}`);
@@ -34,26 +33,24 @@ export async function checkApprovalBeforePhaseExecution(issueId, verbose = false
         const requiresApproval = requiresApprovalResult?.requires_approval === true;
         if (!requiresApproval) {
             if (verbose) {
-                logInfo(`✅ Current status ${currentStatus} does not require approval. Proceeding.`);
+                logInfo(`✅ Phase ${phase} does not require approval. Proceeding.`);
             }
             return {
                 canProceed: true,
                 requiresApproval: false,
             };
         }
-        // 3. Status requires approval - check if already approved
         if (verbose) {
-            logInfo(`🔒 Current status ${currentStatus} requires approval`);
+            logInfo(`🔒 Phase ${phase} requires approval`);
         }
         const existingApprovals = (await callMcpEndpoint('approvals/issue_approvals', {
             issue_id: issueId,
         }));
-        // Check if there's an approved approval for the current status
-        const approvedApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === currentStatus &&
+        const approvedApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === phase &&
             approval.approval_status === 'approved');
         if (approvedApproval) {
             if (verbose) {
-                logInfo(`✅ Found approved approval for ${currentStatus}. Proceeding.`);
+                logInfo(`✅ Found approved approval for ${phase}. Proceeding.`);
             }
             return {
                 canProceed: true,
@@ -61,39 +58,36 @@ export async function checkApprovalBeforePhaseExecution(issueId, verbose = false
                 approvalId: approvedApproval.id,
             };
         }
-        // Check if there's already a pending approval for current status
-        const pendingApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === currentStatus &&
+        const pendingApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === phase &&
             approval.approval_status === 'pending');
         if (pendingApproval) {
             if (verbose) {
-                logWarning(`⏳ Approval already pending for ${currentStatus}. Waiting for review.`);
+                logWarning(`⏳ Approval already pending for ${phase}. Waiting.`);
             }
             return {
                 canProceed: false,
                 requiresApproval: true,
                 approvalId: pendingApproval.id,
-                message: `Waiting for approval of current status: ${currentStatus}`,
+                message: `Waiting for approval of phase: ${phase}`,
             };
         }
-        // No pending or approved approval - need to create one
         if (verbose) {
-            logInfo(`🔔 No approval exists for ${currentStatus}. Creating approval request...`);
+            logInfo(`🔔 No approval exists for ${phase}. Creating approval request...`);
         }
-        // Create approval request
-        const approvalId = await createApprovalRequestWithEmail(issueId, productId, currentStatus, verbose);
+        const approvalId = await createApprovalRequestWithEmail(issueId, productId, phase, verbose);
         if (approvalId) {
             return {
                 canProceed: false,
                 requiresApproval: true,
                 approvalId,
-                message: `Approval request created for status: ${currentStatus}`,
+                message: `Approval request created for phase: ${phase}`,
             };
         }
         logError('Failed to create approval request');
         return {
             canProceed: false,
             requiresApproval: true,
-            message: `Failed to create approval request for status: ${currentStatus}`,
+            message: `Failed to create approval request for phase: ${phase}`,
         };
     }
     catch (error) {
@@ -108,22 +102,18 @@ export async function checkApprovalBeforePhaseExecution(issueId, verbose = false
     }
 }
 /**
- * Create an approval request (emails are sent automatically by the MCP handler)
- * This is for the CURRENT status, not the next status
+ * Create an approval request for a phase. The approval is asking:
+ * "Can we proceed into this phase?"
  */
-async function createApprovalRequestWithEmail(issueId, productId, currentStatus, verbose = false) {
+async function createApprovalRequestWithEmail(issueId, productId, phase, verbose = false) {
     try {
         if (verbose) {
-            logInfo(`Creating approval request for current status: ${currentStatus}`);
+            logInfo(`Creating approval request for phase: ${phase}`);
         }
-        // Create approval request via MCP endpoint
-        // Note: We're requesting approval for the current status
-        // The approval is asking: "Can we proceed from this status?"
-        // Email notifications are sent automatically by the MCP handler
         const result = (await callMcpEndpoint('approvals/create', {
             issue_id: issueId,
-            requested_status: currentStatus,
-            previous_status: null, // We're approving current status, not transitioning
+            requested_status: phase,
+            previous_status: null,
         }));
         const approvalId = result?.approval_id;
         if (!approvalId) {
@@ -132,7 +122,6 @@ async function createApprovalRequestWithEmail(issueId, productId, currentStatus,
         }
         if (verbose) {
             logInfo(`✅ Approval request created: ${approvalId}`);
-            // Log email results if available
             if (result?.emails_sent) {
                 const sentCount = result.emails_sent.filter((e) => e.status === 'sent').length;
                 const failedCount = result.emails_sent.filter((e) => e.status !== 'sent').length;

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

@@ -1,6 +1,25 @@
 /**
- * Issue status updater for workflow pipeline
- * Updates issue status at each phase of the development workflow
+ * Worker-side phase progress writer.
+ *
+ * Under the 2D state model, phase progress lives in the workflow JSONB
+ * column, not in issues.status. The lifecycle column changes only at:
+ *   - claim time (ready_for_ai → assigned_to_ai, via claim_next_ready_issue)
+ *   - first phase entry (assigned_to_ai → in_progress, automatic in enter_phase)
+ *   - terminal completion (handled by orchestrator after all phases done)
+ *
+ * For each phase transition, we call the enter_phase RPC which atomically
+ * closes any prior active phase and sets the target phase to running or
+ * verifying. For non-active terminal states (completed/failed/skipped on a
+ * specific phase, e.g. functional-testing setting itself to completed/failed
+ * when the test result arrives), we call set_phase_state.
+ *
+ * Public exports:
+ *   enterPhase(issueId, phase, state)            — primary write path
+ *   setPhaseState(issueId, phase, state)         — terminal phase outcomes
+ *   updateIssueStatus({issueId, status})         — direct lifecycle changes
+ *   updateIssueStatusForPhase(issueId, phaseName, verbose)
+ *     Stable signature for the orchestrator's 9 call sites; internally
+ *     dispatches to enterPhase or setPhaseState based on the phase name.
  */
 import type { IssueStatus } from '../../types/index.js';
 interface StatusUpdateOptions {
@@ -9,33 +28,41 @@ interface StatusUpdateOptions {
     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)
+ * Forward-progression check for the legacy status enum. Retained for
+ * lifecycle-only updates; phase progress no longer flows through here.
  */
 export declare function isForwardProgression(currentStatus: IssueStatus, newStatus: IssueStatus): boolean;
 /**
- * Update issue status via MCP endpoint
+ * Direct lifecycle status update. Phase-driven callers should use
+ * `enterPhase` / `setPhaseState` instead — this is for true lifecycle
+ * writes only (e.g. shipping, archiving, failing terminally).
  */
 export declare function updateIssueStatus({ issueId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
 /**
- * Map pipeline phase to issue status
+ * Atomic phase transition. Closes any prior running/verifying phase and
+ * marks the target phase as running or verifying. Bumps issues.status to
+ * in_progress automatically when needed. Use this for active phase entry.
+ *
+ * Throws on RPC failure so callers can react (retry, escalate, abort).
+ * Old boolean-returning behavior is preserved by updateIssueStatusForPhase
+ * which wraps this call.
  */
-export declare const getStatusForPhase: (phase: string) => IssueStatus | null;
+export declare function enterPhase(issueId: string, phase: string, state: 'running' | 'verifying', verbose?: boolean): Promise<void>;
 /**
- * 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
+ * Atomic phase state update — typically used to mark a phase as completed,
+ * failed, or skipped without affecting other phases or issues.status.
+ * For example, functional-testing/analyzer uses this to record
+ * `functional_testing → completed` (testing passed) or
+ * `functional_testing → failed` (testing failed).
+ */
+export declare function setPhaseState(issueId: string, phase: string, state: 'pending' | 'running' | 'verifying' | 'completed' | 'failed' | 'skipped', verbose?: boolean): Promise<void>;
+/**
+ * Update issue progress for a pipeline 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 an issue backward in the development workflow.
+ * Signature is preserved (issueId, phase, verbose) so all 9+ orchestrator
+ * call sites continue to work without modification. The internal
+ * implementation has been rewritten to call enter_phase, which writes to
+ * workflow JSONB instead of issues.status.
  */
 export declare const updateIssueStatusForPhase: (issueId: string, phase: string, verbose?: boolean) => Promise<boolean>;
 export {};

package/dist/api/issues/status-updater.js

@@ -1,41 +1,83 @@
 /**
- * Issue status updater for workflow pipeline
- * Updates issue status at each phase of the development workflow
+ * Worker-side phase progress writer.
+ *
+ * Under the 2D state model, phase progress lives in the workflow JSONB
+ * column, not in issues.status. The lifecycle column changes only at:
+ *   - claim time (ready_for_ai → assigned_to_ai, via claim_next_ready_issue)
+ *   - first phase entry (assigned_to_ai → in_progress, automatic in enter_phase)
+ *   - terminal completion (handled by orchestrator after all phases done)
+ *
+ * For each phase transition, we call the enter_phase RPC which atomically
+ * closes any prior active phase and sets the target phase to running or
+ * verifying. For non-active terminal states (completed/failed/skipped on a
+ * specific phase, e.g. functional-testing setting itself to completed/failed
+ * when the test result arrives), we call set_phase_state.
+ *
+ * Public exports:
+ *   enterPhase(issueId, phase, state)            — primary write path
+ *   setPhaseState(issueId, phase, state)         — terminal phase outcomes
+ *   updateIssueStatus({issueId, status})         — direct lifecycle changes
+ *   updateIssueStatusForPhase(issueId, phaseName, verbose)
+ *     Stable signature for the orchestrator's 9 call sites; internally
+ *     dispatches to enterPhase or setPhaseState based on the phase name.
  */
-import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../../config/issue-status.js';
+import { STATUS_PROGRESSION_ORDER } from '../../config/issue-status.js';
 import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 import { getIssue } from './get-issue.js';
+const PHASE_NAME_TO_WORKFLOW = {
+    // Active phase transitions (call enter_phase)
+    'issue-analysis': { kind: 'enter', phase: 'issue_analysis', state: 'running' },
+    'issue-analysis-verification': { kind: 'enter', phase: 'issue_analysis', state: 'verifying' },
+    'user-stories-analysis': { kind: 'enter', phase: 'user_stories_analysis', state: 'running' },
+    'user-stories-analysis-verification': { kind: 'enter', phase: 'user_stories_analysis', state: 'verifying' },
+    'test-cases-analysis': { kind: 'enter', phase: 'test_cases_analysis', state: 'running' },
+    'test-cases-analysis-verification': { kind: 'enter', phase: 'test_cases_analysis', state: 'verifying' },
+    'technical-design': { kind: 'enter', phase: 'technical_design', state: 'running' },
+    'technical-design-verification': { kind: 'enter', phase: 'technical_design', state: 'verifying' },
+    'branch-planning': { kind: 'enter', phase: 'branch_planning', state: 'running' },
+    'branch-planning-verification': { kind: 'enter', phase: 'branch_planning', state: 'verifying' },
+    'code-implementation': { kind: 'enter', phase: 'code_implementation', state: 'running' },
+    'code-implementation-verification': { kind: 'enter', phase: 'code_implementation', state: 'verifying' },
+    'pr-splitting': { kind: 'enter', phase: 'pr_splitting', state: 'running' },
+    'pr-splitting-verification': { kind: 'enter', phase: 'pr_splitting', state: 'verifying' },
+    'pr-execution': { kind: 'enter', phase: 'pr_execution', state: 'running' },
+    'functional-testing': { kind: 'enter', phase: 'functional_testing', state: 'running' },
+    'code-review': { kind: 'enter', phase: 'code_review', state: 'running' },
+    'ready-for-review': { kind: 'enter', phase: 'code_review', state: 'verifying' },
+    'code-refine': { kind: 'enter', phase: 'code_refine', state: 'running' },
+    'code-refine-verification': { kind: 'enter', phase: 'code_refine', state: 'verifying' },
+    'bug-fixing': { kind: 'enter', phase: 'bug_fixing', state: 'running' },
+    // Terminal phase outcomes (call set_phase_state)
+    'testing-passed': { kind: 'terminal', phase: 'functional_testing', state: 'completed' },
+    'testing-failed': { kind: 'terminal', phase: 'functional_testing', state: 'failed' },
+    'testing-in-progress': { kind: 'enter', phase: 'functional_testing', state: 'running' },
+};
 /**
- * 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)
+ * Forward-progression check for the legacy status enum. Retained for
+ * lifecycle-only updates; phase progress no longer flows through here.
  */
 export function isForwardProgression(currentStatus, newStatus) {
-    // Any status can transition to archived
     if (newStatus === 'archived') {
         return true;
     }
-    // Archived can only transition back to backlog (unarchive)
     if (currentStatus === 'archived') {
         return newStatus === 'backlog';
     }
     const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(currentStatus);
     const newIndex = STATUS_PROGRESSION_ORDER.indexOf(newStatus);
-    // Allow moving forward or staying at same level (for retries, etc.)
     return newIndex >= currentIndex;
 }
 /**
- * Update issue status via MCP endpoint
+ * Direct lifecycle status update. Phase-driven callers should use
+ * `enterPhase` / `setPhaseState` instead — this is for true lifecycle
+ * writes only (e.g. shipping, archiving, failing terminally).
  */
 export async function updateIssueStatus({ issueId, status, verbose = false, }) {
     try {
         if (verbose) {
             logInfo(`Updating issue ${issueId} status to: ${status}`);
         }
-        // Get current issue status to check for regression
         let issue;
         let currentStatus;
         try {
@@ -45,14 +87,11 @@ export async function updateIssueStatus({ issueId, status, verbose = false, }) {
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             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) {
                 logInfo('⚠️ Skipping status update due to inability to verify current status');
             }
             return false;
         }
-        // Check if this would be a regression
         if (!isForwardProgression(currentStatus, status)) {
             const message = `⚠️ Skipping status regression: ${currentStatus} → ${status}. Only forward progression allowed.`;
             if (verbose) {
@@ -60,18 +99,13 @@ export async function updateIssueStatus({ issueId, status, verbose = false, }) {
             }
             return false;
         }
-        // Only proceed if status actually changed
         if (currentStatus === status) {
             if (verbose) {
                 logInfo(`Status already at ${status}, no update needed`);
             }
             return true;
         }
-        // Update status
-        await callMcpEndpoint('issues/update', {
-            issue_id: issueId,
-            status,
-        });
+        await callMcpEndpoint('issues/update', { issue_id: issueId, status });
         if (verbose) {
             logInfo(`✅ Issue status updated successfully from ${currentStatus} to: ${status}`);
         }
@@ -86,37 +120,71 @@ export async function updateIssueStatus({ issueId, status, verbose = false, }) {
     }
 }
 /**
- * Map pipeline phase to issue status
+ * Atomic phase transition. Closes any prior running/verifying phase and
+ * marks the target phase as running or verifying. Bumps issues.status to
+ * in_progress automatically when needed. Use this for active phase entry.
+ *
+ * Throws on RPC failure so callers can react (retry, escalate, abort).
+ * Old boolean-returning behavior is preserved by updateIssueStatusForPhase
+ * which wraps this call.
  */
-export const getStatusForPhase = (phase) => {
-    // Use the externalized phase-to-status mapping
-    return PHASE_STATUS_MAP[phase] ?? null;
-};
+export async function enterPhase(issueId, phase, state, verbose = false) {
+    await callMcpEndpoint('issues/enter_phase', {
+        issue_id: issueId,
+        phase,
+        state,
+    });
+    if (verbose) {
+        logInfo(`✅ entered phase ${phase} (${state})`);
+    }
+}
 /**
- * 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
+ * Atomic phase state update — typically used to mark a phase as completed,
+ * failed, or skipped without affecting other phases or issues.status.
+ * For example, functional-testing/analyzer uses this to record
+ * `functional_testing → completed` (testing passed) or
+ * `functional_testing → failed` (testing failed).
+ */
+export async function setPhaseState(issueId, phase, state, verbose = false) {
+    await callMcpEndpoint('issues/set_phase_state', {
+        issue_id: issueId,
+        phase,
+        state,
+    });
+    if (verbose) {
+        logInfo(`✅ set phase ${phase} → ${state}`);
+    }
+}
+/**
+ * Update issue progress for a pipeline 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 an issue backward in the development workflow.
+ * Signature is preserved (issueId, phase, verbose) so all 9+ orchestrator
+ * call sites continue to work without modification. The internal
+ * implementation has been rewritten to call enter_phase, which writes to
+ * workflow JSONB instead of issues.status.
  */
 export const updateIssueStatusForPhase = async (issueId, phase, verbose) => {
-    const status = getStatusForPhase(phase);
-    if (!status) {
-        const message = `⚠️ Unknown phase '${phase}' - skipping status update to prevent regression`;
+    const mapping = PHASE_NAME_TO_WORKFLOW[phase];
+    if (!mapping) {
         if (verbose) {
-            logInfo(message);
+            logInfo(`⚠️ Unknown phase '${phase}' — skipping status update`);
+        }
+        return false;
+    }
+    try {
+        if (mapping.kind === 'enter') {
+            await enterPhase(issueId, mapping.phase, mapping.state, verbose);
+        }
+        else {
+            await setPhaseState(issueId, mapping.phase, mapping.state, verbose);
+        }
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+            logError(`Failed to ${mapping.kind === 'enter' ? 'enter' : 'set'} phase ${mapping.phase} (${mapping.state}): ${message}`);
         }
         return false;
     }
-    return updateIssueStatus({
-        issueId,
-        status,
-        verbose,
-    });
 };

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

@@ -4,6 +4,7 @@ import { type IssueWorkflow } from '../../types/pipeline.js';
  */
 export declare function updateIssue(issueId: string, updates: {
     technical_design?: string;
+    execution_plan?: string;
     status?: string;
     execution_mode?: string;
     workflow?: IssueWorkflow;
@@ -12,6 +13,10 @@ export declare function updateIssue(issueId: string, updates: {
  * Update technical design for an issue
  */
 export declare function updateTechnicalDesign(issueId: string, technicalDesign: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Update execution plan for an issue
+ */
+export declare function updateExecutionPlan(issueId: string, executionPlan: string, verbose?: boolean): Promise<boolean>;
 /**
  * Mark a workflow phase as completed
  * Fetches current workflow, updates the phase status, and saves back